The Ecere SDK - sdk/blob - extras/tiles/sequence.ec

   1 /****************************************************************************
   2    ECERE Tile Engine
   3
   4    Copyright (c) 1997-2001 Jerome Jacovella-St-Louis
   5    All Rights Reserved.
   6
   7    sequence.c - Sprite Sequence System
   8 ****************************************************************************/
   9 import "ecere"
  10
  11 struct SequenceFrame
  12 {
  13    uint16 frame,wait,walk;
  14    uint16 hit;
  15 };
  16
  17 struct Sequence
  18 {
  19    uint16 numEvents;
  20    uint16 *numFrames;
  21    SequenceFrame **frames;
  22 };
  23
  24 void SequenceFree(Sequence *sequence)
  25 {
  26    if(sequence)
  27    {
  28       int c;
  29       if(sequence->frames)
  30       {
  31          for(c=0; c<sequence->numEvents; c++)
  32          {
  33             if(sequence->frames[c])
  34                delete sequence->frames[c];
  35          }
  36          delete sequence->frames;
  37       }
  38       if(sequence->numFrames)
  39          delete sequence->numFrames;
  40       delete sequence;
  41    }
  42 }
  43
  44 Sequence * SequenceInit(uint16 numEvents)
  45 {
  46    Sequence * result = null;
  47    Sequence * sequence = new0 Sequence[1];
  48    if(sequence)
  49    {
  50       sequence->numEvents = numEvents;
  51       sequence->numFrames = new0 uint16[numEvents];
  52       if(sequence->numFrames)
  53       {
  54          sequence->frames = new0 SequenceFrame *[numEvents];
  55          if(sequence->frames)
  56             result = sequence;
  57       }
  58    }
  59    if(!result)
  60       SequenceFree(sequence);
  61    return result;
  62 }
  63
  64 bool SequenceLoadTable(Sequence **sequences, int count, const char * fileName)
  65 {
  66    bool result = false;
  67    File f = FileOpen(fileName, read);
  68    FillBytes(sequences, 0, sizeof(Sequence *) * count);
  69    if(f)
  70    {
  71       int c;
  72       result = true;
  73       for(c=0; c<count; c++)
  74       {
  75          uint16 numEvents = 0;
  76          Sequence * sequence;
  77
  78          if(f.Read(&numEvents, sizeof(uint16), 1)  &&  (sequence = SequenceInit(numEvents)) )
  79          {
  80             int e;
  81             sequences[c] = sequence;
  82             for(e=0; e<numEvents; e++)
  83             {
  84                if(f.Read(&sequence->numFrames[e],sizeof(uint16), 1))
  85                {
  86                   if(sequence->numFrames[e])
  87                   {
  88                      sequence->frames[e] = new0 SequenceFrame[sequence->numFrames[e]];
  89                      if(sequence->frames[e])
  90                      {
  91                         int r;
  92                         for(r=0; r<sequence->numFrames[e]; r++)
  93                         {
  94                            if(!f.Read(&sequence->frames[e][r].frame,sizeof(uint16), 1) ||
  95                               !f.Read(&sequence->frames[e][r].wait, sizeof(uint16), 1) ||
  96                               !f.Read(&sequence->frames[e][r].walk, sizeof(uint16), 1) ||
  97                               !f.Read(&sequence->frames[e][r].hit,  sizeof(uint16), 1))
  98                            { sequences[c] = null; break; }
  99                         }
 100                      }
 101                      else { sequences[c] = null; break; }
 102                   }
 103                }
 104                else { sequences[c] = null; break; }
 105             }
 106             if(!sequences[c])
 107             {
 108                result = false;
 109                SequenceFree(sequence);
 110                break;
 111             }
 112          }
 113       }
 114       if(!result)
 115       {
 116          for(c = 0; c<count; c++)
 117          {
 118             if(sequences[c])
 119             {
 120                SequenceFree(sequences[c]);
 121                sequences[c] = null;
 122             }
 123          }
 124          Logf("Error reading sequence table file (%s).\n", fileName);
 125       }
 126       delete f;
 127    }
 128    else
 129       Logf("Couldn't open sequence table file (%s).\n", fileName);
 130    return result;
 131 }
 132
 133 void SequenceSaveTable(Sequence **sequences, int count, char *fileName)
 134 {
 135    File f = FileOpen(fileName, write);
 136    if(f)
 137    {
 138       int c;
 139       for(c=0; c<count; c++)
 140       {
 141          int e;
 142          Sequence * sequence = sequences[c];
 143          f.Write(&sequence->numEvents, sizeof(uint16), 1);
 144
 145          for(e=0; e<sequence->numEvents; e++)
 146          {
 147             int r;
 148             f.Write(&sequence->numFrames[e],sizeof(uint16), 1);
 149             for(r = 0; r<sequence->numFrames[e]; r++)
 150             {
 151                f.Write(&sequence->frames[e][r].frame,sizeof(uint16), 1);
 152                f.Write(&sequence->frames[e][r].wait, sizeof(uint16), 1);
 153                f.Write(&sequence->frames[e][r].walk, sizeof(uint16), 1);
 154                f.Write(&sequence->frames[e][r].hit,  sizeof(uint16), 1);
 155             }
 156          }
 157       }
 158       delete f;
 159    }
 160 }
 161
 162 Sequence *SequenceLoad(char *fileName)
 163 {
 164    Sequence * result = null;
 165    File f = FileOpen(fileName, read);
 166    if(f)
 167    {
 168       Sequence * sequence;
 169       uint16 numEvents = 0;
 170       if(f.Read(&numEvents, sizeof(uint16), 1)   &&
 171          (sequence = SequenceInit(numEvents))   )
 172       {
 173          int e;
 174          result = sequence;
 175          for(e=0; e<sequence->numEvents; e++)
 176          {
 177             int r;
 178             if(f.Read(&sequence->numFrames[e],sizeof(uint16), 1))
 179             {
 180                if(sequence->numFrames[e])
 181                {
 182                   if((sequence->frames[e] = new0 SequenceFrame[sequence->numFrames[e]]))
 183                   {
 184                      for(r = 0; r<sequence->numFrames[e]; r++)
 185                      {
 186                         if(!f.Read(&sequence->frames[e][r].frame,sizeof(uint16), 1) ||
 187                            !f.Read(&sequence->frames[e][r].wait, sizeof(uint16), 1) ||
 188                            !f.Read(&sequence->frames[e][r].walk, sizeof(uint16), 1) ||
 189                            !f.Read(&sequence->frames[e][r].hit,  sizeof(uint16), 1) )
 190                         { result = null; break; }
 191                      }
 192                   }
 193                   else { result = null; break; }
 194                }
 195             }
 196             else { result = null; break; }
 197          }
 198          if(!result)
 199             SequenceFree(sequence);
 200       }
 201       delete f;
 202
 203       if(!result)
 204          Logf("Error loading sequence file (%s).\n", fileName);
 205    }
 206    else
 207       Logf("Couldn't open sequence file (%s).\n", fileName);
 208    return result;
 209 }
 210
 211 void SequenceSave(Sequence *sequence, char *filename)
 212 {
 213    File f;
 214    uint16 e,r;
 215
 216    f=FileOpen(filename, write);
 217    if(!f) return;
 218    f.Write(&sequence->numEvents, sizeof(uint16), 1);
 219    for(e=0; e<sequence->numEvents; e++)
 220    {
 221       f.Write(&sequence->numFrames[e],sizeof(uint16), 1);
 222       for(r=0; r<sequence->numFrames[e]; r++)
 223       {
 224          f.Write(&sequence->frames[e][r].frame,sizeof(uint16), 1);
 225          f.Write(&sequence->frames[e][r].wait, sizeof(uint16), 1);
 226          f.Write(&sequence->frames[e][r].walk, sizeof(uint16), 1);
 227          f.Write(&sequence->frames[e][r].hit,  sizeof(uint16), 1);
 228       }
 229    }
 230    delete f;
 231 }