src/game/entity.cpp

   1 /*
   2  *
   3  *  Iter Vehemens ad Necem (IVAN)
   4  *  Copyright (C) Timo Kiviluoto
   5  *  Released under the GNU General
   6  *  Public License
   7  *
   8  *  See LICENSING which should be included
   9  *  along with this file for more details
  10  *
  11  */
  12 #include <stdio.h>
  13 /* Compiled through coreset.cpp */
  14
  15
  16 //#define xlogf(...)  do { fprintf(stderr, __VA_ARGS__); fflush(stderr); } while (0)
  17 #define xlogf(...)
  18
  19
  20 ////////////////////////////////////////////////////////////////////////////////
  21 void entity::DumpDeadSet () {
  22 /*
  23   fprintf(stderr, "=== dead set ===\n");
  24   for (VoidSet::const_iterator i = mDeadSet.begin(); i != mDeadSet.end(); ++i) fprintf(stderr, "%p\n", *i);
  25 */
  26 }
  27
  28
  29 ////////////////////////////////////////////////////////////////////////////////
  30 entity::entity (const entity &Entity) : Emitation(Entity.Emitation), Flags(Entity.Flags) {
  31   xlogf("entity::entity0: %p\n", this);
  32   pool::RemoveFromHell(this);
  33   if (Flags & HAS_BE) {
  34     pool::Add(this);
  35   } else {
  36     // just in case
  37     pool::Remove(this);
  38   }
  39   mOnEvents = Entity.mOnEvents;
  40 }
  41
  42
  43 entity::entity (int Flags) : Emitation(0), Flags(Flags|EXISTS) {
  44   xlogf("entity::entity1: %p\n", this);
  45   pool::RemoveFromHell(this);
  46   if (Flags & HAS_BE) {
  47     pool::Add(this);
  48   } else {
  49     // just in case
  50     pool::Remove(this);
  51   }
  52 }
  53
  54
  55 entity::~entity () {
  56   xlogf("entity::~entity: %p\n", this);
  57   pool::Remove(this);
  58   pool::RemoveFromHell(this);
  59 }
  60
  61
  62 /* Calling SendToHell() marks the entity dead,
  63  * so that it will be removed by hell::Burn() at the end of the tick.
  64  * In general, you should never delete an entity instead of calling this,
  65  * because pool::Be() will crash if the entity currently Be()ing is deleted. */
  66 void entity::SendToHell () {
  67   if (Flags&EXISTS) {
  68     if (Flags&HAS_BE) {
  69       pool::Remove(this);
  70       Flags ^= HAS_BE;
  71     }
  72     pool::AddToHell(this);
  73     Flags ^= EXISTS;
  74   }
  75 }
  76
  77
  78 /* These functions tell the poolsystem whether the Be() function of the entity
  79  * ought to be called during each tick, thus allowing it to alter itself independently.
  80  * If the entity is stabile, use Disable(), since it speeds up the game. */
  81 void entity::Enable () {
  82   if (!(Flags&HAS_BE)) {
  83     pool::Add(this);
  84     Flags |= HAS_BE;
  85   }
  86 }
  87
  88
  89 void entity::Disable () {
  90   if (Flags&HAS_BE) {
  91     pool::Remove(this);
  92     Flags ^= HAS_BE;
  93   }
  94 }
  95
  96
  97 int entity::GetUniqueMemoryMark (entity *e) {
  98   if (e) {
  99     int *mp = (int *)e;
 100     //
 101     return mp[-1];
 102   }
 103   return -1;
 104 }
 105
 106
 107 void *entity::operator new (size_t size) {
 108   void *p;
 109   static int mark = 0;
 110   //
 111   if (size == 0) {
 112     fprintf(stderr, "FATAL: ALLOCATING ENTITY OF ZERO SIZE!\n");
 113     abort();
 114   }
 115   p = calloc(1, size+sizeof(int));
 116   {
 117     int *mp = (int *)p;
 118     //
 119     *mp = ++mark;
 120     p = mp+1;
 121   }
 122   return p;
 123 }
 124
 125
 126 void entity::operator delete (void *p) {
 127   if (p) {
 128     int *mp = (int *)p;
 129     //
 130     xlogf("delete(%d): %p\n", mp[-1], p);
 131     --mp;
 132     *mp = -1;
 133     free(mp);
 134   }
 135 }
 136
 137
 138 #undef xlogf