shithub: rott

--- a/rott/rt_actor.c

+++ b/rott/rt_actor.c

@@ -58,6 +58,7 @@

 #include "fx_man.h"

 //MED

 #include "memcheck.h"

+#include "queue.h"

@@ -3632,44 +3633,18 @@

-extern resItem* enemiesToRes;

-extern unsigned int freeSlot;

-void AddEnemyToResurrectList(resItem * res)

-{

-    int timeOfResurrect = DetermineTimeUntilEnemyIsResurrected(res->actor->obclass);

-    objtype * actor = res->actor;

-    SetReverseDeathState(actor);

-    if (ZomROTTResFreeSlots[freeSlot])

-    {

-        //FIND AN EMPTY SLOT

-        for(freeSlot; ZomROTTResFreeSlots[freeSlot] == false; freeSlot++)

-        {

-            if (freeSlot >= sizeof(*enemiesToRes))

-            {

-                Error("ZomROTT couldn't find a free slot to insert entry in!");

-            }

-        }

-    }

-    resItem newEntry;

-    newEntry.actor = actor;

-    newEntry.isInitialized = 1;

-    newEntry.timeOfResurrect = timeOfResurrect;

-    enemiesToRes[freeSlot] = newEntry;

-    ZomROTTResFreeSlots[freeSlot] = false;

-}

+extern Queue enemiesToRes;

-void CleanUpResurrectList()

+void AddEnemyToResurrectList(objtype * ob)

-    memset(enemiesToRes, 0, sizeof(*enemiesToRes));

-    freeSlot = 0;

+    ob->resurrectAtTime = DetermineTimeUntilEnemyIsResurrected(ob->obclass);

+    SetReverseDeathState(ob);

+    enqueue(&enemiesToRes, ob);

 void FreeUpResurrectList()

-    free(enemiesToRes);

-    free(ZomROTTResFreeSlots);

+    clearQueue(&enemiesToRes);

 void SetAfterResurrectState(objtype * actor, statetype * doWhat)

@@ -3731,22 +3706,22 @@

 void ResurrectEnemies()

-    resItem * thing;

+    objtype * actor;

+    int currTime = gamestate.TimeCount/VBLCOUNTER;

+    int killTotal = gamestate.killtotal;

     int index = 0;

-    for (thing = &enemiesToRes[0]; thing < &enemiesToRes[sizeof(*enemiesToRes)]; thing++, index++)

+    actor = enemiesToRes.head->data;

+    if (currTime >= actor->resurrectAtTime)

-        if (thing->timeOfResurrect == 0)

-        {

-            continue;

-        }

-        else if (gamestate.TimeCount/(VBLCOUNTER) >= thing->timeOfResurrect && ZomROTTResFreeSlots[index] == false)

-        {

-            SD_PlaySoundRTP(SD_PLAYERSPAWNSND, thing->actor->x, thing->actor->y);

-            SpawnDuringGameWithState (thing->actor->obclass,thing->actor->tilex,thing->actor->tiley,thing->actor->dir, 1, thing->actor->state);

-            thing->timeOfResurrect = 0;

-            ZomROTTResFreeSlots[index] = true;

-        }

+        SD_PlaySoundRTP(SD_PLAYERSPAWNSND, actor->x, actor->y);

+        SpawnDuringGameWithState (actor->obclass,actor->tilex,actor->tiley,actor->dir, 1, actor->state);

+        dequeue(&enemiesToRes, actor);

+        gamestate.killcount--;

@@ -3843,19 +3818,6 @@

     ConnectAreas();

-void SaveResurrectList(byte ** buffer, int *size)

-{

-    byte * tptr;

-    *size = sizeof(enemiesToRes);

-    *buffer = (byte*)SafeMalloc(*size);

-    tptr = *buffer;

-    memcpy(tptr, enemiesToRes, sizeof(*enemiesToRes));

-    tptr += sizeof(enemiesToRes);

-}

/*

 ========================

@@ -3894,11 +3856,7 @@

         memcpy(copyOfObject, ob, sizeof(objtype));

-        resItem * thingToAdd = malloc(sizeof(resItem));

-        thingToAdd->actor = copyOfObject;

-        AddEnemyToResurrectList(thingToAdd);

+        AddEnemyToResurrectList(copyOfObject);

     if ((ob->obclass == patrolgunobj) && (ob->temp1 == -1))

--- a/rott/rt_actor.h

+++ b/rott/rt_actor.h

@@ -27,6 +27,7 @@

 //***************************************************************************

 #include "states.h"

+#include "queue.h"

 #define FL_SYNCED          0x400

@@ -256,19 +257,10 @@

     struct objstruct         *next, *prev;

     struct objstruct         *nextactive, *prevactive;

     struct objstruct         *nextinarea, *previnarea;

+    int resurrectAtTime;

 } objtype;

-typedef struct resStruct

-{

-    short isInitialized;

-    unsigned int timeOfResurrect;

-    objtype * actor;

-} resItem;

 typedef struct b_struct

 {   int   NMErotate;

     int   NMEdirstried;

@@ -304,10 +296,8 @@

     boolean elevatormusicon;

 } misc_stuff;

-boolean * ZomROTTResFreeSlots;

 extern  boolean          ludicrousgibs;

 extern  objtype*         PLAYER0MISSILE;

 extern  byte             deathshapeoffset[8];

@@ -445,4 +435,4 @@

 void ResurrectEnemies();

-#endif

+#endif

\ No newline at end of file

--- a/rott/rt_game.c

+++ b/rott/rt_game.c

@@ -65,6 +65,7 @@

 #include "develop.h"

 //MED

 #include "memcheck.h"

+#include "queue.h"

 #if (SHAREWARE == 1)

 #define NUMAMMOGRAPHICS 10

@@ -4901,6 +4902,8 @@

 extern boolean allowBlitzMoreMissileWeps;

 extern boolean enableAmmoPickups;

+extern Queue enemiesToRes;

 boolean SaveTheGame (int num, gamestorage_t * game)

     char   loadname[MAX_PATH]="rottgam0.rot";

@@ -5174,9 +5177,17 @@

     //ZomROTT Stuff

     if(enableZomROTT)

-        SaveResurrectList(&altbuffer, &size);

-        StoreBuffer(savehandle,altbuffer,size);

-        SafeFree(altbuffer);

+        size = sizeof(int);

+        SafeWrite(savehandle, &enemiesToRes.sizeOfQueue, size);

+        int x = 0;

+        node * thingToSave = enemiesToRes.head;

+        size = sizeof(objtype);

+        for (x = 0; x < enemiesToRes.sizeOfQueue; x++)

+        {

+            SafeWrite(savehandle, (objtype *) thingToSave->data, size);

+            thingToSave = thingToSave->next;

+        }

     close (savehandle);

@@ -5239,7 +5250,6 @@

 //******************************************************************************

-extern resItem* enemiesToRes;

 extern unsigned int freeSlot;

 boolean LoadTheGame (int num, gamestorage_t * game)

@@ -5569,17 +5579,30 @@

     //ZomROTT Stuff

     if(enableZomROTT)

-        enemiesToRes = calloc(sizeof(resItem), gamestate.killtotal);

-        memset(enemiesToRes, 0, sizeof(*enemiesToRes));

-        size = sizeof(enemiesToRes);

-        memcpy(enemiesToRes, bufptr, size);

-        bufptr += size;

+        queueInit(&enemiesToRes, sizeof(objtype));

-        objtype * findFreeSlotPtr;

-        //find index of free

-        for (findFreeSlotPtr = &enemiesToRes[0]; findFreeSlotPtr != 0; findFreeSlotPtr++)

+        int origQueueSize = 0;

+        size = sizeof(int);

+        memcpy(&origQueueSize, bufptr, size);

+        bufptr+=size;

+        size = sizeof(objtype);

+        int x = 0;

+        while(x < origQueueSize)

-            freeSlot++;

+            objtype * item = (objtype *) malloc(sizeof(objtype));

+            memcpy(item, bufptr, size);

+            enqueue(&enemiesToRes, item);

+            bufptr+=size;

+            x++;

--- a/rott/rt_main.c

+++ b/rott/rt_main.c

@@ -1857,7 +1857,6 @@

 extern boolean enableZomROTT;

-extern int numOfNonGibbedEnemies;

 void UpdateGameObjects ( void )

     int j;

@@ -1894,7 +1893,7 @@

         UpdateLightning ();

         TriggerStuff();

         CheckCriticalStatics();

-        if (enableZomROTT)

+        if (enableZomROTT && gamestate.killcount > 0)

             ResurrectEnemies();

@@ -3548,4 +3547,4 @@

         break;

 #endif

-}

+}

\ No newline at end of file

--- a/rott/rt_ted.c

+++ b/rott/rt_ted.c

@@ -66,6 +66,7 @@

 #include "rt_net.h"

 //MED

 #include "memcheck.h"

+#include "queue.h"

@@ -5666,23 +5667,15 @@

     DoLowMemoryConversionIconPlane ();

-objtype * enemiesToRes = NULL;

 int freeSlot = 0;

+Queue enemiesToRes;

 void SetupZomROTTStuff()

-    resItem * uninitializedRes = malloc(sizeof(resItem));

-    uninitializedRes->isInitialized=false;

-    if (enemiesToRes)

+    if (enemiesToRes.head != NULL && enemiesToRes.tail != NULL)

-        FreeUpResurrectList();

+        clearQueue(&enemiesToRes);

-    enemiesToRes = calloc(sizeof(resItem), gamestate.killtotal);

-    memset(enemiesToRes, uninitializedRes, sizeof(*enemiesToRes));

-    ZomROTTResFreeSlots = calloc(sizeof(int), gamestate.killtotal);

-    memset(ZomROTTResFreeSlots, true, sizeof(*ZomROTTResFreeSlots));

-    //freeSlot = 0;

+    queueInit(&enemiesToRes, sizeof(objtype));

/*

@@ -7091,4 +7084,3 @@