Annotation of brogue-ce/src/brogue/Architect.c, Revision 1.1.1.1
1.1 rubenllo 1: /*
2: * Architect.c
3: * Brogue
4: *
5: * Created by Brian Walker on 1/10/09.
6: * Copyright 2012. All rights reserved.
7: *
8: * This file is part of Brogue.
9: *
10: * This program is free software: you can redistribute it and/or modify
11: * it under the terms of the GNU Affero General Public License as
12: * published by the Free Software Foundation, either version 3 of the
13: * License, or (at your option) any later version.
14: *
15: * This program is distributed in the hope that it will be useful,
16: * but WITHOUT ANY WARRANTY; without even the implied warranty of
17: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18: * GNU Affero General Public License for more details.
19: *
20: * You should have received a copy of the GNU Affero General Public License
21: * along with this program. If not, see <http://www.gnu.org/licenses/>.
22: */
23:
24: #include "Rogue.h"
25: #include "IncludeGlobals.h"
26:
27: short topBlobMinX, topBlobMinY, blobWidth, blobHeight;
28:
29: #ifdef BROGUE_ASSERTS // otherwise handled as a macro in rogue.h
30: boolean cellHasTerrainFlag(short x, short y, unsigned long flagMask) {
31: assert(coordinatesAreInMap(x, y));
32: return ((flagMask) & terrainFlags((x), (y)) ? true : false);
33: }
34: #endif
35:
36: boolean checkLoopiness(short x, short y) {
37: boolean inString;
38: short newX, newY, dir, sdir;
39: short numStrings, maxStringLength, currentStringLength;
40:
41: if (!(pmap[x][y].flags & IN_LOOP)) {
42: return false;
43: }
44:
45: // find an unloopy neighbor to start on
46: for (sdir = 0; sdir < DIRECTION_COUNT; sdir++) {
47: newX = x + cDirs[sdir][0];
48: newY = y + cDirs[sdir][1];
49: if (!coordinatesAreInMap(newX, newY)
50: || !(pmap[newX][newY].flags & IN_LOOP)) {
51: break;
52: }
53: }
54: if (sdir == 8) { // no unloopy neighbors
55: return false; // leave cell loopy
56: }
57:
58: // starting on this unloopy neighbor, work clockwise and count up (a) the number of strings
59: // of loopy neighbors, and (b) the length of the longest such string.
60: numStrings = maxStringLength = currentStringLength = 0;
61: inString = false;
62: for (dir = sdir; dir < sdir + 8; dir++) {
63: newX = x + cDirs[dir % 8][0];
64: newY = y + cDirs[dir % 8][1];
65: if (coordinatesAreInMap(newX, newY) && (pmap[newX][newY].flags & IN_LOOP)) {
66: currentStringLength++;
67: if (!inString) {
68: if (numStrings > 0) {
69: return false; // more than one string here; leave loopy
70: }
71: numStrings++;
72: inString = true;
73: }
74: } else if (inString) {
75: if (currentStringLength > maxStringLength) {
76: maxStringLength = currentStringLength;
77: }
78: currentStringLength = 0;
79: inString = false;
80: }
81: }
82: if (inString && currentStringLength > maxStringLength) {
83: maxStringLength = currentStringLength;
84: }
85: if (numStrings == 1 && maxStringLength <= 4) {
86: pmap[x][y].flags &= ~IN_LOOP;
87:
88: for (dir = 0; dir < DIRECTION_COUNT; dir++) {
89: newX = x + cDirs[dir][0];
90: newY = y + cDirs[dir][1];
91: if (coordinatesAreInMap(newX, newY)) {
92: checkLoopiness(newX, newY);
93: }
94: }
95: return true;
96: } else {
97: return false;
98: }
99: }
100:
101: void auditLoop(short x, short y, char grid[DCOLS][DROWS]) {
102: short dir, newX, newY;
103: if (coordinatesAreInMap(x, y)
104: && !grid[x][y]
105: && !(pmap[x][y].flags & IN_LOOP)) {
106:
107: grid[x][y] = true;
108: for (dir = 0; dir < DIRECTION_COUNT; dir++) {
109: newX = x + nbDirs[dir][0];
110: newY = y + nbDirs[dir][1];
111: if (coordinatesAreInMap(newX, newY)) {
112: auditLoop(newX, newY, grid);
113: }
114: }
115: }
116: }
117:
118: // Assumes it is called with respect to a passable (startX, startY), and that the same is not already included in results.
119: // Returns 10000 if the area included an area machine.
120: short floodFillCount(char results[DCOLS][DROWS], char passMap[DCOLS][DROWS], short startX, short startY) {
121: short dir, newX, newY, count;
122:
123: count = (passMap[startX][startY] == 2 ? 5000 : 1);
124:
125: if (pmap[startX][startY].flags & IS_IN_AREA_MACHINE) {
126: count = 10000;
127: }
128:
129: results[startX][startY] = true;
130:
131: for(dir=0; dir<4; dir++) {
132: newX = startX + nbDirs[dir][0];
133: newY = startY + nbDirs[dir][1];
134: if (coordinatesAreInMap(newX, newY)
135: && passMap[newX][newY]
136: && !results[newX][newY]) {
137:
138: count += floodFillCount(results, passMap, newX, newY);
139: }
140: }
141: return min(count, 10000);
142: }
143:
144: // Rotates around the cell, counting up the number of distinct strings of passable neighbors in a single revolution.
145: // Zero means there are no impassable tiles adjacent.
146: // One means it is adjacent to a wall.
147: // Two means it is in a hallway or something similar.
148: // Three means it is the center of a T-intersection or something similar.
149: // Four means it is in the intersection of two hallways.
150: // Five or more means there is a bug.
151: short passableArcCount(short x, short y) {
152: short arcCount, dir, oldX, oldY, newX, newY;
153:
154: brogueAssert(coordinatesAreInMap(x, y));
155:
156: arcCount = 0;
157: for (dir = 0; dir < DIRECTION_COUNT; dir++) {
158: oldX = x + cDirs[(dir + 7) % 8][0];
159: oldY = y + cDirs[(dir + 7) % 8][1];
160: newX = x + cDirs[dir][0];
161: newY = y + cDirs[dir][1];
162: // Counts every transition from passable to impassable or vice-versa on the way around the cell:
163: if ((coordinatesAreInMap(newX, newY) && cellIsPassableOrDoor(newX, newY))
164: != (coordinatesAreInMap(oldX, oldY) && cellIsPassableOrDoor(oldX, oldY))) {
165: arcCount++;
166: }
167: }
168: return arcCount / 2; // Since we added one when we entered a wall and another when we left.
169: }
170:
171: // locates all loops and chokepoints
172: void analyzeMap(boolean calculateChokeMap) {
173: short i, j, i2, j2, dir, newX, newY, oldX, oldY, passableArcCount, cellCount;
174: char grid[DCOLS][DROWS], passMap[DCOLS][DROWS];
175: boolean designationSurvives;
176:
177: // first find all of the loops
178: rogue.staleLoopMap = false;
179:
180: for(i=0; i<DCOLS; i++) {
181: for(j=0; j<DROWS; j++) {
182: if (cellHasTerrainFlag(i, j, T_PATHING_BLOCKER)
183: && !cellHasTMFlag(i, j, TM_IS_SECRET)) {
184:
185: pmap[i][j].flags &= ~IN_LOOP;
186: passMap[i][j] = false;
187: } else {
188: pmap[i][j].flags |= IN_LOOP;
189: passMap[i][j] = true;
190: }
191: }
192: }
193:
194: for(i=0; i<DCOLS; i++) {
195: for(j=0; j<DROWS; j++) {
196: checkLoopiness(i, j);
197: }
198: }
199:
200: // remove extraneous loop markings
201: zeroOutGrid(grid);
202: auditLoop(0, 0, grid);
203:
204: for(i=0; i<DCOLS; i++) {
205: for(j=0; j<DROWS; j++) {
206: if (pmap[i][j].flags & IN_LOOP) {
207: designationSurvives = false;
208: for (dir = 0; dir < DIRECTION_COUNT; dir++) {
209: newX = i + nbDirs[dir][0];
210: newY = j + nbDirs[dir][1];
211: if (coordinatesAreInMap(newX, newY)
212: && !grid[newX][newY]
213: && !(pmap[newX][newY].flags & IN_LOOP)) {
214: designationSurvives = true;
215: break;
216: }
217: }
218: if (!designationSurvives) {
219: grid[i][j] = true;
220: pmap[i][j].flags &= ~IN_LOOP;
221: }
222: }
223: }
224: }
225:
226: // done finding loops; now flag chokepoints
227: for(i=1; i<DCOLS-1; i++) {
228: for(j=1; j<DROWS-1; j++) {
229: pmap[i][j].flags &= ~IS_CHOKEPOINT;
230: if (passMap[i][j] && !(pmap[i][j].flags & IN_LOOP)) {
231: passableArcCount = 0;
232: for (dir = 0; dir < DIRECTION_COUNT; dir++) {
233: oldX = i + cDirs[(dir + 7) % 8][0];
234: oldY = j + cDirs[(dir + 7) % 8][1];
235: newX = i + cDirs[dir][0];
236: newY = j + cDirs[dir][1];
237: if ((coordinatesAreInMap(newX, newY) && passMap[newX][newY])
238: != (coordinatesAreInMap(oldX, oldY) && passMap[oldX][oldY])) {
239: if (++passableArcCount > 2) {
240: if (!passMap[i-1][j] && !passMap[i+1][j] || !passMap[i][j-1] && !passMap[i][j+1]) {
241: pmap[i][j].flags |= IS_CHOKEPOINT;
242: }
243: break;
244: }
245: }
246: }
247: }
248: }
249: }
250:
251: if (calculateChokeMap) {
252:
253: // Done finding chokepoints; now create a chokepoint map.
254:
255: // The chokepoint map is a number for each passable tile. If the tile is a chokepoint,
256: // then the number indicates the number of tiles that would be rendered unreachable if the
257: // chokepoint were blocked. If the tile is not a chokepoint, then the number indicates
258: // the number of tiles that would be rendered unreachable if the nearest exit chokepoint
259: // were blocked.
260: // The cost of all of this is one depth-first flood-fill per open point that is adjacent to a chokepoint.
261:
262: // Start by setting the chokepoint values really high, and roping off room machines.
263: for(i=0; i<DCOLS; i++) {
264: for(j=0; j<DROWS; j++) {
265: chokeMap[i][j] = 30000;
266: if (pmap[i][j].flags & IS_IN_ROOM_MACHINE) {
267: passMap[i][j] = false;
268: }
269: }
270: }
271:
272: // Scan through and find a chokepoint next to an open point.
273:
274: for(i=0; i<DCOLS; i++) {
275: for(j=0; j<DROWS; j++) {
276: if (passMap[i][j] && (pmap[i][j].flags & IS_CHOKEPOINT)) {
277: for (dir=0; dir<4; dir++) {
278: newX = i + nbDirs[dir][0];
279: newY = j + nbDirs[dir][1];
280: if (coordinatesAreInMap(newX, newY)
281: && passMap[newX][newY]
282: && !(pmap[newX][newY].flags & IS_CHOKEPOINT)) {
283: // OK, (newX, newY) is an open point and (i, j) is a chokepoint.
284: // Pretend (i, j) is blocked by changing passMap, and run a flood-fill cell count starting on (newX, newY).
285: // Keep track of the flooded region in grid[][].
286: zeroOutGrid(grid);
287: passMap[i][j] = false;
288: cellCount = floodFillCount(grid, passMap, newX, newY);
289: passMap[i][j] = true;
290:
291: // CellCount is the size of the region that would be obstructed if the chokepoint were blocked.
292: // CellCounts less than 4 are not useful, so we skip those cases.
293:
294: if (cellCount >= 4) {
295: // Now, on the chokemap, all of those flooded cells should take the lesser of their current value or this resultant number.
296: for(i2=0; i2<DCOLS; i2++) {
297: for(j2=0; j2<DROWS; j2++) {
298: if (grid[i2][j2] && cellCount < chokeMap[i2][j2]) {
299: chokeMap[i2][j2] = cellCount;
300: pmap[i2][j2].flags &= ~IS_GATE_SITE;
301: }
302: }
303: }
304:
305: // The chokepoint itself should also take the lesser of its current value or the flood count.
306: if (cellCount < chokeMap[i][j]) {
307: chokeMap[i][j] = cellCount;
308: pmap[i][j].flags |= IS_GATE_SITE;
309: }
310: }
311: }
312: }
313: }
314: }
315: }
316: }
317: }
318:
319: // Add some loops to the otherwise simply connected network of rooms.
320: void addLoops(short **grid, short minimumPathingDistance) {
321: short newX, newY, oppX, oppY;
322: short **pathMap, **costMap;
323: short i, d, x, y, sCoord[DCOLS*DROWS];
324: const short dirCoords[2][2] = {{1, 0}, {0, 1}};
325:
326: fillSequentialList(sCoord, DCOLS*DROWS);
327: shuffleList(sCoord, DCOLS*DROWS);
328:
329: if (D_INSPECT_LEVELGEN) {
330: colorOverDungeon(&darkGray);
331: hiliteGrid(grid, &white, 100);
332: }
333:
334: pathMap = allocGrid();
335: costMap = allocGrid();
336: copyGrid(costMap, grid);
337: findReplaceGrid(costMap, 0, 0, PDS_OBSTRUCTION);
338: findReplaceGrid(costMap, 1, 30000, 1);
339:
340: for (i = 0; i < DCOLS*DROWS; i++) {
341: x = sCoord[i]/DROWS;
342: y = sCoord[i] % DROWS;
343: if (!grid[x][y]) {
344: for (d=0; d <= 1; d++) { // Try a horizontal door, and then a vertical door.
345: newX = x + dirCoords[d][0];
346: oppX = x - dirCoords[d][0];
347: newY = y + dirCoords[d][1];
348: oppY = y - dirCoords[d][1];
349: if (coordinatesAreInMap(newX, newY)
350: && coordinatesAreInMap(oppX, oppY)
351: && grid[newX][newY] > 0
352: && grid[oppX][oppY] > 0) { // If the tile being inspected has floor on both sides,
353:
354: fillGrid(pathMap, 30000);
355: pathMap[newX][newY] = 0;
356: dijkstraScan(pathMap, costMap, false);
357: if (pathMap[oppX][oppY] > minimumPathingDistance) { // and if the pathing distance between the two flanking floor tiles exceeds minimumPathingDistance,
358: grid[x][y] = 2; // then turn the tile into a doorway.
359: costMap[x][y] = 1; // (Cost map also needs updating.)
360: if (D_INSPECT_LEVELGEN) {
361: plotCharWithColor(G_CLOSED_DOOR, mapToWindowX(x), mapToWindowY(y), &black, &green);
362: }
363: break;
364: }
365: }
366: }
367: }
368: }
369: if (D_INSPECT_LEVELGEN) {
370: temporaryMessage("Added secondary connections:", true);
371: }
372: freeGrid(pathMap);
373: freeGrid(costMap);
374: }
375:
376: // Assumes (startX, startY) is in the machine.
377: // Returns true if everything went well, and false if we ran into a machine component
378: // that was already there, as we don't want to build a machine around it.
379: boolean addTileToMachineInteriorAndIterate(char interior[DCOLS][DROWS], short startX, short startY) {
380: short dir, newX, newY;
381: boolean goodSoFar = true;
382:
383: interior[startX][startY] = true;
384:
385: for (dir = 0; dir < 4 && goodSoFar; dir++) {
386: newX = startX + nbDirs[dir][0];
387: newY = startY + nbDirs[dir][1];
388: if (coordinatesAreInMap(newX, newY)) {
389: if ((pmap[newX][newY].flags & HAS_ITEM)
390: || ((pmap[newX][newY].flags & IS_IN_MACHINE) && !(pmap[newX][newY].flags & IS_GATE_SITE))) {
391: // Abort if there's an item in the room.
392: // Items haven't been populated yet, so the only way this could happen is if another machine
393: // previously placed an item here.
394: // Also abort if we're touching another machine at any point other than a gate tile.
395: return false;
396: }
397: if (!interior[newX][newY]
398: && chokeMap[newX][newY] <= chokeMap[startX][startY] // don't have to worry about walls since they're all 30000
399: && !(pmap[newX][newY].flags & IS_IN_MACHINE)) {
400: //goodSoFar = goodSoFar && addTileToMachineInteriorAndIterate(interior, newX, newY);
401: if (goodSoFar) {
402: goodSoFar = addTileToMachineInteriorAndIterate(interior, newX, newY);
403: }
404: }
405: }
406: }
407: return goodSoFar;
408: }
409:
410: void copyMap(pcell from[DCOLS][DROWS], pcell to[DCOLS][DROWS]) {
411: short i, j;
412:
413: for(i=0; i<DCOLS; i++) {
414: for(j=0; j<DROWS; j++) {
415: to[i][j] = from[i][j];
416: }
417: }
418: }
419:
420: boolean itemIsADuplicate(item *theItem, item **spawnedItems, short itemCount) {
421: short i;
422: if (theItem->category & (STAFF | WAND | POTION | SCROLL | RING | WEAPON | ARMOR | CHARM)) {
423: for (i = 0; i < itemCount; i++) {
424: if (spawnedItems[i]->category == theItem->category
425: && spawnedItems[i]->kind == theItem->kind) {
426:
427: return true;
428: }
429: }
430: }
431: return false;
432: }
433:
434: boolean blueprintQualifies(short i, unsigned long requiredMachineFlags) {
435: if (blueprintCatalog[i].depthRange[0] > rogue.depthLevel
436: || blueprintCatalog[i].depthRange[1] < rogue.depthLevel
437: // Must have the required flags:
438: || (~(blueprintCatalog[i].flags) & requiredMachineFlags)
439: // May NOT have BP_ADOPT_ITEM unless that flag is required:
440: || (blueprintCatalog[i].flags & BP_ADOPT_ITEM & ~requiredMachineFlags)
441: // May NOT have BP_VESTIBULE unless that flag is required:
442: || (blueprintCatalog[i].flags & BP_VESTIBULE & ~requiredMachineFlags)) {
443:
444: return false;
445: }
446: return true;
447: }
448:
449: void abortItemsAndMonsters(item *spawnedItems[MACHINES_BUFFER_LENGTH], creature *spawnedMonsters[MACHINES_BUFFER_LENGTH]) {
450: short i, j;
451:
452: for (i=0; i<MACHINES_BUFFER_LENGTH && spawnedItems[i]; i++) {
453: removeItemFromChain(spawnedItems[i], floorItems);
454: removeItemFromChain(spawnedItems[i], packItems); // just in case; can't imagine why this would arise.
455: for (j=0; j<MACHINES_BUFFER_LENGTH && spawnedMonsters[j]; j++) {
456: // Remove the item from spawned monsters, so it doesn't get double-freed when the creature is killed below.
457: if (spawnedMonsters[j]->carriedItem == spawnedItems[i]) {
458: spawnedMonsters[j]->carriedItem = NULL;
459: break;
460: }
461: }
462: deleteItem(spawnedItems[i]);
463: spawnedItems[i] = NULL;
464: }
465: for (i=0; i<MACHINES_BUFFER_LENGTH && spawnedMonsters[i]; i++) {
466: killCreature(spawnedMonsters[i], true);
467: spawnedMonsters[i] = NULL;
468: }
469: }
470:
471: boolean cellIsFeatureCandidate(short x, short y,
472: short originX, short originY,
473: short distanceBound[2],
474: char interior[DCOLS][DROWS],
475: char occupied[DCOLS][DROWS],
476: char viewMap[DCOLS][DROWS],
477: short **distanceMap,
478: short machineNumber,
479: unsigned long featureFlags,
480: unsigned long bpFlags) {
481: short newX, newY, dir, distance;
482:
483: // No building in the hallway if it's prohibited.
484: // This check comes before the origin check, so an area machine will fail altogether
485: // if its origin is in a hallway and the feature that must be built there does not permit as much.
486: if ((featureFlags & MF_NOT_IN_HALLWAY)
487: && passableArcCount(x, y) > 1) {
488: return false;
489: }
490:
491: // No building along the perimeter of the level if it's prohibited.
492: if ((featureFlags & MF_NOT_ON_LEVEL_PERIMETER)
493: && (x == 0 || x == DCOLS - 1 || y == 0 || y == DROWS - 1)) {
494: return false;
495: }
496:
497: // The origin is a candidate if the feature is flagged to be built at the origin.
498: // If it's a room, the origin (i.e. doorway) is otherwise NOT a candidate.
499: if (featureFlags & MF_BUILD_AT_ORIGIN) {
500: return ((x == originX && y == originY) ? true : false);
501: } else if ((bpFlags & BP_ROOM) && x == originX && y == originY) {
502: return false;
503: }
504:
505: // No building in another feature's personal space!
506: if (occupied[x][y]) {
507: return false;
508: }
509:
510: // Must be in the viewmap if the appropriate flag is set.
511: if ((featureFlags & (MF_IN_VIEW_OF_ORIGIN | MF_IN_PASSABLE_VIEW_OF_ORIGIN))
512: && !viewMap[x][y]) {
513: return false;
514: }
515:
516: // Do a distance check if the feature requests it.
517: if (cellHasTerrainFlag(x, y, T_OBSTRUCTS_PASSABILITY)) { // Distance is calculated for walls too.
518: distance = 10000;
519: for (dir = 0; dir < 4; dir++) {
520: newX = x + nbDirs[dir][0];
521: newY = y + nbDirs[dir][1];
522: if (coordinatesAreInMap(newX, newY)
523: && !cellHasTerrainFlag(newX, newY, T_OBSTRUCTS_PASSABILITY)
524: && distance > distanceMap[newX][newY] + 1) {
525:
526: distance = distanceMap[newX][newY] + 1;
527: }
528: }
529: } else {
530: distance = distanceMap[x][y];
531: }
532:
533: if (distance > distanceBound[1] // distance exceeds max
534: || distance < distanceBound[0]) { // distance falls short of min
535: return false;
536: }
537: if (featureFlags & MF_BUILD_IN_WALLS) { // If we're supposed to build in a wall...
538: if (!interior[x][y]
539: && (pmap[x][y].machineNumber == 0 || pmap[x][y].machineNumber == machineNumber)
540: && cellHasTerrainFlag(x, y, T_OBSTRUCTS_PASSABILITY)) { // ...and this location is a wall that's not already machined...
541: for (dir=0; dir<4; dir++) {
542: newX = x + nbDirs[dir][0];
543: newY = y + nbDirs[dir][1];
544: if (coordinatesAreInMap(newX, newY) // ...and it's next to an interior spot or permitted elsewhere and next to passable spot...
545: && ((interior[newX][newY] && !(newX==originX && newY==originY))
546: || ((featureFlags & MF_BUILD_ANYWHERE_ON_LEVEL)
547: && !cellHasTerrainFlag(newX, newY, T_PATHING_BLOCKER)
548: && pmap[newX][newY].machineNumber == 0))) {
549: return true; // ...then we're golden!
550: }
551: }
552: }
553: return false; // Otherwise, no can do.
554: } else if (cellHasTerrainFlag(x, y, T_OBSTRUCTS_PASSABILITY)) { // Can't build in a wall unless instructed to do so.
555: return false;
556: } else if (featureFlags & MF_BUILD_ANYWHERE_ON_LEVEL) {
557: if ((featureFlags & MF_GENERATE_ITEM)
558: && (cellHasTerrainFlag(x, y, T_OBSTRUCTS_ITEMS | T_PATHING_BLOCKER) || (pmap[x][y].flags & (IS_CHOKEPOINT | IN_LOOP | IS_IN_MACHINE)))) {
559: return false;
560: } else {
561: return !(pmap[x][y].flags & IS_IN_MACHINE);
562: }
563: } else if (interior[x][y]) {
564: return true;
565: }
566: return false;
567: }
568:
569:
570: void addLocationToKey(item *theItem, short x, short y, boolean disposableHere) {
571: short i;
572:
573: for (i=0; i < KEY_ID_MAXIMUM && (theItem->keyLoc[i].x || theItem->keyLoc[i].machine); i++);
574: theItem->keyLoc[i].x = x;
575: theItem->keyLoc[i].y = y;
576: theItem->keyLoc[i].disposableHere = disposableHere;
577: }
578:
579: void addMachineNumberToKey(item *theItem, short machineNumber, boolean disposableHere) {
580: short i;
581:
582: for (i=0; i < KEY_ID_MAXIMUM && (theItem->keyLoc[i].x || theItem->keyLoc[i].machine); i++);
583: theItem->keyLoc[i].machine = machineNumber;
584: theItem->keyLoc[i].disposableHere = disposableHere;
585: }
586:
587: void expandMachineInterior(char interior[DCOLS][DROWS], short minimumInteriorNeighbors) {
588: boolean madeChange;
589: short nbcount, newX, newY, i, j, layer;
590: enum directions dir;
591:
592: do {
593: madeChange = false;
594: for(i=1; i<DCOLS-1; i++) {
595: for(j=1; j < DROWS-1; j++) {
596: if (cellHasTerrainFlag(i, j, T_PATHING_BLOCKER)
597: && pmap[i][j].machineNumber == 0) {
598:
599: // Count up the number of interior open neighbors out of eight:
600: for (nbcount = dir = 0; dir < DIRECTION_COUNT; dir++) {
601: newX = i + nbDirs[dir][0];
602: newY = j + nbDirs[dir][1];
603: if (interior[newX][newY]
604: && !cellHasTerrainFlag(newX, newY, T_PATHING_BLOCKER)) {
605: nbcount++;
606: }
607: }
608: if (nbcount >= minimumInteriorNeighbors) {
609: // Make sure zero exterior open/machine neighbors out of eight:
610: for (nbcount = dir = 0; dir < DIRECTION_COUNT; dir++) {
611: newX = i + nbDirs[dir][0];
612: newY = j + nbDirs[dir][1];
613: if (!interior[newX][newY]
614: && (!cellHasTerrainFlag(newX, newY, T_OBSTRUCTS_PASSABILITY) || pmap[newX][newY].machineNumber != 0)) {
615: nbcount++;
616: break;
617: }
618: }
619: if (!nbcount) {
620: // Eliminate this obstruction; welcome its location into the machine.
621: madeChange = true;
622: interior[i][j] = true;
623: for (layer = 0; layer < NUMBER_TERRAIN_LAYERS; layer++) {
624: if (tileCatalog[pmap[i][j].layers[layer]].flags & T_PATHING_BLOCKER) {
625: pmap[i][j].layers[layer] = (layer == DUNGEON ? FLOOR : NOTHING);
626: }
627: }
628: for (dir = 0; dir < DIRECTION_COUNT; dir++) {
629: newX = i + nbDirs[dir][0];
630: newY = j + nbDirs[dir][1];
631: if (pmap[newX][newY].layers[DUNGEON] == GRANITE) {
632: pmap[newX][newY].layers[DUNGEON] = WALL;
633: }
634: }
635: }
636: }
637: } else if (pmap[i][j].layers[DUNGEON] == DOOR
638: || pmap[i][j].layers[DUNGEON] == SECRET_DOOR) {
639: pmap[i][j].layers[DUNGEON] = FLOOR;
640: }
641: }
642: }
643: } while (madeChange);
644: }
645:
646: boolean fillInteriorForVestibuleMachine(char interior[DCOLS][DROWS], short bp, short originX, short originY) {
647: short **distanceMap, **costMap, qualifyingTileCount, totalFreq, sRows[DROWS], sCols[DCOLS], i, j, k;
648: boolean success = true;
649:
650: zeroOutGrid(interior);
651:
652: distanceMap = allocGrid();
653: fillGrid(distanceMap, 30000);
654: distanceMap[originX][originY] = 0;
655:
656: costMap = allocGrid();
657: populateGenericCostMap(costMap);
658: for(i=0; i<DCOLS; i++) {
659: for(j=0; j<DROWS; j++) {
660: if (costMap[i][j] == 1 && (pmap[i][j].flags & IS_IN_MACHINE)) { //pmap[i][j].machineNumber) {
661: costMap[i][j] = PDS_FORBIDDEN;
662: }
663: }
664: }
665: costMap[originX][originY] = 1;
666: dijkstraScan(distanceMap, costMap, false);
667: freeGrid(costMap);
668:
669: qualifyingTileCount = 0; // Keeps track of how many interior cells we've added.
670: totalFreq = rand_range(blueprintCatalog[bp].roomSize[0], blueprintCatalog[bp].roomSize[1]); // Keeps track of the goal size.
671:
672: fillSequentialList(sCols, DCOLS);
673: shuffleList(sCols, DCOLS);
674: fillSequentialList(sRows, DROWS);
675: shuffleList(sRows, DROWS);
676:
677: for (k=0; k<1000 && qualifyingTileCount < totalFreq; k++) {
678: for(i=0; i<DCOLS && qualifyingTileCount < totalFreq; i++) {
679: for(j=0; j<DROWS && qualifyingTileCount < totalFreq; j++) {
680: if (distanceMap[sCols[i]][sRows[j]] == k) {
681: interior[sCols[i]][sRows[j]] = true;
682: qualifyingTileCount++;
683:
684: if (pmap[sCols[i]][sRows[j]].flags & HAS_ITEM) {
685: // Abort if we've engulfed another machine's item.
686: success = false;
687: qualifyingTileCount = totalFreq; // This is a hack to drop out of these three for-loops.
688: }
689: }
690: }
691: }
692: }
693:
694: // Now make sure the interior map satisfies the machine's qualifications.
695: if ((blueprintCatalog[bp].flags & BP_TREAT_AS_BLOCKING)
696: && levelIsDisconnectedWithBlockingMap(interior, false)) {
697: success = false;
698: } else if ((blueprintCatalog[bp].flags & BP_REQUIRE_BLOCKING)
699: && levelIsDisconnectedWithBlockingMap(interior, true) < 100) {
700: success = false;
701: }
702: freeGrid(distanceMap);
703: return success;
704: }
705:
706: void redesignInterior(char interior[DCOLS][DROWS], short originX, short originY, short theProfileIndex) {
707: short i, j, n, newX, newY;
708: enum directions dir;
709: short orphanList[20][2];
710: short orphanCount = 0;
711: short **grid, **pathingGrid, **costGrid;
712: grid = allocGrid();
713:
714: for (i=0; i<DCOLS; i++) {
715: for (j=0; j<DROWS; j++) {
716: if (interior[i][j]) {
717: if (i == originX && j == originY) {
718: grid[i][j] = 1; // All rooms must grow from this space.
719: } else {
720: grid[i][j] = 0; // Other interior squares are fair game for placing rooms.
721: }
722: } else if (cellIsPassableOrDoor(i, j)) {
723: grid[i][j] = 1; // Treat existing level as already built (though shielded by a film of -1s).
724: for (dir = 0; dir < 4; dir++) {
725: newX = i + nbDirs[dir][0];
726: newY = j + nbDirs[dir][1];
727: if (coordinatesAreInMap(newX, newY)
728: && interior[newX][newY]
729: && (newX != originX || newY != originY)) {
730:
731: orphanList[orphanCount][0] = newX;
732: orphanList[orphanCount][1] = newY;
733: orphanCount++;
734: grid[i][j] = -1; // Treat the orphaned door as off limits.
735:
736: break;
737: }
738: }
739: } else {
740: grid[i][j] = -1; // Exterior spaces are off limits.
741: }
742: }
743: }
744: attachRooms(grid, &dungeonProfileCatalog[theProfileIndex], 40, 40);
745:
746: // Connect to preexisting rooms that were orphaned (mostly preexisting machine rooms).
747: if (orphanCount > 0) {
748: pathingGrid = allocGrid();
749: costGrid = allocGrid();
750: for (n = 0; n < orphanCount; n++) {
751:
752: if (D_INSPECT_MACHINES) {
753: dumpLevelToScreen();
754: copyGrid(pathingGrid, grid);
755: findReplaceGrid(pathingGrid, -1, -1, 0);
756: hiliteGrid(pathingGrid, &green, 50);
757: plotCharWithColor('X', mapToWindowX(orphanList[n][0]), mapToWindowY(orphanList[n][1]), &black, &orange);
758: temporaryMessage("Orphan detected:", true);
759: }
760:
761: for (i=0; i<DCOLS; i++) {
762: for (j=0; j<DROWS; j++) {
763: if (interior[i][j]) {
764: if (grid[i][j] > 0) {
765: pathingGrid[i][j] = 0;
766: costGrid[i][j] = 1;
767: } else {
768: pathingGrid[i][j] = 30000;
769: costGrid[i][j] = 1;
770: }
771: } else {
772: pathingGrid[i][j] = 30000;
773: costGrid[i][j] = PDS_OBSTRUCTION;
774: }
775: }
776: }
777: dijkstraScan(pathingGrid, costGrid, false);
778:
779: i = orphanList[n][0];
780: j = orphanList[n][1];
781: while (pathingGrid[i][j] > 0) {
782: for (dir = 0; dir < 4; dir++) {
783: newX = i + nbDirs[dir][0];
784: newY = j + nbDirs[dir][1];
785:
786: if (coordinatesAreInMap(newX, newY)
787: && pathingGrid[newX][newY] < pathingGrid[i][j]) {
788:
789: grid[i][j] = 1;
790: i = newX;
791: j = newY;
792: break;
793: }
794: }
795: brogueAssert(dir < 4);
796: if (D_INSPECT_MACHINES) {
797: dumpLevelToScreen();
798: displayGrid(pathingGrid);
799: plotCharWithColor('X', mapToWindowX(i), mapToWindowY(j), &black, &orange);
800: temporaryMessage("Orphan connecting:", true);
801: }
802: }
803: }
804: freeGrid(pathingGrid);
805: freeGrid(costGrid);
806: }
807:
808: addLoops(grid, 10);
809: for(i=0; i<DCOLS; i++) {
810: for(j=0; j<DROWS; j++) {
811: if (interior[i][j]) {
812: if (grid[i][j] >= 0) {
813: pmap[i][j].layers[SURFACE] = pmap[i][j].layers[GAS] = NOTHING;
814: }
815: if (grid[i][j] == 0) {
816: pmap[i][j].layers[DUNGEON] = GRANITE;
817: interior[i][j] = false;
818: }
819: if (grid[i][j] >= 1) {
820: pmap[i][j].layers[DUNGEON] = FLOOR;
821: }
822: }
823: }
824: }
825: freeGrid(grid);
826: }
827:
828: void prepareInteriorWithMachineFlags(char interior[DCOLS][DROWS], short originX, short originY, unsigned long flags, short dungeonProfileIndex) {
829: short i, j, newX, newY;
830: enum dungeonLayers layer;
831: enum directions dir;
832:
833: // If requested, clear and expand the room as far as possible until either it's convex or it bumps into surrounding rooms
834: if (flags & BP_MAXIMIZE_INTERIOR) {
835: expandMachineInterior(interior, 1);
836: } else if (flags & BP_OPEN_INTERIOR) {
837: expandMachineInterior(interior, 4);
838: }
839:
840: // If requested, cleanse the interior -- no interesting terrain allowed.
841: if (flags & BP_PURGE_INTERIOR) {
842: for(i=0; i<DCOLS; i++) {
843: for(j=0; j<DROWS; j++) {
844: if (interior[i][j]) {
845: for (layer=0; layer<NUMBER_TERRAIN_LAYERS; layer++) {
846: pmap[i][j].layers[layer] = (layer == DUNGEON ? FLOOR : NOTHING);
847: }
848: }
849: }
850: }
851: }
852:
853: // If requested, purge pathing blockers -- no traps allowed.
854: if (flags & BP_PURGE_PATHING_BLOCKERS) {
855: for(i=0; i<DCOLS; i++) {
856: for(j=0; j<DROWS; j++) {
857: if (interior[i][j]) {
858: for (layer=0; layer<NUMBER_TERRAIN_LAYERS; layer++) {
859: if (tileCatalog[pmap[i][j].layers[layer]].flags & T_PATHING_BLOCKER) {
860: pmap[i][j].layers[layer] = (layer == DUNGEON ? FLOOR : NOTHING);
861: }
862: }
863: }
864: }
865: }
866: }
867:
868: // If requested, purge the liquid layer in the interior -- no liquids allowed.
869: if (flags & BP_PURGE_LIQUIDS) {
870: for(i=0; i<DCOLS; i++) {
871: for(j=0; j<DROWS; j++) {
872: if (interior[i][j]) {
873: pmap[i][j].layers[LIQUID] = NOTHING;
874: }
875: }
876: }
877: }
878:
879: // Surround with walls if requested.
880: if (flags & BP_SURROUND_WITH_WALLS) {
881: for(i=0; i<DCOLS; i++) {
882: for(j=0; j<DROWS; j++) {
883: if (interior[i][j] && !(pmap[i][j].flags & IS_GATE_SITE)) {
884: for (dir=0; dir< DIRECTION_COUNT; dir++) {
885: newX = i + nbDirs[dir][0];
886: newY = j + nbDirs[dir][1];
887: if (coordinatesAreInMap(newX, newY)
888: && !interior[newX][newY]
889: && !cellHasTerrainFlag(newX, newY, T_OBSTRUCTS_PASSABILITY)
890: && !(pmap[newX][newY].flags & IS_GATE_SITE)
891: && !pmap[newX][newY].machineNumber
892: && cellHasTerrainFlag(newX, newY, T_PATHING_BLOCKER)) {
893: for (layer=0; layer<NUMBER_TERRAIN_LAYERS; layer++) {
894: pmap[newX][newY].layers[layer] = (layer == DUNGEON ? WALL : 0);
895: }
896: }
897: }
898: }
899: }
900: }
901: }
902:
903: // Completely clear the interior, fill with granite, and cut entirely new rooms into it from the gate site.
904: // Then zero out any portion of the interior that is still wall.
905: if (flags & BP_REDESIGN_INTERIOR) {
906: redesignInterior(interior, originX, originY, dungeonProfileIndex);
907: }
908:
909: // Reinforce surrounding tiles and interior tiles if requested to prevent tunneling in or through.
910: if (flags & BP_IMPREGNABLE) {
911: for(i=0; i<DCOLS; i++) {
912: for(j=0; j<DROWS; j++) {
913: if (interior[i][j]
914: && !(pmap[i][j].flags & IS_GATE_SITE)) {
915:
916: pmap[i][j].flags |= IMPREGNABLE;
917: for (dir=0; dir< DIRECTION_COUNT; dir++) {
918: newX = i + nbDirs[dir][0];
919: newY = j + nbDirs[dir][1];
920: if (coordinatesAreInMap(newX, newY)
921: && !interior[newX][newY]
922: && !(pmap[newX][newY].flags & IS_GATE_SITE)) {
923:
924: pmap[newX][newY].flags |= IMPREGNABLE;
925: }
926: }
927: }
928: }
929: }
930: }
931: }
932:
933: typedef struct machineData {
934: // Our boolean grids:
935: char interior[DCOLS][DROWS]; // This is the master grid for the machine. All area inside the machine are set to true.
936: char occupied[DCOLS][DROWS]; // This keeps track of what is within the personal space of a previously built feature in the same machine.
937: char candidates[DCOLS][DROWS]; // This is calculated at the start of each feature, and is true where that feature is eligible for building.
938: char blockingMap[DCOLS][DROWS]; // Used during terrain/DF placement in features that are flagged not to tolerate blocking, to see if they block.
939: char viewMap[DCOLS][DROWS]; // Used for features with MF_IN_VIEW_OF_ORIGIN, to calculate which cells are in view of the origin.
940:
941: pcell levelBackup[DCOLS][DROWS];
942:
943: item *spawnedItems[MACHINES_BUFFER_LENGTH];
944: item *spawnedItemsSub[MACHINES_BUFFER_LENGTH];
945: creature *spawnedMonsters[MACHINES_BUFFER_LENGTH];
946: creature *spawnedMonstersSub[MACHINES_BUFFER_LENGTH];
947:
948: short gateCandidates[50][2];
949: short distances[100];
950: short sRows[DROWS];
951: short sCols[DCOLS];
952: } machineData;
953:
954: // Returns true if the machine got built; false if it was aborted.
955: // If empty array parentSpawnedItems or parentSpawnedMonsters is given, will pass those back for deletion if necessary.
956: boolean buildAMachine(enum machineTypes bp,
957: short originX, short originY,
958: unsigned long requiredMachineFlags,
959: item *adoptiveItem,
960: item *parentSpawnedItems[MACHINES_BUFFER_LENGTH],
961: creature *parentSpawnedMonsters[MACHINES_BUFFER_LENGTH]) {
962:
963: short i, j, k, feat, randIndex, totalFreq, instance, instanceCount = 0,
964: featX, featY, itemCount, monsterCount, qualifyingTileCount,
965: **distanceMap = NULL, distance25, distance75, distanceBound[2],
966: personalSpace, failsafe, locationFailsafe,
967: machineNumber;
968:
969: const unsigned long alternativeFlags[2] = {MF_ALTERNATIVE, MF_ALTERNATIVE_2};
970:
971: boolean DFSucceeded, terrainSucceeded, generateEverywhere, chooseBP,
972: chooseLocation, tryAgain, success = false, skipFeature[20];
973:
974: creature *monst = NULL, *nextMonst, *torchBearer = NULL, *leader = NULL;
975:
976: item *theItem = NULL, *torch = NULL;
977:
978: const machineFeature *feature;
979:
980: machineData *p = malloc(sizeof(machineData));
981:
982: memset(p, 0, sizeof(machineData));
983:
984: chooseBP = (((signed short) bp) <= 0 ? true : false);
985:
986: chooseLocation = (originX <= 0 || originY <= 0 ? true : false);
987:
988: failsafe = 10;
989: do {
990: tryAgain = false;
991: if (--failsafe <= 0) {
992: if (distanceMap) {
993: freeGrid(distanceMap);
994: }
995: if (D_MESSAGE_MACHINE_GENERATION) {
996: if (chooseBP || chooseLocation) {
997: printf("\nDepth %i: Failed to build a machine; gave up after 10 unsuccessful attempts to find a suitable blueprint and/or location.",
998: rogue.depthLevel);
999: } else {
1000: printf("\nDepth %i: Failed to build a machine; requested blueprint and location did not work.",
1001: rogue.depthLevel);
1002: }
1003: }
1004: free(p);
1005: return false;
1006: }
1007:
1008: if (chooseBP) { // If no blueprint is given, then pick one:
1009:
1010: // First, choose the blueprint. We choose from among blueprints
1011: // that have the required blueprint flags and that satisfy the depth requirements.
1012: totalFreq = 0;
1013: for (i=1; i<NUMBER_BLUEPRINTS; i++) {
1014: if (blueprintQualifies(i, requiredMachineFlags)) {
1015: totalFreq += blueprintCatalog[i].frequency;
1016: }
1017: }
1018:
1019: if (!totalFreq) { // If no suitable blueprints are in the library, fail.
1020: if (distanceMap) {
1021: freeGrid(distanceMap);
1022: }
1023: if (D_MESSAGE_MACHINE_GENERATION) printf("\nDepth %i: Failed to build a machine because no suitable blueprints were available.",
1024: rogue.depthLevel);
1025: free(p);
1026: return false;
1027: }
1028:
1029: // Pick from among the suitable blueprints.
1030: randIndex = rand_range(1, totalFreq);
1031: for (i=1; i<NUMBER_BLUEPRINTS; i++) {
1032: if (blueprintQualifies(i, requiredMachineFlags)) {
1033: if (randIndex <= blueprintCatalog[i].frequency) {
1034: bp = i;
1035: break;
1036: } else {
1037: randIndex -= blueprintCatalog[i].frequency;
1038: }
1039: }
1040: }
1041:
1042: // If we don't have a blueprint yet, something went wrong.
1043: brogueAssert(bp>0);
1044: }
1045:
1046: // Find a location and map out the machine interior.
1047: if (blueprintCatalog[bp].flags & BP_ROOM) {
1048: // If it's a room machine, count up the gates of appropriate
1049: // choke size and remember where they are. The origin of the room will be the gate location.
1050: zeroOutGrid(p->interior);
1051:
1052: if (chooseLocation) {
1053: analyzeMap(true); // Make sure the chokeMap is up to date.
1054: totalFreq = 0;
1055: for(i=0; i<DCOLS; i++) {
1056: for(j=0; j<DROWS && totalFreq < 50; j++) {
1057: if ((pmap[i][j].flags & IS_GATE_SITE)
1058: && !(pmap[i][j].flags & IS_IN_MACHINE)
1059: && chokeMap[i][j] >= blueprintCatalog[bp].roomSize[0]
1060: && chokeMap[i][j] <= blueprintCatalog[bp].roomSize[1]) {
1061:
1062: //DEBUG printf("\nDepth %i: Gate site qualified with interior size of %i.", rogue.depthLevel, chokeMap[i][j]);
1063: p->gateCandidates[totalFreq][0] = i;
1064: p->gateCandidates[totalFreq][1] = j;
1065: totalFreq++;
1066: }
1067: }
1068: }
1069:
1070: if (totalFreq) {
1071: // Choose the gate.
1072: randIndex = rand_range(0, totalFreq - 1);
1073: originX = p->gateCandidates[randIndex][0];
1074: originY = p->gateCandidates[randIndex][1];
1075: } else {
1076: // If no suitable sites, abort.
1077: if (distanceMap) {
1078: freeGrid(distanceMap);
1079: }
1080: if (D_MESSAGE_MACHINE_GENERATION) printf("\nDepth %i: Failed to build a machine; there was no eligible door candidate for the chosen room machine from blueprint %i.",
1081: rogue.depthLevel,
1082: bp);
1083: free(p);
1084: return false;
1085: }
1086: }
1087:
1088: // Now map out the interior into interior[][].
1089: // Start at the gate location and do a depth-first floodfill to grab all adjoining tiles with the
1090: // same or lower choke value, ignoring any tiles that are already part of a machine.
1091: // If we get false from this, try again. If we've tried too many times already, abort.
1092: tryAgain = !addTileToMachineInteriorAndIterate(p->interior, originX, originY);
1093: } else if (blueprintCatalog[bp].flags & BP_VESTIBULE) {
1094: if (chooseLocation) {
1095: // Door machines must have locations passed in. We can't pick one ourselves.
1096: if (distanceMap) {
1097: freeGrid(distanceMap);
1098: }
1099: if (D_MESSAGE_MACHINE_GENERATION) printf("\nDepth %i: ERROR: Attempted to build a door machine from blueprint %i without a location being provided.",
1100: rogue.depthLevel,
1101: bp);
1102: free(p);
1103: return false;
1104: }
1105: if (!fillInteriorForVestibuleMachine(p->interior, bp, originX, originY)) {
1106: if (distanceMap) {
1107: freeGrid(distanceMap);
1108: }
1109: if (D_MESSAGE_MACHINE_GENERATION) printf("\nDepth %i: Failed to build a door machine from blueprint %i; not enough room.",
1110: rogue.depthLevel,
1111: bp);
1112: free(p);
1113: return false;
1114: }
1115: } else {
1116: // Find a location and map out the interior for a non-room machine.
1117: // The strategy here is simply to pick a random location on the map,
1118: // expand it along a pathing map by one space in all directions until the size reaches
1119: // the chosen size, and then make sure the resulting space qualifies.
1120: // If not, try again. If we've tried too many times already, abort.
1121:
1122: locationFailsafe = 10;
1123: do {
1124: zeroOutGrid(p->interior);
1125: tryAgain = false;
1126:
1127: if (chooseLocation) {
1128: // Pick a random origin location.
1129: randomMatchingLocation(&originX, &originY, FLOOR, NOTHING, -1);
1130: }
1131:
1132: if (!distanceMap) {
1133: distanceMap = allocGrid();
1134: }
1135: fillGrid(distanceMap, 0);
1136: calculateDistances(distanceMap, originX, originY, T_PATHING_BLOCKER, NULL, true, false);
1137: qualifyingTileCount = 0; // Keeps track of how many interior cells we've added.
1138: totalFreq = rand_range(blueprintCatalog[bp].roomSize[0], blueprintCatalog[bp].roomSize[1]); // Keeps track of the goal size.
1139:
1140: fillSequentialList(p->sCols, DCOLS);
1141: shuffleList(p->sCols, DCOLS);
1142: fillSequentialList(p->sRows, DROWS);
1143: shuffleList(p->sRows, DROWS);
1144:
1145: for (k=0; k<1000 && qualifyingTileCount < totalFreq; k++) {
1146: for(i=0; i<DCOLS && qualifyingTileCount < totalFreq; i++) {
1147: for(j=0; j<DROWS && qualifyingTileCount < totalFreq; j++) {
1148: if (distanceMap[p->sCols[i]][p->sRows[j]] == k) {
1149: p->interior[p->sCols[i]][p->sRows[j]] = true;
1150: qualifyingTileCount++;
1151:
1152: if (pmap[p->sCols[i]][p->sRows[j]].flags & (HAS_ITEM | HAS_MONSTER | IS_IN_MACHINE)) {
1153: // Abort if we've entered another machine or engulfed another machine's item or monster.
1154: tryAgain = true;
1155: qualifyingTileCount = totalFreq; // This is a hack to drop out of these three for-loops.
1156: }
1157: }
1158: }
1159: }
1160: }
1161:
1162: // Now make sure the interior map satisfies the machine's qualifications.
1163: if ((blueprintCatalog[bp].flags & BP_TREAT_AS_BLOCKING)
1164: && levelIsDisconnectedWithBlockingMap(p->interior, false)) {
1165: tryAgain = true;
1166: } else if ((blueprintCatalog[bp].flags & BP_REQUIRE_BLOCKING)
1167: && levelIsDisconnectedWithBlockingMap(p->interior, true) < 100) {
1168: tryAgain = true; // BP_REQUIRE_BLOCKING needs some work to make sure the disconnect is interesting.
1169: }
1170: // If locationFailsafe runs out, tryAgain will still be true, and we'll try a different machine.
1171: // If we're not choosing the blueprint, then don't bother with the locationFailsafe; just use the higher-level failsafe.
1172: } while (chooseBP && tryAgain && --locationFailsafe);
1173: }
1174:
1175: // If something went wrong, but we haven't been charged with choosing blueprint OR location,
1176: // then there is nothing to try again, so just fail.
1177: if (tryAgain && !chooseBP && !chooseLocation) {
1178: if (distanceMap) {
1179: freeGrid(distanceMap);
1180: }
1181: free(p);
1182: return false;
1183: }
1184:
1185: // Now loop if necessary.
1186: } while (tryAgain);
1187:
1188: // This is the point of no return. Back up the level so it can be restored if we have to abort this machine after this point.
1189: copyMap(pmap, p->levelBackup);
1190:
1191: // Perform any transformations to the interior indicated by the blueprint flags, including expanding the interior if requested.
1192: prepareInteriorWithMachineFlags(p->interior, originX, originY, blueprintCatalog[bp].flags, blueprintCatalog[bp].dungeonProfileType);
1193:
1194: // If necessary, label the interior as IS_IN_AREA_MACHINE or IS_IN_ROOM_MACHINE and mark down the number.
1195: machineNumber = ++rogue.machineNumber; // Reserve this machine number, starting with 1.
1196: for(i=0; i<DCOLS; i++) {
1197: for(j=0; j<DROWS; j++) {
1198: if (p->interior[i][j]) {
1199: pmap[i][j].flags |= ((blueprintCatalog[bp].flags & BP_ROOM) ? IS_IN_ROOM_MACHINE : IS_IN_AREA_MACHINE);
1200: pmap[i][j].machineNumber = machineNumber;
1201: // also clear any secret doors, since they screw up distance mapping and aren't fun inside machines
1202: if (pmap[i][j].layers[DUNGEON] == SECRET_DOOR) {
1203: pmap[i][j].layers[DUNGEON] = DOOR;
1204: }
1205: }
1206: }
1207: }
1208:
1209: // DEBUG printf("\n\nWorking on blueprint %i, with origin at (%i, %i). Here's the initial interior map:", bp, originX, originY);
1210: // DEBUG logBuffer(interior);
1211:
1212: // Calculate the distance map (so that features that want to be close to or far from the origin can be placed accordingly)
1213: // and figure out the 33rd and 67th percentiles for features that want to be near or far from the origin.
1214: if (!distanceMap) {
1215: distanceMap = allocGrid();
1216: }
1217: fillGrid(distanceMap, 0);
1218: calculateDistances(distanceMap, originX, originY, T_PATHING_BLOCKER, NULL, true, true);
1219: qualifyingTileCount = 0;
1220: for (i=0; i<100; i++) {
1221: p->distances[i] = 0;
1222: }
1223: for(i=0; i<DCOLS; i++) {
1224: for(j=0; j<DROWS; j++) {
1225: if (p->interior[i][j]
1226: && distanceMap[i][j] < 100) {
1227: p->distances[distanceMap[i][j]]++; // create a histogram of distances -- poor man's sort function
1228: qualifyingTileCount++;
1229: }
1230: }
1231: }
1232: distance25 = (int) (qualifyingTileCount / 4);
1233: distance75 = (int) (3 * qualifyingTileCount / 4);
1234: for (i=0; i<100; i++) {
1235: if (distance25 <= p->distances[i]) {
1236: distance25 = i;
1237: break;
1238: } else {
1239: distance25 -= p->distances[i];
1240: }
1241: }
1242: for (i=0; i<100; i++) {
1243: if (distance75 <= p->distances[i]) {
1244: distance75 = i;
1245: break;
1246: } else {
1247: distance75 -= p->distances[i];
1248: }
1249: }
1250: //DEBUG printf("\nDistances calculated: 33rd percentile of distance is %i, and 67th is %i.", distance25, distance75);
1251:
1252: // Now decide which features will be skipped -- of the features marked MF_ALTERNATIVE, skip all but one, chosen randomly.
1253: // Then repeat and do the same with respect to MF_ALTERNATIVE_2, to provide up to two independent sets of alternative features per machine.
1254:
1255: for (i=0; i<blueprintCatalog[bp].featureCount; i++) {
1256: skipFeature[i] = false;
1257: }
1258: for (j = 0; j <= 1; j++) {
1259: totalFreq = 0;
1260: for (i=0; i<blueprintCatalog[bp].featureCount; i++) {
1261: if (blueprintCatalog[bp].feature[i].flags & alternativeFlags[j]) {
1262: skipFeature[i] = true;
1263: totalFreq++;
1264: }
1265: }
1266: if (totalFreq > 0) {
1267: randIndex = rand_range(1, totalFreq);
1268: for (i=0; i<blueprintCatalog[bp].featureCount; i++) {
1269: if (blueprintCatalog[bp].feature[i].flags & alternativeFlags[j]) {
1270: if (randIndex == 1) {
1271: skipFeature[i] = false; // This is the alternative that gets built. The rest do not.
1272: break;
1273: } else {
1274: randIndex--;
1275: }
1276: }
1277: }
1278: }
1279: }
1280:
1281: // Keep track of all monsters and items that we spawn -- if we abort, we have to go back and delete them all.
1282: itemCount = monsterCount = 0;
1283:
1284: // Zero out occupied[][], and use it to keep track of the personal space around each feature that gets placed.
1285: zeroOutGrid(p->occupied);
1286:
1287: // Now tick through the features and build them.
1288: for (feat = 0; feat < blueprintCatalog[bp].featureCount; feat++) {
1289:
1290: if (skipFeature[feat]) {
1291: continue; // Skip the alternative features that were not selected for building.
1292: }
1293:
1294: feature = &(blueprintCatalog[bp].feature[feat]);
1295:
1296: // Figure out the distance bounds.
1297: distanceBound[0] = 0;
1298: distanceBound[1] = 10000;
1299: if (feature->flags & MF_NEAR_ORIGIN) {
1300: distanceBound[1] = distance25;
1301: }
1302: if (feature->flags & MF_FAR_FROM_ORIGIN) {
1303: distanceBound[0] = distance75;
1304: }
1305:
1306: if (feature->flags & (MF_IN_VIEW_OF_ORIGIN | MF_IN_PASSABLE_VIEW_OF_ORIGIN)) {
1307: zeroOutGrid(p->viewMap);
1308: if (feature->flags & MF_IN_PASSABLE_VIEW_OF_ORIGIN) {
1309: getFOVMask(p->viewMap, originX, originY, max(DCOLS, DROWS) * FP_FACTOR, T_PATHING_BLOCKER, 0, false);
1310: } else {
1311: getFOVMask(p->viewMap, originX, originY, max(DCOLS, DROWS) * FP_FACTOR, (T_OBSTRUCTS_PASSABILITY | T_OBSTRUCTS_VISION), 0, false);
1312: }
1313: p->viewMap[originX][originY] = true;
1314:
1315: if (D_INSPECT_MACHINES) {
1316: dumpLevelToScreen();
1317: hiliteCharGrid(p->viewMap, &omniscienceColor, 75);
1318: temporaryMessage("Showing visibility.", true);
1319: }
1320: }
1321:
1322: do { // If the MF_REPEAT_UNTIL_NO_PROGRESS flag is set, repeat until we fail to build the required number of instances.
1323:
1324: // Make a master map of candidate locations for this feature.
1325: qualifyingTileCount = 0;
1326: for(i=0; i<DCOLS; i++) {
1327: for(j=0; j<DROWS; j++) {
1328: if (cellIsFeatureCandidate(i, j,
1329: originX, originY,
1330: distanceBound,
1331: p->interior, p->occupied, p->viewMap, distanceMap,
1332: machineNumber, feature->flags, blueprintCatalog[bp].flags)) {
1333: qualifyingTileCount++;
1334: p->candidates[i][j] = true;
1335: } else {
1336: p->candidates[i][j] = false;
1337: }
1338: }
1339: }
1340:
1341: if (D_INSPECT_MACHINES) {
1342: dumpLevelToScreen();
1343: hiliteCharGrid(p->occupied, &red, 75);
1344: hiliteCharGrid(p->candidates, &green, 75);
1345: hiliteCharGrid(p->interior, &blue, 75);
1346: temporaryMessage("Indicating: Occupied (red); Candidates (green); Interior (blue).", true);
1347: }
1348:
1349: if (feature->flags & MF_EVERYWHERE & ~MF_BUILD_AT_ORIGIN) {
1350: // Generate everywhere that qualifies -- instead of randomly picking tiles, keep spawning until we run out of eligible tiles.
1351: generateEverywhere = true;
1352: } else {
1353: // build as many instances as required
1354: generateEverywhere = false;
1355: instanceCount = rand_range(feature->instanceCountRange[0], feature->instanceCountRange[1]);
1356: }
1357:
1358: // Cache the personal space constant.
1359: personalSpace = feature->personalSpace;
1360:
1361: for (instance = 0; (generateEverywhere || instance < instanceCount) && qualifyingTileCount > 0;) {
1362:
1363: // Find a location for the feature.
1364: if (feature->flags & MF_BUILD_AT_ORIGIN) {
1365: // Does the feature want to be at the origin? If so, put it there. (Just an optimization.)
1366: featX = originX;
1367: featY = originY;
1368: } else {
1369: // Pick our candidate location randomly, and also strike it from
1370: // the candidates map so that subsequent instances of this same feature can't choose it.
1371: featX = -1;
1372: featY = -1;
1373: randIndex = rand_range(1, qualifyingTileCount);
1374: for(i=0; i<DCOLS && featX < 0; i++) {
1375: for(j=0; j<DROWS && featX < 0; j++) {
1376: if (p->candidates[i][j]) {
1377: if (randIndex == 1) {
1378: // This is the place!
1379: featX = i;
1380: featY = j;
1381: i = DCOLS; // break out of the loops
1382: j = DROWS;
1383: } else {
1384: randIndex--;
1385: }
1386: }
1387: }
1388: }
1389: }
1390: // Don't waste time trying the same place again whether or not this attempt succeeds.
1391: p->candidates[featX][featY] = false;
1392: qualifyingTileCount--;
1393:
1394: DFSucceeded = terrainSucceeded = true;
1395:
1396: // Try to build the DF first, if any, since we don't want it to be disrupted by subsequently placed terrain.
1397: if (feature->featureDF) {
1398: DFSucceeded = spawnDungeonFeature(featX, featY, &dungeonFeatureCatalog[feature->featureDF], false,
1399: !(feature->flags & MF_PERMIT_BLOCKING));
1400: }
1401:
1402: // Now try to place the terrain tile, if any.
1403: if (DFSucceeded && feature->terrain) {
1404: // Must we check for blocking?
1405: if (!(feature->flags & MF_PERMIT_BLOCKING)
1406: && ((tileCatalog[feature->terrain].flags & T_PATHING_BLOCKER) || (feature->flags & MF_TREAT_AS_BLOCKING))) {
1407: // Yes, check for blocking.
1408:
1409: zeroOutGrid(p->blockingMap);
1410: p->blockingMap[featX][featY] = true;
1411: terrainSucceeded = !levelIsDisconnectedWithBlockingMap(p->blockingMap, false);
1412: }
1413: if (terrainSucceeded) {
1414: pmap[featX][featY].layers[feature->layer] = feature->terrain;
1415: }
1416: }
1417:
1418: // OK, if placement was successful, clear some personal space around the feature so subsequent features can't be generated too close.
1419: // Personal space of 0 means nothing gets cleared, 1 means that only the tile itself gets cleared, and 2 means the 3x3 grid centered on it.
1420:
1421: if (DFSucceeded && terrainSucceeded) {
1422: for (i = featX - personalSpace + 1;
1423: i <= featX + personalSpace - 1;
1424: i++) {
1425: for (j = featY - personalSpace + 1;
1426: j <= featY + personalSpace - 1;
1427: j++) {
1428: if (coordinatesAreInMap(i, j)) {
1429: if (p->candidates[i][j]) {
1430: brogueAssert(!occupied[i][j] || (i == originX && j == originY)); // Candidates[][] should never be true where occupied[][] is true.
1431: p->candidates[i][j] = false;
1432: qualifyingTileCount--;
1433: }
1434: p->occupied[i][j] = true;
1435: }
1436: }
1437: }
1438: instance++; // we've placed an instance
1439: //DEBUG printf("\nPlaced instance #%i of feature %i at (%i, %i).", instance, feat, featX, featY);
1440: }
1441:
1442: if (DFSucceeded && terrainSucceeded) { // Proceed only if the terrain stuff for this instance succeeded.
1443:
1444: theItem = NULL;
1445:
1446: // Mark the feature location as part of the machine, in case it is not already inside of it.
1447: pmap[featX][featY].flags |= ((blueprintCatalog[bp].flags & BP_ROOM) ? IS_IN_ROOM_MACHINE : IS_IN_AREA_MACHINE);
1448: pmap[featX][featY].machineNumber = machineNumber;
1449:
1450: // Mark the feature location as impregnable if requested.
1451: if (feature->flags & MF_IMPREGNABLE) {
1452: pmap[featX][featY].flags |= IMPREGNABLE;
1453: }
1454:
1455: // Generate an item as necessary.
1456: if ((feature->flags & MF_GENERATE_ITEM)
1457: || (adoptiveItem && (feature->flags & MF_ADOPT_ITEM) && (blueprintCatalog[bp].flags & BP_ADOPT_ITEM))) {
1458: // Are we adopting an item instead of generating one?
1459: if (adoptiveItem && (feature->flags & MF_ADOPT_ITEM) && (blueprintCatalog[bp].flags & BP_ADOPT_ITEM)) {
1460: theItem = adoptiveItem;
1461: adoptiveItem = NULL; // can be adopted only once
1462: } else {
1463: // Have to create an item ourselves.
1464: theItem = generateItem(feature->itemCategory, feature->itemKind);
1465: failsafe = 1000;
1466: while ((theItem->flags & ITEM_CURSED)
1467: || ((feature->flags & MF_REQUIRE_GOOD_RUNIC) && (!(theItem->flags & ITEM_RUNIC))) // runic if requested
1468: || ((feature->flags & MF_NO_THROWING_WEAPONS) && theItem->category == WEAPON && theItem->quantity > 1) // no throwing weapons if prohibited
1469: || itemIsADuplicate(theItem, p->spawnedItems, itemCount)) { // don't want to duplicates of rings, staffs, etc.
1470: deleteItem(theItem);
1471: theItem = generateItem(feature->itemCategory, feature->itemKind);
1472: if (failsafe <= 0) {
1473: break;
1474: }
1475: failsafe--;
1476: }
1477: p->spawnedItems[itemCount] = theItem; // Keep a list of generated items so that we can delete them all if construction fails.
1478: itemCount++;
1479: }
1480: theItem->flags |= feature->itemFlags;
1481:
1482: addLocationToKey(theItem, featX, featY, (feature->flags & MF_KEY_DISPOSABLE) ? true : false);
1483: theItem->originDepth = rogue.depthLevel;
1484: if (feature->flags & MF_SKELETON_KEY) {
1485: addMachineNumberToKey(theItem, machineNumber, (feature->flags & MF_KEY_DISPOSABLE) ? true : false);
1486: }
1487: if (!(feature->flags & MF_OUTSOURCE_ITEM_TO_MACHINE)
1488: && !(feature->flags & MF_MONSTER_TAKE_ITEM)) {
1489: // Place the item at the feature location.
1490: placeItem(theItem, featX, featY);
1491: }
1492: }
1493:
1494: if (feature->flags & (MF_OUTSOURCE_ITEM_TO_MACHINE | MF_BUILD_VESTIBULE)) {
1495: // Put this item up for adoption, or generate a door guard machine.
1496: // Try to create a sub-machine that qualifies.
1497: // If we fail 10 times, abort the entire machine (including any sub-machines already built).
1498: // Also, if we build a sub-machine, and it succeeds, but this (its parent machine) fails,
1499: // we pass the monsters and items that it spawned back to the parent,
1500: // so that if the parent fails, they can all be freed.
1501: for (i=10; i > 0; i--) {
1502: // First make sure our adopted item, if any, is not on the floor or in the pack already.
1503: // Otherwise, a previous attempt to place it may have put it on the floor in a different
1504: // machine, only to have that machine fail and be deleted, leaving the item remaining on
1505: // the floor where placed.
1506: if ((feature->flags & MF_OUTSOURCE_ITEM_TO_MACHINE) && theItem) {
1507: removeItemFromChain(theItem, floorItems);
1508: removeItemFromChain(theItem, packItems);
1509: theItem->nextItem = NULL;
1510: success = buildAMachine(-1, -1, -1, BP_ADOPT_ITEM, theItem, p->spawnedItemsSub, p->spawnedMonstersSub);
1511: } else if (feature->flags & MF_BUILD_VESTIBULE) {
1512: success = buildAMachine(-1, featX, featY, BP_VESTIBULE, NULL, p->spawnedItemsSub, p->spawnedMonstersSub);
1513: }
1514:
1515: // Now put the item up for adoption.
1516: if (success) {
1517: // Success! Now we have to add that machine's items and monsters to our own list, so they
1518: // all get deleted if this machine or its parent fails.
1519: for (j=0; j<MACHINES_BUFFER_LENGTH && p->spawnedItemsSub[j]; j++) {
1520: p->spawnedItems[itemCount] = p->spawnedItemsSub[j];
1521: itemCount++;
1522: p->spawnedItemsSub[j] = NULL;
1523: }
1524: for (j=0; j<MACHINES_BUFFER_LENGTH && p->spawnedMonstersSub[j]; j++) {
1525: p->spawnedMonsters[monsterCount] = p->spawnedMonstersSub[j];
1526: monsterCount++;
1527: p->spawnedMonstersSub[j] = NULL;
1528: }
1529: break;
1530: }
1531: }
1532:
1533: if (!i) {
1534: if (D_MESSAGE_MACHINE_GENERATION) printf("\nDepth %i: Failed to place blueprint %i because it requires an adoptive machine and we couldn't place one.", rogue.depthLevel, bp);
1535: // failure! abort!
1536: copyMap(p->levelBackup, pmap);
1537: abortItemsAndMonsters(p->spawnedItems, p->spawnedMonsters);
1538: freeGrid(distanceMap);
1539: free(p);
1540: return false;
1541: }
1542: theItem = NULL;
1543: }
1544:
1545: // Generate a horde as necessary.
1546: if ((feature->flags & MF_GENERATE_HORDE)
1547: || feature->monsterID) {
1548:
1549: if (feature->flags & MF_GENERATE_HORDE) {
1550: monst = spawnHorde(0,
1551: featX,
1552: featY,
1553: ((HORDE_IS_SUMMONED | HORDE_LEADER_CAPTIVE) & ~(feature->hordeFlags)),
1554: feature->hordeFlags);
1555: if (monst) {
1556: monst->bookkeepingFlags |= MB_JUST_SUMMONED;
1557: }
1558: }
1559:
1560: if (feature->monsterID) {
1561: monst = monsterAtLoc(featX, featY);
1562: if (monst) {
1563: killCreature(monst, true); // If there's already a monster here, quietly bury the body.
1564: }
1565: monst = generateMonster(feature->monsterID, true, true);
1566: if (monst) {
1567: monst->xLoc = featX;
1568: monst->yLoc = featY;
1569: pmap[monst->xLoc][monst->yLoc].flags |= HAS_MONSTER;
1570: monst->bookkeepingFlags |= MB_JUST_SUMMONED;
1571: }
1572: }
1573:
1574: if (monst) {
1575: if (!leader) {
1576: leader = monst;
1577: }
1578:
1579: // Give our item to the monster leader if appropriate.
1580: // Actually just remember that we have to give it to this monster; the actual
1581: // hand-off happens after we're sure that the machine will succeed.
1582: if (theItem && (feature->flags & MF_MONSTER_TAKE_ITEM)) {
1583: torchBearer = monst;
1584: torch = theItem;
1585: }
1586: }
1587:
1588: for (monst = monsters->nextCreature; monst; monst = nextMonst) {
1589: // Have to cache the next monster, as the chain can get disrupted by making a monster dormant below.
1590: nextMonst = monst->nextCreature;
1591: if (monst->bookkeepingFlags & MB_JUST_SUMMONED) {
1592:
1593: // All monsters spawned by a machine are tribemates.
1594: // Assign leader/follower roles if they are not yet assigned.
1595: if (!(monst->bookkeepingFlags & (MB_LEADER | MB_FOLLOWER))) {
1596: if (leader && leader != monst) {
1597: monst->leader = leader;
1598: monst->bookkeepingFlags &= ~MB_LEADER;
1599: monst->bookkeepingFlags |= MB_FOLLOWER;
1600: leader->bookkeepingFlags |= MB_LEADER;
1601: } else {
1602: leader = monst;
1603: }
1604: }
1605:
1606: monst->bookkeepingFlags &= ~MB_JUST_SUMMONED;
1607: p->spawnedMonsters[monsterCount] = monst;
1608: monsterCount++;
1609: if (feature->flags & MF_MONSTER_SLEEPING) {
1610: monst->creatureState = MONSTER_SLEEPING;
1611: }
1612: if (feature->flags & MF_MONSTER_FLEEING) {
1613: monst->creatureState = MONSTER_FLEEING;
1614: monst->creatureMode = MODE_PERM_FLEEING;
1615: }
1616: if (feature->flags & MF_MONSTERS_DORMANT) {
1617: toggleMonsterDormancy(monst);
1618: if (!(feature->flags & MF_MONSTER_SLEEPING) && monst->creatureState != MONSTER_ALLY) {
1619: monst->creatureState = MONSTER_TRACKING_SCENT;
1620: }
1621: }
1622: monst->machineHome = machineNumber; // Monster remembers the machine that spawned it.
1623: }
1624: }
1625: }
1626: }
1627: theItem = NULL;
1628:
1629: // Finished with this instance!
1630: }
1631: } while ((feature->flags & MF_REPEAT_UNTIL_NO_PROGRESS) && instance >= feature->minimumInstanceCount);
1632:
1633: //DEBUG printf("\nFinished feature %i. Here's the candidates map:", feat);
1634: //DEBUG logBuffer(candidates);
1635:
1636: if (instance < feature->minimumInstanceCount && !(feature->flags & MF_REPEAT_UNTIL_NO_PROGRESS)) {
1637: // failure! abort!
1638:
1639: if (D_MESSAGE_MACHINE_GENERATION) printf("\nDepth %i: Failed to place blueprint %i because of feature %i; needed %i instances but got only %i.",
1640: rogue.depthLevel, bp, feat, feature->minimumInstanceCount, instance);
1641:
1642: // Restore the map to how it was before we touched it.
1643: copyMap(p->levelBackup, pmap);
1644: abortItemsAndMonsters(p->spawnedItems, p->spawnedMonsters);
1645: freeGrid(distanceMap);
1646: free(p);
1647: return false;
1648: }
1649: }
1650:
1651: // Clear out the interior flag for all non-wired cells, if requested.
1652: if (blueprintCatalog[bp].flags & BP_NO_INTERIOR_FLAG) {
1653: for(i=0; i<DCOLS; i++) {
1654: for(j=0; j<DROWS; j++) {
1655: if (pmap[i][j].machineNumber == machineNumber
1656: && !cellHasTMFlag(i, j, (TM_IS_WIRED | TM_IS_CIRCUIT_BREAKER))) {
1657:
1658: pmap[i][j].flags &= ~IS_IN_MACHINE;
1659: pmap[i][j].machineNumber = 0;
1660: }
1661: }
1662: }
1663: }
1664:
1665: if (torchBearer && torch) {
1666: if (torchBearer->carriedItem) {
1667: deleteItem(torchBearer->carriedItem);
1668: }
1669: removeItemFromChain(torch, floorItems);
1670: torchBearer->carriedItem = torch;
1671: }
1672:
1673: freeGrid(distanceMap);
1674: if (D_MESSAGE_MACHINE_GENERATION) printf("\nDepth %i: Built a machine from blueprint %i with an origin at (%i, %i).", rogue.depthLevel, bp, originX, originY);
1675:
1676: //Pass created items and monsters to parent where they will be deleted on failure to place parent machine
1677: if (parentSpawnedItems) {
1678: for (i=0; i<itemCount; i++) {
1679: parentSpawnedItems[i] = p->spawnedItems[i];
1680: }
1681: }
1682: if (parentSpawnedMonsters) {
1683: for (i=0; i<monsterCount; i++) {
1684: parentSpawnedMonsters[i] = p->spawnedMonsters[i];
1685: }
1686: }
1687:
1688: free(p);
1689: return true;
1690: }
1691:
1692: // add machines to the dungeon.
1693: void addMachines() {
1694: short machineCount, failsafe;
1695: short randomMachineFactor;
1696:
1697: analyzeMap(true);
1698:
1699: // Add the amulet holder if it's depth 26:
1700: if (rogue.depthLevel == AMULET_LEVEL) {
1701: for (failsafe = 50; failsafe; failsafe--) {
1702: if (buildAMachine(MT_AMULET_AREA, -1, -1, 0, NULL, NULL, NULL)) {
1703: break;
1704: }
1705: }
1706: }
1707:
1708: // Add reward rooms, if any:
1709: machineCount = 0;
1710: while (rogue.depthLevel <= AMULET_LEVEL
1711: && (rogue.rewardRoomsGenerated + machineCount) * 4 + 2 < rogue.depthLevel * MACHINES_FACTOR / FP_FACTOR) {
1712: // try to build at least one every four levels on average
1713: machineCount++;
1714: }
1715: randomMachineFactor = (rogue.depthLevel < 3 && (rogue.rewardRoomsGenerated + machineCount) == 0 ? 40 : 15);
1716: while (rand_percent(max(randomMachineFactor, 15 * MACHINES_FACTOR / FP_FACTOR)) && machineCount < 100) {
1717: randomMachineFactor = 15;
1718: machineCount++;
1719: }
1720:
1721: for (failsafe = 50; machineCount && failsafe; failsafe--) {
1722: if (buildAMachine(-1, -1, -1, BP_REWARD, NULL, NULL, NULL)) {
1723: machineCount--;
1724: rogue.rewardRoomsGenerated++;
1725: }
1726: }
1727: }
1728:
1729: // Add terrain, DFs and flavor machines. Includes traps, torches, funguses, flavor machines, etc.
1730: // If buildAreaMachines is true, build ONLY the autogenerators that include machines.
1731: // If false, build all EXCEPT the autogenerators that include machines.
1732: void runAutogenerators(boolean buildAreaMachines) {
1733: short AG, count, x, y, i;
1734: const autoGenerator *gen;
1735: char grid[DCOLS][DROWS];
1736:
1737: // Cycle through the autoGenerators.
1738: for (AG=1; AG<NUMBER_AUTOGENERATORS; AG++) {
1739:
1740: // Shortcut:
1741: gen = &(autoGeneratorCatalog[AG]);
1742:
1743: if (gen->machine > 0 == buildAreaMachines) {
1744:
1745: // Enforce depth constraints.
1746: if (rogue.depthLevel < gen->minDepth || rogue.depthLevel > gen->maxDepth) {
1747: continue;
1748: }
1749:
1750: // Decide how many of this AG to build.
1751: count = min((gen->minNumberIntercept + rogue.depthLevel * gen->minNumberSlope) / 100, gen->maxNumber);
1752: while (rand_percent(gen->frequency) && count < gen->maxNumber) {
1753: count++;
1754: }
1755:
1756: // Build that many instances.
1757: for (i = 0; i < count; i++) {
1758:
1759: // Find a location for DFs and terrain generations.
1760: //if (randomMatchingLocation(&x, &y, gen->requiredDungeonFoundationType, NOTHING, -1)) {
1761: //if (randomMatchingLocation(&x, &y, -1, -1, gen->requiredDungeonFoundationType)) {
1762: if (randomMatchingLocation(&x, &y, gen->requiredDungeonFoundationType, gen->requiredLiquidFoundationType, -1)) {
1763:
1764: // Spawn the DF.
1765: if (gen->DFType) {
1766: spawnDungeonFeature(x, y, &(dungeonFeatureCatalog[gen->DFType]), false, true);
1767:
1768: if (D_INSPECT_LEVELGEN) {
1769: dumpLevelToScreen();
1770: hiliteCell(x, y, &yellow, 50, true);
1771: temporaryMessage("Dungeon feature added.", true);
1772: }
1773: }
1774:
1775: // Spawn the terrain if it's got the priority to spawn there and won't disrupt connectivity.
1776: if (gen->terrain
1777: && tileCatalog[pmap[x][y].layers[gen->layer]].drawPriority >= tileCatalog[gen->terrain].drawPriority) {
1778:
1779: // Check connectivity.
1780: zeroOutGrid(grid);
1781: grid[x][y] = true;
1782: if (!(tileCatalog[gen->terrain].flags & T_PATHING_BLOCKER)
1783: || !levelIsDisconnectedWithBlockingMap(grid, false)) {
1784:
1785: // Build!
1786: pmap[x][y].layers[gen->layer] = gen->terrain;
1787:
1788: if (D_INSPECT_LEVELGEN) {
1789: dumpLevelToScreen();
1790: hiliteCell(x, y, &yellow, 50, true);
1791: temporaryMessage("Terrain added.", true);
1792: }
1793: }
1794: }
1795: }
1796:
1797: // Attempt to build the machine if requested.
1798: // Machines will find their own locations, so it will not be at the same place as terrain and DF.
1799: if (gen->machine > 0) {
1800: buildAMachine(gen->machine, -1, -1, 0, NULL, NULL, NULL);
1801: }
1802: }
1803: }
1804: }
1805: }
1806:
1807: // Knock down the boundaries between similar lakes where possible.
1808: void cleanUpLakeBoundaries() {
1809: short i, j, x, y, failsafe, layer;
1810: boolean reverse, madeChange;
1811: unsigned long subjectFlags;
1812:
1813: reverse = true;
1814:
1815: failsafe = 100;
1816: do {
1817: madeChange = false;
1818: reverse = !reverse;
1819: failsafe--;
1820:
1821: for (i = (reverse ? DCOLS - 2 : 1);
1822: (reverse ? i > 0 : i < DCOLS - 1);
1823: (reverse ? i-- : i++)) {
1824:
1825: for (j = (reverse ? DROWS - 2 : 1);
1826: (reverse ? j > 0 : j < DROWS - 1);
1827: (reverse ? j-- : j++)) {
1828:
1829: //assert(i >= 1 && i <= DCOLS - 2 && j >= 1 && j <= DROWS - 2);
1830:
1831: //if (cellHasTerrainFlag(i, j, T_OBSTRUCTS_PASSABILITY)
1832: if (cellHasTerrainFlag(i, j, T_LAKE_PATHING_BLOCKER | T_OBSTRUCTS_PASSABILITY)
1833: && !cellHasTMFlag(i, j, TM_IS_SECRET)
1834: && !(pmap[i][j].flags & IMPREGNABLE)) {
1835:
1836: subjectFlags = terrainFlags(i, j) & (T_LAKE_PATHING_BLOCKER | T_OBSTRUCTS_PASSABILITY);
1837:
1838: x = y = 0;
1839: if ((terrainFlags(i - 1, j) & T_LAKE_PATHING_BLOCKER & ~subjectFlags)
1840: && !cellHasTMFlag(i - 1, j, TM_IS_SECRET)
1841: && !cellHasTMFlag(i + 1, j, TM_IS_SECRET)
1842: && (terrainFlags(i - 1, j) & T_LAKE_PATHING_BLOCKER & ~subjectFlags) == (terrainFlags(i + 1, j) & T_LAKE_PATHING_BLOCKER & ~subjectFlags)) {
1843: x = i + 1;
1844: y = j;
1845: } else if ((terrainFlags(i, j - 1) & T_LAKE_PATHING_BLOCKER & ~subjectFlags)
1846: && !cellHasTMFlag(i, j - 1, TM_IS_SECRET)
1847: && !cellHasTMFlag(i, j + 1, TM_IS_SECRET)
1848: && (terrainFlags(i, j - 1) & T_LAKE_PATHING_BLOCKER & ~subjectFlags) == (terrainFlags(i, j + 1) & T_LAKE_PATHING_BLOCKER & ~subjectFlags)) {
1849: x = i;
1850: y = j + 1;
1851: }
1852: if (x) {
1853: madeChange = true;
1854: for (layer = 0; layer < NUMBER_TERRAIN_LAYERS; layer++) {
1855: pmap[i][j].layers[layer] = pmap[x][y].layers[layer];
1856: }
1857: //pmap[i][j].layers[DUNGEON] = CRYSTAL_WALL;
1858: }
1859: }
1860: }
1861: }
1862: } while (madeChange && failsafe > 0);
1863: }
1864:
1865: void removeDiagonalOpenings() {
1866: short i, j, k, x1, y1, x2, layer;
1867: boolean diagonalCornerRemoved;
1868:
1869: do {
1870: diagonalCornerRemoved = false;
1871: for (i=0; i<DCOLS-1; i++) {
1872: for (j=0; j<DROWS-1; j++) {
1873: for (k=0; k<=1; k++) {
1874: if (!(tileCatalog[pmap[i + k][j].layers[DUNGEON]].flags & T_OBSTRUCTS_PASSABILITY)
1875: && (tileCatalog[pmap[i + (1-k)][j].layers[DUNGEON]].flags & T_OBSTRUCTS_PASSABILITY)
1876: && (tileCatalog[pmap[i + (1-k)][j].layers[DUNGEON]].flags & T_OBSTRUCTS_DIAGONAL_MOVEMENT)
1877: && (tileCatalog[pmap[i + k][j+1].layers[DUNGEON]].flags & T_OBSTRUCTS_PASSABILITY)
1878: && (tileCatalog[pmap[i + k][j+1].layers[DUNGEON]].flags & T_OBSTRUCTS_DIAGONAL_MOVEMENT)
1879: && !(tileCatalog[pmap[i + (1-k)][j+1].layers[DUNGEON]].flags & T_OBSTRUCTS_PASSABILITY)) {
1880:
1881: if (rand_percent(50)) {
1882: x1 = i + (1-k);
1883: x2 = i + k;
1884: y1 = j;
1885: } else {
1886: x1 = i + k;
1887: x2 = i + (1-k);
1888: y1 = j + 1;
1889: }
1890: if (!(pmap[x1][y1].flags & HAS_MONSTER) && pmap[x1][y1].machineNumber == 0) {
1891: diagonalCornerRemoved = true;
1892: for (layer = 0; layer < NUMBER_TERRAIN_LAYERS; layer++) {
1893: pmap[x1][y1].layers[layer] = pmap[x2][y1].layers[layer];
1894: }
1895: }
1896: }
1897: }
1898: }
1899: }
1900: } while (diagonalCornerRemoved == true);
1901: }
1902:
1903: void insertRoomAt(short **dungeonMap, short **roomMap, const short roomToDungeonX, const short roomToDungeonY, const short xRoom, const short yRoom) {
1904: short newX, newY;
1905: enum directions dir;
1906:
1907: brogueAssert(coordinatesAreInMap(xRoom + roomToDungeonX, yRoom + roomToDungeonY));
1908:
1909: dungeonMap[xRoom + roomToDungeonX][yRoom + roomToDungeonY] = 1;
1910: for (dir = 0; dir < 4; dir++) {
1911: newX = xRoom + nbDirs[dir][0];
1912: newY = yRoom + nbDirs[dir][1];
1913: if (coordinatesAreInMap(newX, newY)
1914: && roomMap[newX][newY]
1915: && coordinatesAreInMap(newX + roomToDungeonX, newY + roomToDungeonY)
1916: && dungeonMap[newX + roomToDungeonX][newY + roomToDungeonY] == 0) {
1917:
1918: insertRoomAt(dungeonMap, roomMap, roomToDungeonX, roomToDungeonY, newX, newY);
1919: }
1920: }
1921: }
1922:
1923: void designCavern(short **grid, short minWidth, short maxWidth, short minHeight, short maxHeight) {
1924: short destX, destY;
1925: short caveX, caveY, caveWidth, caveHeight;
1926: short fillX = 0, fillY = 0;
1927: boolean foundFillPoint = false;
1928: short **blobGrid;
1929: blobGrid = allocGrid();
1930:
1931: fillGrid(grid, 0);
1932: createBlobOnGrid(blobGrid,
1933: &caveX, &caveY, &caveWidth, &caveHeight,
1934: 5, minWidth, minHeight, maxWidth, maxHeight, 55, "ffffffttt", "ffffttttt");
1935:
1936: // colorOverDungeon(&darkGray);
1937: // hiliteGrid(blobGrid, &tanColor, 80);
1938: // temporaryMessage("Here's the cave:", true);
1939:
1940: // Position the new cave in the middle of the grid...
1941: destX = (DCOLS - caveWidth) / 2;
1942: destY = (DROWS - caveHeight) / 2;
1943: // ...pick a floodfill insertion point...
1944: for (fillX = 0; fillX < DCOLS && !foundFillPoint; fillX++) {
1945: for (fillY = 0; fillY < DROWS && !foundFillPoint; fillY++) {
1946: if (blobGrid[fillX][fillY]) {
1947: foundFillPoint = true;
1948: }
1949: }
1950: }
1951: // ...and copy it to the master grid.
1952: insertRoomAt(grid, blobGrid, destX - caveX, destY - caveY, fillX, fillY);
1953: freeGrid(blobGrid);
1954: }
1955:
1956: // This is a special room that appears at the entrance to the dungeon on depth 1.
1957: void designEntranceRoom(short **grid) {
1958: short roomWidth, roomHeight, roomWidth2, roomHeight2, roomX, roomY, roomX2, roomY2;
1959:
1960: fillGrid(grid, 0);
1961:
1962: roomWidth = 8;
1963: roomHeight = 10;
1964: roomWidth2 = 20;
1965: roomHeight2 = 5;
1966: roomX = DCOLS/2 - roomWidth/2 - 1;
1967: roomY = DROWS - roomHeight - 2;
1968: roomX2 = DCOLS/2 - roomWidth2/2 - 1;
1969: roomY2 = DROWS - roomHeight2 - 2;
1970:
1971: drawRectangleOnGrid(grid, roomX, roomY, roomWidth, roomHeight, 1);
1972: drawRectangleOnGrid(grid, roomX2, roomY2, roomWidth2, roomHeight2, 1);
1973: }
1974:
1975: void designCrossRoom(short **grid) {
1976: short roomWidth, roomHeight, roomWidth2, roomHeight2, roomX, roomY, roomX2, roomY2;
1977:
1978: fillGrid(grid, 0);
1979:
1980: roomWidth = rand_range(3, 12);
1981: roomX = rand_range(max(0, DCOLS/2 - (roomWidth - 1)), min(DCOLS, DCOLS/2));
1982: roomWidth2 = rand_range(4, 20);
1983: roomX2 = (roomX + (roomWidth / 2) + rand_range(0, 2) + rand_range(0, 2) - 3) - (roomWidth2 / 2);
1984:
1985: roomHeight = rand_range(3, 7);
1986: roomY = (DROWS/2 - roomHeight);
1987:
1988: roomHeight2 = rand_range(2, 5);
1989: roomY2 = (DROWS/2 - roomHeight2 - (rand_range(0, 2) + rand_range(0, 1)));
1990:
1991: drawRectangleOnGrid(grid, roomX - 5, roomY + 5, roomWidth, roomHeight, 1);
1992: drawRectangleOnGrid(grid, roomX2 - 5, roomY2 + 5, roomWidth2, roomHeight2, 1);
1993: }
1994:
1995: void designSymmetricalCrossRoom(short **grid) {
1996: short majorWidth, majorHeight, minorWidth, minorHeight;
1997:
1998: fillGrid(grid, 0);
1999:
2000: majorWidth = rand_range(4, 8);
2001: majorHeight = rand_range(4, 5);
2002:
2003: minorWidth = rand_range(3, 4);
2004: if (majorHeight % 2 == 0) {
2005: minorWidth -= 1;
2006: }
2007: minorHeight = 3;//rand_range(2, 3);
2008: if (majorWidth % 2 == 0) {
2009: minorHeight -= 1;
2010: }
2011:
2012: drawRectangleOnGrid(grid, (DCOLS - majorWidth)/2, (DROWS - minorHeight)/2, majorWidth, minorHeight, 1);
2013: drawRectangleOnGrid(grid, (DCOLS - minorWidth)/2, (DROWS - majorHeight)/2, minorWidth, majorHeight, 1);
2014: }
2015:
2016: void designSmallRoom(short **grid) {
2017: short width, height;
2018:
2019: fillGrid(grid, 0);
2020: width = rand_range(3, 6);
2021: height = rand_range(2, 4);
2022: drawRectangleOnGrid(grid, (DCOLS - width) / 2, (DROWS - height) / 2, width, height, 1);
2023: }
2024:
2025: void designCircularRoom(short **grid) {
2026: short radius;
2027:
2028: if (rand_percent(5)) {
2029: radius = rand_range(4, 10);
2030: } else {
2031: radius = rand_range(2, 4);
2032: }
2033:
2034: fillGrid(grid, 0);
2035: drawCircleOnGrid(grid, DCOLS/2, DROWS/2, radius, 1);
2036:
2037: if (radius > 6
2038: && rand_percent(50)) {
2039: drawCircleOnGrid(grid, DCOLS/2, DROWS/2, rand_range(3, radius - 3), 0);
2040: }
2041: }
2042:
2043: void designChunkyRoom(short **grid) {
2044: short i, x, y;
2045: short minX, maxX, minY, maxY;
2046: short chunkCount = rand_range(2, 8);
2047:
2048: fillGrid(grid, 0);
2049: drawCircleOnGrid(grid, DCOLS/2, DROWS/2, 2, 1);
2050: minX = DCOLS/2 - 3;
2051: maxX = DCOLS/2 + 3;
2052: minY = DROWS/2 - 3;
2053: maxY = DROWS/2 + 3;
2054:
2055: for (i=0; i<chunkCount;) {
2056: x = rand_range(minX, maxX);
2057: y = rand_range(minY, maxY);
2058: if (grid[x][y]) {
2059: // colorOverDungeon(&darkGray);
2060: // hiliteGrid(grid, &white, 100);
2061:
2062: drawCircleOnGrid(grid, x, y, 2, 1);
2063: i++;
2064: minX = max(1, min(x - 3, minX));
2065: maxX = min(DCOLS - 2, max(x + 3, maxX));
2066: minY = max(1, min(y - 3, minY));
2067: maxY = min(DROWS - 2, max(y + 3, maxY));
2068:
2069: // hiliteGrid(grid, &green, 50);
2070: // temporaryMessage("Added a chunk:", true);
2071: }
2072: }
2073: }
2074:
2075: // If the indicated tile is a wall on the room stored in grid, and it could be the site of
2076: // a door out of that room, then return the outbound direction that the door faces.
2077: // Otherwise, return NO_DIRECTION.
2078: enum directions directionOfDoorSite(short **grid, short x, short y) {
2079: enum directions dir, solutionDir;
2080: short newX, newY, oppX, oppY;
2081:
2082: if (grid[x][y]) { // Already occupied
2083: return NO_DIRECTION;
2084: }
2085:
2086: solutionDir = NO_DIRECTION;
2087: for (dir=0; dir<4; dir++) {
2088: newX = x + nbDirs[dir][0];
2089: newY = y + nbDirs[dir][1];
2090: oppX = x - nbDirs[dir][0];
2091: oppY = y - nbDirs[dir][1];
2092: if (coordinatesAreInMap(oppX, oppY)
2093: && coordinatesAreInMap(newX, newY)
2094: && grid[oppX][oppY] == 1) {
2095:
2096: // This grid cell would be a valid tile on which to place a door that, facing outward, points dir.
2097: if (solutionDir != NO_DIRECTION) {
2098: // Already claimed by another direction; no doors here!
2099: return NO_DIRECTION;
2100: }
2101: solutionDir = dir;
2102: }
2103: }
2104: return solutionDir;
2105: }
2106:
2107: void chooseRandomDoorSites(short **roomMap, short doorSites[4][2]) {
2108: short i, j, k, newX, newY;
2109: enum directions dir;
2110: short **grid;
2111: boolean doorSiteFailed;
2112:
2113: grid = allocGrid();
2114: copyGrid(grid, roomMap);
2115:
2116: // colorOverDungeon(&darkGray);
2117: // hiliteGrid(grid, &blue, 100);
2118: // temporaryMessage("Generating this room:", true);
2119: // const char dirChars[] = "^v<>";
2120:
2121: for (i=0; i<DCOLS; i++) {
2122: for (j=0; j<DROWS; j++) {
2123: if (!grid[i][j]) {
2124: dir = directionOfDoorSite(roomMap, i, j);
2125: if (dir != NO_DIRECTION) {
2126: // Trace a ray 10 spaces outward from the door site to make sure it doesn't intersect the room.
2127: // If it does, it's not a valid door site.
2128: newX = i + nbDirs[dir][0];
2129: newY = j + nbDirs[dir][1];
2130: doorSiteFailed = false;
2131: for (k=0; k<10 && coordinatesAreInMap(newX, newY) && !doorSiteFailed; k++) {
2132: if (grid[newX][newY]) {
2133: doorSiteFailed = true;
2134: }
2135: newX += nbDirs[dir][0];
2136: newY += nbDirs[dir][1];
2137: }
2138: if (!doorSiteFailed) {
2139: // plotCharWithColor(dirChars[dir], mapToWindowX(i), mapToWindowY(j), &black, &green);
2140: grid[i][j] = dir + 2; // So as not to conflict with 0 or 1, which are used to indicate exterior/interior.
2141: }
2142: }
2143: }
2144: }
2145: }
2146:
2147: // temporaryMessage("Door candidates:", true);
2148:
2149: // Pick four doors, one in each direction, and store them in doorSites[dir].
2150: for (dir=0; dir<4; dir++) {
2151: randomLocationInGrid(grid, &(doorSites[dir][0]), &(doorSites[dir][1]), dir + 2);
2152: }
2153:
2154: freeGrid(grid);
2155: }
2156:
2157: void attachHallwayTo(short **grid, short doorSites[4][2]) {
2158: short i, x, y, newX, newY, dirs[4];
2159: short length;
2160: enum directions dir, dir2;
2161: boolean allowObliqueHallwayExit;
2162:
2163: // Pick a direction.
2164: fillSequentialList(dirs, 4);
2165: shuffleList(dirs, 4);
2166: for (i=0; i<4; i++) {
2167: dir = dirs[i];
2168: if (doorSites[dir][0] != -1
2169: && doorSites[dir][1] != -1
2170: && coordinatesAreInMap(doorSites[dir][0] + nbDirs[dir][0] * HORIZONTAL_CORRIDOR_MAX_LENGTH,
2171: doorSites[dir][1] + nbDirs[dir][1] * VERTICAL_CORRIDOR_MAX_LENGTH)) {
2172: break; // That's our direction!
2173: }
2174: }
2175: if (i==4) {
2176: return; // No valid direction for hallways.
2177: }
2178:
2179: if (dir == UP || dir == DOWN) {
2180: length = rand_range(VERTICAL_CORRIDOR_MIN_LENGTH, VERTICAL_CORRIDOR_MAX_LENGTH);
2181: } else {
2182: length = rand_range(HORIZONTAL_CORRIDOR_MIN_LENGTH, HORIZONTAL_CORRIDOR_MAX_LENGTH);
2183: }
2184:
2185: x = doorSites[dir][0];
2186: y = doorSites[dir][1];
2187: for (i = 0; i < length; i++) {
2188: if (coordinatesAreInMap(x, y)) {
2189: grid[x][y] = true;
2190: }
2191: x += nbDirs[dir][0];
2192: y += nbDirs[dir][1];
2193: }
2194: x = clamp(x - nbDirs[dir][0], 0, DCOLS - 1);
2195: y = clamp(y - nbDirs[dir][1], 0, DROWS - 1); // Now (x, y) points at the last interior cell of the hallway.
2196: allowObliqueHallwayExit = rand_percent(15);
2197: for (dir2 = 0; dir2 < 4; dir2++) {
2198: newX = x + nbDirs[dir2][0];
2199: newY = y + nbDirs[dir2][1];
2200:
2201: if ((dir2 != dir && !allowObliqueHallwayExit)
2202: || !coordinatesAreInMap(newX, newY)
2203: || grid[newX][newY]) {
2204:
2205: doorSites[dir2][0] = -1;
2206: doorSites[dir2][1] = -1;
2207: } else {
2208: doorSites[dir2][0] = newX;
2209: doorSites[dir2][1] = newY;
2210: }
2211: }
2212: }
2213:
2214: // Put a random room shape somewhere on the binary grid,
2215: // and optionally record the coordinates of up to four door sites in doorSites.
2216: // If attachHallway is true, then it will bolt a perpendicular hallway onto the room at one of the four standard door sites,
2217: // and then relocate three of the door sites to radiate from the end of the hallway. (The fourth is defunct.)
2218: // RoomTypeFrequencies specifies the probability of each room type, in the following order:
2219: // 0. Cross room
2220: // 1. Small symmetrical cross room
2221: // 2. Small room
2222: // 3. Circular room
2223: // 4. Chunky room
2224: // 5. Cave
2225: // 6. Cavern (the kind that fills a level)
2226: // 7. Entrance room (the big upside-down T room at the start of depth 1)
2227:
2228: void designRandomRoom(short **grid, boolean attachHallway, short doorSites[4][2],
2229: const short roomTypeFrequencies[ROOM_TYPE_COUNT]) {
2230: short randIndex, i, sum;
2231: enum directions dir;
2232:
2233: sum = 0;
2234: for (i=0; i<ROOM_TYPE_COUNT; i++) {
2235: sum += roomTypeFrequencies[i];
2236: }
2237: randIndex = rand_range(0, sum - 1);
2238: for (i=0; i<ROOM_TYPE_COUNT; i++) {
2239: if (randIndex < roomTypeFrequencies[i]) {
2240: break; // "i" is our room type.
2241: } else {
2242: randIndex -= roomTypeFrequencies[i];
2243: }
2244: }
2245: switch (i) {
2246: case 0:
2247: designCrossRoom(grid);
2248: break;
2249: case 1:
2250: designSymmetricalCrossRoom(grid);
2251: break;
2252: case 2:
2253: designSmallRoom(grid);
2254: break;
2255: case 3:
2256: designCircularRoom(grid);
2257: break;
2258: case 4:
2259: designChunkyRoom(grid);
2260: break;
2261: case 5:
2262: switch (rand_range(0, 2)) {
2263: case 0:
2264: designCavern(grid, 3, 12, 4, 8); // Compact cave room.
2265: break;
2266: case 1:
2267: designCavern(grid, 3, 12, 15, DROWS-2); // Large north-south cave room.
2268: break;
2269: case 2:
2270: designCavern(grid, 20, DROWS-2, 4, 8); // Large east-west cave room.
2271: break;
2272: default:
2273: break;
2274: }
2275: break;
2276: case 6:
2277: designCavern(grid, CAVE_MIN_WIDTH, DCOLS - 2, CAVE_MIN_HEIGHT, DROWS - 2);
2278: break;
2279: case 7:
2280: designEntranceRoom(grid);
2281: break;
2282: default:
2283: break;
2284: }
2285:
2286: if (doorSites) {
2287: chooseRandomDoorSites(grid, doorSites);
2288: if (attachHallway) {
2289: dir = rand_range(0, 3);
2290: for (i=0; doorSites[dir][0] == -1 && i < 3; i++) {
2291: dir = (dir + 1) % 4; // Each room will have at least 2 valid directions for doors.
2292: }
2293: attachHallwayTo(grid, doorSites);
2294: }
2295: }
2296: }
2297:
2298: boolean roomFitsAt(short **dungeonMap, short **roomMap, short roomToDungeonX, short roomToDungeonY) {
2299: short xRoom, yRoom, xDungeon, yDungeon, i, j;
2300:
2301: for (xRoom = 0; xRoom < DCOLS; xRoom++) {
2302: for (yRoom = 0; yRoom < DROWS; yRoom++) {
2303: if (roomMap[xRoom][yRoom]) {
2304: xDungeon = xRoom + roomToDungeonX;
2305: yDungeon = yRoom + roomToDungeonY;
2306:
2307: for (i = xDungeon - 1; i <= xDungeon + 1; i++) {
2308: for (j = yDungeon - 1; j <= yDungeon + 1; j++) {
2309: if (!coordinatesAreInMap(i, j)
2310: || dungeonMap[i][j] > 0) {
2311: return false;
2312: }
2313: }
2314: }
2315: }
2316: }
2317: }
2318: return true;
2319: }
2320:
2321: void attachRooms(short **grid, const dungeonProfile *theDP, short attempts, short maxRoomCount) {
2322: short roomsBuilt, roomsAttempted;
2323: short **roomMap;
2324: short doorSites[4][2];
2325: short i, x, y, sCoord[DCOLS*DROWS];
2326: enum directions dir, oppDir;
2327:
2328: fillSequentialList(sCoord, DCOLS*DROWS);
2329: shuffleList(sCoord, DCOLS*DROWS);
2330:
2331: roomMap = allocGrid();
2332: for (roomsBuilt = roomsAttempted = 0; roomsBuilt < maxRoomCount && roomsAttempted < attempts; roomsAttempted++) {
2333: // Build a room in hyperspace.
2334: fillGrid(roomMap, 0);
2335: designRandomRoom(roomMap, roomsAttempted <= attempts - 5 && rand_percent(theDP->corridorChance),
2336: doorSites, theDP->roomFrequencies);
2337:
2338: if (D_INSPECT_LEVELGEN) {
2339: colorOverDungeon(&darkGray);
2340: hiliteGrid(roomMap, &blue, 100);
2341: if (doorSites[0][0] != -1) plotCharWithColor('^', mapToWindowX(doorSites[0][0]), mapToWindowY(doorSites[0][1]), &black, &green);
2342: if (doorSites[1][0] != -1) plotCharWithColor('v', mapToWindowX(doorSites[1][0]), mapToWindowY(doorSites[1][1]), &black, &green);
2343: if (doorSites[2][0] != -1) plotCharWithColor('<', mapToWindowX(doorSites[2][0]), mapToWindowY(doorSites[2][1]), &black, &green);
2344: if (doorSites[3][0] != -1) plotCharWithColor('>', mapToWindowX(doorSites[3][0]), mapToWindowY(doorSites[3][1]), &black, &green);
2345: temporaryMessage("Generating this room:", true);
2346: }
2347:
2348: // Slide hyperspace across real space, in a random but predetermined order, until the room matches up with a wall.
2349: for (i = 0; i < DCOLS*DROWS; i++) {
2350: x = sCoord[i] / DROWS;
2351: y = sCoord[i] % DROWS;
2352:
2353: dir = directionOfDoorSite(grid, x, y);
2354: oppDir = oppositeDirection(dir);
2355: if (dir != NO_DIRECTION
2356: && doorSites[oppDir][0] != -1
2357: && roomFitsAt(grid, roomMap, x - doorSites[oppDir][0], y - doorSites[oppDir][1])) {
2358:
2359: // Room fits here.
2360: if (D_INSPECT_LEVELGEN) {
2361: colorOverDungeon(&darkGray);
2362: hiliteGrid(grid, &white, 100);
2363: }
2364: insertRoomAt(grid, roomMap, x - doorSites[oppDir][0], y - doorSites[oppDir][1], doorSites[oppDir][0], doorSites[oppDir][1]);
2365: grid[x][y] = 2; // Door site.
2366: if (D_INSPECT_LEVELGEN) {
2367: hiliteGrid(grid, &green, 50);
2368: temporaryMessage("Added room.", true);
2369: }
2370: roomsBuilt++;
2371: break;
2372: }
2373: }
2374: }
2375:
2376: freeGrid(roomMap);
2377: }
2378:
2379: void adjustDungeonProfileForDepth(dungeonProfile *theProfile) {
2380: const short descentPercent = clamp(100 * (rogue.depthLevel - 1) / (AMULET_LEVEL - 1), 0, 100);
2381:
2382: theProfile->roomFrequencies[0] += 20 * (100 - descentPercent) / 100;
2383: theProfile->roomFrequencies[1] += 10 * (100 - descentPercent) / 100;
2384: theProfile->roomFrequencies[3] += 7 * (100 - descentPercent) / 100;
2385: theProfile->roomFrequencies[5] += 10 * descentPercent / 100;
2386:
2387: theProfile->corridorChance += 80 * (100 - descentPercent) / 100;
2388: }
2389:
2390: void adjustDungeonFirstRoomProfileForDepth(dungeonProfile *theProfile) {
2391: short i;
2392: const short descentPercent = clamp(100 * (rogue.depthLevel - 1) / (AMULET_LEVEL - 1), 0, 100);
2393:
2394: if (rogue.depthLevel == 1) {
2395: // All dungeons start with the entrance room on depth 1.
2396: for (i = 0; i < ROOM_TYPE_COUNT; i++) {
2397: theProfile->roomFrequencies[i] = 0;
2398: }
2399: theProfile->roomFrequencies[7] = 1;
2400: } else {
2401: theProfile->roomFrequencies[6] += 50 * descentPercent / 100;
2402: }
2403: }
2404:
2405: // Called by digDungeon().
2406: // Slaps a bunch of rooms and hallways into the grid.
2407: // On the grid, a 0 denotes granite, a 1 denotes floor, and a 2 denotes a possible door site.
2408: // -1 denotes off-limits areas -- rooms can't be placed there and also can't sprout off of there.
2409: // Parent function will translate this grid into pmap[][] to make floors, walls, doors, etc.
2410: void carveDungeon(short **grid) {
2411: dungeonProfile theDP, theFirstRoomDP;
2412:
2413: theDP = dungeonProfileCatalog[DP_BASIC];
2414: adjustDungeonProfileForDepth(&theDP);
2415:
2416: theFirstRoomDP = dungeonProfileCatalog[DP_BASIC_FIRST_ROOM];
2417: adjustDungeonFirstRoomProfileForDepth(&theFirstRoomDP);
2418:
2419: designRandomRoom(grid, false, NULL, theFirstRoomDP.roomFrequencies);
2420:
2421: if (D_INSPECT_LEVELGEN) {
2422: colorOverDungeon(&darkGray);
2423: hiliteGrid(grid, &white, 100);
2424: temporaryMessage("First room placed:", true);
2425: }
2426:
2427: attachRooms(grid, &theDP, 35, 35);
2428:
2429: // colorOverDungeon(&darkGray);
2430: // hiliteGrid(grid, &white, 100);
2431: // temporaryMessage("How does this finished level look?", true);
2432: }
2433:
2434: void finishWalls(boolean includingDiagonals) {
2435: short i, j, x1, y1;
2436: boolean foundExposure;
2437: enum directions dir;
2438:
2439: for (i=0; i<DCOLS; i++) {
2440: for (j=0; j<DROWS; j++) {
2441: if (pmap[i][j].layers[DUNGEON] == GRANITE) {
2442: foundExposure = false;
2443: for (dir = 0; dir < (includingDiagonals ? 8 : 4) && !foundExposure; dir++) {
2444: x1 = i + nbDirs[dir][0];
2445: y1 = j + nbDirs[dir][1];
2446: if (coordinatesAreInMap(x1, y1)
2447: && (!cellHasTerrainFlag(x1, y1, T_OBSTRUCTS_VISION) || !cellHasTerrainFlag(x1, y1, T_OBSTRUCTS_PASSABILITY))) {
2448:
2449: pmap[i][j].layers[DUNGEON] = WALL;
2450: foundExposure = true;
2451: }
2452: }
2453: } else if (pmap[i][j].layers[DUNGEON] == WALL) {
2454: foundExposure = false;
2455: for (dir = 0; dir < (includingDiagonals ? 8 : 4) && !foundExposure; dir++) {
2456: x1 = i + nbDirs[dir][0];
2457: y1 = j + nbDirs[dir][1];
2458: if (coordinatesAreInMap(x1, y1)
2459: && (!cellHasTerrainFlag(x1, y1, T_OBSTRUCTS_VISION) || !cellHasTerrainFlag(x1, y1, T_OBSTRUCTS_PASSABILITY))) {
2460:
2461: foundExposure = true;
2462: }
2463: }
2464: if (foundExposure == false) {
2465: pmap[i][j].layers[DUNGEON] = GRANITE;
2466: }
2467: }
2468: }
2469: }
2470: }
2471:
2472: void liquidType(short *deep, short *shallow, short *shallowWidth) {
2473: short randMin, randMax, rand;
2474:
2475: randMin = (rogue.depthLevel < 4 ? 1 : 0); // no lava before level 4
2476: randMax = (rogue.depthLevel < 17 ? 2 : 3); // no brimstone before level 18
2477: rand = rand_range(randMin, randMax);
2478: if (rogue.depthLevel == DEEPEST_LEVEL) {
2479: rand = 1;
2480: }
2481:
2482: switch(rand) {
2483: case 0:
2484: *deep = LAVA;
2485: *shallow = NOTHING;
2486: *shallowWidth = 0;
2487: break;
2488: case 1:
2489: *deep = DEEP_WATER;
2490: *shallow = SHALLOW_WATER;
2491: *shallowWidth = 2;
2492: break;
2493: case 2:
2494: *deep = CHASM;
2495: *shallow = CHASM_EDGE;
2496: *shallowWidth = 1;
2497: break;
2498: case 3:
2499: *deep = INERT_BRIMSTONE;
2500: *shallow = OBSIDIAN;
2501: *shallowWidth = 2;
2502: break;
2503: }
2504: }
2505:
2506: // Fills a lake marked in unfilledLakeMap with the specified liquid type, scanning outward to reach other lakes within scanWidth.
2507: // Any wreath of shallow liquid must be done elsewhere.
2508: void fillLake(short x, short y, short liquid, short scanWidth, char wreathMap[DCOLS][DROWS], short **unfilledLakeMap) {
2509: short i, j;
2510:
2511: for (i = x - scanWidth; i <= x + scanWidth; i++) {
2512: for (j = y - scanWidth; j <= y + scanWidth; j++) {
2513: if (coordinatesAreInMap(i, j) && unfilledLakeMap[i][j]) {
2514: unfilledLakeMap[i][j] = false;
2515: pmap[i][j].layers[LIQUID] = liquid;
2516: wreathMap[i][j] = 1;
2517: fillLake(i, j, liquid, scanWidth, wreathMap, unfilledLakeMap); // recursive
2518: }
2519: }
2520: }
2521: }
2522:
2523: void lakeFloodFill(short x, short y, short **floodMap, short **grid, short **lakeMap, short dungeonToGridX, short dungeonToGridY) {
2524: short newX, newY;
2525: enum directions dir;
2526:
2527: floodMap[x][y] = true;
2528: for (dir=0; dir<4; dir++) {
2529: newX = x + nbDirs[dir][0];
2530: newY = y + nbDirs[dir][1];
2531: if (coordinatesAreInMap(newX, newY)
2532: && !floodMap[newX][newY]
2533: && (!cellHasTerrainFlag(newX, newY, T_PATHING_BLOCKER) || cellHasTMFlag(newX, newY, TM_CONNECTS_LEVEL))
2534: && !lakeMap[newX][newY]
2535: && (!coordinatesAreInMap(newX+dungeonToGridX, newY+dungeonToGridY) || !grid[newX+dungeonToGridX][newY+dungeonToGridY])) {
2536:
2537: lakeFloodFill(newX, newY, floodMap, grid, lakeMap, dungeonToGridX, dungeonToGridY);
2538: }
2539: }
2540: }
2541:
2542: boolean lakeDisruptsPassability(short **grid, short **lakeMap, short dungeonToGridX, short dungeonToGridY) {
2543: boolean result;
2544: short i, j, x, y;
2545: short **floodMap;
2546:
2547: floodMap = allocGrid();
2548: fillGrid(floodMap, 0);
2549: x = y = -1;
2550: // Get starting location for the fill.
2551: for (i=0; i<DCOLS && x == -1; i++) {
2552: for (j=0; j<DROWS && x == -1; j++) {
2553: if (!cellHasTerrainFlag(i, j, T_PATHING_BLOCKER)
2554: && !lakeMap[i][j]
2555: && (!coordinatesAreInMap(i+dungeonToGridX, j+dungeonToGridY) || !grid[i+dungeonToGridX][j+dungeonToGridY])) {
2556:
2557: x = i;
2558: y = j;
2559: }
2560: }
2561: }
2562: brogueAssert(x != -1);
2563: // Do the flood fill.
2564: lakeFloodFill(x, y, floodMap, grid, lakeMap, dungeonToGridX, dungeonToGridY);
2565:
2566: // See if any dry tiles weren't reached by the flood fill.
2567: result = false;
2568: for (i=0; i<DCOLS && result == false; i++) {
2569: for (j=0; j<DROWS && result == false; j++) {
2570: if (!cellHasTerrainFlag(i, j, T_PATHING_BLOCKER)
2571: && !lakeMap[i][j]
2572: && !floodMap[i][j]
2573: && (!coordinatesAreInMap(i+dungeonToGridX, j+dungeonToGridY) || !grid[i+dungeonToGridX][j+dungeonToGridY])) {
2574:
2575: // if (D_INSPECT_LEVELGEN) {
2576: // dumpLevelToScreen();
2577: // hiliteGrid(lakeMap, &darkBlue, 75);
2578: // hiliteGrid(floodMap, &white, 20);
2579: // plotCharWithColor('X', mapToWindowX(i), mapToWindowY(j), &black, &red);
2580: // temporaryMessage("Failed here.", true);
2581: // }
2582:
2583: result = true;
2584: }
2585: }
2586: }
2587:
2588: freeGrid(floodMap);
2589: return result;
2590: }
2591:
2592: void designLakes(short **lakeMap) {
2593: short i, j, k;
2594: short x, y;
2595: short lakeMaxHeight, lakeMaxWidth;
2596: short lakeX, lakeY, lakeWidth, lakeHeight;
2597:
2598: short **grid; // Holds the current lake.
2599:
2600: grid = allocGrid();
2601: fillGrid(lakeMap, 0);
2602: for (lakeMaxHeight = 15, lakeMaxWidth = 30; lakeMaxHeight >=10; lakeMaxHeight--, lakeMaxWidth -= 2) { // lake generations
2603:
2604: fillGrid(grid, 0);
2605: createBlobOnGrid(grid, &lakeX, &lakeY, &lakeWidth, &lakeHeight, 5, 4, 4, lakeMaxWidth, lakeMaxHeight, 55, "ffffftttt", "ffffttttt");
2606:
2607: // if (D_INSPECT_LEVELGEN) {
2608: // colorOverDungeon(&darkGray);
2609: // hiliteGrid(grid, &white, 100);
2610: // temporaryMessage("Generated a lake.", true);
2611: // }
2612:
2613: for (k=0; k<20; k++) { // placement attempts
2614: // propose a position for the top-left of the grid in the dungeon
2615: x = rand_range(1 - lakeX, DCOLS - lakeWidth - lakeX - 2);
2616: y = rand_range(1 - lakeY, DROWS - lakeHeight - lakeY - 2);
2617:
2618: if (!lakeDisruptsPassability(grid, lakeMap, -x, -y)) { // level with lake is completely connected
2619: //printf("Placed a lake!");
2620:
2621: // copy in lake
2622: for (i = 0; i < lakeWidth; i++) {
2623: for (j = 0; j < lakeHeight; j++) {
2624: if (grid[i + lakeX][j + lakeY]) {
2625: lakeMap[i + lakeX + x][j + lakeY + y] = true;
2626: pmap[i + lakeX + x][j + lakeY + y].layers[DUNGEON] = FLOOR;
2627: }
2628: }
2629: }
2630:
2631: if (D_INSPECT_LEVELGEN) {
2632: dumpLevelToScreen();
2633: hiliteGrid(lakeMap, &white, 50);
2634: temporaryMessage("Added a lake location.", true);
2635: }
2636: break;
2637: }
2638: }
2639: }
2640: freeGrid(grid);
2641: }
2642:
2643: void createWreath(short shallowLiquid, short wreathWidth, char wreathMap[DCOLS][DROWS]) {
2644: short i, j, k, l;
2645: for (i=0; i<DCOLS; i++) {
2646: for (j=0; j<DROWS; j++) {
2647: if (wreathMap[i][j]) {
2648: for (k = i-wreathWidth; k<= i+wreathWidth; k++) {
2649: for (l = j-wreathWidth; l <= j+wreathWidth; l++) {
2650: if (coordinatesAreInMap(k, l) && pmap[k][l].layers[LIQUID] == NOTHING
2651: && (i-k)*(i-k) + (j-l)*(j-l) <= wreathWidth*wreathWidth) {
2652: pmap[k][l].layers[LIQUID] = shallowLiquid;
2653: if (pmap[k][l].layers[DUNGEON] == DOOR) {
2654: pmap[k][l].layers[DUNGEON] = FLOOR;
2655: }
2656: }
2657: }
2658: }
2659: }
2660: }
2661: }
2662: }
2663:
2664: void fillLakes(short **lakeMap) {
2665: short deepLiquid = CRYSTAL_WALL, shallowLiquid = CRYSTAL_WALL, shallowLiquidWidth = 0;
2666: char wreathMap[DCOLS][DROWS];
2667: short i, j;
2668:
2669: for (i=0; i<DCOLS; i++) {
2670: for (j=0; j<DROWS; j++) {
2671: if (lakeMap[i][j]) {
2672: liquidType(&deepLiquid, &shallowLiquid, &shallowLiquidWidth);
2673: zeroOutGrid(wreathMap);
2674: fillLake(i, j, deepLiquid, 4, wreathMap, lakeMap);
2675: createWreath(shallowLiquid, shallowLiquidWidth, wreathMap);
2676:
2677: if (D_INSPECT_LEVELGEN) {
2678: dumpLevelToScreen();
2679: hiliteGrid(lakeMap, &white, 75);
2680: temporaryMessage("Lake filled.", true);
2681: }
2682: }
2683: }
2684: }
2685: }
2686:
2687: void finishDoors() {
2688: short i, j;
2689: const short secretDoorChance = clamp((rogue.depthLevel - 1) * 67 / 25, 0, 67);
2690: for (i=1; i<DCOLS-1; i++) {
2691: for (j=1; j<DROWS-1; j++) {
2692: if (pmap[i][j].layers[DUNGEON] == DOOR
2693: && pmap[i][j].machineNumber == 0) {
2694: if ((!cellHasTerrainFlag(i+1, j, T_OBSTRUCTS_PASSABILITY) || !cellHasTerrainFlag(i-1, j, T_OBSTRUCTS_PASSABILITY))
2695: && (!cellHasTerrainFlag(i, j+1, T_OBSTRUCTS_PASSABILITY) || !cellHasTerrainFlag(i, j-1, T_OBSTRUCTS_PASSABILITY))) {
2696: // If there's passable terrain to the left or right, and there's passable terrain
2697: // above or below, then the door is orphaned and must be removed.
2698: pmap[i][j].layers[DUNGEON] = FLOOR;
2699: } else if ((cellHasTerrainFlag(i+1, j, T_PATHING_BLOCKER) ? 1 : 0)
2700: + (cellHasTerrainFlag(i-1, j, T_PATHING_BLOCKER) ? 1 : 0)
2701: + (cellHasTerrainFlag(i, j+1, T_PATHING_BLOCKER) ? 1 : 0)
2702: + (cellHasTerrainFlag(i, j-1, T_PATHING_BLOCKER) ? 1 : 0) >= 3) {
2703: // If the door has three or more pathing blocker neighbors in the four cardinal directions,
2704: // then the door is orphaned and must be removed.
2705: pmap[i][j].layers[DUNGEON] = FLOOR;
2706: } else if (rand_percent(secretDoorChance)) {
2707: pmap[i][j].layers[DUNGEON] = SECRET_DOOR;
2708: }
2709: }
2710: }
2711: }
2712: }
2713:
2714: void clearLevel() {
2715: short i, j;
2716:
2717: for( i=0; i<DCOLS; i++ ) {
2718: for( j=0; j<DROWS; j++ ) {
2719: pmap[i][j].layers[DUNGEON] = GRANITE;
2720: pmap[i][j].layers[LIQUID] = NOTHING;
2721: pmap[i][j].layers[GAS] = NOTHING;
2722: pmap[i][j].layers[SURFACE] = NOTHING;
2723: pmap[i][j].machineNumber = 0;
2724: pmap[i][j].rememberedTerrain = NOTHING;
2725: pmap[i][j].rememberedTerrainFlags = (T_OBSTRUCTS_EVERYTHING);
2726: pmap[i][j].rememberedTMFlags = 0;
2727: pmap[i][j].rememberedCellFlags = 0;
2728: pmap[i][j].rememberedItemCategory = 0;
2729: pmap[i][j].rememberedItemKind = 0;
2730: pmap[i][j].rememberedItemQuantity = 0;
2731: pmap[i][j].rememberedItemOriginDepth = 0;
2732: pmap[i][j].flags = 0;
2733: pmap[i][j].volume = 0;
2734: }
2735: }
2736: }
2737:
2738: // Scans the map in random order looking for a good place to build a bridge.
2739: // If it finds one, it builds a bridge there, halts and returns true.
2740: boolean buildABridge() {
2741: short i, j, k, l, i2, j2, nCols[DCOLS], nRows[DROWS];
2742: short bridgeRatioX, bridgeRatioY;
2743: boolean foundExposure;
2744:
2745: bridgeRatioX = (short) (100 + (100 + 100 * rogue.depthLevel / 9) * rand_range(10, 20) / 10);
2746: bridgeRatioY = (short) (100 + (400 + 100 * rogue.depthLevel / 18) * rand_range(10, 20) / 10);
2747:
2748: fillSequentialList(nCols, DCOLS);
2749: shuffleList(nCols, DCOLS);
2750: fillSequentialList(nRows, DROWS);
2751: shuffleList(nRows, DROWS);
2752:
2753: for (i2=1; i2<DCOLS-1; i2++) {
2754: i = nCols[i2];
2755: for (j2=1; j2<DROWS-1; j2++) {
2756: j = nRows[j2];
2757: if (!cellHasTerrainFlag(i, j, (T_CAN_BE_BRIDGED | T_PATHING_BLOCKER))
2758: && !pmap[i][j].machineNumber) {
2759:
2760: // try a horizontal bridge
2761: foundExposure = false;
2762: for (k = i + 1;
2763: k < DCOLS // Iterate across the prospective length of the bridge.
2764: && !pmap[k][j].machineNumber // No bridges in machines.
2765: && cellHasTerrainFlag(k, j, T_CAN_BE_BRIDGED) // Candidate tile must be chasm.
2766: && !cellHasTMFlag(k, j, TM_IS_SECRET) // Can't bridge over secret trapdoors.
2767: && !cellHasTerrainFlag(k, j, T_OBSTRUCTS_PASSABILITY) // Candidate tile cannot be a wall.
2768: && cellHasTerrainFlag(k, j-1, (T_CAN_BE_BRIDGED | T_OBSTRUCTS_PASSABILITY)) // Only chasms or walls are permitted next to the length of the bridge.
2769: && cellHasTerrainFlag(k, j+1, (T_CAN_BE_BRIDGED | T_OBSTRUCTS_PASSABILITY));
2770: k++) {
2771:
2772: if (!cellHasTerrainFlag(k, j-1, T_OBSTRUCTS_PASSABILITY) // Can't run against a wall the whole way.
2773: && !cellHasTerrainFlag(k, j+1, T_OBSTRUCTS_PASSABILITY)) {
2774: foundExposure = true;
2775: }
2776: }
2777: if (k < DCOLS
2778: && (k - i > 3) // Can't have bridges shorter than 3 spaces.
2779: && foundExposure
2780: && !cellHasTerrainFlag(k, j, T_PATHING_BLOCKER | T_CAN_BE_BRIDGED) // Must end on an unobstructed land tile.
2781: && !pmap[k][j].machineNumber // Cannot end in a machine.
2782: && 100 * pathingDistance(i, j, k, j, T_PATHING_BLOCKER) / (k - i) > bridgeRatioX) { // Must shorten the pathing distance enough.
2783:
2784: for (l=i+1; l < k; l++) {
2785: pmap[l][j].layers[LIQUID] = BRIDGE;
2786: }
2787: pmap[i][j].layers[SURFACE] = BRIDGE_EDGE;
2788: pmap[k][j].layers[SURFACE] = BRIDGE_EDGE;
2789: return true;
2790: }
2791:
2792: // try a vertical bridge
2793: foundExposure = false;
2794: for (k = j + 1;
2795: k < DROWS
2796: && !pmap[i][k].machineNumber
2797: && cellHasTerrainFlag(i, k, T_CAN_BE_BRIDGED)
2798: && !cellHasTMFlag(i, k, TM_IS_SECRET)
2799: && !cellHasTerrainFlag(i, k, T_OBSTRUCTS_PASSABILITY)
2800: && cellHasTerrainFlag(i-1, k, (T_CAN_BE_BRIDGED | T_OBSTRUCTS_PASSABILITY))
2801: && cellHasTerrainFlag(i+1, k, (T_CAN_BE_BRIDGED | T_OBSTRUCTS_PASSABILITY));
2802: k++) {
2803:
2804: if (!cellHasTerrainFlag(i-1, k, T_OBSTRUCTS_PASSABILITY)
2805: && !cellHasTerrainFlag(i+1, k, T_OBSTRUCTS_PASSABILITY)) {
2806: foundExposure = true;
2807: }
2808: }
2809: if (k < DROWS
2810: && (k - j > 3)
2811: && foundExposure
2812: && !cellHasTerrainFlag(i, k, T_PATHING_BLOCKER | T_CAN_BE_BRIDGED)
2813: && !pmap[i][k].machineNumber // Cannot end in a machine.
2814: && 100 * pathingDistance(i, j, i, k, T_PATHING_BLOCKER) / (k - j) > bridgeRatioY) {
2815:
2816: for (l=j+1; l < k; l++) {
2817: pmap[i][l].layers[LIQUID] = BRIDGE;
2818: }
2819: pmap[i][j].layers[SURFACE] = BRIDGE_EDGE;
2820: pmap[i][k].layers[SURFACE] = BRIDGE_EDGE;
2821: return true;
2822: }
2823: }
2824: }
2825: }
2826: return false;
2827: }
2828:
2829: // This is the master function for digging out a dungeon level.
2830: // Finishing touches -- items, monsters, staircases, etc. -- are handled elsewhere.
2831: void digDungeon() {
2832: short i, j;
2833:
2834: short **grid;
2835:
2836: rogue.machineNumber = 0;
2837:
2838: topBlobMinX = topBlobMinY = blobWidth = blobHeight = 0;
2839:
2840: #ifdef AUDIT_RNG
2841: char RNGMessage[100];
2842: sprintf(RNGMessage, "\n\n\nDigging dungeon level %i:\n", rogue.depthLevel);
2843: RNGLog(RNGMessage);
2844: #endif
2845:
2846: // Clear level and fill with granite
2847: clearLevel();
2848:
2849: grid = allocGrid();
2850: carveDungeon(grid);
2851: addLoops(grid, 20);
2852: for (i=0; i<DCOLS; i++) {
2853: for (j=0; j<DROWS; j++) {
2854: if (grid[i][j] == 1) {
2855: pmap[i][j].layers[DUNGEON] = FLOOR;
2856: } else if (grid[i][j] == 2) {
2857: pmap[i][j].layers[DUNGEON] = (rand_percent(60) && rogue.depthLevel < DEEPEST_LEVEL ? DOOR : FLOOR);
2858: }
2859: }
2860: }
2861: freeGrid(grid);
2862:
2863: finishWalls(false);
2864:
2865: if (D_INSPECT_LEVELGEN) {
2866: dumpLevelToScreen();
2867: temporaryMessage("Carved into the granite:", true);
2868: }
2869: //DEBUG printf("\n%i loops created.", numLoops);
2870: //DEBUG logLevel();
2871:
2872: // Time to add lakes and chasms. Strategy is to generate a series of blob lakes of decreasing size. For each lake,
2873: // propose a position, and then check via a flood fill that the level would remain connected with that placement (i.e. that
2874: // each passable tile can still be reached). If not, make 9 more placement attempts before abandoning that lake
2875: // and proceeding to generate the next smaller one.
2876: // Canvas sizes start at 30x15 and decrease by 2x1 at a time down to a minimum of 20x10. Min generated size is always 4x4.
2877:
2878: // DEBUG logLevel();
2879:
2880: // Now design the lakes and then fill them with various liquids (lava, water, chasm, brimstone).
2881: short **lakeMap = allocGrid();
2882: designLakes(lakeMap);
2883: fillLakes(lakeMap);
2884: freeGrid(lakeMap);
2885:
2886: // Run the non-machine autoGenerators.
2887: runAutogenerators(false);
2888:
2889: // Remove diagonal openings.
2890: removeDiagonalOpenings();
2891:
2892: if (D_INSPECT_LEVELGEN) {
2893: dumpLevelToScreen();
2894: temporaryMessage("Diagonal openings removed.", true);
2895: }
2896:
2897: // Now add some treasure machines.
2898: addMachines();
2899:
2900: if (D_INSPECT_LEVELGEN) {
2901: dumpLevelToScreen();
2902: temporaryMessage("Machines added.", true);
2903: }
2904:
2905: // Run the machine autoGenerators.
2906: runAutogenerators(true);
2907:
2908: // Now knock down the boundaries between similar lakes where possible.
2909: cleanUpLakeBoundaries();
2910:
2911: if (D_INSPECT_LEVELGEN) {
2912: dumpLevelToScreen();
2913: temporaryMessage("Lake boundaries cleaned up.", true);
2914: }
2915:
2916: // Now add some bridges.
2917: while (buildABridge());
2918:
2919: if (D_INSPECT_LEVELGEN) {
2920: dumpLevelToScreen();
2921: temporaryMessage("Bridges added.", true);
2922: }
2923:
2924: // Now remove orphaned doors and upgrade some doors to secret doors
2925: finishDoors();
2926:
2927: // Now finish any exposed granite with walls and revert any unexposed walls to granite
2928: finishWalls(true);
2929:
2930: if (D_INSPECT_LEVELGEN) {
2931: dumpLevelToScreen();
2932: temporaryMessage("Finishing touches added. Level has been generated.", true);
2933: }
2934: }
2935:
2936: void updateMapToShore() {
2937: short i, j;
2938: short **costMap;
2939:
2940: rogue.updatedMapToShoreThisTurn = true;
2941:
2942: costMap = allocGrid();
2943:
2944: // Calculate the map to shore for this level
2945: if (!rogue.mapToShore) {
2946: rogue.mapToShore = allocGrid();
2947: fillGrid(rogue.mapToShore, 0);
2948: }
2949: for (i=0; i<DCOLS; i++) {
2950: for (j=0; j<DROWS; j++) {
2951: if (cellHasTerrainFlag(i, j, T_OBSTRUCTS_PASSABILITY)) {
2952: costMap[i][j] = cellHasTerrainFlag(i, j, T_OBSTRUCTS_DIAGONAL_MOVEMENT) ? PDS_OBSTRUCTION : PDS_FORBIDDEN;
2953: rogue.mapToShore[i][j] = 30000;
2954: } else {
2955: costMap[i][j] = 1;
2956: rogue.mapToShore[i][j] = (cellHasTerrainFlag(i, j, T_LAVA_INSTA_DEATH | T_IS_DEEP_WATER | T_AUTO_DESCENT)
2957: && !cellHasTMFlag(i, j, TM_IS_SECRET)) ? 30000 : 0;
2958: }
2959: }
2960: }
2961: dijkstraScan(rogue.mapToShore, costMap, true);
2962: freeGrid(costMap);
2963: }
2964:
2965: // Calculates the distance map for the given waypoint.
2966: // This is called on all waypoints during setUpWaypoints(),
2967: // and then one waypoint is recalculated per turn thereafter.
2968: void refreshWaypoint(short wpIndex) {
2969: short **costMap;
2970: creature *monst;
2971:
2972: costMap = allocGrid();
2973: populateGenericCostMap(costMap);
2974: for (monst = monsters->nextCreature; monst != NULL; monst = monst->nextCreature) {
2975: if ((monst->creatureState == MONSTER_SLEEPING || (monst->info.flags & MONST_IMMOBILE) || (monst->bookkeepingFlags & MB_CAPTIVE))
2976: && costMap[monst->xLoc][monst->yLoc] >= 0) {
2977:
2978: costMap[monst->xLoc][monst->yLoc] = PDS_FORBIDDEN;
2979: }
2980: }
2981: fillGrid(rogue.wpDistance[wpIndex], 30000);
2982: rogue.wpDistance[wpIndex][rogue.wpCoordinates[wpIndex][0]][rogue.wpCoordinates[wpIndex][1]] = 0;
2983: dijkstraScan(rogue.wpDistance[wpIndex], costMap, true);
2984: freeGrid(costMap);
2985: }
2986:
2987: void setUpWaypoints() {
2988: short i, j, sCoord[DCOLS * DROWS], x, y;
2989: char grid[DCOLS][DROWS];
2990:
2991: zeroOutGrid(grid);
2992: for (i=0; i<DCOLS; i++) {
2993: for (j=0; j<DROWS; j++) {
2994: if (cellHasTerrainFlag(i, j, T_OBSTRUCTS_SCENT)) {
2995: grid[i][j] = 1;
2996: }
2997: }
2998: }
2999: rogue.wpCount = 0;
3000: rogue.wpRefreshTicker = 0;
3001: fillSequentialList(sCoord, DCOLS*DROWS);
3002: shuffleList(sCoord, DCOLS*DROWS);
3003: for (i = 0; i < DCOLS*DROWS && rogue.wpCount < MAX_WAYPOINT_COUNT; i++) {
3004: x = sCoord[i]/DROWS;
3005: y = sCoord[i] % DROWS;
3006: if (!grid[x][y]) {
3007: getFOVMask(grid, x, y, WAYPOINT_SIGHT_RADIUS * FP_FACTOR, T_OBSTRUCTS_SCENT, 0, false);
3008: grid[x][y] = true;
3009: rogue.wpCoordinates[rogue.wpCount][0] = x;
3010: rogue.wpCoordinates[rogue.wpCount][1] = y;
3011: rogue.wpCount++;
3012: // blackOutScreen();
3013: // dumpLevelToScreen();
3014: // hiliteCharGrid(grid, &yellow, 50);
3015: // temporaryMessage("Waypoint coverage so far:", true);
3016: }
3017: }
3018:
3019: for (i=0; i<rogue.wpCount; i++) {
3020: refreshWaypoint(i);
3021: // blackOutScreen();
3022: // dumpLevelToScreen();
3023: // displayGrid(rogue.wpDistance[i]);
3024: // temporaryMessage("Waypoint distance map:", true);
3025: }
3026: }
3027:
3028: void zeroOutGrid(char grid[DCOLS][DROWS]) {
3029: short i, j;
3030: for (i=0; i<DCOLS; i++) {
3031: for (j=0; j<DROWS; j++) {
3032: grid[i][j] = 0;
3033: }
3034: }
3035: }
3036:
3037: short oppositeDirection(short theDir) {
3038: switch (theDir) {
3039: case UP:
3040: return DOWN;
3041: case DOWN:
3042: return UP;
3043: case LEFT:
3044: return RIGHT;
3045: case RIGHT:
3046: return LEFT;
3047: case UPRIGHT:
3048: return DOWNLEFT;
3049: case DOWNLEFT:
3050: return UPRIGHT;
3051: case UPLEFT:
3052: return DOWNRIGHT;
3053: case DOWNRIGHT:
3054: return UPLEFT;
3055: case NO_DIRECTION:
3056: return NO_DIRECTION;
3057: default:
3058: return -1;
3059: }
3060: }
3061:
3062: // blockingMap is optional.
3063: // Returns the size of the connected zone, and marks visited[][] with the zoneLabel.
3064: short connectCell(short x, short y, short zoneLabel, char blockingMap[DCOLS][DROWS], char zoneMap[DCOLS][DROWS]) {
3065: enum directions dir;
3066: short newX, newY, size;
3067:
3068: zoneMap[x][y] = zoneLabel;
3069: size = 1;
3070:
3071: for (dir = 0; dir < 4; dir++) {
3072: newX = x + nbDirs[dir][0];
3073: newY = y + nbDirs[dir][1];
3074:
3075: if (coordinatesAreInMap(newX, newY)
3076: && zoneMap[newX][newY] == 0
3077: && (!blockingMap || !blockingMap[newX][newY])
3078: && cellIsPassableOrDoor(newX, newY)) {
3079:
3080: size += connectCell(newX, newY, zoneLabel, blockingMap, zoneMap);
3081: }
3082: }
3083: return size;
3084: }
3085:
3086: // Make a zone map of connected passable regions that include at least one passable
3087: // cell that borders the blockingMap if blockingMap blocks. Keep track of the size of each zone.
3088: // Then pretend that the blockingMap no longer blocks, and grow these zones into the resulting area
3089: // (without changing the stored zone sizes). If two or more zones now touch, then we block.
3090: // At that point, return the size in cells of the smallest of all of the touching regions
3091: // (or just 1, i.e. true, if countRegionSize is false). If no zones touch, then we don't block, and we return zero, i.e. false.
3092: short levelIsDisconnectedWithBlockingMap(char blockingMap[DCOLS][DROWS], boolean countRegionSize) {
3093: char zoneMap[DCOLS][DROWS];
3094: short i, j, dir, zoneSizes[200], zoneCount, smallestQualifyingZoneSize, borderingZone;
3095:
3096: zoneCount = 0;
3097: smallestQualifyingZoneSize = 10000;
3098: zeroOutGrid(zoneMap);
3099:
3100: // dumpLevelToScreen();
3101: // hiliteCharGrid(blockingMap, &omniscienceColor, 100);
3102: // temporaryMessage("Blocking map:", true);
3103:
3104: // Map out the zones with the blocking area blocked.
3105: for (i=1; i<DCOLS-1; i++) {
3106: for (j=1; j<DROWS-1; j++) {
3107: if (cellIsPassableOrDoor(i, j) && zoneMap[i][j] == 0 && !blockingMap[i][j]) {
3108: for (dir=0; dir<4; dir++) {
3109: if (blockingMap[i + nbDirs[dir][0]][j + nbDirs[dir][1]]) {
3110: zoneCount++;
3111: zoneSizes[zoneCount - 1] = connectCell(i, j, zoneCount, blockingMap, zoneMap);
3112: break;
3113: }
3114: }
3115: }
3116: }
3117: }
3118:
3119: // Expand the zones into the blocking area.
3120: for (i=1; i<DCOLS-1; i++) {
3121: for (j=1; j<DROWS-1; j++) {
3122: if (blockingMap[i][j] && zoneMap[i][j] == 0 && cellIsPassableOrDoor(i, j)) {
3123: for (dir=0; dir<4; dir++) {
3124: borderingZone = zoneMap[i + nbDirs[dir][0]][j + nbDirs[dir][1]];
3125: if (borderingZone != 0) {
3126: connectCell(i, j, borderingZone, NULL, zoneMap);
3127: break;
3128: }
3129: }
3130: }
3131: }
3132: }
3133:
3134: // Figure out which zones touch.
3135: for (i=1; i<DCOLS-1; i++) {
3136: for (j=1; j<DROWS-1; j++) {
3137: if (zoneMap[i][j] != 0) {
3138: for (dir=0; dir<4; dir++) {
3139: borderingZone = zoneMap[i + nbDirs[dir][0]][j + nbDirs[dir][1]];
3140: if (zoneMap[i][j] != borderingZone && borderingZone != 0) {
3141: if (!countRegionSize) {
3142: return true;
3143: }
3144: smallestQualifyingZoneSize = min(smallestQualifyingZoneSize, zoneSizes[zoneMap[i][j] - 1]);
3145: smallestQualifyingZoneSize = min(smallestQualifyingZoneSize, zoneSizes[borderingZone - 1]);
3146: break;
3147: }
3148: }
3149: }
3150: }
3151: }
3152: return (smallestQualifyingZoneSize < 10000 ? smallestQualifyingZoneSize : 0);
3153: }
3154:
3155: void resetDFMessageEligibility() {
3156: short i;
3157:
3158: for (i=0; i<NUMBER_DUNGEON_FEATURES; i++) {
3159: dungeonFeatureCatalog[i].messageDisplayed = false;
3160: }
3161: }
3162:
3163: boolean fillSpawnMap(enum dungeonLayers layer,
3164: enum tileType surfaceTileType,
3165: char spawnMap[DCOLS][DROWS],
3166: boolean blockedByOtherLayers,
3167: boolean refresh,
3168: boolean superpriority) {
3169: short i, j;
3170: creature *monst;
3171: item *theItem;
3172: boolean accomplishedSomething;
3173:
3174: accomplishedSomething = false;
3175:
3176: for (i=0; i<DCOLS; i++) {
3177: for (j=0; j<DROWS; j++) {
3178: if ( // If it's flagged for building in the spawn map,
3179: spawnMap[i][j]
3180: // and the new cell doesn't already contain the fill terrain,
3181: && pmap[i][j].layers[layer] != surfaceTileType
3182: // and the terrain in the layer to be overwritten has a higher priority number (unless superpriority),
3183: && (superpriority || tileCatalog[pmap[i][j].layers[layer]].drawPriority >= tileCatalog[surfaceTileType].drawPriority)
3184: // and we won't be painting into the surface layer when that cell forbids it,
3185: && !(layer == SURFACE && cellHasTerrainFlag(i, j, T_OBSTRUCTS_SURFACE_EFFECTS))
3186: // and, if requested, the fill won't violate the priority of the most important terrain in this cell:
3187: && (!blockedByOtherLayers || tileCatalog[pmap[i][j].layers[highestPriorityLayer(i, j, true)]].drawPriority >= tileCatalog[surfaceTileType].drawPriority)
3188: ) {
3189:
3190: if ((tileCatalog[surfaceTileType].flags & T_IS_FIRE)
3191: && !(tileCatalog[pmap[i][j].layers[layer]].flags & T_IS_FIRE)) {
3192: pmap[i][j].flags |= CAUGHT_FIRE_THIS_TURN;
3193: }
3194:
3195: if ((tileCatalog[pmap[i][j].layers[layer]].flags & T_PATHING_BLOCKER)
3196: != (tileCatalog[surfaceTileType].flags & T_PATHING_BLOCKER)) {
3197:
3198: rogue.staleLoopMap = true;
3199: }
3200:
3201: pmap[i][j].layers[layer] = surfaceTileType; // Place the terrain!
3202: accomplishedSomething = true;
3203:
3204: if (refresh) {
3205: refreshDungeonCell(i, j);
3206: if (player.xLoc == i && player.yLoc == j && !player.status[STATUS_LEVITATING] && refresh) {
3207: flavorMessage(tileFlavor(player.xLoc, player.yLoc));
3208: }
3209: if (pmap[i][j].flags & (HAS_MONSTER)) {
3210: monst = monsterAtLoc(i, j);
3211: applyInstantTileEffectsToCreature(monst);
3212: if (rogue.gameHasEnded) {
3213: return true;
3214: }
3215: }
3216: if (tileCatalog[surfaceTileType].flags & T_IS_FIRE) {
3217: if (pmap[i][j].flags & HAS_ITEM) {
3218: theItem = itemAtLoc(i, j);
3219: if (theItem->flags & ITEM_FLAMMABLE) {
3220: burnItem(theItem);
3221: }
3222: }
3223: }
3224: }
3225: } else {
3226: spawnMap[i][j] = false; // so that the spawnmap reflects what actually got built
3227: }
3228: }
3229: }
3230: return accomplishedSomething;
3231: }
3232:
3233: void spawnMapDF(short x, short y,
3234: enum tileType propagationTerrain,
3235: boolean requirePropTerrain,
3236: short startProb,
3237: short probDec,
3238: char spawnMap[DCOLS][DROWS]) {
3239:
3240: short i, j, dir, t, x2, y2;
3241: boolean madeChange;
3242:
3243: spawnMap[x][y] = t = 1; // incremented before anything else happens
3244:
3245: madeChange = true;
3246:
3247: while (madeChange && startProb > 0) {
3248: madeChange = false;
3249: t++;
3250: for (i = 0; i < DCOLS; i++) {
3251: for (j=0; j < DROWS; j++) {
3252: if (spawnMap[i][j] == t - 1) {
3253: for (dir = 0; dir < 4; dir++) {
3254: x2 = i + nbDirs[dir][0];
3255: y2 = j + nbDirs[dir][1];
3256: if (coordinatesAreInMap(x2, y2)
3257: && (!requirePropTerrain || (propagationTerrain > 0 && cellHasTerrainType(x2, y2, propagationTerrain)))
3258: && (!cellHasTerrainFlag(x2, y2, T_OBSTRUCTS_SURFACE_EFFECTS) || (propagationTerrain > 0 && cellHasTerrainType(x2, y2, propagationTerrain)))
3259: && rand_percent(startProb)) {
3260:
3261: spawnMap[x2][y2] = t;
3262: madeChange = true;
3263: }
3264: }
3265: }
3266: }
3267: }
3268: startProb -= probDec;
3269: if (t > 100) {
3270: for (i = 0; i < DCOLS; i++) {
3271: for (j=0; j < DROWS; j++) {
3272: if (spawnMap[i][j] == t) {
3273: spawnMap[i][j] = 2;
3274: } else if (spawnMap[i][j] > 0) {
3275: spawnMap[i][j] = 1;
3276: }
3277: }
3278: }
3279: t = 2;
3280: }
3281: }
3282: if (requirePropTerrain && !cellHasTerrainType(x, y, propagationTerrain)) {
3283: spawnMap[x][y] = 0;
3284: }
3285: }
3286:
3287: void evacuateCreatures(char blockingMap[DCOLS][DROWS]) {
3288: short i, j, newLoc[2];
3289: creature *monst;
3290:
3291: for (i=0; i<DCOLS; i++) {
3292: for (j=0; j<DROWS; j++) {
3293: if (blockingMap[i][j]
3294: && (pmap[i][j].flags & (HAS_MONSTER | HAS_PLAYER))) {
3295:
3296: monst = monsterAtLoc(i, j);
3297: getQualifyingLocNear(newLoc,
3298: i, j,
3299: true,
3300: blockingMap,
3301: forbiddenFlagsForMonster(&(monst->info)),
3302: (HAS_MONSTER | HAS_PLAYER),
3303: false,
3304: false);
3305: monst->xLoc = newLoc[0];
3306: monst->yLoc = newLoc[1];
3307: pmap[i][j].flags &= ~(HAS_MONSTER | HAS_PLAYER);
3308: pmap[newLoc[0]][newLoc[1]].flags |= (monst == &player ? HAS_PLAYER : HAS_MONSTER);
3309: }
3310: }
3311: }
3312: }
3313:
3314: // returns whether the feature was successfully generated (false if we aborted because of blocking)
3315: boolean spawnDungeonFeature(short x, short y, dungeonFeature *feat, boolean refreshCell, boolean abortIfBlocking) {
3316: short i, j, layer;
3317: char blockingMap[DCOLS][DROWS];
3318: boolean blocking;
3319: boolean succeeded;
3320: creature *monst;
3321:
3322: if ((feat->flags & DFF_RESURRECT_ALLY)
3323: && !resurrectAlly(x, y)) {
3324: return false;
3325: }
3326:
3327: if (feat->description[0] && !feat->messageDisplayed && playerCanSee(x, y)) {
3328: feat->messageDisplayed = true;
3329: message(feat->description, false);
3330: }
3331:
3332: zeroOutGrid(blockingMap);
3333:
3334: // Blocking keeps track of whether to abort if it turns out that the DF would obstruct the level.
3335: blocking = ((abortIfBlocking
3336: && !(feat->flags & DFF_PERMIT_BLOCKING)
3337: && ((tileCatalog[feat->tile].flags & (T_PATHING_BLOCKER))
3338: || (feat->flags & DFF_TREAT_AS_BLOCKING))) ? true : false);
3339:
3340: if (feat->tile) {
3341: if (feat->layer == GAS) {
3342: pmap[x][y].volume += feat->startProbability;
3343: pmap[x][y].layers[GAS] = feat->tile;
3344: if (refreshCell) {
3345: refreshDungeonCell(x, y);
3346: }
3347: succeeded = true;
3348: } else {
3349: spawnMapDF(x, y,
3350: feat->propagationTerrain,
3351: (feat->propagationTerrain ? true : false),
3352: feat->startProbability,
3353: feat->probabilityDecrement,
3354: blockingMap);
3355: if (!blocking || !levelIsDisconnectedWithBlockingMap(blockingMap, false)) {
3356: if (feat->flags & DFF_EVACUATE_CREATURES_FIRST) { // first, evacuate creatures if necessary, so that they do not re-trigger the tile.
3357: evacuateCreatures(blockingMap);
3358: }
3359:
3360: //succeeded = fillSpawnMap(feat->layer, feat->tile, blockingMap, (feat->flags & DFF_BLOCKED_BY_OTHER_LAYERS), refreshCell, (feat->flags & DFF_SUPERPRIORITY));
3361: fillSpawnMap(feat->layer,
3362: feat->tile,
3363: blockingMap,
3364: (feat->flags & DFF_BLOCKED_BY_OTHER_LAYERS),
3365: refreshCell,
3366: (feat->flags & DFF_SUPERPRIORITY)); // this can tweak the spawn map too
3367: succeeded = true; // fail ONLY if we blocked the level. We succeed even if, thanks to priority, nothing gets built.
3368: } else {
3369: succeeded = false;
3370: }
3371: }
3372: } else {
3373: blockingMap[x][y] = true;
3374: succeeded = true; // Automatically succeed if there is no terrain to place.
3375: if (feat->flags & DFF_EVACUATE_CREATURES_FIRST) { // first, evacuate creatures if necessary, so that they do not re-trigger the tile.
3376: evacuateCreatures(blockingMap);
3377: }
3378: }
3379:
3380: if (succeeded && (feat->flags & DFF_CLEAR_OTHER_TERRAIN)) {
3381: for (i=0; i<DCOLS; i++) {
3382: for (j=0; j<DROWS; j++) {
3383: if (blockingMap[i][j]) {
3384: for (layer = 0; layer < NUMBER_TERRAIN_LAYERS; layer++) {
3385: if (layer != feat->layer && layer != GAS) {
3386: pmap[i][j].layers[layer] = (layer == DUNGEON ? FLOOR : NOTHING);
3387: }
3388: }
3389: }
3390: }
3391: }
3392: }
3393:
3394: if (succeeded) {
3395: if ((feat->flags & DFF_AGGRAVATES_MONSTERS) && feat->effectRadius) {
3396: aggravateMonsters(feat->effectRadius, x, y, &gray);
3397: }
3398: if (refreshCell && feat->flashColor && feat->effectRadius) {
3399: colorFlash(feat->flashColor, 0, (IN_FIELD_OF_VIEW | CLAIRVOYANT_VISIBLE), 4, feat->effectRadius, x, y);
3400: }
3401: if (refreshCell && feat->lightFlare) {
3402: createFlare(x, y, feat->lightFlare);
3403: }
3404: }
3405:
3406: if (refreshCell
3407: && (tileCatalog[feat->tile].flags & (T_IS_FIRE | T_AUTO_DESCENT))
3408: && cellHasTerrainFlag(player.xLoc, player.yLoc, (T_IS_FIRE | T_AUTO_DESCENT))) {
3409:
3410: applyInstantTileEffectsToCreature(&player);
3411: }
3412: if (rogue.gameHasEnded) {
3413: return succeeded;
3414: }
3415: // if (succeeded && feat->description[0] && !feat->messageDisplayed && playerCanSee(x, y)) {
3416: // feat->messageDisplayed = true;
3417: // message(feat->description, false);
3418: // }
3419: if (succeeded) {
3420: if (feat->subsequentDF) {
3421: if (feat->flags & DFF_SUBSEQ_EVERYWHERE) {
3422: for (i=0; i<DCOLS; i++) {
3423: for (j=0; j<DROWS; j++) {
3424: if (blockingMap[i][j]) {
3425: spawnDungeonFeature(i, j, &dungeonFeatureCatalog[feat->subsequentDF], refreshCell, abortIfBlocking);
3426: }
3427: }
3428: }
3429: } else {
3430: spawnDungeonFeature(x, y, &dungeonFeatureCatalog[feat->subsequentDF], refreshCell, abortIfBlocking);
3431: }
3432: }
3433: if (feat->tile
3434: && (tileCatalog[feat->tile].flags & (T_IS_DEEP_WATER | T_LAVA_INSTA_DEATH | T_AUTO_DESCENT))) {
3435:
3436: rogue.updatedMapToShoreThisTurn = false;
3437: }
3438:
3439: // awaken dormant creatures?
3440: if (feat->flags & DFF_ACTIVATE_DORMANT_MONSTER) {
3441: for (monst = dormantMonsters->nextCreature; monst != NULL; monst = monst->nextCreature) {
3442: if (monst->xLoc == x && monst->yLoc == y || blockingMap[monst->xLoc][monst->yLoc]) {
3443: // found it!
3444: toggleMonsterDormancy(monst);
3445: monst = dormantMonsters;
3446: }
3447: }
3448: }
3449: }
3450: return succeeded;
3451: }
3452:
3453: void restoreMonster(creature *monst, short **mapToStairs, short **mapToPit) {
3454: short i, *x, *y, turnCount;//, loc[2];
3455: creature *leader;
3456: boolean foundLeader = false;
3457: short **theMap;
3458: enum directions dir;
3459:
3460: x = &(monst->xLoc);
3461: y = &(monst->yLoc);
3462:
3463: if (monst->status[STATUS_ENTERS_LEVEL_IN] > 0) {
3464: if (monst->bookkeepingFlags & (MB_APPROACHING_PIT)) {
3465: theMap = mapToPit;
3466: } else {
3467: theMap = mapToStairs;
3468: }
3469:
3470: if(rogue.patchVersion >= 3) {
3471: pmap[*x][*y].flags &= ~HAS_MONSTER;
3472: }
3473: if (theMap) {
3474: // STATUS_ENTERS_LEVEL_IN accounts for monster speed; convert back to map distance and subtract from distance to stairs
3475: turnCount = rogue.patchVersion < 3 ? ((theMap[monst->xLoc][monst->yLoc] * monst->movementSpeed / 100) - monst->status[STATUS_ENTERS_LEVEL_IN])
3476: : (theMap[monst->xLoc][monst->yLoc] - (monst->status[STATUS_ENTERS_LEVEL_IN] * 100 / monst->movementSpeed));
3477: for (i=0; i < turnCount; i++) {
3478: if ((dir = nextStep(theMap, monst->xLoc, monst->yLoc, NULL, true)) != NO_DIRECTION) {
3479: monst->xLoc += nbDirs[dir][0];
3480: monst->yLoc += nbDirs[dir][1];
3481: } else {
3482: break;
3483: }
3484: }
3485: }
3486: monst->bookkeepingFlags |= MB_PREPLACED;
3487: }
3488:
3489: if ((pmap[*x][*y].flags & (HAS_PLAYER | HAS_STAIRS))
3490: || (monst->bookkeepingFlags & MB_PREPLACED)) {
3491:
3492: if (!(monst->bookkeepingFlags & MB_PREPLACED)) {
3493: // (If if it's preplaced, it won't have set the HAS_MONSTER flag in the first place,
3494: // so clearing it might screw up an existing monster.)
3495: pmap[*x][*y].flags &= ~HAS_MONSTER;
3496: }
3497: getQualifyingPathLocNear(x, y, *x, *y, true, T_DIVIDES_LEVEL & avoidedFlagsForMonster(&(monst->info)), 0,
3498: avoidedFlagsForMonster(&(monst->info)), (HAS_MONSTER | HAS_PLAYER | HAS_STAIRS), true);
3499: }
3500: pmap[*x][*y].flags |= HAS_MONSTER;
3501: monst->bookkeepingFlags &= ~(MB_PREPLACED | MB_APPROACHING_DOWNSTAIRS | MB_APPROACHING_UPSTAIRS | MB_APPROACHING_PIT | MB_ABSORBING);
3502: monst->status[STATUS_ENTERS_LEVEL_IN] = 0;
3503: monst->corpseAbsorptionCounter = 0;
3504:
3505: if ((monst->bookkeepingFlags & MB_SUBMERGED) && !cellHasTMFlag(*x, *y, TM_ALLOWS_SUBMERGING)) {
3506: monst->bookkeepingFlags &= ~MB_SUBMERGED;
3507: }
3508:
3509: if (monst->bookkeepingFlags & MB_FOLLOWER) {
3510: // is the leader on the same level?
3511: for (leader = monsters->nextCreature; leader != NULL; leader = leader->nextCreature) {
3512: if (leader == monst->leader) {
3513: foundLeader = true;
3514: break;
3515: }
3516: }
3517: // if not, it is time to spread your wings and fly solo
3518: if (!foundLeader) {
3519: monst->bookkeepingFlags &= ~MB_FOLLOWER;
3520: monst->leader = NULL;
3521: }
3522: }
3523: }
3524:
3525: void restoreItem(item *theItem) {
3526: short *x, *y, loc[2];
3527: x = &(theItem->xLoc);
3528: y = &(theItem->yLoc);
3529:
3530: if (theItem->flags & ITEM_PREPLACED) {
3531: theItem->flags &= ~ITEM_PREPLACED;
3532: getQualifyingLocNear(loc, *x, *y, true, 0, (T_OBSTRUCTS_ITEMS | T_AUTO_DESCENT | T_IS_DEEP_WATER | T_LAVA_INSTA_DEATH),
3533: (HAS_MONSTER | HAS_ITEM | HAS_STAIRS), true, false);
3534: *x = loc[0];
3535: *y = loc[1];
3536: }
3537: pmap[*x][*y].flags |= HAS_ITEM;
3538: if (theItem->flags & ITEM_MAGIC_DETECTED && itemMagicPolarity(theItem)) {
3539: pmap[*x][*y].flags |= ITEM_DETECTED;
3540: }
3541: }
3542:
3543: // Returns true iff the location is a plain wall, three of the four cardinal neighbors are walls, the remaining cardinal neighbor
3544: // is not a pathing blocker, the two diagonals between the three cardinal walls are also walls, and none of the eight neighbors are in machines.
3545: boolean validStairLoc(short x, short y) {
3546: short newX, newY, dir, neighborWallCount;
3547:
3548: if (x < 1 || x >= DCOLS - 1 || y < 1 || y >= DROWS - 1 || pmap[x][y].layers[DUNGEON] != WALL) {
3549: return false;
3550: }
3551:
3552: for (dir=0; dir< DIRECTION_COUNT; dir++) {
3553: newX = x + nbDirs[dir][0];
3554: newY = y + nbDirs[dir][1];
3555: if (pmap[newX][newY].flags & IS_IN_MACHINE) {
3556: return false;
3557: }
3558: }
3559:
3560: neighborWallCount = 0;
3561: for (dir=0; dir<4; dir++) {
3562: newX = x + nbDirs[dir][0];
3563: newY = y + nbDirs[dir][1];
3564:
3565: if (cellHasTerrainFlag(newX, newY, T_OBSTRUCTS_PASSABILITY)) {
3566: // neighbor is a wall
3567: neighborWallCount++;
3568: } else {
3569: // neighbor is not a wall
3570: if (cellHasTerrainFlag(newX, newY, T_PATHING_BLOCKER)
3571: || passableArcCount(newX, newY) >= 2) {
3572: return false;
3573: }
3574: // now check the two diagonals between the walls
3575:
3576: newX = x - nbDirs[dir][0] + nbDirs[dir][1];
3577: newY = y - nbDirs[dir][1] + nbDirs[dir][0];
3578: if (!cellHasTerrainFlag(newX, newY, T_OBSTRUCTS_PASSABILITY)) {
3579: return false;
3580: }
3581:
3582: newX = x - nbDirs[dir][0] - nbDirs[dir][1];
3583: newY = y - nbDirs[dir][1] - nbDirs[dir][0];
3584: if (!cellHasTerrainFlag(newX, newY, T_OBSTRUCTS_PASSABILITY)) {
3585: return false;
3586: }
3587: }
3588: }
3589: if (neighborWallCount != 3) {
3590: return false;
3591: }
3592: return true;
3593: }
3594:
3595: // The walls on either side become torches. Any adjacent granite then becomes top_wall. All wall neighbors are un-tunnelable.
3596: // Grid is zeroed out within 5 spaces in all directions.
3597: void prepareForStairs(short x, short y, char grid[DCOLS][DROWS]) {
3598: short newX, newY, dir;
3599:
3600: // Add torches to either side.
3601: for (dir=0; dir<4; dir++) {
3602: if (!cellHasTerrainFlag(x + nbDirs[dir][0], y + nbDirs[dir][1], T_OBSTRUCTS_PASSABILITY)) {
3603: newX = x - nbDirs[dir][1];
3604: newY = y - nbDirs[dir][0];
3605: pmap[newX][newY].layers[DUNGEON] = TORCH_WALL;
3606: newX = x + nbDirs[dir][1];
3607: newY = y + nbDirs[dir][0];
3608: pmap[newX][newY].layers[DUNGEON] = TORCH_WALL;
3609: break;
3610: }
3611: }
3612: // Expose granite.
3613: for (dir=0; dir< DIRECTION_COUNT; dir++) {
3614: newX = x + nbDirs[dir][0];
3615: newY = y + nbDirs[dir][1];
3616: if (pmap[newX][newY].layers[DUNGEON] == GRANITE) {
3617: pmap[newX][newY].layers[DUNGEON] = WALL;
3618: }
3619: if (cellHasTerrainFlag(newX, newY, T_OBSTRUCTS_PASSABILITY)) {
3620: pmap[newX][newY].flags |= IMPREGNABLE;
3621: }
3622: }
3623: // Zero out grid in the vicinity.
3624: for (newX = max(0, x - 5); newX < min(DCOLS, x + 5); newX++) {
3625: for (newY = max(0, y - 5); newY < min(DROWS, y + 5); newY++) {
3626: grid[newX][newY] = false;
3627: }
3628: }
3629: }
3630:
3631: // Places the player, monsters, items and stairs.
3632: void initializeLevel() {
3633: short i, j, dir;
3634: short upLoc[2], downLoc[2], **mapToStairs, **mapToPit;
3635: creature *monst;
3636: item *theItem;
3637: char grid[DCOLS][DROWS];
3638: short n = rogue.depthLevel - 1;
3639:
3640: // Place the stairs.
3641:
3642: for (i=0; i < DCOLS; i++) {
3643: for (j=0; j < DROWS; j++) {
3644: grid[i][j] = validStairLoc(i, j);
3645: }
3646: }
3647:
3648: if (D_INSPECT_LEVELGEN) {
3649: dumpLevelToScreen();
3650: hiliteCharGrid(grid, &teal, 100);
3651: temporaryMessage("Stair location candidates:", true);
3652: }
3653:
3654: if (getQualifyingGridLocNear(downLoc, levels[n].downStairsLoc[0], levels[n].downStairsLoc[1], grid, false)) {
3655: prepareForStairs(downLoc[0], downLoc[1], grid);
3656: } else {
3657: getQualifyingLocNear(downLoc, levels[n].downStairsLoc[0], levels[n].downStairsLoc[1], false, 0,
3658: (T_OBSTRUCTS_PASSABILITY | T_OBSTRUCTS_ITEMS | T_AUTO_DESCENT | T_IS_DEEP_WATER | T_LAVA_INSTA_DEATH | T_IS_DF_TRAP),
3659: (HAS_MONSTER | HAS_ITEM | HAS_STAIRS | IS_IN_MACHINE), true, false);
3660: }
3661:
3662: if (rogue.depthLevel == DEEPEST_LEVEL) {
3663: pmap[downLoc[0]][downLoc[1]].layers[DUNGEON] = DUNGEON_PORTAL;
3664: } else {
3665: pmap[downLoc[0]][downLoc[1]].layers[DUNGEON] = DOWN_STAIRS;
3666: }
3667: pmap[downLoc[0]][downLoc[1]].layers[LIQUID] = NOTHING;
3668: pmap[downLoc[0]][downLoc[1]].layers[SURFACE] = NOTHING;
3669:
3670: if (!levels[n+1].visited) {
3671: levels[n+1].upStairsLoc[0] = downLoc[0];
3672: levels[n+1].upStairsLoc[1] = downLoc[1];
3673: }
3674: levels[n].downStairsLoc[0] = downLoc[0];
3675: levels[n].downStairsLoc[1] = downLoc[1];
3676:
3677: if (getQualifyingGridLocNear(upLoc, levels[n].upStairsLoc[0], levels[n].upStairsLoc[1], grid, false)) {
3678: prepareForStairs(upLoc[0], upLoc[1], grid);
3679: } else { // Hopefully this never happens.
3680: getQualifyingLocNear(upLoc, levels[n].upStairsLoc[0], levels[n].upStairsLoc[1], false, 0,
3681: (T_OBSTRUCTS_PASSABILITY | T_OBSTRUCTS_ITEMS | T_AUTO_DESCENT | T_IS_DEEP_WATER | T_LAVA_INSTA_DEATH | T_IS_DF_TRAP),
3682: (HAS_MONSTER | HAS_ITEM | HAS_STAIRS | IS_IN_MACHINE), true, false);
3683: }
3684:
3685: levels[n].upStairsLoc[0] = upLoc[0];
3686: levels[n].upStairsLoc[1] = upLoc[1];
3687:
3688: if (rogue.depthLevel == 1) {
3689: pmap[upLoc[0]][upLoc[1]].layers[DUNGEON] = DUNGEON_EXIT;
3690: } else {
3691: pmap[upLoc[0]][upLoc[1]].layers[DUNGEON] = UP_STAIRS;
3692: }
3693: pmap[upLoc[0]][upLoc[1]].layers[LIQUID] = NOTHING;
3694: pmap[upLoc[0]][upLoc[1]].layers[SURFACE] = NOTHING;
3695:
3696: rogue.downLoc[0] = downLoc[0];
3697: rogue.downLoc[1] = downLoc[1];
3698: pmap[downLoc[0]][downLoc[1]].flags |= HAS_STAIRS;
3699: rogue.upLoc[0] = upLoc[0];
3700: rogue.upLoc[1] = upLoc[1];
3701: pmap[upLoc[0]][upLoc[1]].flags |= HAS_STAIRS;
3702:
3703: if (!levels[rogue.depthLevel-1].visited) {
3704:
3705: // Run a field of view check from up stairs so that monsters do not spawn within sight of it.
3706: for (dir=0; dir<4; dir++) {
3707: if (coordinatesAreInMap(upLoc[0] + nbDirs[dir][0], upLoc[1] + nbDirs[dir][1])
3708: && !cellHasTerrainFlag(upLoc[0] + nbDirs[dir][0], upLoc[1] + nbDirs[dir][1], T_OBSTRUCTS_PASSABILITY)) {
3709:
3710: upLoc[0] += nbDirs[dir][0];
3711: upLoc[1] += nbDirs[dir][1];
3712: break;
3713: }
3714: }
3715: zeroOutGrid(grid);
3716: getFOVMask(grid, upLoc[0], upLoc[1], max(DCOLS, DROWS) * FP_FACTOR, (T_OBSTRUCTS_VISION), 0, false);
3717: for (i=0; i<DCOLS; i++) {
3718: for (j=0; j<DROWS; j++) {
3719: if (grid[i][j]) {
3720: pmap[i][j].flags |= IN_FIELD_OF_VIEW;
3721: }
3722: }
3723: }
3724: populateItems(upLoc[0], upLoc[1]);
3725: populateMonsters();
3726: }
3727:
3728: // Restore items that fell from the previous depth.
3729: for (theItem = floorItems->nextItem; theItem != NULL; theItem = theItem->nextItem) {
3730: restoreItem(theItem);
3731: }
3732:
3733: // Restore creatures that fell from the previous depth or that have been pathing toward the stairs.
3734: mapToStairs = allocGrid();
3735: fillGrid(mapToStairs, 0);
3736: mapToPit = allocGrid();
3737: fillGrid(mapToPit, 0);
3738: calculateDistances(mapToStairs, player.xLoc, player.yLoc, T_PATHING_BLOCKER, NULL, true, true);
3739: calculateDistances(mapToPit,
3740: levels[rogue.depthLevel - 1].playerExitedVia[0],
3741: levels[rogue.depthLevel - 1].playerExitedVia[1],
3742: T_PATHING_BLOCKER,
3743: NULL,
3744: true,
3745: true);
3746: for (monst = monsters->nextCreature; monst != NULL; monst = monst->nextCreature) {
3747: restoreMonster(monst, mapToStairs, mapToPit);
3748: }
3749: freeGrid(mapToStairs);
3750: freeGrid(mapToPit);
3751: }
3752:
3753: // fills (*x, *y) with the coordinates of a random cell with
3754: // no creatures, items or stairs and with either a matching liquid and dungeon type
3755: // or at least one layer of type terrainType.
3756: // A dungeon, liquid type of -1 will match anything.
3757: boolean randomMatchingLocation(short *x, short *y, short dungeonType, short liquidType, short terrainType) {
3758: short failsafeCount = 0;
3759: do {
3760: failsafeCount++;
3761: *x = rand_range(0, DCOLS - 1);
3762: *y = rand_range(0, DROWS - 1);
3763: } while (failsafeCount < 500 && ((terrainType >= 0 && !cellHasTerrainType(*x, *y, terrainType))
3764: || (((dungeonType >= 0 && pmap[*x][*y].layers[DUNGEON] != dungeonType) || (liquidType >= 0 && pmap[*x][*y].layers[LIQUID] != liquidType)) && terrainType < 0)
3765: || (pmap[*x][*y].flags & (HAS_PLAYER | HAS_MONSTER | HAS_STAIRS | HAS_ITEM | IS_IN_MACHINE))
3766: || (terrainType < 0 && !(tileCatalog[dungeonType].flags & T_OBSTRUCTS_ITEMS)
3767: && cellHasTerrainFlag(*x, *y, T_OBSTRUCTS_ITEMS))));
3768: if (failsafeCount >= 500) {
3769: return false;
3770: }
3771: return true;
3772: }
CVSweb
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to Architect.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [contributed] / brogue-ce / src / brogue