Including vault descriptions in seed catalog

Author: flend

src/brogue/Architect.c

@@ -25,6 +25,14 @@
 #include "GlobalsBase.h"
 #include "Globals.h"
 
+static boolean buildAMachineOrChildMachine(enum machineTypes bp,
+                          short originX, short originY,
+                          unsigned long requiredMachineFlags,
+                          item *adoptiveItem,
+                          item *parentSpawnedItems[50],
+                          creature *parentSpawnedMonsters[50],
+                          machineInfo *thisMachineInfoChain);
+
 short topBlobMinX, topBlobMinY, blobWidth, blobHeight;
 
 boolean cellHasTerrainFlag(pos loc, unsigned long flagMask) {
@@ -979,14 +987,84 @@ typedef struct machineData {
     short sCols[DCOLS];
 } machineData;
 
+machineInfo *createMachineInfo(int level, int id, int type) {
+    machineInfo *theInfo = (machineInfo *) malloc(sizeof(machineInfo));
+    memset(theInfo, '\0', sizeof(machineInfo));
+
+    machineInfo *theChildInfo = (machineInfo *) malloc(sizeof(machineInfo));
+    memset(theChildInfo, '\0', sizeof(machineInfo));
+
+    theInfo->level = level;
+    theInfo->type = type;
+    theInfo->id = id;
+    theInfo->childMachineInfo = theChildInfo;
+    theInfo->nextMachineInfo = NULL;
+
+    return theInfo;
+}
+
+void deleteAllMachineInfo(machineInfo *theChain) {
+    machineInfo *thisMachineInfo, *thisMachineInfo2;
+    for (thisMachineInfo = theChain; thisMachineInfo != NULL; thisMachineInfo = thisMachineInfo2) {
+        thisMachineInfo2 = thisMachineInfo->nextMachineInfo;
+        deleteAllMachineInfo(thisMachineInfo->childMachineInfo);
+        free(thisMachineInfo);
+    }
+}
+
+machineInfo *reverseAllMachineInfo(machineInfo *reverseList) {
+    machineInfo *prev = NULL;
+    machineInfo *current = reverseList;
+    machineInfo *next = NULL;
+
+    while (current != NULL) {
+        next = current->nextMachineInfo;
+        current->nextMachineInfo = prev;
+        prev = current;
+        current = next;
+    }
+    return prev;
+}
+
+void addMachineInfoAndChainToChain(machineInfo *theInfo, machineInfo *theChain) {
+    machineInfo *lastMachineInfo = theInfo;
+    while (lastMachineInfo->nextMachineInfo != NULL) {
+        lastMachineInfo = lastMachineInfo->nextMachineInfo;
+    }
+
+    lastMachineInfo->nextMachineInfo = theChain->nextMachineInfo;
+    theChain->nextMachineInfo = theInfo;
+}
+
+void addMachineInfoToChain(machineInfo *theInfo, machineInfo *theChain) {
+    theInfo->nextMachineInfo = theChain->nextMachineInfo;
+    theChain->nextMachineInfo = theInfo;
+}
+
+boolean buildAMachine(enum machineTypes bp,
+                      short originX, short originY,
+                      unsigned long requiredMachineFlags) {
+    machineInfo *tempMachineInfo = createMachineInfo(0, 0, 0);
+    if (buildAMachineOrChildMachine(bp, originX, originY, requiredMachineFlags, NULL, NULL, NULL, tempMachineInfo)) {
+        // Transfer the valid machineInfo into the main chain and delete the head node
+        addMachineInfoToChain(tempMachineInfo->nextMachineInfo, levelMachineInfo);
+        tempMachineInfo->nextMachineInfo = NULL;
+        free(tempMachineInfo);
+        return true;
+    }
+    deleteAllMachineInfo(tempMachineInfo);
+    return false;
+}
+
 // Returns true if the machine got built; false if it was aborted.
 // If empty array parentSpawnedItems or parentSpawnedMonsters is given, will pass those back for deletion if necessary.
-boolean buildAMachine(enum machineTypes bp,
+static boolean buildAMachineOrChildMachine(enum machineTypes bp,
                       short originX, short originY,
                       unsigned long requiredMachineFlags,
                       item *adoptiveItem,
                       item *parentSpawnedItems[MACHINES_BUFFER_LENGTH],
-                      creature *parentSpawnedMonsters[MACHINES_BUFFER_LENGTH]) {
+                      creature *parentSpawnedMonsters[MACHINES_BUFFER_LENGTH],
+                      machineInfo *thisMachineInfoChain) {
 
     short totalFreq, instance, instanceCount = 0,
         itemCount, monsterCount, qualifyingTileCount,
@@ -1245,6 +1323,10 @@ boolean buildAMachine(enum machineTypes bp,
         }
     }
 
+    // Store info about created machine (will be deleted if machine fails)
+    machineInfo *thisMachineInfo = createMachineInfo(rogue.depthLevel, machineNumber, bp);
+    addMachineInfoToChain(thisMachineInfo, thisMachineInfoChain);
+
 //  DEBUG printf("\n\nWorking on blueprint %i, with origin at (%i, %i). Here's the initial interior map:", bp, originX, originY);
 //  DEBUG logBuffer(interior);
 
@@ -1548,9 +1630,9 @@ boolean buildAMachine(enum machineTypes bp,
                                 removeItemFromChain(theItem, floorItems);
                                 removeItemFromChain(theItem, packItems);
                                 theItem->nextItem = NULL;
-                                success = buildAMachine(-1, -1, -1, BP_ADOPT_ITEM, theItem, p->spawnedItemsSub, p->spawnedMonstersSub);
+                                success = buildAMachineOrChildMachine(-1, -1, -1, BP_ADOPT_ITEM, theItem, p->spawnedItemsSub, p->spawnedMonstersSub, thisMachineInfo->childMachineInfo);
                             } else if (feature->flags & MF_BUILD_VESTIBULE) {
-                                success = buildAMachine(-1, featX, featY, BP_VESTIBULE, NULL, p->spawnedItemsSub, p->spawnedMonstersSub);
+                                success = buildAMachineOrChildMachine(-1, featX, featY, BP_VESTIBULE, NULL, p->spawnedItemsSub, p->spawnedMonstersSub, thisMachineInfo->childMachineInfo);
                             }
 
                             // Now put the item up for adoption.
@@ -1569,6 +1651,13 @@ boolean buildAMachine(enum machineTypes bp,
                                 }
                                 break;
                             }
+                            else {
+                                // Remove failed machine from info
+                                deleteAllMachineInfo(thisMachineInfo->childMachineInfo);
+                                machineInfo *theChildInfo = (machineInfo *) malloc(sizeof(machineInfo));
+                                memset(theChildInfo, '\0', sizeof(machineInfo));
+                                thisMachineInfo->childMachineInfo = theChildInfo;
+                            }
                         }
 
                         if (!i) {
@@ -1737,7 +1826,7 @@ static void addMachines() {
     // Add the amulet holder if it's depth 26:
     if (rogue.depthLevel == gameConst->amuletLevel) {
         for (failsafe = 50; failsafe; failsafe--) {
-            if (buildAMachine(MT_AMULET_AREA, -1, -1, 0, NULL, NULL, NULL)) {
+            if (buildAMachine(MT_AMULET_AREA, -1, -1, 0)) {
                 break;
             }
         }
@@ -1757,7 +1846,7 @@ static void addMachines() {
     }
 
     for (failsafe = 50; machineCount && failsafe; failsafe--) {
-        if (buildAMachine(-1, -1, -1, BP_REWARD, NULL, NULL, NULL)) {
+        if (buildAMachine(-1, -1, -1, BP_REWARD)) {
             machineCount--;
             rogue.rewardRoomsGenerated++;
         }
@@ -1835,7 +1924,7 @@ static void runAutogenerators(boolean buildAreaMachines) {
                 // Attempt to build the machine if requested.
                 // Machines will find their own locations, so it will not be at the same place as terrain and DF.
                 if (gen->machine > 0) {
-                    buildAMachine(gen->machine, -1, -1, 0, NULL, NULL, NULL);
+                    buildAMachine(gen->machine, -1, -1, 0);
                 }
             }
         }

src/brogue/GlobalsBase.c

@@ -49,6 +49,8 @@ creatureList purgatory;     // used to hold dead allies awaiting resurrection
 item *floorItems;
 item *packItems;
 item *monsterItemsHopper;
+machineInfo *allMachineInfo;
+machineInfo *levelMachineInfo;
 
 char displayedMessage[MESSAGE_LINES][COLS*2];
 short messagesUnconfirmed;

src/brogue/GlobalsBase.h

@@ -65,6 +65,8 @@ extern creatureList purgatory;
 extern item *floorItems;
 extern item *packItems;
 extern item *monsterItemsHopper;
+extern machineInfo *allMachineInfo;
+extern machineInfo *levelMachineInfo;
 extern short numberOfWaypoints;
 
 extern char displayedMessage[MESSAGE_LINES][COLS*2];

src/brogue/Monsters.c

@@ -851,7 +851,7 @@ creature *spawnHorde(short hordeID, pos loc, unsigned long forbiddenFlags, unsig
 
     if (theHorde->machine > 0) {
         // Build the accompanying machine (e.g. a goblin encampment)
-        buildAMachine(theHorde->machine, loc.x, loc.y, 0, NULL, NULL, NULL);
+        buildAMachine(theHorde->machine, loc.x, loc.y, 0);
     }
 
     leader = generateMonster(theHorde->leaderType, true, true);

src/brogue/Rogue.h

@@ -1392,6 +1392,15 @@ typedef struct keyLocationProfile {
     boolean disposableHere;
 } keyLocationProfile;
 
+typedef struct machineInfo {
+    int type;
+    int level;
+    int id;
+    // Child machines are deleted when the parent is deleted, so should only be in the childMachineInfo chain
+    struct machineInfo *childMachineInfo;
+    struct machineInfo *nextMachineInfo;
+} machineInfo;
+
 typedef struct item {
     unsigned short category;
     short kind;
@@ -2376,7 +2385,6 @@ typedef struct gameConstants {
     const int amuletLevel;                          // level on which the amulet appears (used in signed arithmetic)
 
     const int depthAccelerator;                     // factor for how fast depth-dependent features scale compared to usual 26-level dungeon
-    const int minimumAltarLevel;                    // how deep before resurrection and commutation altars can be generated
     const int minimumLavaLevel;                     // how deep before lava can be generated
     const int minimumBrimstoneLevel;                // how deep before brimstone can be generated
     const int mutationsOccurAboveLevel;                // how deep before monster mutations can be generated
@@ -2901,11 +2909,10 @@ extern "C" {
     void analyzeMap(boolean calculateChokeMap);
     boolean buildAMachine(enum machineTypes bp,
                           short originX, short originY,
-                          unsigned long requiredMachineFlags,
-                          item *adoptiveItem,
-                          item *parentSpawnedItems[MACHINES_BUFFER_LENGTH],
-                          creature *parentSpawnedMonsters[MACHINES_BUFFER_LENGTH]);
+                          unsigned long requiredMachineFlags);
     void attachRooms(short **grid, const dungeonProfile *theDP, short attempts, short maxRoomCount);
+    machineInfo *createMachineInfo(int level, int id, int type);
+    void deleteAllMachineInfo(machineInfo *theChain);
     void digDungeon(void);
     void updateMapToShore(void);
     short levelIsDisconnectedWithBlockingMap(char blockingMap[DCOLS][DROWS], boolean countRegionSize);
@@ -3496,7 +3503,7 @@ extern "C" {
     int quitImmediately(void);
     void dialogAlert(char *message);
     void mainBrogueJunction(void);
-    int printSeedCatalog(uint64_t startingSeed, uint64_t numberOfSeedsToScan, unsigned int scanThroughDepth, boolean isCsvFormat, char *errorMessage);
+    int printSeedCatalog(uint64_t startingSeed, uint64_t numberOfSeedsToScan, unsigned int scanThroughDepth, boolean isCsvFormat, boolean includeVaults, char *errorMessage);
 
     void initializeButton(brogueButton *button);
     void drawButtonsInState(buttonState *state, screenDisplayBuffer *button_dbuf);
@@ -3519,6 +3526,10 @@ extern "C" {
                           rogueEvent *returnEvent);
 
     void dijkstraScan(short **distanceMap, short **costMap, boolean useDiagonals);
+    void deleteAllMachineInfo(machineInfo *theChain);
+    void addMachineInfoAndChainToChain(machineInfo *theInfo, machineInfo *theChain);
+    void addMachineInfoToChain(machineInfo *theInfo, machineInfo *theChain);
+    machineInfo *reverseAllMachineInfo(machineInfo *reverseList);
 
 #if defined __cplusplus
 }

src/brogue/RogueMain.c

@@ -331,6 +331,8 @@ void initializeRogue(uint64_t seed) {
     memset(monsterItemsHopper, '\0', sizeof(item));
     monsterItemsHopper->nextItem = NULL;
 
+    allMachineInfo = createMachineInfo(0, 0, 0);
+
     for (i = 0; i < MAX_ITEMS_IN_MONSTER_ITEMS_HOPPER; i++) {
         theItem = generateItem(ALL_ITEMS & ~FOOD, -1); // Monsters can't carry food: the food clock cannot be cheated!
         theItem->nextItem = monsterItemsHopper->nextItem;
@@ -687,6 +689,9 @@ void startLevel(short oldLevelNumber, short stairDirection) {
 
         levels[rogue.depthLevel-1].items = NULL;
 
+        // Initialize a chain for the level only
+        levelMachineInfo = createMachineInfo(0, 0, 0);
+
         pos upStairLocation;
         int failsafe;
         for (failsafe = 50; failsafe; failsafe--) {
@@ -730,6 +735,15 @@ void startLevel(short oldLevelNumber, short stairDirection) {
             }
         }
 
+        machineInfo *firstRealNode = levelMachineInfo->nextMachineInfo;
+        levelMachineInfo->nextMachineInfo = NULL;
+        free(levelMachineInfo);
+
+        if (firstRealNode != NULL) {
+            machineInfo *reversed = reverseAllMachineInfo(firstRealNode);
+            addMachineInfoAndChainToChain(reversed, allMachineInfo);
+        }
+
         // re-seed the RNG
         seedRandomGenerator(oldSeed);
 
@@ -863,7 +877,7 @@ void startLevel(short oldLevelNumber, short stairDirection) {
     if (itemAtLoc(player.loc)) {
         item *theItem = itemAtLoc(player.loc);
         char msg[COLS * 3], itemDescription[COLS * 3] = "";
-        
+
         // the message pane wraps so we don't need to limit the description
         describedItemName(theItem, itemDescription, COLS * 3);
         sprintf(msg, "Below you lies %s.", itemDescription);
@@ -955,7 +969,7 @@ static void removeDeadMonstersFromList(creatureList *list) {
             removeCreature(list, decedent);
             if (decedent->leader == &player
                 && !(decedent->bookkeepingFlags & MB_DOES_NOT_RESURRECT)
-                && (!(decedent->info.flags & MONST_INANIMATE) 
+                && (!(decedent->info.flags & MONST_INANIMATE)
                     || (monsterCatalog[decedent->info.monsterID].abilityFlags & MA_ENTER_SUMMONS))
                 && (decedent->bookkeepingFlags & MB_WEAPON_AUTO_ID)
                 && !(decedent->bookkeepingFlags & MB_ADMINISTRATIVE_DEATH)) {
@@ -1027,6 +1041,8 @@ void freeEverything() {
         freeGrid(rogue.wpDistance[i]);
     }
 
+    deleteAllMachineInfo(allMachineInfo);
+
     deleteAllFlares();
     if (rogue.flares) {
         free(rogue.flares);
@@ -1218,7 +1234,7 @@ void victory(boolean superVictory) {
     unsigned long totalValue = 0;
     rogueHighScoresEntry theEntry;
     boolean qualified, isPlayback;
-    
+
     char recordingFilename[BROGUE_FILENAME_MAX] = {0};
 
     rogue.gameInProgress = false;