prj/cam/src/actreact/ssrclife.cpp

   1 /*
   2 @Copyright Looking Glass Studios, Inc.
   3 1996,1997,1998,1999,2000 Unpublished Work.
   4 */
   5
   6 // $Header: r:/t2repos/thief2/src/actreact/ssrclife.cpp,v 1.5 1998/10/05 17:28:14 mahk Exp $
   7 #include <ssrclife.h>
   8 #include <sdesbase.h>
   9 #include <iobjsys.h>
  10 #include <stimbase.h>
  11
  12
  13 // Must be last header
  14 #include <dbmem.h>
  15
  16
  17 ////////////////////////////////////////////////////////////
  18 // PERIODIC LIFE CYCLE IMPL
  19 //
  20
  21 //------------------------------------------------------------
  22 // STRUCT DESC
  23 //
  24
  25 static const char* periodic_flags[] =
  26 {
  27   "No Max Firings" ,
  28   "Destroy Object on Completion"
  29 };
  30
  31 #define NUM_PERIODIC_FLAGS (sizeof(periodic_flags)/sizeof(periodic_flags[0]))
  32
  33
  34 static sFieldDesc periodic_fields[] =
  35 {
  36    { "Flags", kFieldTypeBits, FieldLocation(sPeriodicLifeCycle,flags), kFieldFlagNone, 0, NUM_PERIODIC_FLAGS, NUM_PERIODIC_FLAGS, periodic_flags },
  37    { "Period", kFieldTypeInt, FieldLocation(sPeriodicLifeCycle,period), kFieldFlagUnsigned },
  38    { "Max Firings", kFieldTypeInt, FieldLocation(sPeriodicLifeCycle,max_firings) },
  39    { "Intensity Slope", kFieldTypeFloat, FieldLocation(sPeriodicLifeCycle,slope) },
  40 };
  41
  42 static sStructDesc periodic_sdesc = StructDescBuild(sPeriodicLifeCycle,kStructFlagNone,periodic_fields);
  43
  44 const sStructDesc* sPeriodicLifeCycle::gpDesc = &periodic_sdesc;
  45
  46 //------------------------------------------------------------
  47 // Firing Iterator
  48 //
  49
  50 struct sPeriodicLifeCycleFire
  51 {
  52    // our life cycle
  53    sPeriodicLifeCycle& life;
  54
  55    typedef tStimTimeStamp tTime;
  56
  57    // config variables
  58    tTime start;
  59    tTime last;
  60    tTime now;
  61    tStimLevel level;
  62
  63    // iteration variables
  64    tTime t;
  65    int i;
  66
  67    int to_fire;
  68
  69    sPeriodicLifeCycleFire(sPeriodicLifeCycle* plife, BOOL initial, tStimLevel lv, tTime s, tTime l, tTime n)
  70       : start(s),last(l),now(n), i (0),life(*plife),level(lv)
  71    {
  72
  73       // handle zero period case somewhat gracefully...
  74       if (life.period == 0)
  75       {
  76          Warning(("Stim source has zero-length period\n"));
  77          life.period++;
  78       }
  79
  80       // convert period to freq so we don't have to divide twice
  81       // @NOTE: possible precision issue.
  82       float freq = 1.0/life.period;
  83
  84       if (last < start) last = start;
  85       if (now < start)
  86       {
  87          to_fire = 0;
  88          t = start;
  89          return;
  90       }
  91
  92       // how many times we've already fired.
  93       int fired = (last - start) * freq;
  94       to_fire = (now - start) * freq;
  95
  96       // special case: send an event at the first firing
  97       if (!initial)
  98          fired++;
  99       to_fire ++;
 100
 101       if (!(life.flags & sPeriodicLifeCycle::kNoMaxFirings))
 102       {
 103          if (fired >= life.max_firings)
 104             to_fire = 0; // we're expired
 105          else if (to_fire >= life.max_firings)
 106             to_fire = life.max_firings;
 107       }
 108
 109       // set up iteration
 110       t = start + life.period * fired;
 111       i = fired;
 112       level += i * life.slope;
 113
 114    }
 115
 116    BOOL Next(tStimLevel* plev, tTime* pt, ulong* flags)
 117    {
 118       *plev = level;
 119       *pt = t;
 120
 121       if (i >= to_fire)
 122          return FALSE;
 123
 124       t += life.period;
 125       level += life.slope;
 126       i++;
 127
 128       *flags = 0;
 129
 130       ulong destroy_mask = sPeriodicLifeCycle::kNoMaxFirings|sPeriodicLifeCycle::kDestroy;
 131
 132       // destroy set but not no max firings
 133       if ((life.flags & destroy_mask) == sPeriodicLifeCycle::kDestroy
 134           && i == life.max_firings)
 135          *flags |= kStimDestroySrcObj;
 136
 137       return TRUE;
 138    }
 139 };
 140
 141 sPeriodicLifeCycle::sFire* sPeriodicLifeCycle::BeginFiring(BOOL initial,
 142                                                            tStimLevel level,
 143                                                            tStimTimeStamp start,
 144                                                            tStimTimeStamp last,
 145                                                            tStimTimeStamp now)
 146 {
 147    return new sFire(this,initial,level,start,last,now);
 148 }
 149
 150 BOOL sPeriodicLifeCycle::FireNext(sFire* fire, tStimLevel* nextlevel, tStimTimeStamp* nexttime, ulong* flags)
 151 {
 152    Assert_(fire);
 153    return fire->Next(nextlevel,nexttime,flags);
 154 }
 155
 156 BOOL sPeriodicLifeCycle::EndFiring(sFire* fire)
 157 {
 158    BOOL retval = (flags & kNoMaxFirings) || fire->i < max_firings;
 159    delete fire;
 160    return retval;
 161 }
 162