Annotation of brogue-ce/src/brogue/Time.c, Revision 1.1
1.1 ! rubenllo 1: /*
! 2: * Time.c
! 3: * Brogue
! 4: *
! 5: * Created by Brian Walker on 6/21/13.
! 6: * Copyright 2013. 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: void exposeCreatureToFire(creature *monst) {
! 28: char buf[COLS], buf2[COLS];
! 29: if ((monst->bookkeepingFlags & MB_IS_DYING)
! 30: || monst->status[STATUS_IMMUNE_TO_FIRE]
! 31: || (monst->info.flags & MONST_INVULNERABLE)
! 32: || (monst->bookkeepingFlags & MB_SUBMERGED)
! 33: || ((!monst->status[STATUS_LEVITATING]) && cellHasTMFlag(monst->xLoc, monst->yLoc, TM_EXTINGUISHES_FIRE))) {
! 34: return;
! 35: }
! 36: if (monst->status[STATUS_BURNING] == 0) {
! 37: if (monst == &player) {
! 38: rogue.minersLight.lightColor = &fireForeColor;
! 39: player.info.foreColor = &torchLightColor;
! 40: refreshDungeonCell(player.xLoc, player.yLoc);
! 41: //updateVision(); // this screws up the firebolt visual effect by erasing it while a message is displayed
! 42: combatMessage("you catch fire", &badMessageColor);
! 43: } else if (canDirectlySeeMonster(monst)) {
! 44: monsterName(buf, monst, true);
! 45: sprintf(buf2, "%s catches fire", buf);
! 46: combatMessage(buf2, messageColorFromVictim(monst));
! 47: }
! 48: }
! 49: monst->status[STATUS_BURNING] = monst->maxStatus[STATUS_BURNING] = max(monst->status[STATUS_BURNING], 7);
! 50: }
! 51:
! 52: void updateFlavorText() {
! 53: char buf[DCOLS * 3];
! 54: if (rogue.disturbed && !rogue.gameHasEnded) {
! 55: if (rogue.armor
! 56: && (rogue.armor->flags & ITEM_RUNIC)
! 57: && rogue.armor->enchant2 == A_RESPIRATION
! 58: && tileCatalog[pmap[player.xLoc][player.yLoc].layers[highestPriorityLayer(player.xLoc, player.yLoc, false)]].flags & T_RESPIRATION_IMMUNITIES) {
! 59:
! 60: flavorMessage("A pocket of cool, clean air swirls around you.");
! 61: } else if (player.status[STATUS_LEVITATING]) {
! 62: describeLocation(buf, player.xLoc, player.yLoc);
! 63: flavorMessage(buf);
! 64: } else {
! 65: flavorMessage(tileFlavor(player.xLoc, player.yLoc));
! 66: }
! 67: }
! 68: }
! 69:
! 70: void updatePlayerUnderwaterness() {
! 71: if (rogue.inWater) {
! 72: if (!cellHasTerrainFlag(player.xLoc, player.yLoc, T_IS_DEEP_WATER) || player.status[STATUS_LEVITATING]
! 73: || cellHasTerrainFlag(player.xLoc, player.yLoc, (T_ENTANGLES | T_OBSTRUCTS_PASSABILITY))) {
! 74:
! 75: rogue.inWater = false;
! 76: updateMinersLightRadius();
! 77: updateVision(true);
! 78: displayLevel();
! 79: }
! 80: } else {
! 81: if (cellHasTerrainFlag(player.xLoc, player.yLoc, T_IS_DEEP_WATER) && !player.status[STATUS_LEVITATING]
! 82: && !cellHasTerrainFlag(player.xLoc, player.yLoc, (T_ENTANGLES | T_OBSTRUCTS_PASSABILITY))) {
! 83:
! 84: rogue.inWater = true;
! 85: updateMinersLightRadius();
! 86: updateVision(true);
! 87: displayLevel();
! 88: }
! 89: }
! 90: }
! 91:
! 92: boolean monsterShouldFall(creature *monst) {
! 93: return (!(monst->status[STATUS_LEVITATING])
! 94: && cellHasTerrainFlag(monst->xLoc, monst->yLoc, T_AUTO_DESCENT)
! 95: && !cellHasTerrainFlag(monst->xLoc, monst->yLoc, T_ENTANGLES | T_OBSTRUCTS_PASSABILITY)
! 96: && !(monst->bookkeepingFlags & MB_PREPLACED));
! 97: }
! 98:
! 99: // Called at least every 100 ticks; may be called more frequently.
! 100: void applyInstantTileEffectsToCreature(creature *monst) {
! 101: char buf[COLS], buf2[COLS], buf3[COLS];
! 102: short *x = &(monst->xLoc), *y = &(monst->yLoc), damage;
! 103: enum dungeonLayers layer;
! 104: item *theItem;
! 105:
! 106: if (monst->bookkeepingFlags & MB_IS_DYING) {
! 107: return; // the monster is already dead.
! 108: }
! 109:
! 110: if (monst == &player) {
! 111: if (!player.status[STATUS_LEVITATING]) {
! 112: pmap[*x][*y].flags |= KNOWN_TO_BE_TRAP_FREE;
! 113: }
! 114: } else if (!player.status[STATUS_HALLUCINATING]
! 115: && !monst->status[STATUS_LEVITATING]
! 116: && canSeeMonster(monst)
! 117: && !(cellHasTerrainFlag(*x, *y, T_IS_DF_TRAP))) {
! 118: pmap[*x][*y].flags |= KNOWN_TO_BE_TRAP_FREE;
! 119: }
! 120:
! 121: // You will discover the secrets of any tile you stand on.
! 122: if (monst == &player
! 123: && !(monst->status[STATUS_LEVITATING])
! 124: && cellHasTMFlag(*x, *y, TM_IS_SECRET)
! 125: && playerCanSee(*x, *y)) {
! 126:
! 127: discover(*x, *y);
! 128: }
! 129:
! 130: // Submerged monsters in terrain that doesn't permit submersion should immediately surface.
! 131: if ((monst->bookkeepingFlags & MB_SUBMERGED) && !cellHasTMFlag(*x, *y, TM_ALLOWS_SUBMERGING)) {
! 132: monst->bookkeepingFlags &= ~MB_SUBMERGED;
! 133: }
! 134:
! 135: // Visual effect for submersion in water.
! 136: if (monst == &player) {
! 137: updatePlayerUnderwaterness();
! 138: }
! 139:
! 140: // Obstructed krakens can't seize their prey.
! 141: if ((monst->bookkeepingFlags & MB_SEIZING)
! 142: && (cellHasTerrainFlag(*x, *y, T_OBSTRUCTS_PASSABILITY))
! 143: && !(monst->info.flags & MONST_ATTACKABLE_THRU_WALLS)) {
! 144:
! 145: monst->bookkeepingFlags &= ~MB_SEIZING;
! 146: }
! 147:
! 148: // Creatures plunge into chasms and through trap doors.
! 149: if (monsterShouldFall(monst)) {
! 150: if (monst == &player) {
! 151: // player falling takes place at the end of the turn
! 152: if (!(monst->bookkeepingFlags & MB_IS_FALLING)) {
! 153: monst->bookkeepingFlags |= MB_IS_FALLING;
! 154: }
! 155: return;
! 156: } else { // it's a monster
! 157: monst->bookkeepingFlags |= MB_IS_FALLING; // handled at end of turn
! 158: }
! 159: }
! 160:
! 161: // lava
! 162: if (!(monst->status[STATUS_LEVITATING])
! 163: && !(monst->status[STATUS_IMMUNE_TO_FIRE])
! 164: && !(monst->info.flags & MONST_INVULNERABLE)
! 165: && !cellHasTerrainFlag(*x, *y, (T_ENTANGLES | T_OBSTRUCTS_PASSABILITY))
! 166: && !cellHasTMFlag(*x, *y, TM_EXTINGUISHES_FIRE)
! 167: && cellHasTerrainFlag(*x, *y, T_LAVA_INSTA_DEATH)) {
! 168:
! 169: if (monst == &player) {
! 170: sprintf(buf, "you plunge into %s!",
! 171: tileCatalog[pmap[*x][*y].layers[layerWithFlag(*x, *y, T_LAVA_INSTA_DEATH)]].description);
! 172: message(buf, true);
! 173: sprintf(buf, "Killed by %s",
! 174: tileCatalog[pmap[*x][*y].layers[layerWithFlag(*x, *y, T_LAVA_INSTA_DEATH)]].description);
! 175: gameOver(buf, true);
! 176: return;
! 177: } else { // it's a monster
! 178: if (canSeeMonster(monst)) {
! 179: monsterName(buf, monst, true);
! 180: sprintf(buf2, "%s is consumed by the %s instantly!", buf,
! 181: tileCatalog[pmap[*x][*y].layers[layerWithFlag(*x, *y, T_LAVA_INSTA_DEATH)]].description);
! 182: messageWithColor(buf2, messageColorFromVictim(monst), false);
! 183: }
! 184: killCreature(monst, false);
! 185: spawnDungeonFeature(*x, *y, &(dungeonFeatureCatalog[DF_CREATURE_FIRE]), true, false);
! 186: refreshDungeonCell(*x, *y);
! 187: return;
! 188: }
! 189: }
! 190:
! 191: // Water puts out fire.
! 192: if (cellHasTMFlag(*x, *y, TM_EXTINGUISHES_FIRE)
! 193: && monst->status[STATUS_BURNING]
! 194: && !monst->status[STATUS_LEVITATING]
! 195: && !(monst->info.flags & MONST_ATTACKABLE_THRU_WALLS)
! 196: && !(monst->info.flags & MONST_FIERY)) {
! 197: extinguishFireOnCreature(monst);
! 198: }
! 199:
! 200: // If you see a monster use a secret door, you discover it.
! 201: if (playerCanSee(*x, *y)
! 202: && cellHasTMFlag(*x, *y, TM_IS_SECRET)
! 203: && (cellHasTerrainFlag(*x, *y, T_OBSTRUCTS_PASSABILITY))) {
! 204: discover(*x, *y);
! 205: }
! 206:
! 207: // Pressure plates.
! 208: if (!(monst->status[STATUS_LEVITATING])
! 209: && !(monst->bookkeepingFlags & MB_SUBMERGED)
! 210: && (!cellHasTMFlag(*x, *y, TM_ALLOWS_SUBMERGING) || !(monst->info.flags & MONST_SUBMERGES))
! 211: && cellHasTerrainFlag(*x, *y, T_IS_DF_TRAP)
! 212: && !(pmap[*x][*y].flags & PRESSURE_PLATE_DEPRESSED)) {
! 213:
! 214: pmap[*x][*y].flags |= PRESSURE_PLATE_DEPRESSED;
! 215: if (playerCanSee(*x, *y) && cellHasTMFlag(*x, *y, TM_IS_SECRET)) {
! 216: discover(*x, *y);
! 217: refreshDungeonCell(*x, *y);
! 218: }
! 219: if (canSeeMonster(monst)) {
! 220: monsterName(buf, monst, true);
! 221: sprintf(buf2, "a pressure plate clicks underneath %s!", buf);
! 222: message(buf2, true);
! 223: } else if (playerCanSee(*x, *y)) {
! 224: // usually means an invisible monster
! 225: message("a pressure plate clicks!", false);
! 226: }
! 227: for (layer = 0; layer < NUMBER_TERRAIN_LAYERS; layer++) {
! 228: if (tileCatalog[pmap[*x][*y].layers[layer]].flags & T_IS_DF_TRAP) {
! 229: spawnDungeonFeature(*x, *y, &(dungeonFeatureCatalog[tileCatalog[pmap[*x][*y].layers[layer]].fireType]), true, false);
! 230: promoteTile(*x, *y, layer, false);
! 231: }
! 232: }
! 233: }
! 234:
! 235: if (cellHasTMFlag(*x, *y, TM_PROMOTES_ON_STEP)) { // flying creatures activate too
! 236: // Because this uses no pressure plate to keep track of whether it's already depressed,
! 237: // it will trigger every time this function is called while the monster or player is on the tile.
! 238: // Because this function can be called several times per turn, multiple promotions can
! 239: // happen unpredictably if the tile does not promote to a tile without the T_PROMOTES_ON_STEP
! 240: // attribute. That's acceptable for some effects, e.g. doors opening,
! 241: // but not for others, e.g. magical glyphs activating.
! 242: for (layer = 0; layer < NUMBER_TERRAIN_LAYERS; layer++) {
! 243: if (tileCatalog[pmap[*x][*y].layers[layer]].mechFlags & TM_PROMOTES_ON_STEP) {
! 244: promoteTile(*x, *y, layer, false);
! 245: }
! 246: }
! 247: }
! 248:
! 249: if (cellHasTMFlag(*x, *y, TM_PROMOTES_ON_PLAYER_ENTRY) && monst == &player) {
! 250: // Subject to same caveats as T_PROMOTES_ON_STEP above.
! 251: for (layer = 0; layer < NUMBER_TERRAIN_LAYERS; layer++) {
! 252: if (tileCatalog[pmap[*x][*y].layers[layer]].mechFlags & TM_PROMOTES_ON_PLAYER_ENTRY) {
! 253: promoteTile(*x, *y, layer, false);
! 254: }
! 255: }
! 256: }
! 257:
! 258: if (cellHasTMFlag(*x, *y, TM_PROMOTES_ON_SACRIFICE_ENTRY)
! 259: && monst->machineHome == pmap[*x][*y].machineNumber
! 260: && (monst->bookkeepingFlags & MB_MARKED_FOR_SACRIFICE)) {
! 261: // Subject to same caveats as T_PROMOTES_ON_STEP above.
! 262: for (layer = 0; layer < NUMBER_TERRAIN_LAYERS; layer++) {
! 263: if (tileCatalog[pmap[*x][*y].layers[layer]].mechFlags & TM_PROMOTES_ON_SACRIFICE_ENTRY) {
! 264: promoteTile(*x, *y, layer, false);
! 265: }
! 266: }
! 267: }
! 268:
! 269: // spiderwebs
! 270: if (cellHasTerrainFlag(*x, *y, T_ENTANGLES) && !monst->status[STATUS_STUCK]
! 271: && !(monst->info.flags & (MONST_IMMUNE_TO_WEBS | MONST_INVULNERABLE))
! 272: && !(monst->bookkeepingFlags & MB_SUBMERGED)) {
! 273:
! 274: monst->status[STATUS_STUCK] = monst->maxStatus[STATUS_STUCK] = rand_range(3, 7);
! 275: if (monst == &player) {
! 276: if (!rogue.automationActive) {
! 277: // Don't interrupt exploration with this message.
! 278: sprintf(buf2, "you are stuck fast in %s!",
! 279: tileCatalog[pmap[*x][*y].layers[layerWithFlag(*x, *y, T_ENTANGLES)]].description);
! 280: message(buf2, false);
! 281: }
! 282: } else if (canDirectlySeeMonster(monst)) { // it's a monster
! 283: if (!rogue.automationActive) {
! 284: monsterName(buf, monst, true);
! 285: sprintf(buf2, "%s is stuck fast in %s!", buf,
! 286: tileCatalog[pmap[*x][*y].layers[layerWithFlag(*x, *y, T_ENTANGLES)]].description);
! 287: message(buf2, false);
! 288: }
! 289: }
! 290: }
! 291:
! 292: // explosions
! 293: if (cellHasTerrainFlag(*x, *y, T_CAUSES_EXPLOSIVE_DAMAGE) && !monst->status[STATUS_EXPLOSION_IMMUNITY]
! 294: && !(monst->bookkeepingFlags & MB_SUBMERGED)) {
! 295: damage = rand_range(15, 20);
! 296: damage = max(damage, monst->info.maxHP / 2);
! 297: monst->status[STATUS_EXPLOSION_IMMUNITY] = 5;
! 298: if (monst == &player) {
! 299: rogue.disturbed = true;
! 300: for (layer = 0; layer < NUMBER_TERRAIN_LAYERS && !(tileCatalog[pmap[*x][*y].layers[layer]].flags & T_CAUSES_EXPLOSIVE_DAMAGE); layer++);
! 301: message(tileCatalog[pmap[*x][*y].layers[layer]].flavorText, false);
! 302: if (rogue.armor && (rogue.armor->flags & ITEM_RUNIC) && rogue.armor->enchant2 == A_DAMPENING) {
! 303: itemName(rogue.armor, buf2, false, false, NULL);
! 304: sprintf(buf, "Your %s pulses and absorbs the damage.", buf2);
! 305: messageWithColor(buf, &goodMessageColor, false);
! 306: autoIdentify(rogue.armor);
! 307: } else if (inflictDamage(NULL, &player, damage, &yellow, false)) {
! 308: strcpy(buf2, tileCatalog[pmap[*x][*y].layers[layerWithFlag(*x, *y, T_CAUSES_EXPLOSIVE_DAMAGE)]].description);
! 309: sprintf(buf, "Killed by %s", buf2);
! 310: gameOver(buf, true);
! 311: return;
! 312: }
! 313: } else { // it's a monster
! 314: if (monst->creatureState == MONSTER_SLEEPING) {
! 315: monst->creatureState = MONSTER_TRACKING_SCENT;
! 316: }
! 317: monsterName(buf, monst, true);
! 318:
! 319: // Get explosive layer before damage in case a death DF replaces the explosion
! 320: strcpy(buf3, tileCatalog[pmap[*x][*y].layers[layerWithFlag(*x, *y, T_CAUSES_EXPLOSIVE_DAMAGE)]].description);
! 321: if (inflictDamage(NULL, monst, damage, &yellow, false)) {
! 322: // if killed
! 323: sprintf(buf2, "%s %s %s.", buf,
! 324: (monst->info.flags & MONST_INANIMATE) ? "is destroyed by" : "dies in",
! 325: buf3);
! 326: messageWithColor(buf2, messageColorFromVictim(monst), false);
! 327: refreshDungeonCell(*x, *y);
! 328: return;
! 329: } else {
! 330: // if survived
! 331: sprintf(buf2, "%s engulfs %s.",
! 332: tileCatalog[pmap[*x][*y].layers[layerWithFlag(*x, *y, T_CAUSES_EXPLOSIVE_DAMAGE)]].description, buf);
! 333: messageWithColor(buf2, messageColorFromVictim(monst), false);
! 334: }
! 335: }
! 336: }
! 337:
! 338: // Toxic gases!
! 339: // If it's the player, and he's wearing armor of respiration, then no effect from toxic gases.
! 340: if (monst == &player
! 341: && cellHasTerrainFlag(*x, *y, T_RESPIRATION_IMMUNITIES)
! 342: && rogue.armor
! 343: && (rogue.armor->flags & ITEM_RUNIC)
! 344: && rogue.armor->enchant2 == A_RESPIRATION) {
! 345: if (!(rogue.armor->flags & ITEM_RUNIC_IDENTIFIED)) {
! 346: message("Your armor trembles and a pocket of clean air swirls around you.", false);
! 347: autoIdentify(rogue.armor);
! 348: }
! 349: } else {
! 350:
! 351: // zombie gas
! 352: if (cellHasTerrainFlag(*x, *y, T_CAUSES_NAUSEA)
! 353: && !(monst->info.flags & (MONST_INANIMATE | MONST_INVULNERABLE))
! 354: && !(monst->bookkeepingFlags & MB_SUBMERGED)) {
! 355: if (monst == &player) {
! 356: rogue.disturbed = true;
! 357: }
! 358: if (canDirectlySeeMonster(monst) && !(monst->status[STATUS_NAUSEOUS])) {
! 359: if (monst->creatureState == MONSTER_SLEEPING) {
! 360: monst->creatureState = MONSTER_TRACKING_SCENT;
! 361: }
! 362: flashMonster(monst, &brown, 100);
! 363: monsterName(buf, monst, true);
! 364: sprintf(buf2, "%s choke%s and gag%s on the overpowering stench of decay.", buf,
! 365: (monst == &player ? "": "s"), (monst == &player ? "": "s"));
! 366: message(buf2, false);
! 367: }
! 368: monst->status[STATUS_NAUSEOUS] = monst->maxStatus[STATUS_NAUSEOUS] = max(monst->status[STATUS_NAUSEOUS], 20);
! 369: }
! 370:
! 371: // confusion gas
! 372: if (cellHasTerrainFlag(*x, *y, T_CAUSES_CONFUSION) && !(monst->info.flags & (MONST_INANIMATE | MONST_INVULNERABLE))) {
! 373: if (monst == &player) {
! 374: rogue.disturbed = true;
! 375: }
! 376: if (canDirectlySeeMonster(monst) && !(monst->status[STATUS_CONFUSED])) {
! 377: if (monst->creatureState == MONSTER_SLEEPING) {
! 378: monst->creatureState = MONSTER_TRACKING_SCENT;
! 379: }
! 380: flashMonster(monst, &confusionGasColor, 100);
! 381: monsterName(buf, monst, true);
! 382: sprintf(buf2, "%s %s very confused!", buf, (monst == &player ? "feel": "looks"));
! 383: message(buf2, false);
! 384: }
! 385: monst->status[STATUS_CONFUSED] = monst->maxStatus[STATUS_CONFUSED] = max(monst->status[STATUS_CONFUSED], 25);
! 386: }
! 387:
! 388: // paralysis gas
! 389: if (cellHasTerrainFlag(*x, *y, T_CAUSES_PARALYSIS)
! 390: && !(monst->info.flags & (MONST_INANIMATE | MONST_INVULNERABLE))
! 391: && !(monst->bookkeepingFlags & MB_SUBMERGED)) {
! 392:
! 393: if (canDirectlySeeMonster(monst) && !monst->status[STATUS_PARALYZED]) {
! 394: flashMonster(monst, &pink, 100);
! 395: monsterName(buf, monst, true);
! 396: sprintf(buf2, "%s %s paralyzed!", buf, (monst == &player ? "are": "is"));
! 397: message(buf2, (monst == &player));
! 398: }
! 399: monst->status[STATUS_PARALYZED] = monst->maxStatus[STATUS_PARALYZED] = max(monst->status[STATUS_PARALYZED], 20);
! 400: if (monst == &player) {
! 401: rogue.disturbed = true;
! 402: }
! 403: }
! 404: }
! 405:
! 406: // poisonous lichen
! 407: if (cellHasTerrainFlag(*x, *y, T_CAUSES_POISON)
! 408: && !(monst->info.flags & (MONST_INANIMATE | MONST_INVULNERABLE))
! 409: && !monst->status[STATUS_LEVITATING]) {
! 410:
! 411: if (monst == &player && !player.status[STATUS_POISONED]) {
! 412: rogue.disturbed = true;
! 413: }
! 414: if (canDirectlySeeMonster(monst) && !(monst->status[STATUS_POISONED])) {
! 415: if (monst->creatureState == MONSTER_SLEEPING) {
! 416: monst->creatureState = MONSTER_TRACKING_SCENT;
! 417: }
! 418: flashMonster(monst, &green, 100);
! 419: monsterName(buf, monst, true);
! 420: sprintf(buf2, "the lichen's grasping tendrils poison %s.", buf);
! 421: messageWithColor(buf2, messageColorFromVictim(monst), false);
! 422: }
! 423: damage = max(0, 5 - monst->status[STATUS_POISONED]);
! 424: addPoison(monst, damage, 0); // Lichen doesn't increase poison concentration above 1.
! 425: }
! 426:
! 427: // fire
! 428: if (cellHasTerrainFlag(*x, *y, T_IS_FIRE)) {
! 429: exposeCreatureToFire(monst);
! 430: } else if (cellHasTerrainFlag(*x, *y, T_IS_FLAMMABLE)
! 431: // We should only expose to fire if it is flammable and not on fire. However, when
! 432: // gas burns, it only sets the volume to 0 and doesn't clear the layer (for visual
! 433: // reasons). This can cause crashes if the fire tile fails to spawn, so we also exclude it.
! 434: && !(pmap[*x][*y].layers[GAS] != NOTHING && pmap[*x][*y].volume == 0)
! 435: && !cellHasTerrainFlag(*x, *y, T_IS_FIRE)
! 436: && monst->status[STATUS_BURNING]
! 437: && !(monst->bookkeepingFlags & (MB_SUBMERGED | MB_IS_FALLING))) {
! 438: exposeTileToFire(*x, *y, true);
! 439: }
! 440:
! 441: // keys
! 442: if (cellHasTMFlag(*x, *y, TM_PROMOTES_WITH_KEY) && (theItem = keyOnTileAt(*x, *y))) {
! 443: useKeyAt(theItem, *x, *y);
! 444: }
! 445: }
! 446:
! 447: void applyGradualTileEffectsToCreature(creature *monst, short ticks) {
! 448: short itemCandidates, randItemIndex;
! 449: short x = monst->xLoc, y = monst->yLoc, damage;
! 450: char buf[COLS * 5], buf2[COLS * 3];
! 451: item *theItem;
! 452: enum dungeonLayers layer;
! 453:
! 454: if (!(monst->status[STATUS_LEVITATING])
! 455: && cellHasTerrainFlag(x, y, T_IS_DEEP_WATER)
! 456: && !cellHasTerrainFlag(x, y, (T_ENTANGLES | T_OBSTRUCTS_PASSABILITY))
! 457: && !(monst->info.flags & MONST_IMMUNE_TO_WATER)) {
! 458: if (monst == &player) {
! 459: if (!(pmap[x][y].flags & HAS_ITEM) && rand_percent(ticks * 50 / 100)) {
! 460: itemCandidates = numberOfMatchingPackItems(ALL_ITEMS, 0, (ITEM_EQUIPPED), false);
! 461: if (itemCandidates) {
! 462: randItemIndex = rand_range(1, itemCandidates);
! 463: for (theItem = packItems->nextItem; theItem != NULL; theItem = theItem->nextItem) {
! 464: if (!(theItem->flags & (ITEM_EQUIPPED))) {
! 465: if (randItemIndex == 1) {
! 466: break;
! 467: } else {
! 468: randItemIndex--;
! 469: }
! 470: }
! 471: }
! 472: theItem = dropItem(theItem);
! 473: if (theItem) {
! 474: itemName(theItem, buf2, false, true, NULL);
! 475: sprintf(buf, "%s float%s away in the current!",
! 476: buf2,
! 477: (theItem->quantity == 1 ? "s" : ""));
! 478: messageWithColor(buf, &itemMessageColor, false);
! 479: }
! 480: }
! 481: }
! 482: } else if (monst->carriedItem && !(pmap[x][y].flags & HAS_ITEM) && rand_percent(ticks * 50 / 100)) { // it's a monster with an item
! 483: makeMonsterDropItem(monst);
! 484: }
! 485: }
! 486:
! 487: if (cellHasTerrainFlag(x, y, T_CAUSES_DAMAGE)
! 488: && !(monst->info.flags & (MONST_INANIMATE | MONST_INVULNERABLE))
! 489: && !(monst->bookkeepingFlags & MB_SUBMERGED)) {
! 490:
! 491: damage = (monst->info.maxHP / 15) * ticks / 100;
! 492: damage = max(1, damage);
! 493: for (layer = 0; layer < NUMBER_TERRAIN_LAYERS && !(tileCatalog[pmap[x][y].layers[layer]].flags & T_CAUSES_DAMAGE); layer++);
! 494: if (monst == &player) {
! 495: if (rogue.armor && (rogue.armor->flags & ITEM_RUNIC) && rogue.armor->enchant2 == A_RESPIRATION) {
! 496: if (!(rogue.armor->flags & ITEM_RUNIC_IDENTIFIED)) {
! 497: message("Your armor trembles and a pocket of clean air swirls around you.", false);
! 498: autoIdentify(rogue.armor);
! 499: }
! 500: } else {
! 501: rogue.disturbed = true;
! 502: messageWithColor(tileCatalog[pmap[x][y].layers[layer]].flavorText, &badMessageColor, false);
! 503: if (inflictDamage(NULL, &player, damage, tileCatalog[pmap[x][y].layers[layer]].backColor, true)) {
! 504: sprintf(buf, "Killed by %s", tileCatalog[pmap[x][y].layers[layer]].description);
! 505: gameOver(buf, true);
! 506: return;
! 507: }
! 508: }
! 509: } else { // it's a monster
! 510: if (monst->creatureState == MONSTER_SLEEPING) {
! 511: monst->creatureState = MONSTER_TRACKING_SCENT;
! 512: }
! 513: if (inflictDamage(NULL, monst, damage, tileCatalog[pmap[x][y].layers[layer]].backColor, true)) {
! 514: if (canSeeMonster(monst)) {
! 515: monsterName(buf, monst, true);
! 516: sprintf(buf2, "%s dies.", buf);
! 517: messageWithColor(buf2, messageColorFromVictim(monst), false);
! 518: }
! 519: refreshDungeonCell(x, y);
! 520: return;
! 521: }
! 522: }
! 523: }
! 524:
! 525: if (cellHasTerrainFlag(x, y, T_CAUSES_HEALING)
! 526: && !(monst->info.flags & MONST_INANIMATE)
! 527: && !(monst->bookkeepingFlags & MB_SUBMERGED)) {
! 528:
! 529: damage = (monst->info.maxHP / 15) * ticks / 100;
! 530: damage = max(1, damage);
! 531: if (monst->currentHP < monst->info.maxHP) {
! 532: monst->currentHP = min(monst->currentHP + damage, monst->info.maxHP);
! 533: if (monst == &player) {
! 534: messageWithColor("you feel much better.", &goodMessageColor, false);
! 535: }
! 536: }
! 537: }
! 538: }
! 539:
! 540: void updateClairvoyance() {
! 541: short i, j, clairvoyanceRadius, dx, dy;
! 542: boolean cursed;
! 543: unsigned long cFlags;
! 544:
! 545: for (i=0; i<DCOLS; i++) {
! 546: for (j=0; j<DROWS; j++) {
! 547:
! 548: pmap[i][j].flags &= ~WAS_CLAIRVOYANT_VISIBLE;
! 549:
! 550: if (pmap[i][j].flags & CLAIRVOYANT_VISIBLE) {
! 551: pmap[i][j].flags |= WAS_CLAIRVOYANT_VISIBLE;
! 552: }
! 553:
! 554: pmap[i][j].flags &= ~(CLAIRVOYANT_VISIBLE | CLAIRVOYANT_DARKENED);
! 555: }
! 556: }
! 557:
! 558: cursed = (rogue.clairvoyance < 0);
! 559: if (cursed) {
! 560: clairvoyanceRadius = (rogue.clairvoyance - 1) * -1;
! 561: cFlags = CLAIRVOYANT_DARKENED;
! 562: } else {
! 563: clairvoyanceRadius = (rogue.clairvoyance > 0) ? rogue.clairvoyance + 1 : 0;
! 564: cFlags = CLAIRVOYANT_VISIBLE | DISCOVERED;
! 565: }
! 566:
! 567: for (i = max(0, player.xLoc - clairvoyanceRadius); i < min(DCOLS, player.xLoc + clairvoyanceRadius + 1); i++) {
! 568: for (j = max(0, player.yLoc - clairvoyanceRadius); j < min(DROWS, player.yLoc + clairvoyanceRadius + 1); j++) {
! 569:
! 570: dx = (player.xLoc - i);
! 571: dy = (player.yLoc - j);
! 572:
! 573: if (dx*dx + dy*dy < clairvoyanceRadius*clairvoyanceRadius + clairvoyanceRadius
! 574: && (pmap[i][j].layers[DUNGEON] != GRANITE || pmap[i][j].flags & DISCOVERED)) {
! 575:
! 576: if (cFlags & DISCOVERED) {
! 577: discoverCell(i, j);
! 578: }
! 579: pmap[i][j].flags |= cFlags;
! 580: if (!(pmap[i][j].flags & HAS_PLAYER) && !cursed) {
! 581: pmap[i][j].flags &= ~STABLE_MEMORY;
! 582: }
! 583: }
! 584: }
! 585: }
! 586: }
! 587:
! 588: void updateTelepathy() {
! 589: short i, j;
! 590: creature *monst;
! 591: boolean grid[DCOLS][DROWS];
! 592:
! 593: for (i=0; i<DCOLS; i++) {
! 594: for (j=0; j<DROWS; j++) {
! 595: pmap[i][j].flags &= ~WAS_TELEPATHIC_VISIBLE;
! 596: if (pmap[i][j].flags & TELEPATHIC_VISIBLE) {
! 597: pmap[i][j].flags |= WAS_TELEPATHIC_VISIBLE;
! 598: }
! 599: pmap[i][j].flags &= ~(TELEPATHIC_VISIBLE);
! 600: }
! 601: }
! 602:
! 603: zeroOutGrid(grid);
! 604: for (monst = monsters->nextCreature; monst; monst = monst->nextCreature) {
! 605: if (monsterRevealed(monst)) {
! 606: getFOVMask(grid, monst->xLoc, monst->yLoc, 2 * FP_FACTOR, T_OBSTRUCTS_VISION, 0, false);
! 607: pmap[monst->xLoc][monst->yLoc].flags |= TELEPATHIC_VISIBLE;
! 608: discoverCell(monst->xLoc, monst->yLoc);
! 609: }
! 610: }
! 611: for (monst = dormantMonsters->nextCreature; monst != NULL; monst = monst->nextCreature) {
! 612: if (monsterRevealed(monst)) {
! 613: getFOVMask(grid, monst->xLoc, monst->yLoc, 2 * FP_FACTOR, T_OBSTRUCTS_VISION, 0, false);
! 614: pmap[monst->xLoc][monst->yLoc].flags |= TELEPATHIC_VISIBLE;
! 615: discoverCell(monst->xLoc, monst->yLoc);
! 616: }
! 617: }
! 618: for (i = 0; i < DCOLS; i++) {
! 619: for (j = 0; j < DROWS; j++) {
! 620: if (grid[i][j]) {
! 621: pmap[i][j].flags |= TELEPATHIC_VISIBLE;
! 622: discoverCell(i, j);
! 623: }
! 624: }
! 625: }
! 626: }
! 627:
! 628: short scentDistance(short x1, short y1, short x2, short y2) {
! 629: if (abs(x1 - x2) > abs(y1 - y2)) {
! 630: return 2 * abs(x1 - x2) + abs(y1 - y2);
! 631: } else {
! 632: return abs(x1 - x2) + 2 * abs(y1 - y2);
! 633: }
! 634: }
! 635:
! 636: void updateScent() {
! 637: short i, j;
! 638: char grid[DCOLS][DROWS];
! 639:
! 640: zeroOutGrid(grid);
! 641:
! 642: getFOVMask(grid, player.xLoc, player.yLoc, DCOLS * FP_FACTOR, T_OBSTRUCTS_SCENT, 0, false);
! 643:
! 644: for (i=0; i<DCOLS; i++) {
! 645: for (j=0; j<DROWS; j++) {
! 646: if (grid[i][j]) {
! 647: addScentToCell(i, j, scentDistance(player.xLoc, player.yLoc, i, j));
! 648: }
! 649: }
! 650: }
! 651: addScentToCell(player.xLoc, player.yLoc, 0);
! 652: }
! 653:
! 654: short armorAggroAdjustment(item *theArmor) {
! 655: if (!theArmor
! 656: || !(theArmor->category & ARMOR)) {
! 657:
! 658: return 0;
! 659: }
! 660: return max(0, armorTable[theArmor->kind].strengthRequired - 12);
! 661: }
! 662:
! 663: short currentAggroValue() {
! 664: // Default value of 14 in the light.
! 665: short stealthVal = 14;
! 666:
! 667: if (player.status[STATUS_INVISIBLE]) {
! 668: stealthVal = 1; // Invisibility means stealth range of 1, no matter what.
! 669: } else {
! 670: if (playerInDarkness()) {
! 671: // In darkness, halve, rounded down.
! 672: stealthVal = stealthVal / 2;
! 673: }
! 674: if (pmap[player.xLoc][player.yLoc].flags & IS_IN_SHADOW) {
! 675: // When not standing in a lit area, halve, rounded down (stacks with darkness halving).
! 676: stealthVal = stealthVal / 2;
! 677: }
! 678:
! 679: // Add 1 for each point of your armor's natural (unenchanted) strength requirement above 12.
! 680: stealthVal += armorAggroAdjustment(rogue.armor);
! 681:
! 682: // Halve (rounded up) if you just rested.
! 683: if (rogue.justRested) {
! 684: stealthVal = (stealthVal + 1) / 2;
! 685: }
! 686:
! 687: if (player.status[STATUS_AGGRAVATING] > 0) {
! 688: stealthVal += player.status[STATUS_AGGRAVATING];
! 689: }
! 690:
! 691: // Subtract your bonuses from rings of stealth.
! 692: // (Cursed rings of stealth will end up adding here.)
! 693: stealthVal -= rogue.stealthBonus;
! 694:
! 695: // Can't go below 2 unless you just rested.
! 696: if (stealthVal < 2 && !rogue.justRested) {
! 697: stealthVal = 2;
! 698: } else if (stealthVal < 1) { // Can't go below 1, ever.
! 699: stealthVal = 1;
! 700: }
! 701: }
! 702: return stealthVal;
! 703: }
! 704:
! 705: void demoteVisibility() {
! 706: short i, j;
! 707:
! 708: for (i=0; i<DCOLS; i++) {
! 709: for (j=0; j<DROWS; j++) {
! 710: pmap[i][j].flags &= ~WAS_VISIBLE;
! 711: if (pmap[i][j].flags & VISIBLE) {
! 712: pmap[i][j].flags &= ~VISIBLE;
! 713: pmap[i][j].flags |= WAS_VISIBLE;
! 714: }
! 715: }
! 716: }
! 717: }
! 718:
! 719: void discoverCell(const short x, const short y) {
! 720: pmap[x][y].flags &= ~STABLE_MEMORY;
! 721: if (!(pmap[x][y].flags & DISCOVERED)) {
! 722: pmap[x][y].flags |= DISCOVERED;
! 723: if (!cellHasTerrainFlag(x, y, T_PATHING_BLOCKER)) {
! 724: rogue.xpxpThisTurn++;
! 725: }
! 726: }
! 727: }
! 728:
! 729: void updateVision(boolean refreshDisplay) {
! 730: short i, j;
! 731: char grid[DCOLS][DROWS];
! 732: item *theItem;
! 733: creature *monst;
! 734:
! 735: demoteVisibility();
! 736: for (i=0; i<DCOLS; i++) {
! 737: for (j=0; j<DROWS; j++) {
! 738: pmap[i][j].flags &= ~IN_FIELD_OF_VIEW;
! 739: }
! 740: }
! 741:
! 742: // Calculate player's field of view (distinct from what is visible, as lighting hasn't been done yet).
! 743: zeroOutGrid(grid);
! 744: getFOVMask(grid, player.xLoc, player.yLoc, (DCOLS + DROWS) * FP_FACTOR, (T_OBSTRUCTS_VISION), 0, false);
! 745: for (i=0; i<DCOLS; i++) {
! 746: for (j=0; j<DROWS; j++) {
! 747: if (grid[i][j]) {
! 748: pmap[i][j].flags |= IN_FIELD_OF_VIEW;
! 749: }
! 750: }
! 751: }
! 752: pmap[player.xLoc][player.yLoc].flags |= IN_FIELD_OF_VIEW | VISIBLE;
! 753:
! 754: if (rogue.clairvoyance < 0) {
! 755: discoverCell(player.xLoc, player.yLoc);
! 756: }
! 757:
! 758: if (rogue.clairvoyance != 0) {
! 759: updateClairvoyance();
! 760: }
! 761:
! 762: updateTelepathy();
! 763: updateLighting();
! 764: updateFieldOfViewDisplay(true, refreshDisplay);
! 765:
! 766: // for (i=0; i<DCOLS; i++) {
! 767: // for (j=0; j<DROWS; j++) {
! 768: // if (pmap[i][j].flags & VISIBLE) {
! 769: // plotCharWithColor(' ', mapToWindowX(i), mapToWindowY(j), &yellow, &yellow);
! 770: // } else if (pmap[i][j].flags & IN_FIELD_OF_VIEW) {
! 771: // plotCharWithColor(' ', mapToWindowX(i), mapToWindowY(j), &blue, &blue);
! 772: // }
! 773: // }
! 774: // }
! 775: // displayMoreSign();
! 776:
! 777: if (player.status[STATUS_HALLUCINATING] > 0) {
! 778: for (theItem = floorItems->nextItem; theItem != NULL; theItem = theItem->nextItem) {
! 779: if ((pmap[theItem->xLoc][theItem->yLoc].flags & DISCOVERED) && refreshDisplay) {
! 780: refreshDungeonCell(theItem->xLoc, theItem->yLoc);
! 781: }
! 782: }
! 783: for (monst = monsters->nextCreature; monst != NULL; monst = monst->nextCreature) {
! 784: if ((pmap[monst->xLoc][monst->yLoc].flags & DISCOVERED) && refreshDisplay) {
! 785: refreshDungeonCell(monst->xLoc, monst->yLoc);
! 786: }
! 787: }
! 788: }
! 789: }
! 790:
! 791: void checkNutrition() {
! 792: item *theItem;
! 793: char buf[DCOLS*3], foodWarning[DCOLS*3];
! 794:
! 795: if (numberOfMatchingPackItems(FOOD, 0, 0, false) == 0) {
! 796: sprintf(foodWarning, " and have no food");
! 797: } else {
! 798: foodWarning[0] = '\0';
! 799: }
! 800:
! 801: if (player.status[STATUS_NUTRITION] == HUNGER_THRESHOLD) {
! 802: player.status[STATUS_NUTRITION]--;
! 803: sprintf(buf, "you are hungry%s.", foodWarning);
! 804: message(buf, foodWarning[0]);
! 805: } else if (player.status[STATUS_NUTRITION] == WEAK_THRESHOLD) {
! 806: player.status[STATUS_NUTRITION]--;
! 807: sprintf(buf, "you feel weak with hunger%s.", foodWarning);
! 808: message(buf, true);
! 809: } else if (player.status[STATUS_NUTRITION] == FAINT_THRESHOLD) {
! 810: player.status[STATUS_NUTRITION]--;
! 811: sprintf(buf, "you feel faint with hunger%s.", foodWarning);
! 812: message(buf, true);
! 813: } else if (player.status[STATUS_NUTRITION] <= 1) {
! 814: // Force the player to eat something if he has it
! 815: for (theItem = packItems->nextItem; theItem != NULL; theItem = theItem->nextItem) {
! 816: if (theItem->category == FOOD) {
! 817: sprintf(buf, "unable to control your hunger, you eat a %s.", (theItem->kind == FRUIT ? "mango" : "ration of food"));
! 818: messageWithColor(buf, &itemMessageColor, true);
! 819: apply(theItem, false);
! 820: break;
! 821: }
! 822: }
! 823: }
! 824:
! 825: if (player.status[STATUS_NUTRITION] == 1) { // Didn't manage to eat any food above.
! 826: player.status[STATUS_NUTRITION] = 0; // So the status bar changes in time for the message:
! 827: message("you are starving to death!", true);
! 828: }
! 829: }
! 830:
! 831: void burnItem(item *theItem) {
! 832: short x, y;
! 833: char buf1[COLS * 3], buf2[COLS * 3];
! 834: itemName(theItem, buf1, false, true, NULL);
! 835: sprintf(buf2, "%s burn%s up!",
! 836: buf1,
! 837: theItem->quantity == 1 ? "s" : "");
! 838: x = theItem->xLoc;
! 839: y = theItem->yLoc;
! 840: removeItemFromChain(theItem, floorItems);
! 841: deleteItem(theItem);
! 842: pmap[x][y].flags &= ~(HAS_ITEM | ITEM_DETECTED);
! 843: if (pmap[x][y].flags & (ANY_KIND_OF_VISIBLE | DISCOVERED | ITEM_DETECTED)) {
! 844: refreshDungeonCell(x, y);
! 845: }
! 846: if (playerCanSee(x, y)) {
! 847: messageWithColor(buf2, &itemMessageColor, false);
! 848: }
! 849: spawnDungeonFeature(x, y, &(dungeonFeatureCatalog[DF_ITEM_FIRE]), true, false);
! 850: }
! 851:
! 852: void flashCreatureAlert(creature *monst, char msg[200], color *foreColor, color *backColor) {
! 853: short x, y;
! 854: if (monst->yLoc > DROWS / 2) {
! 855: y = mapToWindowY(monst->yLoc - 2);
! 856: } else {
! 857: y = mapToWindowY(monst->yLoc + 2);
! 858: }
! 859: x = mapToWindowX(monst->xLoc - strLenWithoutEscapes(msg) / 2);
! 860: if (x > COLS - strLenWithoutEscapes(msg)) {
! 861: x = COLS - strLenWithoutEscapes(msg);
! 862: }
! 863: flashMessage(msg, x, y, (rogue.playbackMode ? 100 : 1000), foreColor, backColor);
! 864: rogue.disturbed = true;
! 865: }
! 866:
! 867: void handleHealthAlerts() {
! 868: short i, currentPercent, previousPercent,
! 869: thresholds[] = {5, 10, 25, 40},
! 870: pThresholds[] = {100, 90, 50};
! 871: char buf[DCOLS];
! 872:
! 873: const short healthThresholdsCount = 4,
! 874: poisonThresholdsCount = 3;
! 875:
! 876: assureCosmeticRNG;
! 877:
! 878: currentPercent = player.currentHP * 100 / player.info.maxHP;
! 879: previousPercent = player.previousHealthPoints * 100 / player.info.maxHP;
! 880:
! 881: if (currentPercent < previousPercent && !rogue.gameHasEnded) {
! 882: for (i=0; i < healthThresholdsCount; i++) {
! 883: if (currentPercent < thresholds[i] && previousPercent >= thresholds[i]) {
! 884: sprintf(buf, " <%i%% health ", thresholds[i]);
! 885: flashCreatureAlert(&player, buf, &badMessageColor, &darkRed);
! 886: break;
! 887: }
! 888: }
! 889: }
! 890:
! 891: if (!rogue.gameHasEnded) {
! 892: currentPercent = player.status[STATUS_POISONED] * player.poisonAmount * 100 / player.currentHP;
! 893:
! 894: if (currentPercent > rogue.previousPoisonPercent && !rogue.gameHasEnded) {
! 895: for (i=0; i < poisonThresholdsCount; i++) {
! 896: if (currentPercent > pThresholds[i] && rogue.previousPoisonPercent <= pThresholds[i]) {
! 897: if (currentPercent < 100) {
! 898: sprintf(buf, " >%i%% poisoned ", pThresholds[i]);
! 899: } else {
! 900: strcpy(buf, " Fatally poisoned ");
! 901: }
! 902: flashCreatureAlert(&player, buf, &yellow, &darkGreen);
! 903: break;
! 904: }
! 905: }
! 906: }
! 907: rogue.previousPoisonPercent = currentPercent;
! 908: }
! 909:
! 910: restoreRNG;
! 911: }
! 912:
! 913: void addXPXPToAlly(short XPXP, creature *monst) {
! 914: char theMonsterName[100], buf[200];
! 915: if (!(monst->info.flags & (MONST_INANIMATE | MONST_IMMOBILE))
! 916: && !(monst->bookkeepingFlags & MB_TELEPATHICALLY_REVEALED)
! 917: && monst->creatureState == MONSTER_ALLY
! 918: && monst->spawnDepth <= rogue.depthLevel
! 919: && rogue.depthLevel <= AMULET_LEVEL) {
! 920:
! 921: monst->xpxp += XPXP;
! 922: //printf("\n%i xpxp added to your %s this turn.", rogue.xpxpThisTurn, monst->info.monsterName);
! 923: if (monst->xpxp >= XPXP_NEEDED_FOR_TELEPATHIC_BOND
! 924: && !(monst->bookkeepingFlags & MB_TELEPATHICALLY_REVEALED)) {
! 925:
! 926: monst->bookkeepingFlags |= MB_TELEPATHICALLY_REVEALED;
! 927: updateVision(true);
! 928: monsterName(theMonsterName, monst, false);
! 929: sprintf(buf, "you have developed a telepathic bond with your %s.", theMonsterName);
! 930: messageWithColor(buf, &advancementMessageColor, false);
! 931: }
! 932: if (monst->xpxp > 1500 * 20) {
! 933: rogue.featRecord[FEAT_COMPANION] = true;
! 934: }
! 935: }
! 936: }
! 937:
! 938: void handleXPXP() {
! 939: creature *monst;
! 940: //char buf[DCOLS*2], theMonsterName[50];
! 941:
! 942: for (monst = monsters->nextCreature; monst != NULL; monst = monst->nextCreature) {
! 943: addXPXPToAlly(rogue.xpxpThisTurn, monst);
! 944: }
! 945: if (rogue.depthLevel > 1) {
! 946: for (monst = levels[rogue.depthLevel - 2].monsters; monst != NULL; monst = monst->nextCreature) {
! 947: addXPXPToAlly(rogue.xpxpThisTurn, monst);
! 948: }
! 949: }
! 950: if (rogue.depthLevel < DEEPEST_LEVEL) {
! 951: for (monst = levels[rogue.depthLevel].monsters; monst != NULL; monst = monst->nextCreature) {
! 952: addXPXPToAlly(rogue.xpxpThisTurn, monst);
! 953: }
! 954: }
! 955: rogue.xpxpThisTurn = 0;
! 956: }
! 957:
! 958: void playerFalls() {
! 959: short damage;
! 960: short layer;
! 961:
! 962: if (cellHasTMFlag(player.xLoc, player.yLoc, TM_IS_SECRET)
! 963: && playerCanSee(player.xLoc, player.yLoc)) {
! 964:
! 965: discover(player.xLoc, player.yLoc);
! 966: }
! 967:
! 968: monstersFall(); // Monsters must fall with the player rather than getting suspended on the previous level.
! 969: updateFloorItems(); // Likewise, items should fall with the player rather than getting suspended above.
! 970:
! 971: layer = layerWithFlag(player.xLoc, player.yLoc, T_AUTO_DESCENT);
! 972: if (layer >= 0) {
! 973: message(tileCatalog[pmap[player.xLoc][player.yLoc].layers[layer]].flavorText, true);
! 974: } else if (layer == -1) {
! 975: message("You plunge downward!", true);
! 976: }
! 977:
! 978: player.bookkeepingFlags &= ~(MB_IS_FALLING | MB_SEIZED | MB_SEIZING);
! 979: rogue.disturbed = true;
! 980:
! 981: if (rogue.depthLevel < DEEPEST_LEVEL) {
! 982: rogue.depthLevel++;
! 983: startLevel(rogue.depthLevel - 1, 0);
! 984: damage = randClumpedRange(FALL_DAMAGE_MIN, FALL_DAMAGE_MAX, 2);
! 985: messageWithColor("You are damaged by the fall.", &badMessageColor, false);
! 986: if (inflictDamage(NULL, &player, damage, &red, false)) {
! 987: gameOver("Killed by a fall", true);
! 988: } else if (rogue.depthLevel > rogue.deepestLevel) {
! 989: rogue.deepestLevel = rogue.depthLevel;
! 990: }
! 991: } else {
! 992: message("A strange force seizes you as you fall.", false);
! 993: teleport(&player, -1, -1, true);
! 994: }
! 995: createFlare(player.xLoc, player.yLoc, GENERIC_FLASH_LIGHT);
! 996: animateFlares(rogue.flares, rogue.flareCount);
! 997: rogue.flareCount = 0;
! 998: }
! 999:
! 1000:
! 1001:
! 1002: void activateMachine(short machineNumber) {
! 1003: short i, j, x, y, layer, sRows[DROWS], sCols[DCOLS], monsterCount, maxMonsters;
! 1004: creature **activatedMonsterList, *monst;
! 1005:
! 1006: fillSequentialList(sCols, DCOLS);
! 1007: shuffleList(sCols, DCOLS);
! 1008: fillSequentialList(sRows, DROWS);
! 1009: shuffleList(sRows, DROWS);
! 1010:
! 1011: for (i=0; i<DCOLS; i++) {
! 1012: for (j=0; j<DROWS; j++) {
! 1013: x = sCols[i];
! 1014: y = sRows[j];
! 1015: if ((pmap[x][y].flags & IS_IN_MACHINE)
! 1016: && pmap[x][y].machineNumber == machineNumber
! 1017: && !(pmap[x][y].flags & IS_POWERED)
! 1018: && cellHasTMFlag(x, y, TM_IS_WIRED)) {
! 1019:
! 1020: pmap[x][y].flags |= IS_POWERED;
! 1021: for (layer = 0; layer < NUMBER_TERRAIN_LAYERS; layer++) {
! 1022: if (tileCatalog[pmap[x][y].layers[layer]].mechFlags & TM_IS_WIRED) {
! 1023: promoteTile(x, y, layer, false);
! 1024: }
! 1025: }
! 1026: }
! 1027: }
! 1028: }
! 1029:
! 1030: monsterCount = maxMonsters = 0;
! 1031: activatedMonsterList = NULL;
! 1032: for (monst = monsters->nextCreature; monst != NULL; monst = monst->nextCreature) {
! 1033: if (monst->machineHome == machineNumber
! 1034: && monst->spawnDepth == rogue.depthLevel
! 1035: && (monst->info.flags & MONST_GETS_TURN_ON_ACTIVATION)) {
! 1036:
! 1037: monsterCount++;
! 1038:
! 1039: if (monsterCount > maxMonsters) {
! 1040: maxMonsters += 10;
! 1041: activatedMonsterList = realloc(activatedMonsterList, sizeof(creature *) * maxMonsters);
! 1042: }
! 1043: activatedMonsterList[monsterCount - 1] = monst;
! 1044: }
! 1045: }
! 1046: for (i=0; i<monsterCount; i++) {
! 1047: if (!(activatedMonsterList[i]->bookkeepingFlags & MB_IS_DYING)) {
! 1048: monstersTurn(activatedMonsterList[i]);
! 1049: }
! 1050: }
! 1051:
! 1052: if (activatedMonsterList) {
! 1053: free(activatedMonsterList);
! 1054: }
! 1055: }
! 1056:
! 1057: boolean circuitBreakersPreventActivation(short machineNumber) {
! 1058: short i, j;
! 1059: for (i=0; i<DCOLS; i++) {
! 1060: for (j=0; j<DROWS; j++) {
! 1061: if (pmap[i][j].machineNumber == machineNumber
! 1062: && cellHasTMFlag(i, j, TM_IS_CIRCUIT_BREAKER)) {
! 1063:
! 1064: return true;
! 1065: }
! 1066: }
! 1067: }
! 1068: return false;
! 1069: }
! 1070:
! 1071: void promoteTile(short x, short y, enum dungeonLayers layer, boolean useFireDF) {
! 1072: short i, j;
! 1073: enum dungeonFeatureTypes DFType;
! 1074: floorTileType *tile;
! 1075:
! 1076: tile = &(tileCatalog[pmap[x][y].layers[layer]]);
! 1077:
! 1078: DFType = (useFireDF ? tile->fireType : tile->promoteType);
! 1079:
! 1080: if ((tile->mechFlags & TM_VANISHES_UPON_PROMOTION)) {
! 1081: if (tileCatalog[pmap[x][y].layers[layer]].flags & T_PATHING_BLOCKER) {
! 1082: rogue.staleLoopMap = true;
! 1083: }
! 1084: pmap[x][y].layers[layer] = (layer == DUNGEON ? FLOOR : NOTHING); // even the dungeon layer implicitly has floor underneath it
! 1085: if (layer == GAS) {
! 1086: pmap[x][y].volume = 0;
! 1087: }
! 1088: refreshDungeonCell(x, y);
! 1089: }
! 1090: if (DFType) {
! 1091: spawnDungeonFeature(x, y, &dungeonFeatureCatalog[DFType], true, false);
! 1092: }
! 1093:
! 1094: if (!useFireDF && (tile->mechFlags & TM_IS_WIRED)
! 1095: && !(pmap[x][y].flags & IS_POWERED)
! 1096: && !circuitBreakersPreventActivation(pmap[x][y].machineNumber)) {
! 1097: // Send power through all cells in the same machine that are not IS_POWERED,
! 1098: // and on any such cell, promote each terrain layer that is T_IS_WIRED.
! 1099: // Note that machines need not be contiguous.
! 1100: pmap[x][y].flags |= IS_POWERED;
! 1101: activateMachine(pmap[x][y].machineNumber); // It lives!!!
! 1102:
! 1103: // Power fades from the map immediately after we finish.
! 1104: for (i=0; i<DCOLS; i++) {
! 1105: for (j=0; j<DROWS; j++) {
! 1106: pmap[i][j].flags &= ~IS_POWERED;
! 1107: }
! 1108: }
! 1109: }
! 1110: }
! 1111:
! 1112: boolean exposeTileToElectricity(short x, short y) {
! 1113: enum dungeonLayers layer;
! 1114: boolean promotedSomething = false;
! 1115:
! 1116: if (!cellHasTMFlag(x, y, TM_PROMOTES_ON_ELECTRICITY)) {
! 1117: return false;
! 1118: }
! 1119: for (layer=0; layer < NUMBER_TERRAIN_LAYERS; layer++) {
! 1120: if (tileCatalog[pmap[x][y].layers[layer]].mechFlags & TM_PROMOTES_ON_ELECTRICITY) {
! 1121: promoteTile(x, y, layer, false);
! 1122: promotedSomething = true;
! 1123: }
! 1124: }
! 1125: return promotedSomething;
! 1126: }
! 1127:
! 1128: boolean exposeTileToFire(short x, short y, boolean alwaysIgnite) {
! 1129: enum dungeonLayers layer;
! 1130: short ignitionChance = 0, bestExtinguishingPriority = 1000, explosiveNeighborCount = 0;
! 1131: short newX, newY;
! 1132: enum directions dir;
! 1133: boolean fireIgnited = false, explosivePromotion = false;
! 1134:
! 1135: if (!cellHasTerrainFlag(x, y, T_IS_FLAMMABLE)) {
! 1136: return false;
! 1137: }
! 1138:
! 1139: // Pick the extinguishing layer with the best priority.
! 1140: for (layer=0; layer < NUMBER_TERRAIN_LAYERS; layer++) {
! 1141: if ((tileCatalog[pmap[x][y].layers[layer]].mechFlags & TM_EXTINGUISHES_FIRE)
! 1142: && tileCatalog[pmap[x][y].layers[layer]].drawPriority < bestExtinguishingPriority) {
! 1143: bestExtinguishingPriority = tileCatalog[pmap[x][y].layers[layer]].drawPriority;
! 1144: }
! 1145: }
! 1146:
! 1147: // Pick the fire type of the most flammable layer that is either gas or equal-or-better priority than the best extinguishing layer.
! 1148: for (layer=0; layer < NUMBER_TERRAIN_LAYERS; layer++) {
! 1149: if ((tileCatalog[pmap[x][y].layers[layer]].flags & T_IS_FLAMMABLE)
! 1150: && (layer == GAS || tileCatalog[pmap[x][y].layers[layer]].drawPriority <= bestExtinguishingPriority)
! 1151: && tileCatalog[pmap[x][y].layers[layer]].chanceToIgnite > ignitionChance) {
! 1152: ignitionChance = tileCatalog[pmap[x][y].layers[layer]].chanceToIgnite;
! 1153: }
! 1154: }
! 1155:
! 1156: if (alwaysIgnite || (ignitionChance && rand_percent(ignitionChance))) { // If it ignites...
! 1157: fireIgnited = true;
! 1158:
! 1159: // Count explosive neighbors.
! 1160: if (cellHasTMFlag(x, y, TM_EXPLOSIVE_PROMOTE)) {
! 1161: for (dir = 0, explosiveNeighborCount = 0; dir < DIRECTION_COUNT; dir++) {
! 1162: newX = x + nbDirs[dir][0];
! 1163: newY = y + nbDirs[dir][1];
! 1164: if (coordinatesAreInMap(newX, newY)
! 1165: && (cellHasTerrainFlag(newX, newY, T_IS_FIRE | T_OBSTRUCTS_GAS) || cellHasTMFlag(newX, newY, TM_EXPLOSIVE_PROMOTE))) {
! 1166:
! 1167: explosiveNeighborCount++;
! 1168: }
! 1169: }
! 1170: if (explosiveNeighborCount >= 8) {
! 1171: explosivePromotion = true;
! 1172: }
! 1173: }
! 1174:
! 1175: // Flammable layers are consumed.
! 1176: for (layer=0; layer < NUMBER_TERRAIN_LAYERS; layer++) {
! 1177: if (tileCatalog[pmap[x][y].layers[layer]].flags & T_IS_FLAMMABLE) {
! 1178: // pmap[x][y].layers[GAS] is not cleared here, which is a bug.
! 1179: // We preserve the layer anyways because this results in nicer gas burning behavior.
! 1180: if (layer == GAS) {
! 1181: pmap[x][y].volume = 0; // Flammable gas burns its volume away.
! 1182: }
! 1183: promoteTile(x, y, layer, !explosivePromotion);
! 1184: }
! 1185: }
! 1186: refreshDungeonCell(x, y);
! 1187: }
! 1188: return fireIgnited;
! 1189: }
! 1190:
! 1191: // Only the gas layer can be volumetric.
! 1192: void updateVolumetricMedia() {
! 1193: short i, j, newX, newY, numSpaces;
! 1194: unsigned long highestNeighborVolume;
! 1195: unsigned long sum;
! 1196: enum tileType gasType;
! 1197: enum directions dir;
! 1198: unsigned short newGasVolume[DCOLS][DROWS];
! 1199:
! 1200: for (i=0; i<DCOLS; i++) {
! 1201: for (j=0; j<DROWS; j++) {
! 1202: newGasVolume[i][j] = 0;
! 1203: }
! 1204: }
! 1205:
! 1206: for (i=0; i<DCOLS; i++) {
! 1207: for (j=0; j<DROWS; j++) {
! 1208: if (!cellHasTerrainFlag(i, j, T_OBSTRUCTS_GAS)) {
! 1209: sum = pmap[i][j].volume;
! 1210: numSpaces = 1;
! 1211: highestNeighborVolume = pmap[i][j].volume;
! 1212: gasType = pmap[i][j].layers[GAS];
! 1213: for (dir=0; dir< DIRECTION_COUNT; dir++) {
! 1214: newX = i + nbDirs[dir][0];
! 1215: newY = j + nbDirs[dir][1];
! 1216: if (coordinatesAreInMap(newX, newY)
! 1217: && !cellHasTerrainFlag(newX, newY, T_OBSTRUCTS_GAS)) {
! 1218:
! 1219: sum += pmap[newX][newY].volume;
! 1220: numSpaces++;
! 1221: if (pmap[newX][newY].volume > highestNeighborVolume) {
! 1222: highestNeighborVolume = pmap[newX][newY].volume;
! 1223: gasType = pmap[newX][newY].layers[GAS];
! 1224: }
! 1225: }
! 1226: }
! 1227: if (cellHasTerrainFlag(i, j, T_AUTO_DESCENT)) { // if it's a chasm tile or trap door,
! 1228: numSpaces++; // this will allow gas to escape from the level entirely
! 1229: }
! 1230: newGasVolume[i][j] += sum / max(1, numSpaces);
! 1231: if ((unsigned) rand_range(0, numSpaces - 1) < (sum % numSpaces)) {
! 1232: newGasVolume[i][j]++; // stochastic rounding
! 1233: }
! 1234: if (pmap[i][j].layers[GAS] != gasType && newGasVolume[i][j] > 3) {
! 1235: if (pmap[i][j].layers[GAS] != NOTHING) {
! 1236: newGasVolume[i][j] = min(3, newGasVolume[i][j]); // otherwise interactions between gases are crazy
! 1237: }
! 1238: pmap[i][j].layers[GAS] = gasType;
! 1239: } else if (pmap[i][j].layers[GAS] && newGasVolume[i][j] < 1) {
! 1240: pmap[i][j].layers[GAS] = NOTHING;
! 1241: refreshDungeonCell(i, j);
! 1242: }
! 1243: if (pmap[i][j].volume > 0) {
! 1244: if (tileCatalog[pmap[i][j].layers[GAS]].mechFlags & TM_GAS_DISSIPATES_QUICKLY) {
! 1245: newGasVolume[i][j] -= (rand_percent(50) ? 1 : 0);
! 1246: } else if (tileCatalog[pmap[i][j].layers[GAS]].mechFlags & TM_GAS_DISSIPATES) {
! 1247: newGasVolume[i][j] -= (rand_percent(20) ? 1 : 0);
! 1248: }
! 1249: }
! 1250: } else if (pmap[i][j].volume > 0) { // if has gas but can't hold gas,
! 1251: // disperse gas instantly into neighboring tiles that can hold gas
! 1252: numSpaces = 0;
! 1253: for (dir = 0; dir < DIRECTION_COUNT; dir++) {
! 1254: newX = i + nbDirs[dir][0];
! 1255: newY = j + nbDirs[dir][1];
! 1256: if (coordinatesAreInMap(newX, newY)
! 1257: && !cellHasTerrainFlag(newX, newY, T_OBSTRUCTS_GAS)) {
! 1258:
! 1259: numSpaces++;
! 1260: }
! 1261: }
! 1262: if (numSpaces > 0) {
! 1263: for (dir = 0; dir < DIRECTION_COUNT; dir++) {
! 1264: newX = i + nbDirs[dir][0];
! 1265: newY = j + nbDirs[dir][1];
! 1266: if (coordinatesAreInMap(newX, newY)
! 1267: && !cellHasTerrainFlag(newX, newY, T_OBSTRUCTS_GAS)) {
! 1268:
! 1269: newGasVolume[newX][newY] += (pmap[i][j].volume / numSpaces);
! 1270: if (pmap[i][j].volume / numSpaces) {
! 1271: pmap[newX][newY].layers[GAS] = pmap[i][j].layers[GAS];
! 1272: }
! 1273: }
! 1274: }
! 1275: }
! 1276: newGasVolume[i][j] = 0;
! 1277: pmap[i][j].layers[GAS] = NOTHING;
! 1278: }
! 1279: }
! 1280: }
! 1281:
! 1282: for (i=0; i<DCOLS; i++) {
! 1283: for (j=0; j<DROWS; j++) {
! 1284: if (pmap[i][j].volume != newGasVolume[i][j]) {
! 1285: pmap[i][j].volume = newGasVolume[i][j];
! 1286: refreshDungeonCell(i, j);
! 1287: }
! 1288: }
! 1289: }
! 1290: }
! 1291:
! 1292: void updateYendorWardenTracking() {
! 1293: creature *prevMonst;
! 1294: short n;
! 1295:
! 1296: if (!rogue.yendorWarden) {
! 1297: return;
! 1298: }
! 1299: if (rogue.yendorWarden->depth == rogue.depthLevel) {
! 1300: return;
! 1301: }
! 1302: if (!(rogue.yendorWarden->bookkeepingFlags & MB_PREPLACED)) {
! 1303: levels[rogue.yendorWarden->depth - 1].mapStorage[rogue.yendorWarden->xLoc][rogue.yendorWarden->yLoc].flags &= ~HAS_MONSTER;
! 1304: }
! 1305: n = rogue.yendorWarden->depth - 1;
! 1306:
! 1307: // remove traversing monster from other level monster chain
! 1308: if (rogue.yendorWarden == levels[n].monsters) {
! 1309: levels[n].monsters = rogue.yendorWarden->nextCreature;
! 1310: } else {
! 1311: for (prevMonst = levels[n].monsters; prevMonst->nextCreature != rogue.yendorWarden; prevMonst = prevMonst->nextCreature);
! 1312: prevMonst->nextCreature = rogue.yendorWarden->nextCreature;
! 1313: }
! 1314:
! 1315: if (rogue.yendorWarden->depth > rogue.depthLevel) {
! 1316: rogue.yendorWarden->depth = rogue.depthLevel + 1;
! 1317: n = rogue.yendorWarden->depth - 1;
! 1318: rogue.yendorWarden->bookkeepingFlags |= MB_APPROACHING_UPSTAIRS;
! 1319: rogue.yendorWarden->xLoc = levels[n].downStairsLoc[0];
! 1320: rogue.yendorWarden->yLoc = levels[n].downStairsLoc[1];
! 1321: } else {
! 1322: rogue.yendorWarden->depth = rogue.depthLevel - 1;
! 1323: n = rogue.yendorWarden->depth - 1;
! 1324: rogue.yendorWarden->bookkeepingFlags |= MB_APPROACHING_DOWNSTAIRS;
! 1325: rogue.yendorWarden->xLoc = levels[n].upStairsLoc[0];
! 1326: rogue.yendorWarden->yLoc = levels[n].upStairsLoc[1];
! 1327: }
! 1328: rogue.yendorWarden->nextCreature = levels[rogue.yendorWarden->depth - 1].monsters;
! 1329: levels[rogue.yendorWarden->depth - 1].monsters = rogue.yendorWarden;
! 1330: rogue.yendorWarden->bookkeepingFlags |= MB_PREPLACED;
! 1331: rogue.yendorWarden->status[STATUS_ENTERS_LEVEL_IN] = 50;
! 1332: }
! 1333:
! 1334: // Monsters who are over chasms or other descent tiles won't fall until this is called.
! 1335: // This is to avoid having the monster chain change unpredictably in the middle of a turn.
! 1336: void monstersFall() {
! 1337: creature *monst, *previousCreature, *nextCreature;
! 1338: short x, y;
! 1339: char buf[DCOLS], buf2[DCOLS];
! 1340:
! 1341: // monsters plunge into chasms at the end of the turn
! 1342: for (monst = monsters->nextCreature; monst != NULL; monst = nextCreature) {
! 1343: nextCreature = monst->nextCreature;
! 1344: if ((monst->bookkeepingFlags & MB_IS_FALLING) || monsterShouldFall(monst)) {
! 1345: if (rogue.patchVersion >= 3) monst->bookkeepingFlags |= MB_IS_FALLING;
! 1346:
! 1347: x = monst->xLoc;
! 1348: y = monst->yLoc;
! 1349:
! 1350: if (canSeeMonster(monst)) {
! 1351: monsterName(buf, monst, true);
! 1352: sprintf(buf2, "%s plunges out of sight!", buf);
! 1353: messageWithColor(buf2, messageColorFromVictim(monst), false);
! 1354: }
! 1355:
! 1356: if (rogue.patchVersion < 3) {
! 1357: monst->status[STATUS_ENTRANCED] = 0;
! 1358: monst->bookkeepingFlags |= MB_PREPLACED;
! 1359: monst->bookkeepingFlags &= ~(MB_IS_FALLING | MB_SEIZED | MB_SEIZING);
! 1360: monst->targetCorpseLoc[0] = monst->targetCorpseLoc[1] = 0;
! 1361: }
! 1362:
! 1363: if (monst->info.flags & MONST_GETS_TURN_ON_ACTIVATION) {
! 1364: // Guardians and mirrored totems never survive the fall. If they did, they might block the level below.
! 1365: killCreature(monst, false);
! 1366: } else if (!inflictDamage(NULL, monst, randClumpedRange(6, 12, 2), &red, false)) {
! 1367: demoteMonsterFromLeadership(monst);
! 1368:
! 1369: if (rogue.patchVersion >= 3) {
! 1370: monst->status[STATUS_ENTRANCED] = 0;
! 1371: monst->bookkeepingFlags |= MB_PREPLACED;
! 1372: monst->bookkeepingFlags &= ~(MB_IS_FALLING | MB_SEIZED | MB_SEIZING);
! 1373: monst->targetCorpseLoc[0] = monst->targetCorpseLoc[1] = 0;
! 1374: }
! 1375:
! 1376: // remove from monster chain
! 1377: for (previousCreature = monsters;
! 1378: previousCreature->nextCreature != monst;
! 1379: previousCreature = previousCreature->nextCreature);
! 1380: previousCreature->nextCreature = monst->nextCreature;
! 1381:
! 1382: // add to next level's chain
! 1383: monst->nextCreature = levels[rogue.depthLevel-1 + 1].monsters;
! 1384: levels[rogue.depthLevel-1 + 1].monsters = monst;
! 1385:
! 1386: monst->depth = rogue.depthLevel + 1;
! 1387:
! 1388: if (monst == rogue.yendorWarden) {
! 1389: updateYendorWardenTracking();
! 1390: }
! 1391: }
! 1392:
! 1393: pmap[x][y].flags &= ~HAS_MONSTER;
! 1394: refreshDungeonCell(x, y);
! 1395: }
! 1396: }
! 1397: }
! 1398:
! 1399: void updateEnvironment() {
! 1400: short i, j, direction, newX, newY, promotions[DCOLS][DROWS];
! 1401: long promoteChance;
! 1402: enum dungeonLayers layer;
! 1403: floorTileType *tile;
! 1404: boolean isVolumetricGas = false;
! 1405:
! 1406: monstersFall();
! 1407:
! 1408: // update gases twice
! 1409: for (i=0; i<DCOLS && !isVolumetricGas; i++) {
! 1410: for (j=0; j<DROWS && !isVolumetricGas; j++) {
! 1411: if (!isVolumetricGas && pmap[i][j].layers[GAS]) {
! 1412: isVolumetricGas = true;
! 1413: }
! 1414: }
! 1415: }
! 1416: if (isVolumetricGas) {
! 1417: updateVolumetricMedia();
! 1418: updateVolumetricMedia();
! 1419: }
! 1420:
! 1421: // Do random tile promotions in two passes to keep generations distinct.
! 1422: // First pass, make a note of each terrain layer at each coordinate that is going to promote:
! 1423: for (i=0; i<DCOLS; i++) {
! 1424: for (j=0; j<DROWS; j++) {
! 1425: promotions[i][j] = 0;
! 1426: for (layer = 0; layer < NUMBER_TERRAIN_LAYERS; layer++) {
! 1427: tile = &(tileCatalog[pmap[i][j].layers[layer]]);
! 1428: if (tile->promoteChance < 0) {
! 1429: promoteChance = 0;
! 1430: for (direction = 0; direction < 4; direction++) {
! 1431: if (coordinatesAreInMap(i + nbDirs[direction][0], j + nbDirs[direction][1])
! 1432: && !cellHasTerrainFlag(i + nbDirs[direction][0], j + nbDirs[direction][1], T_OBSTRUCTS_PASSABILITY)
! 1433: && pmap[i + nbDirs[direction][0]][j + nbDirs[direction][1]].layers[layer] != pmap[i][j].layers[layer]
! 1434: && !(pmap[i][j].flags & CAUGHT_FIRE_THIS_TURN)) {
! 1435: promoteChance += -1 * tile->promoteChance;
! 1436: }
! 1437: }
! 1438: } else {
! 1439: promoteChance = tile->promoteChance;
! 1440: }
! 1441: if (promoteChance
! 1442: && !(pmap[i][j].flags & CAUGHT_FIRE_THIS_TURN)
! 1443: && rand_range(0, 10000) < promoteChance) {
! 1444: promotions[i][j] |= Fl(layer);
! 1445: //promoteTile(i, j, layer, false);
! 1446: }
! 1447: }
! 1448: }
! 1449: }
! 1450: // Second pass, do the promotions:
! 1451: for (i=0; i<DCOLS; i++) {
! 1452: for (j=0; j<DROWS; j++) {
! 1453: for (layer = 0; layer < NUMBER_TERRAIN_LAYERS; layer++) {
! 1454: if ((promotions[i][j] & Fl(layer))) {
! 1455: //&& (tileCatalog[pmap[i][j].layers[layer]].promoteChance != 0)){
! 1456: // make sure that it's still a promotable layer
! 1457: promoteTile(i, j, layer, false);
! 1458: }
! 1459: }
! 1460: }
! 1461: }
! 1462:
! 1463: // Bookkeeping for fire, pressure plates and key-activated tiles.
! 1464: for (i=0; i<DCOLS; i++) {
! 1465: for (j=0; j<DROWS; j++) {
! 1466: pmap[i][j].flags &= ~(CAUGHT_FIRE_THIS_TURN);
! 1467: if (!(pmap[i][j].flags & (HAS_PLAYER | HAS_MONSTER | HAS_ITEM))
! 1468: && (pmap[i][j].flags & PRESSURE_PLATE_DEPRESSED)) {
! 1469:
! 1470: pmap[i][j].flags &= ~PRESSURE_PLATE_DEPRESSED;
! 1471: }
! 1472: if (cellHasTMFlag(i, j, TM_PROMOTES_WITHOUT_KEY) && !keyOnTileAt(i, j)) {
! 1473: for (layer = 0; layer < NUMBER_TERRAIN_LAYERS; layer++) {
! 1474: if (tileCatalog[pmap[i][j].layers[layer]].mechFlags & TM_PROMOTES_WITHOUT_KEY) {
! 1475: promoteTile(i, j, layer, false);
! 1476: }
! 1477: }
! 1478: }
! 1479: }
! 1480: }
! 1481:
! 1482: // Update fire.
! 1483: for (i=0; i<DCOLS; i++) {
! 1484: for (j=0; j<DROWS; j++) {
! 1485: if (cellHasTerrainFlag(i, j, T_IS_FIRE) && !(pmap[i][j].flags & CAUGHT_FIRE_THIS_TURN)) {
! 1486: exposeTileToFire(i, j, false);
! 1487: for (direction=0; direction<4; direction++) {
! 1488: newX = i + nbDirs[direction][0];
! 1489: newY = j + nbDirs[direction][1];
! 1490: if (coordinatesAreInMap(newX, newY)) {
! 1491: exposeTileToFire(newX, newY, false);
! 1492: }
! 1493: }
! 1494: }
! 1495: }
! 1496: }
! 1497:
! 1498: // Terrain that affects items and vice versa
! 1499: updateFloorItems();
! 1500: }
! 1501:
! 1502: void updateAllySafetyMap() {
! 1503: short i, j;
! 1504: short **playerCostMap, **monsterCostMap;
! 1505:
! 1506: rogue.updatedAllySafetyMapThisTurn = true;
! 1507:
! 1508: playerCostMap = allocGrid();
! 1509: monsterCostMap = allocGrid();
! 1510:
! 1511: for (i=0; i<DCOLS; i++) {
! 1512: for (j=0; j<DROWS; j++) {
! 1513: allySafetyMap[i][j] = 30000;
! 1514:
! 1515: playerCostMap[i][j] = monsterCostMap[i][j] = 1;
! 1516:
! 1517: if (cellHasTerrainFlag(i, j, T_OBSTRUCTS_PASSABILITY)
! 1518: && (!cellHasTMFlag(i, j, TM_IS_SECRET) || (discoveredTerrainFlagsAtLoc(i, j) & T_OBSTRUCTS_PASSABILITY))) {
! 1519:
! 1520: playerCostMap[i][j] = monsterCostMap[i][j] = cellHasTerrainFlag(i, j, T_OBSTRUCTS_DIAGONAL_MOVEMENT) ? PDS_OBSTRUCTION : PDS_FORBIDDEN;
! 1521: } else if (cellHasTerrainFlag(i, j, T_PATHING_BLOCKER & ~T_OBSTRUCTS_PASSABILITY)) {
! 1522: playerCostMap[i][j] = monsterCostMap[i][j] = PDS_FORBIDDEN;
! 1523: } else if (cellHasTerrainFlag(i, j, T_SACRED)) {
! 1524: playerCostMap[i][j] = 1;
! 1525: monsterCostMap[i][j] = PDS_FORBIDDEN;
! 1526: } else if ((pmap[i][j].flags & HAS_MONSTER) && monstersAreEnemies(&player, monsterAtLoc(i, j))) {
! 1527: playerCostMap[i][j] = 1;
! 1528: monsterCostMap[i][j] = PDS_FORBIDDEN;
! 1529: allySafetyMap[i][j] = 0;
! 1530: }
! 1531: }
! 1532: }
! 1533:
! 1534: playerCostMap[player.xLoc][player.yLoc] = PDS_FORBIDDEN;
! 1535: monsterCostMap[player.xLoc][player.yLoc] = PDS_FORBIDDEN;
! 1536:
! 1537: dijkstraScan(allySafetyMap, playerCostMap, false);
! 1538:
! 1539: for (i=0; i<DCOLS; i++) {
! 1540: for (j=0; j<DROWS; j++) {
! 1541: if (monsterCostMap[i][j] < 0) {
! 1542: continue;
! 1543: }
! 1544:
! 1545: if (allySafetyMap[i][j] == 30000) {
! 1546: allySafetyMap[i][j] = 150;
! 1547: }
! 1548:
! 1549: allySafetyMap[i][j] = 50 * allySafetyMap[i][j] / (50 + allySafetyMap[i][j]);
! 1550:
! 1551: allySafetyMap[i][j] *= -3;
! 1552:
! 1553: if (pmap[i][j].flags & IN_LOOP) {
! 1554: allySafetyMap[i][j] -= 10;
! 1555: }
! 1556: }
! 1557: }
! 1558: dijkstraScan(allySafetyMap, monsterCostMap, false);
! 1559:
! 1560: freeGrid(playerCostMap);
! 1561: freeGrid(monsterCostMap);
! 1562: }
! 1563:
! 1564: void resetDistanceCellInGrid(short **grid, short x, short y) {
! 1565: enum directions dir;
! 1566: short newX, newY;
! 1567: for (dir = 0; dir < 4; dir++) {
! 1568: newX = x + nbDirs[dir][0];
! 1569: newY = y + nbDirs[dir][1];
! 1570: if (coordinatesAreInMap(newX, newY)
! 1571: && grid[x][y] > grid[newX][newY] + 1) {
! 1572:
! 1573: grid[x][y] = grid[newX][newY] + 1;
! 1574: }
! 1575: }
! 1576: }
! 1577:
! 1578: void updateSafetyMap() {
! 1579: short i, j;
! 1580: short **playerCostMap, **monsterCostMap;
! 1581: creature *monst;
! 1582:
! 1583: rogue.updatedSafetyMapThisTurn = true;
! 1584:
! 1585: playerCostMap = allocGrid();
! 1586: monsterCostMap = allocGrid();
! 1587:
! 1588: for (i=0; i<DCOLS; i++) {
! 1589: for (j=0; j<DROWS; j++) {
! 1590: safetyMap[i][j] = 30000;
! 1591:
! 1592: playerCostMap[i][j] = monsterCostMap[i][j] = 1; // prophylactic
! 1593:
! 1594: if (cellHasTerrainFlag(i, j, T_OBSTRUCTS_PASSABILITY)
! 1595: && (!cellHasTMFlag(i, j, TM_IS_SECRET) || (discoveredTerrainFlagsAtLoc(i, j) & T_OBSTRUCTS_PASSABILITY))) {
! 1596:
! 1597: playerCostMap[i][j] = monsterCostMap[i][j] = cellHasTerrainFlag(i, j, T_OBSTRUCTS_DIAGONAL_MOVEMENT) ? PDS_OBSTRUCTION : PDS_FORBIDDEN;
! 1598: } else if (cellHasTerrainFlag(i, j, T_SACRED)) {
! 1599: playerCostMap[i][j] = 1;
! 1600: monsterCostMap[i][j] = PDS_FORBIDDEN;
! 1601: } else if (cellHasTerrainFlag(i, j, T_LAVA_INSTA_DEATH)) {
! 1602: monsterCostMap[i][j] = PDS_FORBIDDEN;
! 1603: if (player.status[STATUS_LEVITATING] || !player.status[STATUS_IMMUNE_TO_FIRE]) {
! 1604: playerCostMap[i][j] = 1;
! 1605: } else {
! 1606: playerCostMap[i][j] = PDS_FORBIDDEN;
! 1607: }
! 1608: } else {
! 1609: if (pmap[i][j].flags & HAS_MONSTER) {
! 1610: monst = monsterAtLoc(i, j);
! 1611: if ((monst->creatureState == MONSTER_SLEEPING
! 1612: || monst->turnsSpentStationary > 2
! 1613: || (monst->info.flags & MONST_GETS_TURN_ON_ACTIVATION)
! 1614: || monst->creatureState == MONSTER_ALLY)
! 1615: && monst->creatureState != MONSTER_FLEEING) {
! 1616:
! 1617: playerCostMap[i][j] = 1;
! 1618: monsterCostMap[i][j] = PDS_FORBIDDEN;
! 1619: continue;
! 1620: }
! 1621: }
! 1622:
! 1623: if (cellHasTerrainFlag(i, j, (T_AUTO_DESCENT | T_IS_DF_TRAP))) {
! 1624: monsterCostMap[i][j] = PDS_FORBIDDEN;
! 1625: if (player.status[STATUS_LEVITATING]) {
! 1626: playerCostMap[i][j] = 1;
! 1627: } else {
! 1628: playerCostMap[i][j] = PDS_FORBIDDEN;
! 1629: }
! 1630: } else if (cellHasTerrainFlag(i, j, T_IS_FIRE)) {
! 1631: monsterCostMap[i][j] = PDS_FORBIDDEN;
! 1632: if (player.status[STATUS_IMMUNE_TO_FIRE]) {
! 1633: playerCostMap[i][j] = 1;
! 1634: } else {
! 1635: playerCostMap[i][j] = PDS_FORBIDDEN;
! 1636: }
! 1637: } else if (cellHasTerrainFlag(i, j, (T_IS_DEEP_WATER | T_SPONTANEOUSLY_IGNITES))) {
! 1638: if (player.status[STATUS_LEVITATING]) {
! 1639: playerCostMap[i][j] = 1;
! 1640: } else {
! 1641: playerCostMap[i][j] = 5;
! 1642: }
! 1643: monsterCostMap[i][j] = 5;
! 1644: } else if (cellHasTerrainFlag(i, j, T_OBSTRUCTS_PASSABILITY)
! 1645: && cellHasTMFlag(i, j, TM_IS_SECRET) && !(discoveredTerrainFlagsAtLoc(i, j) & T_OBSTRUCTS_PASSABILITY)
! 1646: && !(pmap[i][j].flags & IN_FIELD_OF_VIEW)) {
! 1647: // Secret door that the player can't currently see
! 1648: playerCostMap[i][j] = 100;
! 1649: monsterCostMap[i][j] = 1;
! 1650: } else {
! 1651: playerCostMap[i][j] = monsterCostMap[i][j] = 1;
! 1652: }
! 1653: }
! 1654: }
! 1655: }
! 1656:
! 1657: safetyMap[player.xLoc][player.yLoc] = 0;
! 1658: playerCostMap[player.xLoc][player.yLoc] = 1;
! 1659: monsterCostMap[player.xLoc][player.yLoc] = PDS_FORBIDDEN;
! 1660:
! 1661: playerCostMap[rogue.upLoc[0]][rogue.upLoc[1]] = PDS_FORBIDDEN;
! 1662: monsterCostMap[rogue.upLoc[0]][rogue.upLoc[1]] = PDS_FORBIDDEN;
! 1663: playerCostMap[rogue.downLoc[0]][rogue.downLoc[1]] = PDS_FORBIDDEN;
! 1664: monsterCostMap[rogue.downLoc[0]][rogue.downLoc[1]] = PDS_FORBIDDEN;
! 1665:
! 1666: dijkstraScan(safetyMap, playerCostMap, false);
! 1667:
! 1668: for (i=0; i<DCOLS; i++) {
! 1669: for (j=0; j<DROWS; j++) {
! 1670: if (cellHasTerrainFlag(i, j, T_OBSTRUCTS_PASSABILITY)
! 1671: && cellHasTMFlag(i, j, TM_IS_SECRET) && !(discoveredTerrainFlagsAtLoc(i, j) & T_OBSTRUCTS_PASSABILITY)
! 1672: && !(pmap[i][j].flags & IN_FIELD_OF_VIEW)) {
! 1673:
! 1674: // Secret doors that the player can't see are not particularly safe themselves;
! 1675: // the areas behind them are.
! 1676: resetDistanceCellInGrid(safetyMap, i, j);
! 1677: }
! 1678: }
! 1679: }
! 1680:
! 1681: for (i=0; i<DCOLS; i++) {
! 1682: for (j=0; j<DROWS; j++) {
! 1683: if (monsterCostMap[i][j] < 0) {
! 1684: continue;
! 1685: }
! 1686:
! 1687: if (safetyMap[i][j] == 30000) {
! 1688: safetyMap[i][j] = 150;
! 1689: }
! 1690:
! 1691: safetyMap[i][j] = 50 * safetyMap[i][j] / (50 + safetyMap[i][j]);
! 1692:
! 1693: safetyMap[i][j] *= -3;
! 1694:
! 1695: if (pmap[i][j].flags & IN_LOOP) {
! 1696: safetyMap[i][j] -= 10;
! 1697: }
! 1698: }
! 1699: }
! 1700: dijkstraScan(safetyMap, monsterCostMap, false);
! 1701: for (i=0; i<DCOLS; i++) {
! 1702: for (j=0; j<DROWS; j++) {
! 1703: if (monsterCostMap[i][j] < 0) {
! 1704: safetyMap[i][j] = 30000;
! 1705: }
! 1706: }
! 1707: }
! 1708: freeGrid(playerCostMap);
! 1709: freeGrid(monsterCostMap);
! 1710: }
! 1711:
! 1712: void updateSafeTerrainMap() {
! 1713: short i, j;
! 1714: short **costMap;
! 1715: creature *monst;
! 1716:
! 1717: rogue.updatedMapToSafeTerrainThisTurn = true;
! 1718: costMap = allocGrid();
! 1719:
! 1720: for (i=0; i<DCOLS; i++) {
! 1721: for (j=0; j<DROWS; j++) {
! 1722: monst = monsterAtLoc(i, j);
! 1723: if (cellHasTerrainFlag(i, j, T_OBSTRUCTS_PASSABILITY)
! 1724: && (!cellHasTMFlag(i, j, TM_IS_SECRET) || (discoveredTerrainFlagsAtLoc(i, j) & T_OBSTRUCTS_PASSABILITY))) {
! 1725:
! 1726: costMap[i][j] = cellHasTerrainFlag(i, j, T_OBSTRUCTS_DIAGONAL_MOVEMENT) ? PDS_OBSTRUCTION : PDS_FORBIDDEN;
! 1727: rogue.mapToSafeTerrain[i][j] = 30000; // OOS prophylactic
! 1728: } else if ((monst && (monst->turnsSpentStationary > 1 || (monst->info.flags & MONST_GETS_TURN_ON_ACTIVATION)))
! 1729: || (cellHasTerrainFlag(i, j, T_PATHING_BLOCKER & ~T_HARMFUL_TERRAIN) && !cellHasTMFlag(i, j, TM_IS_SECRET))) {
! 1730:
! 1731: costMap[i][j] = PDS_FORBIDDEN;
! 1732: rogue.mapToSafeTerrain[i][j] = 30000;
! 1733: } else if (cellHasTerrainFlag(i, j, T_HARMFUL_TERRAIN) || pmap[i][j].layers[DUNGEON] == DOOR) {
! 1734: // The door thing is an aesthetically offensive but necessary hack to make sure
! 1735: // that monsters trying to find their way out of caustic gas do not sprint for
! 1736: // the doors. Doors are superficially free of gas, but as soon as they are opened,
! 1737: // gas will fill their tile, so they are not actually safe. Without this fix,
! 1738: // allies will fidget back and forth in a doorway while they asphyxiate.
! 1739: // This will have to do. It's a difficult problem to solve elegantly.
! 1740: costMap[i][j] = 1;
! 1741: rogue.mapToSafeTerrain[i][j] = 30000;
! 1742: } else {
! 1743: costMap[i][j] = 1;
! 1744: rogue.mapToSafeTerrain[i][j] = 0;
! 1745: }
! 1746: }
! 1747: }
! 1748: dijkstraScan(rogue.mapToSafeTerrain, costMap, false);
! 1749: freeGrid(costMap);
! 1750: }
! 1751:
! 1752: void processIncrementalAutoID() {
! 1753: item *theItem, *autoIdentifyItems[3] = {rogue.armor, rogue.ringLeft, rogue.ringRight};
! 1754: char buf[DCOLS*3], theItemName[DCOLS*3];
! 1755: short i;
! 1756:
! 1757: for (i=0; i<3; i++) {
! 1758: theItem = autoIdentifyItems[i];
! 1759: if (theItem
! 1760: && theItem->charges > 0
! 1761: && (!(theItem->flags & ITEM_IDENTIFIED) || ((theItem->category & RING) && !ringTable[theItem->kind].identified))) {
! 1762:
! 1763: theItem->charges--;
! 1764: if (theItem->charges <= 0) {
! 1765: itemName(theItem, theItemName, false, false, NULL);
! 1766: sprintf(buf, "you are now familiar enough with your %s to identify it.", theItemName);
! 1767: messageWithColor(buf, &itemMessageColor, false);
! 1768:
! 1769: if (theItem->category & ARMOR) {
! 1770: // Don't necessarily reveal the armor's runic specifically, just that it has one.
! 1771: theItem->flags |= ITEM_IDENTIFIED;
! 1772: } else if (theItem->category & RING) {
! 1773: identify(theItem);
! 1774: }
! 1775: updateIdentifiableItems();
! 1776:
! 1777: itemName(theItem, theItemName, true, true, NULL);
! 1778: sprintf(buf, "%s %s.", (theItem->quantity > 1 ? "they are" : "it is"), theItemName);
! 1779: messageWithColor(buf, &itemMessageColor, false);
! 1780: }
! 1781: }
! 1782: }
! 1783: }
! 1784:
! 1785: short staffChargeDuration(const item *theItem) {
! 1786: // staffs of blinking and obstruction recharge half as fast so they're less powerful
! 1787: return (theItem->kind == STAFF_BLINKING || theItem->kind == STAFF_OBSTRUCTION ? 10000 : 5000) / theItem->enchant1;
! 1788: }
! 1789:
! 1790: // Multiplier can be negative, in which case staffs and charms will be drained instead of recharged.
! 1791: void rechargeItemsIncrementally(short multiplier) {
! 1792: item *theItem;
! 1793: char buf[DCOLS*3], theItemName[DCOLS*3];
! 1794: short rechargeIncrement, staffRechargeDuration;
! 1795:
! 1796: if (rogue.wisdomBonus) {
! 1797: // at level 27, you recharge anything to full in one turn
! 1798: rechargeIncrement = 10 * ringWisdomMultiplier(rogue.wisdomBonus * FP_FACTOR) / FP_FACTOR;
! 1799: } else {
! 1800: rechargeIncrement = 10;
! 1801: }
! 1802:
! 1803: rechargeIncrement *= multiplier;
! 1804:
! 1805: for (theItem = packItems->nextItem; theItem != NULL; theItem = theItem->nextItem) {
! 1806: if (theItem->category & STAFF) {
! 1807: if (theItem->charges < theItem->enchant1 && rechargeIncrement > 0
! 1808: || theItem->charges > 0 && rechargeIncrement < 0) {
! 1809:
! 1810: theItem->enchant2 -= rechargeIncrement;
! 1811: }
! 1812: staffRechargeDuration = staffChargeDuration(theItem);
! 1813: while (theItem->enchant2 <= 0) {
! 1814: // if it's time to add a staff charge
! 1815: if (theItem->charges < theItem->enchant1) {
! 1816: theItem->charges++;
! 1817: }
! 1818: theItem->enchant2 += randClumpedRange(max(staffRechargeDuration / 3, 1), staffRechargeDuration * 5 / 3, 3);
! 1819: }
! 1820: while (theItem->enchant2 > staffRechargeDuration * 5 / 3) {
! 1821: // if it's time to drain a staff charge
! 1822: if (theItem->charges > 0) {
! 1823: theItem->charges--;
! 1824: }
! 1825: theItem->enchant2 -= staffRechargeDuration;
! 1826: }
! 1827: } else if ((theItem->category & CHARM) && (theItem->charges > 0)) {
! 1828: theItem->charges = clamp(theItem->charges - multiplier, 0, charmRechargeDelay(theItem->kind, theItem->enchant1));
! 1829: if (theItem->charges == 0) {
! 1830: itemName(theItem, theItemName, false, false, NULL);
! 1831: sprintf(buf, "your %s has recharged.", theItemName);
! 1832: message(buf, false);
! 1833: }
! 1834: }
! 1835: }
! 1836: }
! 1837:
! 1838: void extinguishFireOnCreature(creature *monst) {
! 1839:
! 1840: monst->status[STATUS_BURNING] = 0;
! 1841: if (monst == &player) {
! 1842: player.info.foreColor = &white;
! 1843: rogue.minersLight.lightColor = &minersLightColor;
! 1844: refreshDungeonCell(player.xLoc, player.yLoc);
! 1845: updateVision(true);
! 1846: message("you are no longer on fire.", false);
! 1847: }
! 1848: }
! 1849:
! 1850: // n is the monster's depthLevel - 1.
! 1851: void monsterEntersLevel(creature *monst, short n) {
! 1852: creature *prevMonst;
! 1853: char monstName[COLS], buf[COLS];
! 1854: boolean pit = false;
! 1855:
! 1856: if (rogue.patchVersion >= 3) {
! 1857: levels[n].mapStorage[monst->xLoc][monst->yLoc].flags &= ~HAS_MONSTER;
! 1858: }
! 1859:
! 1860: // place traversing monster near the stairs on this level
! 1861: if (monst->bookkeepingFlags & MB_APPROACHING_DOWNSTAIRS) {
! 1862: monst->xLoc = rogue.upLoc[0];
! 1863: monst->yLoc = rogue.upLoc[1];
! 1864: } else if (monst->bookkeepingFlags & MB_APPROACHING_UPSTAIRS) {
! 1865: monst->xLoc = rogue.downLoc[0];
! 1866: monst->yLoc = rogue.downLoc[1];
! 1867: } else if (monst->bookkeepingFlags & MB_APPROACHING_PIT) { // jumping down pit
! 1868: pit = true;
! 1869: monst->xLoc = levels[n].playerExitedVia[0];
! 1870: monst->yLoc = levels[n].playerExitedVia[1];
! 1871: } else {
! 1872: brogueAssert(false);
! 1873: }
! 1874: monst->depth = rogue.depthLevel;
! 1875: monst->targetCorpseLoc[0] = monst->targetCorpseLoc[1] = 0;
! 1876:
! 1877: if (!pit) {
! 1878: getQualifyingPathLocNear(&(monst->xLoc), &(monst->yLoc), monst->xLoc, monst->yLoc, true,
! 1879: T_DIVIDES_LEVEL & avoidedFlagsForMonster(&(monst->info)), 0,
! 1880: avoidedFlagsForMonster(&(monst->info)), HAS_STAIRS, false);
! 1881: }
! 1882: if (!pit
! 1883: && (pmap[monst->xLoc][monst->yLoc].flags & (HAS_PLAYER | HAS_MONSTER))
! 1884: && !(terrainFlags(monst->xLoc, monst->yLoc) & avoidedFlagsForMonster(&(monst->info)))) {
! 1885: // Monsters using the stairs will displace any creatures already located there, to thwart stair-dancing.
! 1886: prevMonst = monsterAtLoc(monst->xLoc, monst->yLoc);
! 1887: brogueAssert(prevMonst);
! 1888: getQualifyingPathLocNear(&(prevMonst->xLoc), &(prevMonst->yLoc), monst->xLoc, monst->yLoc, true,
! 1889: T_DIVIDES_LEVEL & avoidedFlagsForMonster(&(prevMonst->info)), 0,
! 1890: avoidedFlagsForMonster(&(prevMonst->info)), (HAS_MONSTER | HAS_PLAYER | HAS_STAIRS), false);
! 1891: pmap[monst->xLoc][monst->yLoc].flags &= ~(HAS_PLAYER | HAS_MONSTER);
! 1892: pmap[prevMonst->xLoc][prevMonst->yLoc].flags |= (prevMonst == &player ? HAS_PLAYER : HAS_MONSTER);
! 1893: refreshDungeonCell(prevMonst->xLoc, prevMonst->yLoc);
! 1894: //DEBUG printf("\nBumped a creature (%s) from (%i, %i) to (%i, %i).", prevMonst->info.monsterName, monst->xLoc, monst->yLoc, prevMonst->xLoc, prevMonst->yLoc);
! 1895: }
! 1896:
! 1897: // remove traversing monster from other level monster chain
! 1898: if (monst == levels[n].monsters) {
! 1899: levels[n].monsters = monst->nextCreature;
! 1900: } else {
! 1901: for (prevMonst = levels[n].monsters; prevMonst->nextCreature != monst; prevMonst = prevMonst->nextCreature);
! 1902: prevMonst->nextCreature = monst->nextCreature;
! 1903: }
! 1904:
! 1905: // prepend traversing monster to current level monster chain
! 1906: monst->nextCreature = monsters->nextCreature;
! 1907: monsters->nextCreature = monst;
! 1908:
! 1909: monst->status[STATUS_ENTERS_LEVEL_IN] = 0;
! 1910: monst->bookkeepingFlags |= MB_PREPLACED;
! 1911: monst->bookkeepingFlags &= ~MB_IS_FALLING;
! 1912: restoreMonster(monst, NULL, NULL);
! 1913: //DEBUG printf("\nPlaced a creature (%s) at (%i, %i).", monst->info.monsterName, monst->xLoc, monst->yLoc);
! 1914: monst->ticksUntilTurn = monst->movementSpeed;
! 1915: refreshDungeonCell(monst->xLoc, monst->yLoc);
! 1916:
! 1917: if (pit) {
! 1918: monsterName(monstName, monst, true);
! 1919: if (!monst->status[STATUS_LEVITATING]) {
! 1920: if (inflictDamage(NULL, monst, randClumpedRange(6, 12, 2), &red, false)) {
! 1921: if (canSeeMonster(monst)) {
! 1922: sprintf(buf, "%s plummets from above and splatters against the ground!", monstName);
! 1923: messageWithColor(buf, messageColorFromVictim(monst), false);
! 1924: }
! 1925: } else {
! 1926: if (canSeeMonster(monst)) {
! 1927: sprintf(buf, "%s falls from above and crashes to the ground!", monstName);
! 1928: message(buf, false);
! 1929: }
! 1930: }
! 1931: } else if (canSeeMonster(monst)) {
! 1932: sprintf(buf, "%s swoops into the cavern from above.", monstName);
! 1933: message(buf, false);
! 1934: }
! 1935: }
! 1936: }
! 1937:
! 1938: void monstersApproachStairs() {
! 1939: creature *monst, *nextMonst;
! 1940: short n;
! 1941:
! 1942: for (n = rogue.depthLevel - 2; n <= rogue.depthLevel; n += 2) { // cycle through previous and next level
! 1943: if (n >= 0 && n < DEEPEST_LEVEL && levels[n].visited) {
! 1944: for (monst = levels[n].monsters; monst != NULL;) {
! 1945: nextMonst = monst->nextCreature;
! 1946: if (monst->status[STATUS_ENTERS_LEVEL_IN] > 1) {
! 1947: monst->status[STATUS_ENTERS_LEVEL_IN]--;
! 1948: } else if (monst->status[STATUS_ENTERS_LEVEL_IN] == 1) {
! 1949: monsterEntersLevel(monst, n);
! 1950: }
! 1951: monst = nextMonst;
! 1952: }
! 1953: }
! 1954: }
! 1955:
! 1956: if (rogue.yendorWarden
! 1957: && abs(rogue.depthLevel - rogue.yendorWarden->depth) > 1) {
! 1958:
! 1959: updateYendorWardenTracking();
! 1960: }
! 1961: }
! 1962:
! 1963: void decrementPlayerStatus() {
! 1964: // Handle hunger.
! 1965: if (!player.status[STATUS_PARALYZED]) {
! 1966: // No nutrition is expended while paralyzed.
! 1967: if (player.status[STATUS_NUTRITION] > 0) {
! 1968: if (!numberOfMatchingPackItems(AMULET, 0, 0, false) || rand_percent(20)) {
! 1969: player.status[STATUS_NUTRITION]--;
! 1970: }
! 1971: }
! 1972: checkNutrition();
! 1973: }
! 1974:
! 1975: if (player.status[STATUS_TELEPATHIC] > 0 && !--player.status[STATUS_TELEPATHIC]) {
! 1976: updateVision(true);
! 1977: message("your preternatural mental sensitivity fades.", false);
! 1978: }
! 1979:
! 1980: if (player.status[STATUS_DARKNESS] > 0) {
! 1981: player.status[STATUS_DARKNESS]--;
! 1982: updateMinersLightRadius();
! 1983: //updateVision();
! 1984: }
! 1985:
! 1986: if (player.status[STATUS_HALLUCINATING] > 0 && !--player.status[STATUS_HALLUCINATING]) {
! 1987: displayLevel();
! 1988: message("your hallucinations fade.", false);
! 1989: }
! 1990:
! 1991: if (player.status[STATUS_LEVITATING] > 0 && !--player.status[STATUS_LEVITATING]) {
! 1992: message("you are no longer levitating.", false);
! 1993: }
! 1994:
! 1995: if (player.status[STATUS_CONFUSED] > 0 && !--player.status[STATUS_CONFUSED]) {
! 1996: message("you no longer feel confused.", false);
! 1997: }
! 1998:
! 1999: if (player.status[STATUS_NAUSEOUS] > 0 && !--player.status[STATUS_NAUSEOUS]) {
! 2000: message("you feel less nauseous.", false);
! 2001: }
! 2002:
! 2003: if (player.status[STATUS_PARALYZED] > 0 && !--player.status[STATUS_PARALYZED]) {
! 2004: message("you can move again.", false);
! 2005: }
! 2006:
! 2007: if (player.status[STATUS_HASTED] > 0 && !--player.status[STATUS_HASTED]) {
! 2008: player.movementSpeed = player.info.movementSpeed;
! 2009: player.attackSpeed = player.info.attackSpeed;
! 2010: synchronizePlayerTimeState();
! 2011: message("your supernatural speed fades.", false);
! 2012: }
! 2013:
! 2014: if (player.status[STATUS_SLOWED] > 0 && !--player.status[STATUS_SLOWED]) {
! 2015: player.movementSpeed = player.info.movementSpeed;
! 2016: player.attackSpeed = player.info.attackSpeed;
! 2017: synchronizePlayerTimeState();
! 2018: message("your normal speed resumes.", false);
! 2019: }
! 2020:
! 2021: if (player.status[STATUS_WEAKENED] > 0 && !--player.status[STATUS_WEAKENED]) {
! 2022: player.weaknessAmount = 0;
! 2023: message("strength returns to your muscles as the weakening toxin wears off.", false);
! 2024: updateEncumbrance();
! 2025: }
! 2026:
! 2027: if (player.status[STATUS_DONNING]) {
! 2028: player.status[STATUS_DONNING]--;
! 2029: recalculateEquipmentBonuses();
! 2030: }
! 2031:
! 2032: if (player.status[STATUS_IMMUNE_TO_FIRE] > 0 && !--player.status[STATUS_IMMUNE_TO_FIRE]) {
! 2033: message("you no longer feel immune to fire.", false);
! 2034: }
! 2035:
! 2036: if (player.status[STATUS_STUCK] && !cellHasTerrainFlag(player.xLoc, player.yLoc, T_ENTANGLES)) {
! 2037: player.status[STATUS_STUCK] = 0;
! 2038: }
! 2039:
! 2040: if (player.status[STATUS_EXPLOSION_IMMUNITY]) {
! 2041: player.status[STATUS_EXPLOSION_IMMUNITY]--;
! 2042: }
! 2043:
! 2044: if (player.status[STATUS_DISCORDANT]) {
! 2045: player.status[STATUS_DISCORDANT]--;
! 2046: }
! 2047:
! 2048: if (player.status[STATUS_AGGRAVATING]) {
! 2049: player.status[STATUS_AGGRAVATING]--;
! 2050: }
! 2051:
! 2052: if (player.status[STATUS_SHIELDED]) {
! 2053: player.status[STATUS_SHIELDED] -= player.maxStatus[STATUS_SHIELDED] / 20;
! 2054: if (player.status[STATUS_SHIELDED] <= 0) {
! 2055: player.status[STATUS_SHIELDED] = player.maxStatus[STATUS_SHIELDED] = 0;
! 2056: }
! 2057: }
! 2058:
! 2059: if (player.status[STATUS_INVISIBLE] > 0 && !--player.status[STATUS_INVISIBLE]) {
! 2060: message("you are no longer invisible.", false);
! 2061: }
! 2062:
! 2063: if (rogue.monsterSpawnFuse <= 0) {
! 2064: spawnPeriodicHorde();
! 2065: rogue.monsterSpawnFuse = rand_range(125, 175);
! 2066: }
! 2067: }
! 2068:
! 2069: boolean dangerChanged(boolean danger[4]) {
! 2070: enum directions dir;
! 2071: short newX, newY;
! 2072: for (dir = 0; dir < 4; dir++) {
! 2073: newX = player.xLoc + nbDirs[dir][0];
! 2074: newY = player.yLoc + nbDirs[dir][1];
! 2075: if (danger[dir] != monsterAvoids(&player, newX, newY)) {
! 2076: return true;
! 2077: }
! 2078: }
! 2079: return false;
! 2080: }
! 2081:
! 2082: void autoRest() {
! 2083: short i = 0;
! 2084: boolean initiallyEmbedded; // Stop as soon as we're free from crystal.
! 2085: boolean danger[4];
! 2086: short newX, newY;
! 2087: enum directions dir;
! 2088:
! 2089: for (dir = 0; dir < 4; dir++) {
! 2090: newX = player.xLoc + nbDirs[dir][0];
! 2091: newY = player.yLoc + nbDirs[dir][1];
! 2092: danger[dir] = monsterAvoids(&player, newX, newY);
! 2093: }
! 2094:
! 2095: rogue.disturbed = false;
! 2096: rogue.automationActive = true;
! 2097: initiallyEmbedded = cellHasTerrainFlag(player.xLoc, player.yLoc, T_OBSTRUCTS_PASSABILITY);
! 2098:
! 2099: if ((player.currentHP < player.info.maxHP
! 2100: || player.status[STATUS_HALLUCINATING]
! 2101: || player.status[STATUS_CONFUSED]
! 2102: || player.status[STATUS_NAUSEOUS]
! 2103: || player.status[STATUS_POISONED]
! 2104: || player.status[STATUS_DARKNESS]
! 2105: || initiallyEmbedded)
! 2106: && !rogue.disturbed) {
! 2107: while (i++ < TURNS_FOR_FULL_REGEN
! 2108: && (player.currentHP < player.info.maxHP
! 2109: || player.status[STATUS_HALLUCINATING]
! 2110: || player.status[STATUS_CONFUSED]
! 2111: || player.status[STATUS_NAUSEOUS]
! 2112: || player.status[STATUS_POISONED]
! 2113: || player.status[STATUS_DARKNESS]
! 2114: || cellHasTerrainFlag(player.xLoc, player.yLoc, T_OBSTRUCTS_PASSABILITY))
! 2115: && !rogue.disturbed
! 2116: && (!initiallyEmbedded || cellHasTerrainFlag(player.xLoc, player.yLoc, T_OBSTRUCTS_PASSABILITY))) {
! 2117:
! 2118: recordKeystroke(REST_KEY, false, false);
! 2119: rogue.justRested = true;
! 2120: playerTurnEnded();
! 2121: if (dangerChanged(danger) || pauseBrogue(1)) {
! 2122: rogue.disturbed = true;
! 2123: }
! 2124: }
! 2125: } else {
! 2126: for (i=0; i<100 && !rogue.disturbed; i++) {
! 2127: recordKeystroke(REST_KEY, false, false);
! 2128: rogue.justRested = true;
! 2129: playerTurnEnded();
! 2130: if (dangerChanged(danger) || pauseBrogue(1)) {
! 2131: rogue.disturbed = true;
! 2132: }
! 2133: }
! 2134: }
! 2135: rogue.automationActive = false;
! 2136: }
! 2137:
! 2138: void manualSearch() {
! 2139: recordKeystroke(SEARCH_KEY, false, false);
! 2140:
! 2141: if (player.status[STATUS_SEARCHING] <= 0) {
! 2142: player.status[STATUS_SEARCHING] = 0;
! 2143: player.maxStatus[STATUS_SEARCHING] = 5;
! 2144: }
! 2145:
! 2146: player.status[STATUS_SEARCHING] += 1;
! 2147:
! 2148: /* The search strength values were chosen based on equating the expected
! 2149: number of cells discovered by 5x 80 searches (1.7.4) and 1x 200 search
! 2150: (1.7.5). 1x200 discovers an average of 932 cells; 5.65 times more cells than
! 2151: the 165 of 5x80. This factor is intepreted as the advantage of undelayed
! 2152: searching. Hence, we chose a short radius r and a long radius s such that
! 2153:
! 2154: 4 * 5.65 * E_r + E_s ~= 932
! 2155:
! 2156: where E_x is the expected no. of cells discovered with radius x. We choose
! 2157: r=60, s=160, giving 852 < 932 (under to account for removal of 1.7.5 stealth
! 2158: range doubling).
! 2159: */
! 2160: short searchStrength = 0;
! 2161: if (player.status[STATUS_SEARCHING] < 5) {
! 2162: searchStrength = (rogue.awarenessBonus >= 0 ? 60 : 30);
! 2163: } else {
! 2164: // Do a final, larger-radius search on the fifth search in a row
! 2165: searchStrength = 160;
! 2166: message("you finish your detailed search of the area.", false);
! 2167: player.status[STATUS_SEARCHING] = 0;
! 2168: }
! 2169:
! 2170: // ensure our search is no weaker than the current passive search
! 2171: search(max(searchStrength, rogue.awarenessBonus + 30));
! 2172:
! 2173: rogue.justSearched = true;
! 2174: playerTurnEnded();
! 2175: }
! 2176:
! 2177: // Call this periodically (when haste/slow wears off and when moving between depths)
! 2178: // to keep environmental updates in sync with player turns.
! 2179: void synchronizePlayerTimeState() {
! 2180: rogue.ticksTillUpdateEnvironment = player.ticksUntilTurn;
! 2181: }
! 2182:
! 2183: void playerRecoversFromAttacking(boolean anAttackHit) {
! 2184: if (player.ticksUntilTurn >= 0) {
! 2185: // Don't do this if the player's weapon of speed just fired.
! 2186: if (rogue.weapon && (rogue.weapon->flags & ITEM_ATTACKS_STAGGER) && anAttackHit) {
! 2187: player.ticksUntilTurn += 2 * player.attackSpeed;
! 2188: } else if (rogue.weapon && (rogue.weapon->flags & ITEM_ATTACKS_QUICKLY)) {
! 2189: player.ticksUntilTurn += player.attackSpeed / 2;
! 2190: } else {
! 2191: player.ticksUntilTurn += player.attackSpeed;
! 2192: }
! 2193: }
! 2194: }
! 2195:
! 2196:
! 2197: static void recordCurrentCreatureHealths() {
! 2198: creature *monst;
! 2199: CYCLE_MONSTERS_AND_PLAYERS(monst) {
! 2200: monst->previousHealthPoints = monst->currentHP;
! 2201: }
! 2202: }
! 2203:
! 2204: // This is the dungeon schedule manager, called every time the player's turn comes to an end.
! 2205: // It hands control over to monsters until they've all expended their accumulated ticks,
! 2206: // updating the environment (gas spreading, flames spreading and burning out, etc.) every
! 2207: // 100 ticks.
! 2208: void playerTurnEnded() {
! 2209: short soonestTurn, damage, turnsRequiredToShore, turnsToShore;
! 2210: char buf[COLS], buf2[COLS];
! 2211: creature *monst, *monst2, *nextMonst;
! 2212: boolean fastForward = false;
! 2213: short oldRNG;
! 2214:
! 2215: brogueAssert(rogue.RNG == RNG_SUBSTANTIVE);
! 2216:
! 2217: handleXPXP();
! 2218: resetDFMessageEligibility();
! 2219: recordCurrentCreatureHealths();
! 2220:
! 2221: if (player.bookkeepingFlags & MB_IS_FALLING) {
! 2222: playerFalls();
! 2223: if (!rogue.gameHasEnded) {
! 2224: handleHealthAlerts();
! 2225: }
! 2226: return;
! 2227: }
! 2228:
! 2229: // This happens in updateEnvironment, but some monsters move faster than the
! 2230: // environment updates in the loop below. This means they need to fall at
! 2231: // the start of the turn to avoid them being able to act while suspended
! 2232: // over a chasm
! 2233: monstersFall();
! 2234:
! 2235: do {
! 2236: if (rogue.gameHasEnded) {
! 2237: return;
! 2238: }
! 2239:
! 2240: if (!player.status[STATUS_PARALYZED]) {
! 2241: rogue.playerTurnNumber++; // So recordings don't register more turns than you actually have.
! 2242: }
! 2243: rogue.absoluteTurnNumber++;
! 2244:
! 2245: if (player.status[STATUS_INVISIBLE]) {
! 2246: rogue.scentTurnNumber += 10; // Your scent fades very quickly while you are invisible.
! 2247: } else {
! 2248: rogue.scentTurnNumber += 3; // this must happen per subjective player time
! 2249: }
! 2250: if (rogue.scentTurnNumber > 20000) {
! 2251: resetScentTurnNumber();
! 2252: }
! 2253:
! 2254: //updateFlavorText();
! 2255:
! 2256: // Regeneration/starvation:
! 2257: if (player.status[STATUS_NUTRITION] <= 0) {
! 2258: player.currentHP--;
! 2259: if (player.currentHP <= 0) {
! 2260: gameOver("Starved to death", true);
! 2261: return;
! 2262: }
! 2263: } else if (player.currentHP < player.info.maxHP
! 2264: && !player.status[STATUS_POISONED]) {
! 2265: if ((player.turnsUntilRegen -= 1000) <= 0) {
! 2266: player.currentHP++;
! 2267: if (player.previousHealthPoints < player.currentHP) {
! 2268: player.previousHealthPoints++; // Regeneration doesn't display on the status bar.
! 2269: }
! 2270: player.turnsUntilRegen += player.info.turnsBetweenRegen;
! 2271: }
! 2272: if (player.regenPerTurn) {
! 2273: player.currentHP += player.regenPerTurn;
! 2274: if (player.previousHealthPoints < player.currentHP) {
! 2275: player.previousHealthPoints = min(player.currentHP, player.previousHealthPoints + player.regenPerTurn);
! 2276: }
! 2277: }
! 2278: }
! 2279:
! 2280: if (rogue.awarenessBonus > -30 && !(pmap[player.xLoc][player.yLoc].flags & SEARCHED_FROM_HERE)) {
! 2281: // Low-grade auto-search wherever you step, but only once per tile.
! 2282: search(rogue.awarenessBonus + 30);
! 2283: pmap[player.xLoc][player.yLoc].flags |= SEARCHED_FROM_HERE;
! 2284: }
! 2285: if (!rogue.justSearched && player.status[STATUS_SEARCHING] > 0) {
! 2286: // Searching only "charges up" when done on consecutive turns
! 2287: player.status[STATUS_SEARCHING] = 0;
! 2288: }
! 2289: if (rogue.staleLoopMap) {
! 2290: analyzeMap(false); // Don't need to update the chokemap.
! 2291: }
! 2292:
! 2293: for (monst = monsters->nextCreature; monst != NULL; monst = nextMonst) {
! 2294: nextMonst = monst->nextCreature;
! 2295: if ((monst->bookkeepingFlags & MB_BOUND_TO_LEADER)
! 2296: && (!monst->leader || !(monst->bookkeepingFlags & MB_FOLLOWER))
! 2297: && (monst->creatureState != MONSTER_ALLY)) {
! 2298:
! 2299: killCreature(monst, false);
! 2300: if (canSeeMonster(monst)) {
! 2301: monsterName(buf2, monst, true);
! 2302: sprintf(buf, "%s dissipates into thin air", buf2);
! 2303: combatMessage(buf, messageColorFromVictim(monst));
! 2304: }
! 2305: }
! 2306: }
! 2307:
! 2308: if (player.status[STATUS_BURNING] > 0) {
! 2309: damage = rand_range(1, 3);
! 2310: if (!(player.status[STATUS_IMMUNE_TO_FIRE]) && inflictDamage(NULL, &player, damage, &orange, true)) {
! 2311: gameOver("Burned to death", true);
! 2312: }
! 2313: if (!--player.status[STATUS_BURNING]) {
! 2314: extinguishFireOnCreature(&player);
! 2315: }
! 2316: }
! 2317:
! 2318: if (player.status[STATUS_POISONED] > 0) {
! 2319: player.status[STATUS_POISONED]--;
! 2320: if (inflictDamage(NULL, &player, player.poisonAmount, &green, true)) {
! 2321: gameOver("Died from poison", true);
! 2322: }
! 2323: if (!player.status[STATUS_POISONED]) {
! 2324: player.poisonAmount = 0;
! 2325: }
! 2326: }
! 2327:
! 2328: if (player.ticksUntilTurn == 0) { // attacking adds ticks elsewhere
! 2329: player.ticksUntilTurn += player.movementSpeed;
! 2330: } else if (player.ticksUntilTurn < 0) { // if he gets a free turn
! 2331: player.ticksUntilTurn = 0;
! 2332: }
! 2333:
! 2334: updateScent();
! 2335: // updateVision(true);
! 2336: // rogue.aggroRange = currentAggroValue();
! 2337: // if (rogue.displayAggroRangeMode) {
! 2338: // displayLevel();
! 2339: // }
! 2340: rogue.updatedSafetyMapThisTurn = false;
! 2341: rogue.updatedAllySafetyMapThisTurn = false;
! 2342: rogue.updatedMapToSafeTerrainThisTurn = false;
! 2343:
! 2344: for (monst = monsters->nextCreature; monst != NULL; monst = monst->nextCreature) {
! 2345: if (D_SAFETY_VISION || monst->creatureState == MONSTER_FLEEING && pmap[monst->xLoc][monst->yLoc].flags & IN_FIELD_OF_VIEW) {
! 2346: updateSafetyMap(); // only if there is a fleeing monster who can see the player
! 2347: break;
! 2348: }
! 2349: }
! 2350:
! 2351: if (D_BULLET_TIME && !rogue.justRested) {
! 2352: player.ticksUntilTurn = 0;
! 2353: }
! 2354:
! 2355: applyGradualTileEffectsToCreature(&player, player.ticksUntilTurn);
! 2356:
! 2357: if (rogue.gameHasEnded) {
! 2358: return;
! 2359: }
! 2360:
! 2361: rogue.heardCombatThisTurn = false;
! 2362:
! 2363: while (player.ticksUntilTurn > 0) {
! 2364: soonestTurn = 10000;
! 2365: for(monst = monsters->nextCreature; monst != NULL; monst = monst->nextCreature) {
! 2366: soonestTurn = min(soonestTurn, monst->ticksUntilTurn);
! 2367: }
! 2368: soonestTurn = min(soonestTurn, player.ticksUntilTurn);
! 2369: soonestTurn = min(soonestTurn, rogue.ticksTillUpdateEnvironment);
! 2370: for(monst = monsters->nextCreature; monst != NULL; monst = monst->nextCreature) {
! 2371: monst->ticksUntilTurn -= soonestTurn;
! 2372: }
! 2373: rogue.ticksTillUpdateEnvironment -= soonestTurn;
! 2374: if (rogue.ticksTillUpdateEnvironment <= 0) {
! 2375: rogue.ticksTillUpdateEnvironment += 100;
! 2376:
! 2377: // stuff that happens periodically according to an objective time measurement goes here:
! 2378: rechargeItemsIncrementally(1); // staffs recharge every so often
! 2379: processIncrementalAutoID(); // become more familiar with worn armor and rings
! 2380: rogue.monsterSpawnFuse--; // monsters spawn in the level every so often
! 2381:
! 2382: for (monst = monsters->nextCreature; monst != NULL;) {
! 2383: nextMonst = monst->nextCreature;
! 2384: applyInstantTileEffectsToCreature(monst);
! 2385: monst = nextMonst; // this weirdness is in case the monster dies in the previous step
! 2386: }
! 2387:
! 2388: for (monst = monsters->nextCreature; monst != NULL;) {
! 2389: nextMonst = monst->nextCreature;
! 2390: decrementMonsterStatus(monst);
! 2391: monst = nextMonst;
! 2392: }
! 2393:
! 2394: // monsters with a dungeon feature spawn it every so often
! 2395: for (monst = monsters->nextCreature; monst != NULL;) {
! 2396: nextMonst = monst->nextCreature;
! 2397: if (monst->info.DFChance
! 2398: && !(monst->info.flags & MONST_GETS_TURN_ON_ACTIVATION)
! 2399: && rand_percent(monst->info.DFChance)) {
! 2400:
! 2401: spawnDungeonFeature(monst->xLoc, monst->yLoc, &dungeonFeatureCatalog[monst->info.DFType], true, false);
! 2402: }
! 2403: monst = nextMonst;
! 2404: }
! 2405:
! 2406: updateEnvironment(); // Update fire and gas, items floating around in water, monsters falling into chasms, etc.
! 2407: decrementPlayerStatus();
! 2408: applyInstantTileEffectsToCreature(&player);
! 2409: if (rogue.gameHasEnded) { // caustic gas, lava, trapdoor, etc.
! 2410: return;
! 2411: }
! 2412: monstersApproachStairs();
! 2413:
! 2414: if (player.ticksUntilTurn > 100 && !fastForward) {
! 2415: fastForward = rogue.playbackFastForward || pauseBrogue(25);
! 2416: }
! 2417:
! 2418: // Rolling waypoint refresh:
! 2419: rogue.wpRefreshTicker++;
! 2420: if (rogue.wpRefreshTicker >= rogue.wpCount) {
! 2421: rogue.wpRefreshTicker = 0;
! 2422: }
! 2423: refreshWaypoint(rogue.wpRefreshTicker);
! 2424: }
! 2425:
! 2426: for (monst = monsters->nextCreature; (monst != NULL) && (rogue.gameHasEnded == false); monst = monst->nextCreature) {
! 2427: if (monst->ticksUntilTurn <= 0) {
! 2428: if (monst->currentHP > monst->info.maxHP) {
! 2429: monst->currentHP = monst->info.maxHP;
! 2430: }
! 2431:
! 2432: if ((monst->info.flags & MONST_GETS_TURN_ON_ACTIVATION)
! 2433: || monst->status[STATUS_PARALYZED]
! 2434: || monst->status[STATUS_ENTRANCED]
! 2435: || (monst->bookkeepingFlags & MB_CAPTIVE)) {
! 2436:
! 2437: // Do not pass go; do not collect 200 gold.
! 2438: monst->ticksUntilTurn = monst->movementSpeed;
! 2439: } else {
! 2440: monstersTurn(monst);
! 2441: }
! 2442:
! 2443: for(monst2 = monsters->nextCreature; monst2 != NULL; monst2 = monst2->nextCreature) {
! 2444: if (monst2 == monst) { // monst still alive and on the level
! 2445: applyGradualTileEffectsToCreature(monst, monst->ticksUntilTurn);
! 2446: break;
! 2447: }
! 2448: }
! 2449: monst = monsters; // loop through from the beginning to be safe
! 2450: }
! 2451: }
! 2452:
! 2453: player.ticksUntilTurn -= soonestTurn;
! 2454:
! 2455: if (rogue.gameHasEnded) {
! 2456: return;
! 2457: }
! 2458: }
! 2459: // DEBUG displayLevel();
! 2460: //checkForDungeonErrors();
! 2461:
! 2462: updateVision(true);
! 2463: rogue.aggroRange = currentAggroValue();
! 2464: if (rogue.displayAggroRangeMode) {
! 2465: displayLevel();
! 2466: }
! 2467:
! 2468: for(monst = monsters->nextCreature; monst != NULL; monst = monst->nextCreature) {
! 2469: if (canSeeMonster(monst) && !(monst->bookkeepingFlags & (MB_WAS_VISIBLE | MB_ALREADY_SEEN))) {
! 2470: monst->bookkeepingFlags |= MB_WAS_VISIBLE;
! 2471: if (monst->creatureState != MONSTER_ALLY) {
! 2472: rogue.disturbed = true;
! 2473: if (rogue.cautiousMode || rogue.automationActive) {
! 2474: oldRNG = rogue.RNG;
! 2475: rogue.RNG = RNG_COSMETIC;
! 2476: //assureCosmeticRNG;
! 2477: monsterName(buf2, monst, false);
! 2478: sprintf(buf, "you %s a%s %s",
! 2479: playerCanDirectlySee(monst->xLoc, monst->yLoc) ? "see" : "sense",
! 2480: (isVowelish(buf2) ? "n" : ""),
! 2481: buf2);
! 2482: if (rogue.cautiousMode) {
! 2483: strcat(buf, ".");
! 2484: message(buf, true);
! 2485: } else {
! 2486: combatMessage(buf, 0);
! 2487: }
! 2488: restoreRNG;
! 2489: }
! 2490: }
! 2491: if (cellHasTerrainFlag(monst->xLoc, monst->yLoc, T_OBSTRUCTS_PASSABILITY)
! 2492: && cellHasTMFlag(monst->xLoc, monst->yLoc, TM_IS_SECRET)) {
! 2493:
! 2494: discover(monst->xLoc, monst->yLoc);
! 2495: }
! 2496: if (canDirectlySeeMonster(monst)) {
! 2497: if (rogue.weapon && rogue.weapon->flags & ITEM_RUNIC
! 2498: && rogue.weapon->enchant2 == W_SLAYING
! 2499: && !(rogue.weapon->flags & ITEM_RUNIC_HINTED)
! 2500: && monsterIsInClass(monst, rogue.weapon->vorpalEnemy)) {
! 2501:
! 2502: rogue.weapon->flags |= ITEM_RUNIC_HINTED;
! 2503: itemName(rogue.weapon, buf2, false, false, NULL);
! 2504: sprintf(buf, "the runes on your %s gleam balefully.", buf2);
! 2505: messageWithColor(buf, &itemMessageColor, true);
! 2506: }
! 2507: if (rogue.armor && rogue.armor->flags & ITEM_RUNIC
! 2508: && rogue.armor->enchant2 == A_IMMUNITY
! 2509: && !(rogue.armor->flags & ITEM_RUNIC_HINTED)
! 2510: && monsterIsInClass(monst, rogue.armor->vorpalEnemy)) {
! 2511:
! 2512: rogue.armor->flags |= ITEM_RUNIC_HINTED;
! 2513: itemName(rogue.armor, buf2, false, false, NULL);
! 2514: sprintf(buf, "the runes on your %s glow protectively.", buf2);
! 2515: messageWithColor(buf, &itemMessageColor, true);
! 2516: }
! 2517: }
! 2518: } else if (!canSeeMonster(monst)
! 2519: && (monst->bookkeepingFlags & MB_WAS_VISIBLE)
! 2520: && !(monst->bookkeepingFlags & MB_CAPTIVE)) {
! 2521: monst->bookkeepingFlags &= ~MB_WAS_VISIBLE;
! 2522: }
! 2523: }
! 2524:
! 2525: displayCombatText();
! 2526:
! 2527: if (player.status[STATUS_PARALYZED]) {
! 2528: if (!fastForward) {
! 2529: fastForward = rogue.playbackFastForward || pauseBrogue(25);
! 2530: }
! 2531: }
! 2532:
! 2533: //checkNutrition(); // Now handled within decrementPlayerStatus().
! 2534: if (!rogue.playbackFastForward) {
! 2535: shuffleTerrainColors(100, false);
! 2536: }
! 2537:
! 2538: displayAnnotation();
! 2539:
! 2540: refreshSideBar(-1, -1, false);
! 2541:
! 2542: applyInstantTileEffectsToCreature(&player);
! 2543: if (rogue.gameHasEnded) { // caustic gas, lava, trapdoor, etc.
! 2544: return;
! 2545: }
! 2546:
! 2547: if (player.currentHP > player.info.maxHP) {
! 2548: player.currentHP = player.info.maxHP;
! 2549: }
! 2550:
! 2551: if (player.bookkeepingFlags & MB_IS_FALLING) {
! 2552: playerFalls();
! 2553: handleHealthAlerts();
! 2554: return;
! 2555: }
! 2556:
! 2557: } while (player.status[STATUS_PARALYZED]);
! 2558:
! 2559: rogue.justRested = false;
! 2560: rogue.justSearched = false;
! 2561: updateFlavorText();
! 2562:
! 2563: if (!rogue.updatedMapToShoreThisTurn) {
! 2564: updateMapToShore();
! 2565: }
! 2566:
! 2567: // "point of no return" check
! 2568: if ((player.status[STATUS_LEVITATING] && cellHasTerrainFlag(player.xLoc, player.yLoc, T_LAVA_INSTA_DEATH | T_IS_DEEP_WATER | T_AUTO_DESCENT))
! 2569: || (player.status[STATUS_IMMUNE_TO_FIRE] && cellHasTerrainFlag(player.xLoc, player.yLoc, T_LAVA_INSTA_DEATH))) {
! 2570: if (!rogue.receivedLevitationWarning) {
! 2571: turnsRequiredToShore = rogue.mapToShore[player.xLoc][player.yLoc] * player.movementSpeed / 100;
! 2572: if (cellHasTerrainFlag(player.xLoc, player.yLoc, T_LAVA_INSTA_DEATH)) {
! 2573: turnsToShore = max(player.status[STATUS_LEVITATING], player.status[STATUS_IMMUNE_TO_FIRE]) * 100 / player.movementSpeed;
! 2574: } else {
! 2575: turnsToShore = player.status[STATUS_LEVITATING] * 100 / player.movementSpeed;
! 2576: }
! 2577: if (turnsRequiredToShore == turnsToShore || turnsRequiredToShore + 1 == turnsToShore) {
! 2578: message("better head back to solid ground!", true);
! 2579: rogue.receivedLevitationWarning = true;
! 2580: } else if (turnsRequiredToShore > turnsToShore
! 2581: && turnsRequiredToShore < 10000) {
! 2582: message("you're past the point of no return!", true);
! 2583: rogue.receivedLevitationWarning = true;
! 2584: }
! 2585: }
! 2586: } else {
! 2587: rogue.receivedLevitationWarning = false;
! 2588: }
! 2589:
! 2590: emptyGraveyard();
! 2591: rogue.playbackBetweenTurns = true;
! 2592: RNGCheck();
! 2593: handleHealthAlerts();
! 2594:
! 2595: if (rogue.flareCount > 0) {
! 2596: animateFlares(rogue.flares, rogue.flareCount);
! 2597: rogue.flareCount = 0;
! 2598: }
! 2599: }
! 2600:
! 2601: void resetScentTurnNumber() { // don't want player.scentTurnNumber to roll over the short maxint!
! 2602: short i, j, d;
! 2603: rogue.scentTurnNumber -= 15000;
! 2604: for (d = 0; d < DEEPEST_LEVEL; d++) {
! 2605: if (levels[d].visited) {
! 2606: for (i=0; i<DCOLS; i++) {
! 2607: for (j=0; j<DROWS; j++) {
! 2608: if (levels[d].scentMap[i][j] > 15000) {
! 2609: levels[d].scentMap[i][j] -= 15000;
! 2610: } else {
! 2611: levels[d].scentMap[i][j] = 0;
! 2612: }
! 2613: }
! 2614: }
! 2615: }
! 2616: }
! 2617: }
CVSweb
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to Time.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [contributed] / brogue-ce / src / brogue