Annotation of brogue-ce/src/brogue/Movement.c, Revision 1.1
1.1 ! rubenllo 1: /*
! 2: * Movement.c
! 3: * Brogue
! 4: *
! 5: * Created by Brian Walker on 1/10/09.
! 6: * Copyright 2012. All rights reserved.
! 7: *
! 8: * This file is part of Brogue.
! 9: *
! 10: * This program is free software: you can redistribute it and/or modify
! 11: * it under the terms of the GNU Affero General Public License as
! 12: * published by the Free Software Foundation, either version 3 of the
! 13: * License, or (at your option) any later version.
! 14: *
! 15: * This program is distributed in the hope that it will be useful,
! 16: * but WITHOUT ANY WARRANTY; without even the implied warranty of
! 17: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
! 18: * GNU Affero General Public License for more details.
! 19: *
! 20: * You should have received a copy of the GNU Affero General Public License
! 21: * along with this program. If not, see <http://www.gnu.org/licenses/>.
! 22: */
! 23:
! 24: #include "Rogue.h"
! 25: #include "IncludeGlobals.h"
! 26:
! 27: void playerRuns(short direction) {
! 28: short newX, newY, dir;
! 29: boolean cardinalPassability[4];
! 30:
! 31: rogue.disturbed = (player.status[STATUS_CONFUSED] ? true : false);
! 32:
! 33: for (dir = 0; dir < 4; dir++) {
! 34: newX = player.xLoc + nbDirs[dir][0];
! 35: newY = player.yLoc + nbDirs[dir][1];
! 36: cardinalPassability[dir] = monsterAvoids(&player, newX, newY);
! 37: }
! 38:
! 39: while (!rogue.disturbed) {
! 40: if (!playerMoves(direction)) {
! 41: rogue.disturbed = true;
! 42: break;
! 43: }
! 44:
! 45: newX = player.xLoc + nbDirs[direction][0];
! 46: newY = player.yLoc + nbDirs[direction][1];
! 47: if (!coordinatesAreInMap(newX, newY)
! 48: || monsterAvoids(&player, newX, newY)) {
! 49:
! 50: rogue.disturbed = true;
! 51: }
! 52: if (isDisturbed(player.xLoc, player.yLoc)) {
! 53: rogue.disturbed = true;
! 54: } else if (direction < 4) {
! 55: for (dir = 0; dir < 4; dir++) {
! 56: newX = player.xLoc + nbDirs[dir][0];
! 57: newY = player.yLoc + nbDirs[dir][1];
! 58: if (cardinalPassability[dir] != monsterAvoids(&player, newX, newY)
! 59: && !(nbDirs[dir][0] + nbDirs[direction][0] == 0 &&
! 60: nbDirs[dir][1] + nbDirs[direction][1] == 0)) {
! 61: // dir is not the x-opposite or y-opposite of direction
! 62: rogue.disturbed = true;
! 63: }
! 64: }
! 65: }
! 66: }
! 67: updateFlavorText();
! 68: }
! 69:
! 70: enum dungeonLayers highestPriorityLayer(short x, short y, boolean skipGas) {
! 71: short bestPriority = 10000;
! 72: enum dungeonLayers tt, best = 0;
! 73:
! 74: for (tt = 0; tt < NUMBER_TERRAIN_LAYERS; tt++) {
! 75: if (tt == GAS && skipGas) {
! 76: continue;
! 77: }
! 78: if (pmap[x][y].layers[tt] && tileCatalog[pmap[x][y].layers[tt]].drawPriority < bestPriority) {
! 79: bestPriority = tileCatalog[pmap[x][y].layers[tt]].drawPriority;
! 80: best = tt;
! 81: }
! 82: }
! 83: return best;
! 84: }
! 85:
! 86: enum dungeonLayers layerWithTMFlag(short x, short y, unsigned long flag) {
! 87: enum dungeonLayers layer;
! 88:
! 89: for (layer = 0; layer < NUMBER_TERRAIN_LAYERS; layer++) {
! 90: if (tileCatalog[pmap[x][y].layers[layer]].mechFlags & flag) {
! 91: return layer;
! 92: }
! 93: }
! 94: return NO_LAYER;
! 95: }
! 96:
! 97: enum dungeonLayers layerWithFlag(short x, short y, unsigned long flag) {
! 98: enum dungeonLayers layer;
! 99:
! 100: for (layer = 0; layer < NUMBER_TERRAIN_LAYERS; layer++) {
! 101: if (tileCatalog[pmap[x][y].layers[layer]].flags & flag) {
! 102: return layer;
! 103: }
! 104: }
! 105: return NO_LAYER;
! 106: }
! 107:
! 108: // Retrieves a pointer to the flavor text of the highest-priority terrain at the given location
! 109: char *tileFlavor(short x, short y) {
! 110: return tileCatalog[pmap[x][y].layers[highestPriorityLayer(x, y, false)]].flavorText;
! 111: }
! 112:
! 113: // Retrieves a pointer to the description text of the highest-priority terrain at the given location
! 114: char *tileText(short x, short y) {
! 115: return tileCatalog[pmap[x][y].layers[highestPriorityLayer(x, y, false)]].description;
! 116: }
! 117:
! 118: void describedItemBasedOnParameters(short theCategory, short theKind, short theQuantity, short theOriginDepth, char *buf) {
! 119: item *tempItem = initializeItem();
! 120: tempItem->category = theCategory;
! 121: tempItem->kind = theKind;
! 122: tempItem->quantity = theQuantity;
! 123: tempItem->originDepth = theOriginDepth;
! 124: itemName(tempItem, buf, false, true, NULL);
! 125: free(tempItem);
! 126: return;
! 127: }
! 128:
! 129: // Describes the item in question either by naming it if the player has already seen its name,
! 130: // or by tersely identifying its category otherwise.
! 131: void describedItemName(item *theItem, char *buf) {
! 132: if (rogue.playbackOmniscience || (!player.status[STATUS_HALLUCINATING])) {
! 133: itemName(theItem, buf, (theItem->category & (WEAPON | ARMOR) ? false : true), true, NULL);
! 134: } else {
! 135: describeHallucinatedItem(buf);
! 136: }
! 137: }
! 138:
! 139: void describeLocation(char *buf, short x, short y) {
! 140: creature *monst;
! 141: item *theItem, *magicItem;
! 142: boolean standsInTerrain;
! 143: boolean subjectMoving;
! 144: boolean prepositionLocked = false;
! 145: boolean monsterDormant;
! 146:
! 147: char subject[COLS * 3];
! 148: char verb[COLS * 3];
! 149: char preposition[COLS * 3];
! 150: char object[COLS * 3];
! 151: char adjective[COLS * 3];
! 152:
! 153: assureCosmeticRNG;
! 154:
! 155: if (x == player.xLoc && y == player.yLoc) {
! 156: if (player.status[STATUS_LEVITATING]) {
! 157: sprintf(buf, "you are hovering above %s.", tileText(x, y));
! 158: } else {
! 159: strcpy(buf, tileFlavor(x, y));
! 160: }
! 161: restoreRNG;
! 162: return;
! 163: }
! 164:
! 165: monst = NULL;
! 166: standsInTerrain = ((tileCatalog[pmap[x][y].layers[highestPriorityLayer(x, y, false)]].mechFlags & TM_STAND_IN_TILE) ? true : false);
! 167: theItem = itemAtLoc(x, y);
! 168: monsterDormant = false;
! 169: if (pmap[x][y].flags & HAS_MONSTER) {
! 170: monst = monsterAtLoc(x, y);
! 171: } else if (pmap[x][y].flags & HAS_DORMANT_MONSTER) {
! 172: monst = dormantMonsterAtLoc(x, y);
! 173: monsterDormant = true;
! 174: }
! 175:
! 176: // detecting magical items
! 177: magicItem = NULL;
! 178: if (theItem && !playerCanSeeOrSense(x, y)
! 179: && (theItem->flags & ITEM_MAGIC_DETECTED)
! 180: && itemMagicPolarity(theItem)) {
! 181: magicItem = theItem;
! 182: } else if (monst && !canSeeMonster(monst)
! 183: && monst->carriedItem
! 184: && (monst->carriedItem->flags & ITEM_MAGIC_DETECTED)
! 185: && itemMagicPolarity(monst->carriedItem)) {
! 186: magicItem = monst->carriedItem;
! 187: }
! 188: if (magicItem && !(pmap[x][y].flags & DISCOVERED)) {
! 189: switch (itemMagicPolarity(magicItem)) {
! 190: case 1:
! 191: strcpy(object, magicItem->category == AMULET ? "the Amulet of Yendor" : "benevolent magic");
! 192: break;
! 193: case -1:
! 194: strcpy(object, "malevolent magic");
! 195: break;
! 196: default:
! 197: strcpy(object, "mysterious magic");
! 198: break;
! 199: }
! 200: sprintf(buf, "you can detect the aura of %s here.", object);
! 201: restoreRNG;
! 202: return;
! 203: }
! 204:
! 205: // telepathy
! 206: if (monst
! 207: && !canSeeMonster(monst)
! 208: && monsterRevealed(monst)) {
! 209:
! 210: strcpy(adjective, (((!player.status[STATUS_HALLUCINATING] || rogue.playbackOmniscience) && !monst->info.isLarge)
! 211: || (player.status[STATUS_HALLUCINATING] && !rogue.playbackOmniscience && rand_range(0, 1)) ? "small" : "large"));
! 212: if (pmap[x][y].flags & DISCOVERED) {
! 213: strcpy(object, tileText(x, y));
! 214: if (monst->bookkeepingFlags & MB_SUBMERGED) {
! 215: strcpy(preposition, "under ");
! 216: } else if (monsterDormant) {
! 217: strcpy(preposition, "coming from within ");
! 218: } else if (standsInTerrain) {
! 219: strcpy(preposition, "in ");
! 220: } else {
! 221: strcpy(preposition, "over ");
! 222: }
! 223: } else {
! 224: strcpy(object, "here");
! 225: strcpy(preposition, "");
! 226: }
! 227:
! 228: sprintf(buf, "you can sense a %s psychic emanation %s%s.", adjective, preposition, object);
! 229: restoreRNG;
! 230: return;
! 231: }
! 232:
! 233: if (monst && !canSeeMonster(monst) && !rogue.playbackOmniscience) {
! 234: // Monster is not visible.
! 235: monst = NULL;
! 236: }
! 237:
! 238: if (!playerCanSeeOrSense(x, y)) {
! 239: if (pmap[x][y].flags & DISCOVERED) { // memory
! 240: if (pmap[x][y].rememberedItemCategory) {
! 241: if (player.status[STATUS_HALLUCINATING] && !rogue.playbackOmniscience) {
! 242: describeHallucinatedItem(object);
! 243: } else {
! 244: describedItemBasedOnParameters(pmap[x][y].rememberedItemCategory, pmap[x][y].rememberedItemKind,
! 245: pmap[x][y].rememberedItemQuantity, pmap[x][y].rememberedItemOriginDepth, object);
! 246: }
! 247: } else {
! 248: strcpy(object, tileCatalog[pmap[x][y].rememberedTerrain].description);
! 249: }
! 250: sprintf(buf, "you remember seeing %s here.", object);
! 251: restoreRNG;
! 252: return;
! 253: } else if (pmap[x][y].flags & MAGIC_MAPPED) { // magic mapped
! 254: sprintf(buf, "you expect %s to be here.", tileCatalog[pmap[x][y].rememberedTerrain].description);
! 255: restoreRNG;
! 256: return;
! 257: }
! 258: strcpy(buf, "");
! 259: restoreRNG;
! 260: return;
! 261: }
! 262:
! 263: if (monst) {
! 264:
! 265: monsterName(subject, monst, true);
! 266:
! 267: if (pmap[x][y].layers[GAS] && monst->status[STATUS_INVISIBLE]) { // phantoms in gas
! 268: sprintf(buf, "you can perceive the faint outline of %s in %s.", subject, tileCatalog[pmap[x][y].layers[GAS]].description);
! 269: restoreRNG;
! 270: return;
! 271: }
! 272:
! 273: subjectMoving = (monst->turnsSpentStationary == 0
! 274: && !(monst->info.flags & (MONST_GETS_TURN_ON_ACTIVATION | MONST_IMMOBILE))
! 275: && monst->creatureState != MONSTER_SLEEPING
! 276: && !(monst->bookkeepingFlags & (MB_SEIZED | MB_CAPTIVE)));
! 277: if ((monst->info.flags & MONST_ATTACKABLE_THRU_WALLS)
! 278: && cellHasTerrainFlag(x, y, T_OBSTRUCTS_PASSABILITY)) {
! 279: strcpy(verb, "is embedded");
! 280: } else if (cellHasTerrainFlag(x, y, T_OBSTRUCTS_PASSABILITY)) {
! 281: strcpy(verb, "is trapped");
! 282: subjectMoving = false;
! 283: } else if (monst->bookkeepingFlags & MB_CAPTIVE) {
! 284: strcpy(verb, "is shackled in place");
! 285: subjectMoving = false;
! 286: } else if (monst->status[STATUS_PARALYZED]) {
! 287: strcpy(verb, "is frozen in place");
! 288: subjectMoving = false;
! 289: } else if (monst->status[STATUS_STUCK]) {
! 290: strcpy(verb, "is entangled");
! 291: subjectMoving = false;
! 292: } else if (monst->status[STATUS_LEVITATING]) {
! 293: strcpy(verb, (subjectMoving ? "is flying" : "is hovering"));
! 294: strcpy(preposition, "over");
! 295: prepositionLocked = true;
! 296: } else if (monsterCanSubmergeNow(monst)) {
! 297: strcpy(verb, (subjectMoving ? "is gliding" : "is drifting"));
! 298: } else if (cellHasTerrainFlag(x, y, T_MOVES_ITEMS) && !(monst->info.flags & MONST_SUBMERGES)) {
! 299: strcpy(verb, (subjectMoving ? "is swimming" : "is struggling"));
! 300: } else if (cellHasTerrainFlag(x, y, T_AUTO_DESCENT)) {
! 301: strcpy(verb, "is suspended in mid-air");
! 302: strcpy(preposition, "over");
! 303: prepositionLocked = true;
! 304: subjectMoving = false;
! 305: } else if (monst->status[STATUS_CONFUSED]) {
! 306: strcpy(verb, "is staggering");
! 307: } else if ((monst->info.flags & MONST_RESTRICTED_TO_LIQUID)
! 308: && !cellHasTMFlag(monst->xLoc, monst->yLoc, TM_ALLOWS_SUBMERGING)) {
! 309: strcpy(verb, "is lying");
! 310: subjectMoving = false;
! 311: } else if (monst->info.flags & MONST_IMMOBILE) {
! 312: strcpy(verb, "is resting");
! 313: } else {
! 314: switch (monst->creatureState) {
! 315: case MONSTER_SLEEPING:
! 316: strcpy(verb, "is sleeping");
! 317: subjectMoving = false;
! 318: break;
! 319: case MONSTER_WANDERING:
! 320: strcpy(verb, subjectMoving ? "is wandering" : "is standing");
! 321: break;
! 322: case MONSTER_FLEEING:
! 323: strcpy(verb, subjectMoving ? "is fleeing" : "is standing");
! 324: break;
! 325: case MONSTER_TRACKING_SCENT:
! 326: strcpy(verb, subjectMoving ? "is charging" : "is standing");
! 327: break;
! 328: case MONSTER_ALLY:
! 329: strcpy(verb, subjectMoving ? "is following you" : "is standing");
! 330: break;
! 331: default:
! 332: strcpy(verb, "is standing");
! 333: break;
! 334: }
! 335: }
! 336: if (monst->status[STATUS_BURNING] && !(monst->info.flags & MONST_FIERY)) {
! 337: strcat(verb, ", burning,");
! 338: }
! 339:
! 340: if (theItem) {
! 341: strcpy(preposition, "over");
! 342: describedItemName(theItem, object);
! 343: } else {
! 344: if (!prepositionLocked) {
! 345: strcpy(preposition, subjectMoving ? (standsInTerrain ? "through" : "across")
! 346: : (standsInTerrain ? "in" : "on"));
! 347: }
! 348:
! 349: strcpy(object, tileText(x, y));
! 350:
! 351: }
! 352: } else { // no monster
! 353: strcpy(object, tileText(x, y));
! 354: if (theItem) {
! 355: describedItemName(theItem, subject);
! 356: subjectMoving = cellHasTerrainFlag(x, y, T_MOVES_ITEMS);
! 357: if (player.status[STATUS_HALLUCINATING] && !rogue.playbackOmniscience) {
! 358: strcpy(verb, "is");
! 359: } else {
! 360: strcpy(verb, (theItem->quantity > 1 || (theItem->category & GOLD)) ? "are" : "is");
! 361: }
! 362: if (cellHasTerrainFlag(x, y, T_OBSTRUCTS_PASSABILITY)) {
! 363: strcat(verb, " enclosed");
! 364: } else {
! 365: strcat(verb, subjectMoving ? " drifting" : " lying");
! 366: }
! 367: strcpy(preposition, standsInTerrain ? (subjectMoving ? "through" : "in")
! 368: : (subjectMoving ? "across" : "on"));
! 369:
! 370:
! 371: } else { // no item
! 372: sprintf(buf, "you %s %s.", (playerCanDirectlySee(x, y) ? "see" : "sense"), object);
! 373: restoreRNG;
! 374: return;
! 375: }
! 376: }
! 377:
! 378: sprintf(buf, "%s %s %s %s.", subject, verb, preposition, object);
! 379: restoreRNG;
! 380: }
! 381:
! 382: void printLocationDescription(short x, short y) {
! 383: char buf[DCOLS*3];
! 384: describeLocation(buf, x, y);
! 385: flavorMessage(buf);
! 386: }
! 387:
! 388: void useKeyAt(item *theItem, short x, short y) {
! 389: short layer, i;
! 390: creature *monst;
! 391: char buf[COLS], buf2[COLS], terrainName[COLS], preposition[10];
! 392: boolean disposable;
! 393:
! 394: strcpy(terrainName, "unknown terrain"); // redundant failsafe
! 395: for (layer = 0; layer < NUMBER_TERRAIN_LAYERS; layer++) {
! 396: if (tileCatalog[pmap[x][y].layers[layer]].mechFlags & TM_PROMOTES_WITH_KEY) {
! 397: if (tileCatalog[pmap[x][y].layers[layer]].description[0] == 'a'
! 398: && tileCatalog[pmap[x][y].layers[layer]].description[1] == ' ') {
! 399: sprintf(terrainName, "the %s", &(tileCatalog[pmap[x][y].layers[layer]].description[2]));
! 400: } else {
! 401: strcpy(terrainName, tileCatalog[pmap[x][y].layers[layer]].description);
! 402: }
! 403: if (tileCatalog[pmap[x][y].layers[layer]].mechFlags & TM_STAND_IN_TILE) {
! 404: strcpy(preposition, "in");
! 405: } else {
! 406: strcpy(preposition, "on");
! 407: }
! 408: promoteTile(x, y, layer, false);
! 409: }
! 410: }
! 411:
! 412: disposable = false;
! 413: for (i=0; i < KEY_ID_MAXIMUM && (theItem->keyLoc[i].x || theItem->keyLoc[i].machine); i++) {
! 414: if (theItem->keyLoc[i].x == x && theItem->keyLoc[i].y == y && theItem->keyLoc[i].disposableHere) {
! 415: disposable = true;
! 416: } else if (theItem->keyLoc[i].machine == pmap[x][y].machineNumber && theItem->keyLoc[i].disposableHere) {
! 417: disposable = true;
! 418: }
! 419: }
! 420:
! 421: if (disposable) {
! 422: if (removeItemFromChain(theItem, packItems)) {
! 423: itemName(theItem, buf2, true, false, NULL);
! 424: sprintf(buf, "you use your %s %s %s.",
! 425: buf2,
! 426: preposition,
! 427: terrainName);
! 428: messageWithColor(buf, &itemMessageColor, false);
! 429: deleteItem(theItem);
! 430: } else if (removeItemFromChain(theItem, floorItems)) {
! 431: deleteItem(theItem);
! 432: pmap[x][y].flags &= ~HAS_ITEM;
! 433: } else if (pmap[x][y].flags & HAS_MONSTER) {
! 434: monst = monsterAtLoc(x, y);
! 435: if (monst->carriedItem && monst->carriedItem == theItem) {
! 436: monst->carriedItem = NULL;
! 437: deleteItem(theItem);
! 438: }
! 439: }
! 440: }
! 441: }
! 442:
! 443: short randValidDirectionFrom(creature *monst, short x, short y, boolean respectAvoidancePreferences) {
! 444: short i, newX, newY, validDirections[8], count = 0;
! 445:
! 446: brogueAssert(rogue.RNG == RNG_SUBSTANTIVE);
! 447: for (i=0; i<8; i++) {
! 448: newX = x + nbDirs[i][0];
! 449: newY = y + nbDirs[i][1];
! 450: if (coordinatesAreInMap(newX, newY)
! 451: && !cellHasTerrainFlag(newX, newY, T_OBSTRUCTS_PASSABILITY)
! 452: && !diagonalBlocked(x, y, newX, newY, false)
! 453: && (!respectAvoidancePreferences
! 454: || (!monsterAvoids(monst, newX, newY))
! 455: || ((pmap[newX][newY].flags & HAS_PLAYER) && monst->creatureState != MONSTER_ALLY))) {
! 456: validDirections[count++] = i;
! 457: }
! 458: }
! 459: if (count == 0) {
! 460: // Rare, and important in this case that the function returns BEFORE a random roll is made to avoid OOS.
! 461: return NO_DIRECTION;
! 462: }
! 463: return validDirections[rand_range(0, count - 1)];
! 464: }
! 465:
! 466: void vomit(creature *monst) {
! 467: char buf[COLS], monstName[COLS];
! 468: spawnDungeonFeature(monst->xLoc, monst->yLoc, &dungeonFeatureCatalog[DF_VOMIT], true, false);
! 469:
! 470: if (canDirectlySeeMonster(monst)
! 471: && !rogue.automationActive) {
! 472:
! 473: monsterName(monstName, monst, true);
! 474: sprintf(buf, "%s vomit%s profusely", monstName, (monst == &player ? "" : "s"));
! 475: combatMessage(buf, NULL);
! 476: }
! 477: }
! 478:
! 479: void moveEntrancedMonsters(enum directions dir) {
! 480: creature *monst, *nextMonst;
! 481:
! 482: dir = oppositeDirection(dir);
! 483:
! 484: if (rogue.patchVersion >= 3) {
! 485: for (monst = monsters->nextCreature; monst != NULL; monst = monst->nextCreature) {
! 486: monst->bookkeepingFlags &= ~MB_HAS_ENTRANCED_MOVED;
! 487: }
! 488:
! 489: for (monst = monsters->nextCreature; monst != NULL; monst = monst->nextCreature) {
! 490: if (!(monst->bookkeepingFlags & MB_HAS_ENTRANCED_MOVED)
! 491: && monst->status[STATUS_ENTRANCED]
! 492: && !monst->status[STATUS_STUCK]
! 493: && !monst->status[STATUS_PARALYZED]
! 494: && !(monst->bookkeepingFlags & MB_CAPTIVE)) {
! 495:
! 496: moveMonster(monst, nbDirs[dir][0], nbDirs[dir][1]);
! 497: monst->bookkeepingFlags |= MB_HAS_ENTRANCED_MOVED;
! 498: monst = monsters; // loop through from the beginning to be safe
! 499: }
! 500: }
! 501:
! 502: } else {
! 503: for (monst = monsters->nextCreature; monst != NULL; monst = nextMonst) {
! 504: nextMonst = monst->nextCreature;
! 505: if (monst->status[STATUS_ENTRANCED]
! 506: && !monst->status[STATUS_STUCK]
! 507: && !monst->status[STATUS_PARALYZED]
! 508: && !(monst->bookkeepingFlags & MB_CAPTIVE)) {
! 509:
! 510: moveMonster(monst, nbDirs[dir][0], nbDirs[dir][1]);
! 511: }
! 512: }
! 513: }
! 514:
! 515: }
! 516:
! 517: void becomeAllyWith(creature *monst) {
! 518: demoteMonsterFromLeadership(monst);
! 519: // Drop your item.
! 520: if (monst->carriedItem) {
! 521: makeMonsterDropItem(monst);
! 522: }
! 523: // If you're going to change into something, it should be friendly.
! 524: if (monst->carriedMonster) {
! 525: becomeAllyWith(monst->carriedMonster);
! 526: }
! 527: monst->creatureState = MONSTER_ALLY;
! 528: monst->bookkeepingFlags |= MB_FOLLOWER;
! 529: monst->leader = &player;
! 530: monst->bookkeepingFlags &= ~(MB_CAPTIVE | MB_SEIZED);
! 531: refreshDungeonCell(monst->xLoc, monst->yLoc);
! 532: }
! 533:
! 534: void freeCaptive(creature *monst) {
! 535: char buf[COLS * 3], monstName[COLS];
! 536:
! 537: becomeAllyWith(monst);
! 538: monsterName(monstName, monst, false);
! 539: sprintf(buf, "you free the grateful %s and gain a faithful ally.", monstName);
! 540: message(buf, false);
! 541: }
! 542:
! 543: boolean freeCaptivesEmbeddedAt(short x, short y) {
! 544: creature *monst;
! 545:
! 546: if (pmap[x][y].flags & HAS_MONSTER) {
! 547: // Free any captives trapped in the tunnelized terrain.
! 548: monst = monsterAtLoc(x, y);
! 549: if ((monst->bookkeepingFlags & MB_CAPTIVE)
! 550: && !(monst->info.flags & MONST_ATTACKABLE_THRU_WALLS)
! 551: && (cellHasTerrainFlag(x, y, T_OBSTRUCTS_PASSABILITY))) {
! 552: freeCaptive(monst);
! 553: return true;
! 554: }
! 555: }
! 556: return false;
! 557: }
! 558:
! 559: // Do we need confirmation so we don't accidently hit an acid mound?
! 560: boolean abortAttackAgainstAcidicTarget(creature *hitList[8]) {
! 561: short i;
! 562: char monstName[COLS], weaponName[COLS];
! 563: char buf[COLS*3];
! 564:
! 565: if (rogue.weapon
! 566: && !(rogue.weapon->flags & ITEM_PROTECTED)
! 567: && !player.status[STATUS_HALLUCINATING]
! 568: && !player.status[STATUS_CONFUSED]) {
! 569:
! 570: for (i=0; i<8; i++) {
! 571: if (hitList[i]
! 572: && (hitList[i]->info.flags & MONST_DEFEND_DEGRADE_WEAPON)
! 573: && canSeeMonster(hitList[i])
! 574: && (!(rogue.weapon->flags & ITEM_RUNIC)
! 575: || !(rogue.weapon->flags & ITEM_RUNIC_IDENTIFIED)
! 576: || rogue.weapon->enchant2 != W_SLAYING
! 577: || !monsterIsInClass(hitList[i], rogue.weapon->vorpalEnemy))) {
! 578:
! 579: monsterName(monstName, hitList[i], true);
! 580: itemName(rogue.weapon, weaponName, false, false, NULL);
! 581: sprintf(buf, "Degrade your %s by attacking %s?", weaponName, monstName);
! 582: if (confirm(buf, false)) {
! 583: return false; // Fire when ready!
! 584: } else {
! 585: return true; // Abort!
! 586: }
! 587: }
! 588: }
! 589: }
! 590: return false;
! 591: }
! 592:
! 593: // Returns true if a whip attack was launched.
! 594: // If "aborted" pointer is provided, sets it to true if it was aborted because
! 595: // the player opted not to attack an acid mound (in which case the whole turn
! 596: // should be aborted), as opposed to there being no valid whip attack available
! 597: // (in which case the player/monster should move instead).
! 598: boolean handleWhipAttacks(creature *attacker, enum directions dir, boolean *aborted) {
! 599: bolt theBolt;
! 600: creature *defender, *hitList[8] = {0};
! 601: short strikeLoc[2], originLoc[2], targetLoc[2];
! 602:
! 603: const char boltChar[DIRECTION_COUNT] = "||~~\\//\\";
! 604:
! 605: brogueAssert(dir > NO_DIRECTION && dir < DIRECTION_COUNT);
! 606:
! 607: if (attacker == &player) {
! 608: if (!rogue.weapon || !(rogue.weapon->flags & ITEM_ATTACKS_EXTEND)) {
! 609: return false;
! 610: }
! 611: } else if (!(attacker->info.abilityFlags & MA_ATTACKS_EXTEND)) {
! 612: return false;
! 613: }
! 614: originLoc[0] = attacker->xLoc;
! 615: originLoc[1] = attacker->yLoc;
! 616: targetLoc[0] = attacker->xLoc + nbDirs[dir][0];
! 617: targetLoc[1] = attacker->yLoc + nbDirs[dir][1];
! 618: getImpactLoc(strikeLoc, originLoc, targetLoc, 5, false);
! 619:
! 620: defender = monsterAtLoc(strikeLoc[0], strikeLoc[1]);
! 621: if (defender
! 622: && (attacker != &player || canSeeMonster(defender))
! 623: && !monsterIsHidden(defender, attacker)
! 624: && monsterWillAttackTarget(attacker, defender)) {
! 625:
! 626: if (attacker == &player) {
! 627: hitList[0] = defender;
! 628: if (abortAttackAgainstAcidicTarget(hitList)) {
! 629: if (aborted) {
! 630: *aborted = true;
! 631: }
! 632: return false;
! 633: }
! 634: }
! 635: attacker->bookkeepingFlags &= ~MB_SUBMERGED;
! 636: theBolt = boltCatalog[BOLT_WHIP];
! 637: theBolt.theChar = boltChar[dir];
! 638: zap(originLoc, targetLoc, &theBolt, false);
! 639: return true;
! 640: }
! 641: return false;
! 642: }
! 643:
! 644: // Returns true if a spear attack was launched.
! 645: // If "aborted" pointer is provided, sets it to true if it was aborted because
! 646: // the player opted not to attack an acid mound (in which case the whole turn
! 647: // should be aborted), as opposed to there being no valid spear attack available
! 648: // (in which case the player/monster should move instead).
! 649: boolean handleSpearAttacks(creature *attacker, enum directions dir, boolean *aborted) {
! 650: creature *defender, *hitList[8] = {0};
! 651: short targetLoc[2], range = 2, i = 0, h = 0;
! 652: boolean proceed = false, visualEffect = false;
! 653:
! 654: const char boltChar[DIRECTION_COUNT] = "||--\\//\\";
! 655:
! 656: brogueAssert(dir > NO_DIRECTION && dir < DIRECTION_COUNT);
! 657:
! 658: if (attacker == &player) {
! 659: if (!rogue.weapon || !(rogue.weapon->flags & ITEM_ATTACKS_PENETRATE)) {
! 660: return false;
! 661: }
! 662: } else if (!(attacker->info.abilityFlags & MA_ATTACKS_PENETRATE)) {
! 663: return false;
! 664: }
! 665:
! 666: for (i = 0; i < range; i++) {
! 667: targetLoc[0] = attacker->xLoc + (1 + i) * nbDirs[dir][0];
! 668: targetLoc[1] = attacker->yLoc + (1 + i) * nbDirs[dir][1];
! 669: if (!coordinatesAreInMap(targetLoc[0], targetLoc[1])) {
! 670: break;
! 671: }
! 672:
! 673: /* Add creatures that we are willing to attack to the potential
! 674: hitlist. Any of those that are either right by us or visible will
! 675: trigger the attack. */
! 676: defender = monsterAtLoc(targetLoc[0], targetLoc[1]);
! 677: if (defender
! 678: && (!cellHasTerrainFlag(targetLoc[0], targetLoc[1], T_OBSTRUCTS_PASSABILITY)
! 679: || (defender->info.flags & MONST_ATTACKABLE_THRU_WALLS))
! 680: && monsterWillAttackTarget(attacker, defender)) {
! 681:
! 682: hitList[h++] = defender;
! 683:
! 684: /* We check if i=0, i.e. the defender is right next to us, because
! 685: we have to do "normal" attacking here. We can't just return
! 686: false and leave to playerMoves/moveMonster due to the collateral hitlist. */
! 687: if (i == 0 || !monsterIsHidden(defender, attacker)
! 688: && (attacker != &player || canSeeMonster(defender))) {
! 689: // We'll attack.
! 690: proceed = true;
! 691: }
! 692: }
! 693:
! 694: if (cellHasTerrainFlag(targetLoc[0], targetLoc[1], (T_OBSTRUCTS_PASSABILITY | T_OBSTRUCTS_VISION))) {
! 695: break;
! 696: }
! 697: }
! 698: range = i;
! 699: if (proceed) {
! 700: if (attacker == &player) {
! 701: if (abortAttackAgainstAcidicTarget(hitList)) {
! 702: if (aborted) {
! 703: *aborted = true;
! 704: }
! 705: return false;
! 706: }
! 707: }
! 708: if (!rogue.playbackFastForward) {
! 709: for (i = 0; i < range; i++) {
! 710: targetLoc[0] = attacker->xLoc + (1 + i) * nbDirs[dir][0];
! 711: targetLoc[1] = attacker->yLoc + (1 + i) * nbDirs[dir][1];
! 712: if (coordinatesAreInMap(targetLoc[0], targetLoc[1])
! 713: && playerCanSeeOrSense(targetLoc[0], targetLoc[1])) {
! 714:
! 715: visualEffect = true;
! 716: plotForegroundChar(boltChar[dir], targetLoc[0], targetLoc[1], &lightBlue, true);
! 717: }
! 718: }
! 719: }
! 720: attacker->bookkeepingFlags &= ~MB_SUBMERGED;
! 721: // Artificially reverse the order of the attacks,
! 722: // so that spears of force can send both monsters flying.
! 723: for (i = h - 1; i >= 0; i--) {
! 724: attack(attacker, hitList[i], false);
! 725: }
! 726: if (visualEffect) {
! 727: pauseBrogue(16);
! 728: for (i = 0; i < range; i++) {
! 729: targetLoc[0] = attacker->xLoc + (1 + i) * nbDirs[dir][0];
! 730: targetLoc[1] = attacker->yLoc + (1 + i) * nbDirs[dir][1];
! 731: if (coordinatesAreInMap(targetLoc[0], targetLoc[1])) {
! 732: refreshDungeonCell(targetLoc[0], targetLoc[1]);
! 733: }
! 734: }
! 735: }
! 736: return true;
! 737: }
! 738: return false;
! 739: }
! 740:
! 741: void buildFlailHitList(const short x, const short y, const short newX, const short newY, creature *hitList[16]) {
! 742: creature *monst;
! 743: short mx, my;
! 744: short i = 0;
! 745:
! 746: for (monst = monsters->nextCreature; monst != NULL; monst = monst->nextCreature) {
! 747: mx = monst->xLoc;
! 748: my = monst->yLoc;
! 749: if (distanceBetween(x, y, mx, my) == 1
! 750: && distanceBetween(newX, newY, mx, my) == 1
! 751: && canSeeMonster(monst)
! 752: && monstersAreEnemies(&player, monst)
! 753: && monst->creatureState != MONSTER_ALLY
! 754: && !(monst->bookkeepingFlags & MB_IS_DYING)
! 755: && (!cellHasTerrainFlag(monst->xLoc, monst->yLoc, T_OBSTRUCTS_PASSABILITY) || (monst->info.flags & MONST_ATTACKABLE_THRU_WALLS))) {
! 756:
! 757: while (hitList[i]) {
! 758: i++;
! 759: }
! 760: hitList[i] = monst;
! 761: }
! 762: }
! 763: }
! 764:
! 765: boolean diagonalBlocked(const short x1, const short y1, const short x2, const short y2, const boolean limitToPlayerKnowledge) {
! 766: unsigned long tFlags;
! 767: if (x1 == x2 || y1 == y2) {
! 768: return false; // If it's not a diagonal, it's not diagonally blocked.
! 769: }
! 770: getLocationFlags(x1, y2, &tFlags, NULL, NULL, limitToPlayerKnowledge);
! 771: if (tFlags & T_OBSTRUCTS_DIAGONAL_MOVEMENT) {
! 772: return true;
! 773: }
! 774: getLocationFlags(x2, y1, &tFlags, NULL, NULL, limitToPlayerKnowledge);
! 775: if (tFlags & T_OBSTRUCTS_DIAGONAL_MOVEMENT) {
! 776: return true;
! 777: }
! 778: return false;
! 779: }
! 780:
! 781: // Called whenever the player voluntarily tries to move in a given direction.
! 782: // Can be called from movement keys, exploration, or auto-travel.
! 783: boolean playerMoves(short direction) {
! 784: short initialDirection = direction, i, layer;
! 785: short x = player.xLoc, y = player.yLoc;
! 786: short newX, newY, newestX, newestY;
! 787: boolean playerMoved = false, alreadyRecorded = false, specialAttackAborted = false, anyAttackHit = false;
! 788: creature *defender = NULL, *tempMonst = NULL, *hitList[16] = {NULL};
! 789: char monstName[COLS];
! 790: char buf[COLS*3];
! 791: const int directionKeys[8] = {UP_KEY, DOWN_KEY, LEFT_KEY, RIGHT_KEY, UPLEFT_KEY, DOWNLEFT_KEY, UPRIGHT_KEY, DOWNRIGHT_KEY};
! 792:
! 793: brogueAssert(direction >= 0 && direction < DIRECTION_COUNT);
! 794:
! 795: newX = x + nbDirs[direction][0];
! 796: newY = y + nbDirs[direction][1];
! 797:
! 798: if (!coordinatesAreInMap(newX, newY)) {
! 799: return false;
! 800: }
! 801:
! 802: if (player.status[STATUS_CONFUSED]) {
! 803: // Confirmation dialog if you're moving while confused and you're next to lava and not levitating or immune to fire.
! 804: if (player.status[STATUS_LEVITATING] <= 1
! 805: && player.status[STATUS_IMMUNE_TO_FIRE] <= 1) {
! 806:
! 807: for (i=0; i<8; i++) {
! 808: newestX = x + nbDirs[i][0];
! 809: newestY = y + nbDirs[i][1];
! 810: if (coordinatesAreInMap(newestX, newestY)
! 811: && (pmap[newestX][newestY].flags & (DISCOVERED | MAGIC_MAPPED))
! 812: && !diagonalBlocked(x, y, newestX, newestY, false)
! 813: && cellHasTerrainFlag(newestX, newestY, T_LAVA_INSTA_DEATH)
! 814: && !cellHasTerrainFlag(newestX, newestY, T_OBSTRUCTS_PASSABILITY | T_ENTANGLES)
! 815: && !((pmap[newestX][newestY].flags & HAS_MONSTER)
! 816: && canSeeMonster(monsterAtLoc(newestX, newestY))
! 817: && monsterAtLoc(newestX, newestY)->creatureState != MONSTER_ALLY)) {
! 818:
! 819: if (!confirm("Risk stumbling into lava?", false)) {
! 820: return false;
! 821: } else {
! 822: break;
! 823: }
! 824: }
! 825: }
! 826: }
! 827:
! 828: direction = randValidDirectionFrom(&player, x, y, false);
! 829: if (direction == -1) {
! 830: return false;
! 831: } else {
! 832: newX = x + nbDirs[direction][0];
! 833: newY = y + nbDirs[direction][1];
! 834: if (!coordinatesAreInMap(newX, newY)) {
! 835: return false;
! 836: }
! 837: if (!alreadyRecorded) {
! 838: recordKeystroke(directionKeys[initialDirection], false, false);
! 839: alreadyRecorded = true;
! 840: }
! 841: }
! 842: }
! 843:
! 844: if (pmap[newX][newY].flags & HAS_MONSTER) {
! 845: defender = monsterAtLoc(newX, newY);
! 846: }
! 847:
! 848: // If there's no enemy at the movement location that the player is aware of, consider terrain promotions.
! 849: if (!defender
! 850: || (!canSeeMonster(defender) && !monsterRevealed(defender))
! 851: || !monstersAreEnemies(&player, defender)) {
! 852:
! 853: if (cellHasTerrainFlag(newX, newY, T_OBSTRUCTS_PASSABILITY) && cellHasTMFlag(newX, newY, TM_PROMOTES_ON_PLAYER_ENTRY)) {
! 854: layer = layerWithTMFlag(newX, newY, TM_PROMOTES_ON_PLAYER_ENTRY);
! 855: if (tileCatalog[pmap[newX][newY].layers[layer]].flags & T_OBSTRUCTS_PASSABILITY) {
! 856: if (!alreadyRecorded) {
! 857: recordKeystroke(directionKeys[initialDirection], false, false);
! 858: alreadyRecorded = true;
! 859: }
! 860: message(tileCatalog[pmap[newX][newY].layers[layer]].flavorText, false);
! 861: promoteTile(newX, newY, layer, false);
! 862: playerTurnEnded();
! 863: return true;
! 864: }
! 865: }
! 866:
! 867: if (rogue.patchVersion < 1 && player.status[STATUS_STUCK] && cellHasTerrainFlag(x, y, T_ENTANGLES)) {
! 868: // Don't interrupt exploration with this message.
! 869: if (--player.status[STATUS_STUCK]) {
! 870: if (!rogue.automationActive) {
! 871: message("you struggle but cannot free yourself.", false);
! 872: }
! 873: } else {
! 874: if (!rogue.automationActive) {
! 875: message("you break free!", false);
! 876: }
! 877: if (tileCatalog[pmap[x][y].layers[SURFACE]].flags & T_ENTANGLES) {
! 878: pmap[x][y].layers[SURFACE] = NOTHING;
! 879: }
! 880: }
! 881: moveEntrancedMonsters(direction);
! 882: if (!alreadyRecorded) {
! 883: recordKeystroke(directionKeys[initialDirection], false, false);
! 884: alreadyRecorded = true;
! 885: }
! 886: if (player.status[STATUS_STUCK]) {
! 887: playerTurnEnded();
! 888: return true;
! 889: }
! 890: }
! 891: }
! 892:
! 893: if (((!cellHasTerrainFlag(newX, newY, T_OBSTRUCTS_PASSABILITY) || (cellHasTMFlag(newX, newY, TM_PROMOTES_WITH_KEY) && keyInPackFor(newX, newY)))
! 894: && !diagonalBlocked(x, y, newX, newY, false)
! 895: && (!cellHasTerrainFlag(x, y, T_OBSTRUCTS_PASSABILITY) || (cellHasTMFlag(x, y, TM_PROMOTES_WITH_KEY) && keyInPackFor(x, y))))
! 896: || (defender && defender->info.flags & MONST_ATTACKABLE_THRU_WALLS)) {
! 897: // if the move is not blocked
! 898:
! 899: if (handleWhipAttacks(&player, direction, &specialAttackAborted)
! 900: || handleSpearAttacks(&player, direction, &specialAttackAborted)) {
! 901:
! 902: if (!alreadyRecorded) {
! 903: recordKeystroke(directionKeys[initialDirection], false, false);
! 904: alreadyRecorded = true;
! 905: }
! 906: playerRecoversFromAttacking(true);
! 907: moveEntrancedMonsters(direction);
! 908: playerTurnEnded();
! 909: return true;
! 910: } else if (specialAttackAborted) { // Canceled an attack against an acid mound.
! 911: brogueAssert(!alreadyRecorded);
! 912: rogue.disturbed = true;
! 913: return false;
! 914: }
! 915:
! 916: if (defender) {
! 917: // if there is a monster there
! 918:
! 919: if (defender->bookkeepingFlags & MB_CAPTIVE) {
! 920: monsterName(monstName, defender, false);
! 921: sprintf(buf, "Free the captive %s?", monstName);
! 922: if (alreadyRecorded || confirm(buf, false)) {
! 923: if (!alreadyRecorded) {
! 924: recordKeystroke(directionKeys[initialDirection], false, false);
! 925: alreadyRecorded = true;
! 926: }
! 927: if (cellHasTMFlag(newX, newY, TM_PROMOTES_WITH_KEY) && keyInPackFor(newX, newY)) {
! 928: useKeyAt(keyInPackFor(newX, newY), newX, newY);
! 929: }
! 930: freeCaptive(defender);
! 931: player.ticksUntilTurn += player.attackSpeed;
! 932: playerTurnEnded();
! 933: return true;
! 934: } else {
! 935: return false;
! 936: }
! 937: }
! 938:
! 939: if (defender->creatureState != MONSTER_ALLY) {
! 940: // Make a hit list of monsters the player is attacking this turn.
! 941: // We separate this tallying phase from the actual attacking phase because sometimes the attacks themselves
! 942: // create more monsters, and those shouldn't be attacked in the same turn.
! 943:
! 944: buildHitList(hitList, &player, defender,
! 945: rogue.weapon && (rogue.weapon->flags & ITEM_ATTACKS_ALL_ADJACENT));
! 946:
! 947: if (abortAttackAgainstAcidicTarget(hitList)) { // Acid mound attack confirmation.
! 948: brogueAssert(!alreadyRecorded);
! 949: rogue.disturbed = true;
! 950: return false;
! 951: }
! 952:
! 953: if (player.status[STATUS_NAUSEOUS]) {
! 954: if (!alreadyRecorded) {
! 955: recordKeystroke(directionKeys[initialDirection], false, false);
! 956: alreadyRecorded = true;
! 957: }
! 958: if (rand_percent(25)) {
! 959: vomit(&player);
! 960: playerTurnEnded();
! 961: return false;
! 962: }
! 963: }
! 964:
! 965: // Proceeding with the attack.
! 966:
! 967: if (!alreadyRecorded) {
! 968: recordKeystroke(directionKeys[initialDirection], false, false);
! 969: alreadyRecorded = true;
! 970: }
! 971:
! 972: // Attack!
! 973: for (i=0; i<16; i++) {
! 974: if (hitList[i]
! 975: && monsterWillAttackTarget(&player, hitList[i])
! 976: && !(hitList[i]->bookkeepingFlags & MB_IS_DYING)
! 977: && !rogue.gameHasEnded) {
! 978:
! 979: if (attack(&player, hitList[i], false)) {
! 980: anyAttackHit = true;
! 981: }
! 982: }
! 983: }
! 984:
! 985: playerRecoversFromAttacking(anyAttackHit);
! 986: moveEntrancedMonsters(direction);
! 987: playerTurnEnded();
! 988: return true;
! 989: }
! 990: }
! 991:
! 992: if (player.bookkeepingFlags & MB_SEIZED) {
! 993: for (tempMonst = monsters->nextCreature; tempMonst != NULL; tempMonst = tempMonst->nextCreature) {
! 994: if ((tempMonst->bookkeepingFlags & MB_SEIZING)
! 995: && monstersAreEnemies(&player, tempMonst)
! 996: && distanceBetween(player.xLoc, player.yLoc, tempMonst->xLoc, tempMonst->yLoc) == 1
! 997: && !diagonalBlocked(player.xLoc, player.yLoc, tempMonst->xLoc, tempMonst->yLoc, false)
! 998: && !tempMonst->status[STATUS_ENTRANCED]) {
! 999:
! 1000: monsterName(monstName, tempMonst, true);
! 1001: if (alreadyRecorded || !canSeeMonster(tempMonst)) {
! 1002: if (!alreadyRecorded) {
! 1003: recordKeystroke(directionKeys[initialDirection], false, false);
! 1004: alreadyRecorded = true;
! 1005: }
! 1006: sprintf(buf, "you struggle but %s is holding your legs!", monstName);
! 1007: moveEntrancedMonsters(direction);
! 1008: message(buf, false);
! 1009: playerTurnEnded();
! 1010: return true;
! 1011: } else {
! 1012: sprintf(buf, "you cannot move; %s is holding your legs!", monstName);
! 1013: message(buf, false);
! 1014: return false;
! 1015: }
! 1016: }
! 1017: }
! 1018: player.bookkeepingFlags &= ~MB_SEIZED; // failsafe
! 1019: }
! 1020:
! 1021: if (pmap[newX][newY].flags & (DISCOVERED | MAGIC_MAPPED)
! 1022: && player.status[STATUS_LEVITATING] <= 1
! 1023: && !player.status[STATUS_CONFUSED]
! 1024: && cellHasTerrainFlag(newX, newY, T_LAVA_INSTA_DEATH)
! 1025: && player.status[STATUS_IMMUNE_TO_FIRE] <= 1
! 1026: && !cellHasTerrainFlag(newX, newY, T_ENTANGLES)
! 1027: && !cellHasTMFlag(newX, newY, TM_IS_SECRET)) {
! 1028: message("that would be certain death!", false);
! 1029: return false; // player won't willingly step into lava
! 1030: } else if (pmap[newX][newY].flags & (DISCOVERED | MAGIC_MAPPED)
! 1031: && player.status[STATUS_LEVITATING] <= 1
! 1032: && !player.status[STATUS_CONFUSED]
! 1033: && cellHasTerrainFlag(newX, newY, T_AUTO_DESCENT)
! 1034: && !cellHasTerrainFlag(newX, newY, T_ENTANGLES)
! 1035: && !cellHasTMFlag(newX, newY, TM_IS_SECRET)
! 1036: && !confirm("Dive into the depths?", false)) {
! 1037: return false;
! 1038: } else if (playerCanSee(newX, newY)
! 1039: && !player.status[STATUS_CONFUSED]
! 1040: && !player.status[STATUS_BURNING]
! 1041: && player.status[STATUS_IMMUNE_TO_FIRE] <= 1
! 1042: && cellHasTerrainFlag(newX, newY, T_IS_FIRE)
! 1043: && !cellHasTMFlag(newX, newY, TM_EXTINGUISHES_FIRE)
! 1044: && !confirm("Venture into flame?", false)) {
! 1045: return false;
! 1046: } else if (playerCanSee(newX, newY)
! 1047: && !player.status[STATUS_CONFUSED]
! 1048: && !player.status[STATUS_BURNING]
! 1049: && cellHasTerrainFlag(newX, newY, T_CAUSES_CONFUSION | T_CAUSES_PARALYSIS)
! 1050: && (!rogue.armor || !(rogue.armor->flags & ITEM_RUNIC) || !(rogue.armor->flags & ITEM_RUNIC_IDENTIFIED) || rogue.armor->enchant2 != A_RESPIRATION)
! 1051: && !confirm("Venture into dangerous gas?", false)) {
! 1052: return false;
! 1053: } else if (pmap[newX][newY].flags & (ANY_KIND_OF_VISIBLE | MAGIC_MAPPED)
! 1054: && player.status[STATUS_LEVITATING] <= 1
! 1055: && !player.status[STATUS_CONFUSED]
! 1056: && cellHasTerrainFlag(newX, newY, T_IS_DF_TRAP)
! 1057: && !(pmap[newX][newY].flags & PRESSURE_PLATE_DEPRESSED)
! 1058: && !cellHasTMFlag(newX, newY, TM_IS_SECRET)
! 1059: && !confirm("Step onto the pressure plate?", false)) {
! 1060: return false;
! 1061: }
! 1062:
! 1063: if (rogue.weapon && (rogue.weapon->flags & ITEM_LUNGE_ATTACKS)) {
! 1064: newestX = player.xLoc + 2*nbDirs[direction][0];
! 1065: newestY = player.yLoc + 2*nbDirs[direction][1];
! 1066: if (coordinatesAreInMap(newestX, newestY) && (pmap[newestX][newestY].flags & HAS_MONSTER)) {
! 1067: tempMonst = monsterAtLoc(newestX, newestY);
! 1068: if (tempMonst
! 1069: && canSeeMonster(tempMonst)
! 1070: && monstersAreEnemies(&player, tempMonst)
! 1071: && tempMonst->creatureState != MONSTER_ALLY
! 1072: && !(tempMonst->bookkeepingFlags & MB_IS_DYING)
! 1073: && (!cellHasTerrainFlag(tempMonst->xLoc, tempMonst->yLoc, T_OBSTRUCTS_PASSABILITY) || (tempMonst->info.flags & MONST_ATTACKABLE_THRU_WALLS))) {
! 1074:
! 1075: hitList[0] = tempMonst;
! 1076: if (abortAttackAgainstAcidicTarget(hitList)) { // Acid mound attack confirmation.
! 1077: brogueAssert(!alreadyRecorded);
! 1078: rogue.disturbed = true;
! 1079: return false;
! 1080: }
! 1081: }
! 1082: }
! 1083: }
! 1084: if (rogue.weapon && (rogue.weapon->flags & ITEM_PASS_ATTACKS)) {
! 1085: buildFlailHitList(x, y, newX, newY, hitList);
! 1086: if (abortAttackAgainstAcidicTarget(hitList)) { // Acid mound attack confirmation.
! 1087: brogueAssert(!alreadyRecorded);
! 1088: rogue.disturbed = true;
! 1089: return false;
! 1090: }
! 1091: }
! 1092:
! 1093: if (rogue.patchVersion >= 1 && player.status[STATUS_STUCK] && cellHasTerrainFlag(x, y, T_ENTANGLES)) {
! 1094: // Don't interrupt exploration with this message.
! 1095: if (--player.status[STATUS_STUCK]) {
! 1096: if (!rogue.automationActive) {
! 1097: message("you struggle but cannot free yourself.", false);
! 1098: }
! 1099: moveEntrancedMonsters(direction);
! 1100: if (!alreadyRecorded) {
! 1101: recordKeystroke(directionKeys[initialDirection], false, false);
! 1102: alreadyRecorded = true;
! 1103: }
! 1104: playerTurnEnded();
! 1105: return true;
! 1106: } else {
! 1107: if (!rogue.automationActive) {
! 1108: message("you break free!", false);
! 1109: }
! 1110: if (tileCatalog[pmap[x][y].layers[SURFACE]].flags & T_ENTANGLES) {
! 1111: pmap[x][y].layers[SURFACE] = NOTHING;
! 1112: }
! 1113: }
! 1114: }
! 1115:
! 1116: if (player.status[STATUS_NAUSEOUS]) {
! 1117: if (!alreadyRecorded) {
! 1118: recordKeystroke(directionKeys[initialDirection], false, false);
! 1119: alreadyRecorded = true;
! 1120: }
! 1121: if (rand_percent(25)) {
! 1122: vomit(&player);
! 1123: playerTurnEnded();
! 1124: return true;
! 1125: }
! 1126: }
! 1127:
! 1128: // Are we taking the stairs?
! 1129: if (rogue.downLoc[0] == newX && rogue.downLoc[1] == newY) {
! 1130: if (!alreadyRecorded) {
! 1131: recordKeystroke(directionKeys[initialDirection], false, false);
! 1132: alreadyRecorded = true;
! 1133: }
! 1134: useStairs(1);
! 1135: } else if (rogue.upLoc[0] == newX && rogue.upLoc[1] == newY) {
! 1136: if (!alreadyRecorded) {
! 1137: recordKeystroke(directionKeys[initialDirection], false, false);
! 1138: alreadyRecorded = true;
! 1139: }
! 1140: useStairs(-1);
! 1141: } else {
! 1142: // Okay, we're finally moving!
! 1143: if (!alreadyRecorded) {
! 1144: recordKeystroke(directionKeys[initialDirection], false, false);
! 1145: alreadyRecorded = true;
! 1146: }
! 1147:
! 1148: player.xLoc += nbDirs[direction][0];
! 1149: player.yLoc += nbDirs[direction][1];
! 1150: pmap[x][y].flags &= ~HAS_PLAYER;
! 1151: pmap[player.xLoc][player.yLoc].flags |= HAS_PLAYER;
! 1152: pmap[player.xLoc][player.yLoc].flags &= ~IS_IN_PATH;
! 1153: if (defender && defender->creatureState == MONSTER_ALLY) { // Swap places with ally.
! 1154: pmap[defender->xLoc][defender->yLoc].flags &= ~HAS_MONSTER;
! 1155: defender->xLoc = x;
! 1156: defender->yLoc = y;
! 1157: if (monsterAvoids(defender, x, y)) {
! 1158: getQualifyingPathLocNear(&(defender->xLoc), &(defender->yLoc), player.xLoc, player.yLoc, true, forbiddenFlagsForMonster(&(defender->info)), 0, 0, (HAS_PLAYER | HAS_MONSTER | HAS_STAIRS), false);
! 1159: }
! 1160: //getQualifyingLocNear(loc, player.xLoc, player.yLoc, true, NULL, forbiddenFlagsForMonster(&(defender->info)) & ~(T_IS_DF_TRAP | T_IS_DEEP_WATER | T_SPONTANEOUSLY_IGNITES), HAS_MONSTER, false, false);
! 1161: //defender->xLoc = loc[0];
! 1162: //defender->yLoc = loc[1];
! 1163: pmap[defender->xLoc][defender->yLoc].flags |= HAS_MONSTER;
! 1164: }
! 1165:
! 1166: if (pmap[player.xLoc][player.yLoc].flags & HAS_ITEM) {
! 1167: pickUpItemAt(player.xLoc, player.yLoc);
! 1168: rogue.disturbed = true;
! 1169: }
! 1170: refreshDungeonCell(x, y);
! 1171: refreshDungeonCell(player.xLoc, player.yLoc);
! 1172: playerMoved = true;
! 1173:
! 1174: checkForMissingKeys(x, y);
! 1175: if (monsterShouldFall(&player)) {
! 1176: player.bookkeepingFlags |= MB_IS_FALLING;
! 1177: }
! 1178: moveEntrancedMonsters(direction);
! 1179:
! 1180: // Perform a lunge or flail attack if appropriate.
! 1181: for (i=0; i<16; i++) {
! 1182: if (hitList[i]) {
! 1183: if (attack(&player, hitList[i], (rogue.weapon && (rogue.weapon->flags & ITEM_LUNGE_ATTACKS)))) {
! 1184: anyAttackHit = true;
! 1185: }
! 1186: }
! 1187: }
! 1188: if (hitList[0]) {
! 1189: playerRecoversFromAttacking(anyAttackHit);
! 1190: }
! 1191:
! 1192: playerTurnEnded();
! 1193: }
! 1194: } else if (cellHasTerrainFlag(newX, newY, T_OBSTRUCTS_PASSABILITY)) {
! 1195: i = pmap[newX][newY].layers[layerWithFlag(newX, newY, T_OBSTRUCTS_PASSABILITY)];
! 1196: if ((tileCatalog[i].flags & T_OBSTRUCTS_PASSABILITY)
! 1197: && (!diagonalBlocked(x, y, newX, newY, false) || !cellHasTMFlag(newX, newY, TM_PROMOTES_WITH_KEY))) {
! 1198:
! 1199: if (!(pmap[newX][newY].flags & DISCOVERED)) {
! 1200: if (!alreadyRecorded) {
! 1201: recordKeystroke(directionKeys[initialDirection], false, false);
! 1202: alreadyRecorded = true;
! 1203: }
! 1204: discoverCell(newX, newY);
! 1205: refreshDungeonCell(newX, newY);
! 1206: }
! 1207:
! 1208: messageWithColor(tileCatalog[i].flavorText, &backgroundMessageColor, false);
! 1209: }
! 1210: }
! 1211: return playerMoved;
! 1212: }
! 1213:
! 1214: // replaced in Dijkstra.c:
! 1215: /*
! 1216: // returns true if the cell value changed
! 1217: boolean updateDistanceCell(short **distanceMap, short x, short y) {
! 1218: short dir, newX, newY;
! 1219: boolean somethingChanged = false;
! 1220:
! 1221: if (distanceMap[x][y] >= 0 && distanceMap[x][y] < 30000) {
! 1222: for (dir=0; dir< DIRECTION_COUNT; dir++) {
! 1223: newX = x + nbDirs[dir][0];
! 1224: newY = y + nbDirs[dir][1];
! 1225: if (coordinatesAreInMap(newX, newY)
! 1226: && distanceMap[newX][newY] >= distanceMap[x][y] + 2
! 1227: && !diagonalBlocked(x, y, newX, newY)) {
! 1228: distanceMap[newX][newY] = distanceMap[x][y] + 1;
! 1229: somethingChanged = true;
! 1230: }
! 1231: }
! 1232: }
! 1233: return somethingChanged;
! 1234: }
! 1235:
! 1236: void dijkstraScan(short **distanceMap, char passMap[DCOLS][DROWS], boolean allowDiagonals) {
! 1237: short i, j, maxDir;
! 1238: enum directions dir;
! 1239: boolean somethingChanged;
! 1240:
! 1241: maxDir = (allowDiagonals ? 8 : 4);
! 1242:
! 1243: do {
! 1244: somethingChanged = false;
! 1245: for (i=1; i<DCOLS-1; i++) {
! 1246: for (j=1; j<DROWS-1; j++) {
! 1247: if (!passMap || passMap[i][j]) {
! 1248: for (dir = 0; dir < maxDir; dir++) {
! 1249: if (coordinatesAreInMap(i + nbDirs[dir][0], j + nbDirs[dir][1])
! 1250: && (!passMap || passMap[i + nbDirs[dir][0]][j + nbDirs[dir][1]])
! 1251: && distanceMap[i + nbDirs[dir][0]][j + nbDirs[dir][1]] >= distanceMap[i][j] + 2) {
! 1252: distanceMap[i + nbDirs[dir][0]][j + nbDirs[dir][1]] = distanceMap[i][j] + 1;
! 1253: somethingChanged = true;
! 1254: }
! 1255: }
! 1256: }
! 1257: }
! 1258: }
! 1259:
! 1260:
! 1261: for (i = DCOLS - 1; i >= 0; i--) {
! 1262: for (j = DROWS - 1; j >= 0; j--) {
! 1263: if (!passMap || passMap[i][j]) {
! 1264: for (dir = 0; dir < maxDir; dir++) {
! 1265: if (coordinatesAreInMap(i + nbDirs[dir][0], j + nbDirs[dir][1])
! 1266: && (!passMap || passMap[i + nbDirs[dir][0]][j + nbDirs[dir][1]])
! 1267: && distanceMap[i + nbDirs[dir][0]][j + nbDirs[dir][1]] >= distanceMap[i][j] + 2) {
! 1268: distanceMap[i + nbDirs[dir][0]][j + nbDirs[dir][1]] = distanceMap[i][j] + 1;
! 1269: somethingChanged = true;
! 1270: }
! 1271: }
! 1272: }
! 1273: }
! 1274: }
! 1275: } while (somethingChanged);
! 1276: }*/
! 1277:
! 1278: /*void enqueue(short x, short y, short val, distanceQueue *dQ) {
! 1279: short *qX2, *qY2, *qVal2;
! 1280:
! 1281: // if we need to allocate more memory:
! 1282: if (dQ->qLen + 1 > dQ->qMaxLen) {
! 1283: dQ->qMaxLen *= 2;
! 1284: qX2 = realloc(dQ->qX, dQ->qMaxLen);
! 1285: if (qX2) {
! 1286: free(dQ->qX);
! 1287: dQ->qX = qX2;
! 1288: } else {
! 1289: // out of memory
! 1290: }
! 1291: qY2 = realloc(dQ->qY, dQ->qMaxLen);
! 1292: if (qY2) {
! 1293: free(dQ->qY);
! 1294: dQ->qY = qY2;
! 1295: } else {
! 1296: // out of memory
! 1297: }
! 1298: qVal2 = realloc(dQ->qVal, dQ->qMaxLen);
! 1299: if (qVal2) {
! 1300: free(dQ->qVal);
! 1301: dQ->qVal = qVal2;
! 1302: } else {
! 1303: // out of memory
! 1304: }
! 1305: }
! 1306:
! 1307: dQ->qX[dQ->qLen] = x;
! 1308: dQ->qY[dQ->qLen] = y;
! 1309: (dQ->qVal)[dQ->qLen] = val;
! 1310:
! 1311: dQ->qLen++;
! 1312:
! 1313: if (val < dQ->qMinVal) {
! 1314: dQ->qMinVal = val;
! 1315: dQ->qMinCount = 1;
! 1316: } else if (val == dQ->qMinVal) {
! 1317: dQ->qMinCount++;
! 1318: }
! 1319: }
! 1320:
! 1321: void updateQueueMinCache(distanceQueue *dQ) {
! 1322: short i;
! 1323: dQ->qMinCount = 0;
! 1324: dQ->qMinVal = 30001;
! 1325: for (i = 0; i < dQ->qLen; i++) {
! 1326: if (dQ->qVal[i] < dQ->qMinVal) {
! 1327: dQ->qMinVal = dQ->qVal[i];
! 1328: dQ->qMinCount = 1;
! 1329: } else if (dQ->qVal[i] == dQ->qMinVal) {
! 1330: dQ->qMinCount++;
! 1331: }
! 1332: }
! 1333: }
! 1334:
! 1335: // removes the lowest value from the queue, populates x/y/value variables and updates min caching
! 1336: void dequeue(short *x, short *y, short *val, distanceQueue *dQ) {
! 1337: short i, minIndex;
! 1338:
! 1339: if (dQ->qMinCount <= 0) {
! 1340: updateQueueMinCache(dQ);
! 1341: }
! 1342:
! 1343: *val = dQ->qMinVal;
! 1344:
! 1345: // find the last instance of the minVal
! 1346: for (minIndex = dQ->qLen - 1; minIndex >= 0 && dQ->qVal[minIndex] != *val; minIndex--);
! 1347:
! 1348: // populate the return variables
! 1349: *x = dQ->qX[minIndex];
! 1350: *y = dQ->qY[minIndex];
! 1351:
! 1352: dQ->qLen--;
! 1353:
! 1354: // delete the minValue queue entry
! 1355: for (i = minIndex; i < dQ->qLen; i++) {
! 1356: dQ->qX[i] = dQ->qX[i+1];
! 1357: dQ->qY[i] = dQ->qY[i+1];
! 1358: dQ->qVal[i] = dQ->qVal[i+1];
! 1359: }
! 1360:
! 1361: // update min values
! 1362: dQ->qMinCount--;
! 1363: if (!dQ->qMinCount && dQ->qLen) {
! 1364: updateQueueMinCache(dQ);
! 1365: }
! 1366:
! 1367: }
! 1368:
! 1369: void dijkstraScan(short **distanceMap, char passMap[DCOLS][DROWS], boolean allowDiagonals) {
! 1370: short i, j, maxDir, val;
! 1371: enum directions dir;
! 1372: distanceQueue dQ;
! 1373:
! 1374: dQ.qMaxLen = DCOLS * DROWS * 1.5;
! 1375: dQ.qX = (short *) malloc(dQ.qMaxLen * sizeof(short));
! 1376: dQ.qY = (short *) malloc(dQ.qMaxLen * sizeof(short));
! 1377: dQ.qVal = (short *) malloc(dQ.qMaxLen * sizeof(short));
! 1378: dQ.qLen = 0;
! 1379: dQ.qMinVal = 30000;
! 1380: dQ.qMinCount = 0;
! 1381:
! 1382: maxDir = (allowDiagonals ? 8 : 4);
! 1383:
! 1384: // seed the queue with the entire map
! 1385: for (i=0; i<DCOLS; i++) {
! 1386: for (j=0; j<DROWS; j++) {
! 1387: if (!passMap || passMap[i][j]) {
! 1388: enqueue(i, j, distanceMap[i][j], &dQ);
! 1389: }
! 1390: }
! 1391: }
! 1392:
! 1393: // iterate through queue updating lowest entries until the queue is empty
! 1394: while (dQ.qLen) {
! 1395: dequeue(&i, &j, &val, &dQ);
! 1396: if (distanceMap[i][j] == val) { // if it hasn't been improved since joining the queue
! 1397: for (dir = 0; dir < maxDir; dir++) {
! 1398: if (coordinatesAreInMap(i + nbDirs[dir][0], j + nbDirs[dir][1])
! 1399: && (!passMap || passMap[i + nbDirs[dir][0]][j + nbDirs[dir][1]])
! 1400: && distanceMap[i + nbDirs[dir][0]][j + nbDirs[dir][1]] >= distanceMap[i][j] + 2) {
! 1401:
! 1402: distanceMap[i + nbDirs[dir][0]][j + nbDirs[dir][1]] = distanceMap[i][j] + 1;
! 1403:
! 1404: enqueue(i + nbDirs[dir][0], j + nbDirs[dir][1], distanceMap[i][j] + 1, &dQ);
! 1405: }
! 1406: }
! 1407: }
! 1408: }
! 1409:
! 1410: free(dQ.qX);
! 1411: free(dQ.qY);
! 1412: free(dQ.qVal);
! 1413: }*/
! 1414:
! 1415: /*
! 1416: void calculateDistances(short **distanceMap, short destinationX, short destinationY, unsigned long blockingTerrainFlags, creature *traveler) {
! 1417: short i, j;
! 1418: boolean somethingChanged;
! 1419:
! 1420: for (i=0; i<DCOLS; i++) {
! 1421: for (j=0; j<DROWS; j++) {
! 1422: distanceMap[i][j] = ((traveler && traveler == &player && !(pmap[i][j].flags & (DISCOVERED | MAGIC_MAPPED)))
! 1423: || ((traveler && monsterAvoids(traveler, i, j))
! 1424: || cellHasTerrainFlag(i, j, blockingTerrainFlags))) ? -1 : 30000;
! 1425: }
! 1426: }
! 1427:
! 1428: distanceMap[destinationX][destinationY] = 0;
! 1429:
! 1430: // dijkstraScan(distanceMap);
! 1431: do {
! 1432: somethingChanged = false;
! 1433: for (i=0; i<DCOLS; i++) {
! 1434: for (j=0; j<DROWS; j++) {
! 1435: if (updateDistanceCell(distanceMap, i, j)) {
! 1436: somethingChanged = true;
! 1437: }
! 1438: }
! 1439: }
! 1440:
! 1441:
! 1442: for (i = DCOLS - 1; i >= 0; i--) {
! 1443: for (j = DROWS - 1; j >= 0; j--) {
! 1444: if (updateDistanceCell(distanceMap, i, j)) {
! 1445: somethingChanged = true;
! 1446: }
! 1447: }
! 1448: }
! 1449: } while (somethingChanged);
! 1450: }*/
! 1451:
! 1452: // Returns -1 if there are no beneficial moves.
! 1453: // If preferDiagonals is true, we will prefer diagonal moves.
! 1454: // Always rolls downhill on the distance map.
! 1455: // If monst is provided, do not return a direction pointing to
! 1456: // a cell that the monster avoids.
! 1457: short nextStep(short **distanceMap, short x, short y, creature *monst, boolean preferDiagonals) {
! 1458: short newX, newY, bestScore;
! 1459: enum directions dir, bestDir;
! 1460: creature *blocker;
! 1461: boolean blocked;
! 1462:
! 1463: brogueAssert(coordinatesAreInMap(x, y));
! 1464:
! 1465: bestScore = 0;
! 1466: bestDir = NO_DIRECTION;
! 1467:
! 1468: for (dir = (preferDiagonals ? 7 : 0);
! 1469: (preferDiagonals ? dir >= 0 : dir < DIRECTION_COUNT);
! 1470: (preferDiagonals ? dir-- : dir++)) {
! 1471:
! 1472: newX = x + nbDirs[dir][0];
! 1473: newY = y + nbDirs[dir][1];
! 1474:
! 1475: brogueAssert(coordinatesAreInMap(newX, newY));
! 1476: if (coordinatesAreInMap(newX, newY)) {
! 1477: blocked = false;
! 1478: blocker = monsterAtLoc(newX, newY);
! 1479: if (monst
! 1480: && monsterAvoids(monst, newX, newY)) {
! 1481:
! 1482: blocked = true;
! 1483: } else if (monst
! 1484: && blocker
! 1485: && !canPass(monst, blocker)
! 1486: && !monstersAreTeammates(monst, blocker)
! 1487: && !monstersAreEnemies(monst, blocker)) {
! 1488: blocked = true;
! 1489: }
! 1490: if ((distanceMap[x][y] - distanceMap[newX][newY]) > bestScore
! 1491: && !diagonalBlocked(x, y, newX, newY, monst == &player)
! 1492: && knownToPlayerAsPassableOrSecretDoor(newX, newY)
! 1493: && !blocked) {
! 1494:
! 1495: bestDir = dir;
! 1496: bestScore = distanceMap[x][y] - distanceMap[newX][newY];
! 1497: }
! 1498: }
! 1499: }
! 1500: return bestDir;
! 1501: }
! 1502:
! 1503: void displayRoute(short **distanceMap, boolean removeRoute) {
! 1504: short currentX = player.xLoc, currentY = player.yLoc, dir, newX, newY;
! 1505: boolean advanced;
! 1506:
! 1507: if (distanceMap[player.xLoc][player.yLoc] < 0 || distanceMap[player.xLoc][player.yLoc] == 30000) {
! 1508: return;
! 1509: }
! 1510: do {
! 1511: if (removeRoute) {
! 1512: refreshDungeonCell(currentX, currentY);
! 1513: } else {
! 1514: hiliteCell(currentX, currentY, &hiliteColor, 50, true);
! 1515: }
! 1516: advanced = false;
! 1517: for (dir = 7; dir >= 0; dir--) {
! 1518: newX = currentX + nbDirs[dir][0];
! 1519: newY = currentY + nbDirs[dir][1];
! 1520: if (coordinatesAreInMap(newX, newY)
! 1521: && distanceMap[newX][newY] >= 0 && distanceMap[newX][newY] < distanceMap[currentX][currentY]
! 1522: && !diagonalBlocked(currentX, currentY, newX, newY, true)) {
! 1523:
! 1524: currentX = newX;
! 1525: currentY = newY;
! 1526: advanced = true;
! 1527: break;
! 1528: }
! 1529: }
! 1530: } while (advanced);
! 1531: }
! 1532:
! 1533: void travelRoute(short path[1000][2], short steps) {
! 1534: short i, j;
! 1535: short dir;
! 1536: creature *monst;
! 1537:
! 1538: brogueAssert(!rogue.playbackMode);
! 1539:
! 1540: rogue.disturbed = false;
! 1541: rogue.automationActive = true;
! 1542:
! 1543: for (monst = monsters->nextCreature; monst != NULL; monst = monst->nextCreature) {
! 1544: if (canSeeMonster(monst)) {
! 1545: monst->bookkeepingFlags |= MB_ALREADY_SEEN;
! 1546: } else {
! 1547: monst->bookkeepingFlags &= ~MB_ALREADY_SEEN;
! 1548: }
! 1549: }
! 1550:
! 1551: for (i=0; i < steps && !rogue.disturbed; i++) {
! 1552: for (j = i + 1; j < steps - 1; j++) {
! 1553: // Check to see if the path has become obstructed or avoided since the last time we saw it.
! 1554: if (diagonalBlocked(path[j-1][0], path[j-1][1], path[j][0], path[j][1], true)
! 1555: || monsterAvoids(&player, path[j][0], path[j][1])) {
! 1556:
! 1557: rogue.disturbed = true;
! 1558: break;
! 1559: }
! 1560: }
! 1561: for (dir = 0; dir < DIRECTION_COUNT && !rogue.disturbed; dir++) {
! 1562: if (player.xLoc + nbDirs[dir][0] == path[i][0]
! 1563: && player.yLoc + nbDirs[dir][1] == path[i][1]) {
! 1564:
! 1565: if (!playerMoves(dir)) {
! 1566: rogue.disturbed = true;
! 1567: }
! 1568: if (pauseBrogue(25)) {
! 1569: rogue.disturbed = true;
! 1570: }
! 1571: break;
! 1572: }
! 1573: }
! 1574: }
! 1575: rogue.disturbed = true;
! 1576: rogue.automationActive = false;
! 1577: updateFlavorText();
! 1578: }
! 1579:
! 1580: void travelMap(short **distanceMap) {
! 1581: short currentX = player.xLoc, currentY = player.yLoc, dir, newX, newY;
! 1582: boolean advanced;
! 1583:
! 1584: rogue.disturbed = false;
! 1585: rogue.automationActive = true;
! 1586:
! 1587: if (distanceMap[player.xLoc][player.yLoc] < 0 || distanceMap[player.xLoc][player.yLoc] == 30000) {
! 1588: return;
! 1589: }
! 1590: do {
! 1591: advanced = false;
! 1592: for (dir = 7; dir >= 0; dir--) {
! 1593: newX = currentX + nbDirs[dir][0];
! 1594: newY = currentY + nbDirs[dir][1];
! 1595: if (coordinatesAreInMap(newX, newY)
! 1596: && distanceMap[newX][newY] >= 0
! 1597: && distanceMap[newX][newY] < distanceMap[currentX][currentY]
! 1598: && !diagonalBlocked(currentX, currentY, newX, newY, true)) {
! 1599:
! 1600: if (!playerMoves(dir)) {
! 1601: rogue.disturbed = true;
! 1602: }
! 1603: if (pauseBrogue(500)) {
! 1604: rogue.disturbed = true;
! 1605: }
! 1606: currentX = newX;
! 1607: currentY = newY;
! 1608: advanced = true;
! 1609: break;
! 1610: }
! 1611: }
! 1612: } while (advanced && !rogue.disturbed);
! 1613: rogue.disturbed = true;
! 1614: rogue.automationActive = false;
! 1615: updateFlavorText();
! 1616: }
! 1617:
! 1618: void travel(short x, short y, boolean autoConfirm) {
! 1619: short **distanceMap, i;
! 1620: rogueEvent theEvent;
! 1621: unsigned short staircaseConfirmKey;
! 1622:
! 1623: confirmMessages();
! 1624:
! 1625: if (D_WORMHOLING) {
! 1626: recordMouseClick(mapToWindowX(x), mapToWindowY(y), true, false);
! 1627: pmap[player.xLoc][player.yLoc].flags &= ~HAS_PLAYER;
! 1628: refreshDungeonCell(player.xLoc, player.yLoc);
! 1629: player.xLoc = x;
! 1630: player.yLoc = y;
! 1631: pmap[x][y].flags |= HAS_PLAYER;
! 1632: updatePlayerUnderwaterness();
! 1633: refreshDungeonCell(x, y);
! 1634: updateVision(true);
! 1635: return;
! 1636: }
! 1637:
! 1638: if (abs(player.xLoc - x) + abs(player.yLoc - y) == 1) {
! 1639: // targeting a cardinal neighbor
! 1640: for (i=0; i<4; i++) {
! 1641: if (nbDirs[i][0] == (x - player.xLoc) && nbDirs[i][1] == (y - player.yLoc)) {
! 1642: playerMoves(i);
! 1643: break;
! 1644: }
! 1645: }
! 1646: return;
! 1647: }
! 1648:
! 1649: if (!(pmap[x][y].flags & (DISCOVERED | MAGIC_MAPPED))) {
! 1650: message("You have not explored that location.", false);
! 1651: return;
! 1652: }
! 1653:
! 1654: distanceMap = allocGrid();
! 1655:
! 1656: calculateDistances(distanceMap, x, y, 0, &player, false, false);
! 1657: if (distanceMap[player.xLoc][player.yLoc] < 30000) {
! 1658: if (autoConfirm) {
! 1659: travelMap(distanceMap);
! 1660: //refreshSideBar(-1, -1, false);
! 1661: } else {
! 1662: if (rogue.upLoc[0] == x && rogue.upLoc[1] == y) {
! 1663: staircaseConfirmKey = ASCEND_KEY;
! 1664: } else if (rogue.downLoc[0] == x && rogue.downLoc[1] == y) {
! 1665: staircaseConfirmKey = DESCEND_KEY;
! 1666: } else {
! 1667: staircaseConfirmKey = 0;
! 1668: }
! 1669: displayRoute(distanceMap, false);
! 1670: message("Travel this route? (y/n)", false);
! 1671:
! 1672: do {
! 1673: nextBrogueEvent(&theEvent, true, false, false);
! 1674: } while (theEvent.eventType != MOUSE_UP && theEvent.eventType != KEYSTROKE);
! 1675:
! 1676: displayRoute(distanceMap, true); // clear route display
! 1677: confirmMessages();
! 1678:
! 1679: if ((theEvent.eventType == MOUSE_UP && windowToMapX(theEvent.param1) == x && windowToMapY(theEvent.param2) == y)
! 1680: || (theEvent.eventType == KEYSTROKE && (theEvent.param1 == 'Y' || theEvent.param1 == 'y'
! 1681: || theEvent.param1 == RETURN_KEY
! 1682: || (theEvent.param1 == staircaseConfirmKey
! 1683: && theEvent.param1 != 0)))) {
! 1684: travelMap(distanceMap);
! 1685: //refreshSideBar(-1, -1, false);
! 1686: commitDraws();
! 1687: } else if (theEvent.eventType == MOUSE_UP) {
! 1688: executeMouseClick(&theEvent);
! 1689: }
! 1690: }
! 1691: // if (player.xLoc == x && player.yLoc == y) {
! 1692: // rogue.cursorLoc[0] = rogue.cursorLoc[1] = 0;
! 1693: // } else {
! 1694: // rogue.cursorLoc[0] = x;
! 1695: // rogue.cursorLoc[1] = y;
! 1696: // }
! 1697: } else {
! 1698: rogue.cursorLoc[0] = rogue.cursorLoc[1] = -1;
! 1699: message("No path is available.", false);
! 1700: }
! 1701: freeGrid(distanceMap);
! 1702: }
! 1703:
! 1704: void populateGenericCostMap(short **costMap) {
! 1705: short i, j;
! 1706:
! 1707: for (i=0; i<DCOLS; i++) {
! 1708: for (j=0; j<DROWS; j++) {
! 1709: if (cellHasTerrainFlag(i, j, T_OBSTRUCTS_PASSABILITY)
! 1710: && (!cellHasTMFlag(i, j, TM_IS_SECRET) || (discoveredTerrainFlagsAtLoc(i, j) & T_OBSTRUCTS_PASSABILITY))) {
! 1711:
! 1712: costMap[i][j] = cellHasTerrainFlag(i, j, T_OBSTRUCTS_DIAGONAL_MOVEMENT) ? PDS_OBSTRUCTION : PDS_FORBIDDEN;
! 1713: } else if (cellHasTerrainFlag(i, j, T_PATHING_BLOCKER & ~T_OBSTRUCTS_PASSABILITY)) {
! 1714: costMap[i][j] = PDS_FORBIDDEN;
! 1715: } else {
! 1716: costMap[i][j] = 1;
! 1717: }
! 1718: }
! 1719: }
! 1720: }
! 1721:
! 1722: void getLocationFlags(const short x, const short y,
! 1723: unsigned long *tFlags, unsigned long *TMFlags, unsigned long *cellFlags,
! 1724: const boolean limitToPlayerKnowledge) {
! 1725: if (limitToPlayerKnowledge
! 1726: && (pmap[x][y].flags & (DISCOVERED | MAGIC_MAPPED))
! 1727: && !playerCanSee(x, y)) {
! 1728:
! 1729: if (tFlags) {
! 1730: *tFlags = pmap[x][y].rememberedTerrainFlags;
! 1731: }
! 1732: if (TMFlags) {
! 1733: *TMFlags = pmap[x][y].rememberedTMFlags;
! 1734: }
! 1735: if (cellFlags) {
! 1736: *cellFlags = pmap[x][y].rememberedCellFlags;
! 1737: }
! 1738: } else {
! 1739: if (tFlags) {
! 1740: *tFlags = terrainFlags(x, y);
! 1741: }
! 1742: if (TMFlags) {
! 1743: *TMFlags = terrainMechFlags(x, y);
! 1744: }
! 1745: if (cellFlags) {
! 1746: *cellFlags = pmap[x][y].flags;
! 1747: }
! 1748: }
! 1749: }
! 1750:
! 1751: void populateCreatureCostMap(short **costMap, creature *monst) {
! 1752: short i, j, unexploredCellCost;
! 1753: creature *currentTenant;
! 1754: item *theItem;
! 1755: unsigned long tFlags, cFlags;
! 1756:
! 1757: unexploredCellCost = 10 + (clamp(rogue.depthLevel, 5, 15) - 5) * 2;
! 1758:
! 1759: for (i=0; i<DCOLS; i++) {
! 1760: for (j=0; j<DROWS; j++) {
! 1761: if (monst == &player && !(pmap[i][j].flags & (DISCOVERED | MAGIC_MAPPED))) {
! 1762: costMap[i][j] = PDS_OBSTRUCTION;
! 1763: continue;
! 1764: }
! 1765:
! 1766: getLocationFlags(i, j, &tFlags, NULL, &cFlags, monst == &player);
! 1767:
! 1768: if ((tFlags & T_OBSTRUCTS_PASSABILITY)
! 1769: && (!cellHasTMFlag(i, j, TM_IS_SECRET) || (discoveredTerrainFlagsAtLoc(i, j) & T_OBSTRUCTS_PASSABILITY) || monst == &player)) {
! 1770:
! 1771: costMap[i][j] = (tFlags & T_OBSTRUCTS_DIAGONAL_MOVEMENT) ? PDS_OBSTRUCTION : PDS_FORBIDDEN;
! 1772: continue;
! 1773: }
! 1774:
! 1775: if ((tFlags & T_LAVA_INSTA_DEATH)
! 1776: && !(monst->info.flags & (MONST_IMMUNE_TO_FIRE | MONST_FLIES | MONST_INVULNERABLE))
! 1777: && (monst->status[STATUS_LEVITATING] || monst->status[STATUS_IMMUNE_TO_FIRE])
! 1778: && max(monst->status[STATUS_LEVITATING], monst->status[STATUS_IMMUNE_TO_FIRE]) < (rogue.mapToShore[i][j] + distanceBetween(i, j, monst->xLoc, monst->yLoc) * monst->movementSpeed / 100)) {
! 1779: // Only a temporary effect will permit the monster to survive the lava, and the remaining duration either isn't
! 1780: // enough to get it to the spot, or it won't suffice to let it return to shore if it does get there.
! 1781: // Treat these locations as obstacles.
! 1782: costMap[i][j] = PDS_FORBIDDEN;
! 1783: continue;
! 1784: }
! 1785:
! 1786: if (((tFlags & T_AUTO_DESCENT) || (tFlags & T_IS_DEEP_WATER) && !(monst->info.flags & MONST_IMMUNE_TO_WATER))
! 1787: && !(monst->info.flags & MONST_FLIES)
! 1788: && (monst->status[STATUS_LEVITATING])
! 1789: && monst->status[STATUS_LEVITATING] < (rogue.mapToShore[i][j] + distanceBetween(i, j, monst->xLoc, monst->yLoc) * monst->movementSpeed / 100)) {
! 1790: // Only a temporary effect will permit the monster to levitate over the chasm/water, and the remaining duration either isn't
! 1791: // enough to get it to the spot, or it won't suffice to let it return to shore if it does get there.
! 1792: // Treat these locations as obstacles.
! 1793: costMap[i][j] = PDS_FORBIDDEN;
! 1794: continue;
! 1795: }
! 1796:
! 1797: if (monsterAvoids(monst, i, j)) {
! 1798: costMap[i][j] = PDS_FORBIDDEN;
! 1799: continue;
! 1800: }
! 1801:
! 1802: if (cFlags & HAS_MONSTER) {
! 1803: currentTenant = monsterAtLoc(i, j);
! 1804: if (currentTenant
! 1805: && (currentTenant->info.flags & (MONST_IMMUNE_TO_WEAPONS | MONST_INVULNERABLE))
! 1806: && !canPass(monst, currentTenant)) {
! 1807:
! 1808: costMap[i][j] = PDS_FORBIDDEN;
! 1809: continue;
! 1810: }
! 1811: }
! 1812:
! 1813: if ((cFlags & KNOWN_TO_BE_TRAP_FREE)
! 1814: || (monst != &player && monst->creatureState != MONSTER_ALLY)) {
! 1815:
! 1816: costMap[i][j] = 10;
! 1817: } else {
! 1818: // Player and allies give locations that are known to be free of traps
! 1819: // an advantage that increases with depth level, based on the depths
! 1820: // at which traps are generated.
! 1821: costMap[i][j] = unexploredCellCost;
! 1822: }
! 1823:
! 1824: if (!(monst->info.flags & MONST_INVULNERABLE)) {
! 1825: if ((tFlags & T_CAUSES_NAUSEA)
! 1826: || cellHasTMFlag(i, j, TM_PROMOTES_ON_ITEM_PICKUP)
! 1827: || (tFlags & T_ENTANGLES) && !(monst->info.flags & MONST_IMMUNE_TO_WEBS)) {
! 1828:
! 1829: costMap[i][j] += 20;
! 1830: }
! 1831: }
! 1832:
! 1833: if (monst == &player) {
! 1834: theItem = itemAtLoc(i, j);
! 1835: if (theItem && (theItem->flags & ITEM_PLAYER_AVOIDS)) {
! 1836: costMap[i][j] += 10;
! 1837: }
! 1838: }
! 1839: }
! 1840: }
! 1841: }
! 1842:
! 1843: enum directions adjacentFightingDir() {
! 1844: short newX, newY;
! 1845: enum directions dir;
! 1846: creature *monst;
! 1847:
! 1848: if (cellHasTerrainFlag(player.xLoc, player.yLoc, T_OBSTRUCTS_PASSABILITY)) {
! 1849: return NO_DIRECTION;
! 1850: }
! 1851: for (dir = 0; dir < DIRECTION_COUNT; dir++) {
! 1852: newX = player.xLoc + nbDirs[dir][0];
! 1853: newY = player.yLoc + nbDirs[dir][1];
! 1854: monst = monsterAtLoc(newX, newY);
! 1855: if (monst
! 1856: && canSeeMonster(monst)
! 1857: && (!diagonalBlocked(player.xLoc, player.yLoc, newX, newY, false) || (monst->info.flags & MONST_ATTACKABLE_THRU_WALLS))
! 1858: && monstersAreEnemies(&player, monst)
! 1859: && !(monst->info.flags & (MONST_IMMUNE_TO_WEAPONS | MONST_INVULNERABLE))) {
! 1860:
! 1861: return dir;
! 1862: }
! 1863: }
! 1864: return NO_DIRECTION;
! 1865: }
! 1866:
! 1867: #define exploreGoalValue(x, y) (0 - abs((x) - DCOLS / 2) / 3 - abs((x) - DCOLS / 2) / 4)
! 1868:
! 1869: void getExploreMap(short **map, boolean headingToStairs) {// calculate explore map
! 1870: short i, j;
! 1871: short **costMap;
! 1872: item *theItem;
! 1873:
! 1874: costMap = allocGrid();
! 1875: populateCreatureCostMap(costMap, &player);
! 1876:
! 1877: for (i=0; i<DCOLS; i++) {
! 1878: for (j=0; j<DROWS; j++) {
! 1879: map[i][j] = 30000; // Can be overridden later.
! 1880: theItem = itemAtLoc(i, j);
! 1881: if (!(pmap[i][j].flags & DISCOVERED)) {
! 1882: if ((pmap[i][j].flags & MAGIC_MAPPED)
! 1883: && (tileCatalog[pmap[i][j].layers[DUNGEON]].flags | tileCatalog[pmap[i][j].layers[LIQUID]].flags) & T_PATHING_BLOCKER) {
! 1884: // Magic-mapped cells revealed as obstructions should be treated as such even though they're not discovered.
! 1885: costMap[i][j] = cellHasTerrainFlag(i, j, T_OBSTRUCTS_DIAGONAL_MOVEMENT) ? PDS_OBSTRUCTION : PDS_FORBIDDEN;
! 1886: } else {
! 1887: costMap[i][j] = 1;
! 1888: map[i][j] = exploreGoalValue(i, j);
! 1889: }
! 1890: } else if (theItem
! 1891: && !monsterAvoids(&player, i, j)) {
! 1892: if (theItem->flags & ITEM_PLAYER_AVOIDS) {
! 1893: costMap[i][j] = 20;
! 1894: } else {
! 1895: costMap[i][j] = 1;
! 1896: map[i][j] = exploreGoalValue(i, j) - 10;
! 1897: }
! 1898: }
! 1899: }
! 1900: }
! 1901:
! 1902: costMap[rogue.downLoc[0]][rogue.downLoc[1]] = 100;
! 1903: costMap[rogue.upLoc[0]][rogue.upLoc[1]] = 100;
! 1904:
! 1905: if (headingToStairs) {
! 1906: map[rogue.downLoc[0]][rogue.downLoc[1]] = 0; // head to the stairs
! 1907: }
! 1908:
! 1909: dijkstraScan(map, costMap, true);
! 1910:
! 1911: //displayGrid(costMap);
! 1912: freeGrid(costMap);
! 1913: }
! 1914:
! 1915: boolean explore(short frameDelay) {
! 1916: short **distanceMap;
! 1917: short path[1000][2], steps;
! 1918: boolean madeProgress, headingToStairs;
! 1919: enum directions dir;
! 1920: creature *monst;
! 1921:
! 1922: // Explore commands should never be written to a recording.
! 1923: // Instead, the elemental movement commands that compose it
! 1924: // should be written individually.
! 1925: brogueAssert(!rogue.playbackMode);
! 1926:
! 1927: clearCursorPath();
! 1928:
! 1929: madeProgress = false;
! 1930: headingToStairs = false;
! 1931:
! 1932: if (player.status[STATUS_CONFUSED]) {
! 1933: message("Not while you're confused.", false);
! 1934: return false;
! 1935: }
! 1936: if (cellHasTerrainFlag(player.xLoc, player.yLoc, T_OBSTRUCTS_PASSABILITY)) {
! 1937: message("Not while you're trapped.", false);
! 1938: return false;
! 1939: }
! 1940:
! 1941: for (monst = monsters->nextCreature; monst != NULL; monst = monst->nextCreature) {
! 1942: if (canSeeMonster(monst)) {
! 1943: monst->bookkeepingFlags |= MB_ALREADY_SEEN;
! 1944: } else {
! 1945: monst->bookkeepingFlags &= ~MB_ALREADY_SEEN;
! 1946: }
! 1947: }
! 1948:
! 1949: // fight any adjacent enemies
! 1950: dir = adjacentFightingDir();
! 1951: if (dir != NO_DIRECTION
! 1952: && startFighting(dir, (player.status[STATUS_HALLUCINATING] ? true : false))) {
! 1953:
! 1954: return true;
! 1955: }
! 1956:
! 1957: if (!rogue.autoPlayingLevel) {
! 1958: message(KEYBOARD_LABELS ? "Exploring... press any key to stop." : "Exploring... touch anywhere to stop.",
! 1959: false);
! 1960: // A little hack so the exploring message remains bright while exploring and then auto-dims when
! 1961: // another message is displayed:
! 1962: confirmMessages();
! 1963: printString(KEYBOARD_LABELS ? "Exploring... press any key to stop." : "Exploring... touch anywhere to stop.",
! 1964: mapToWindowX(0), mapToWindowY(-1), &white, &black, NULL);
! 1965: }
! 1966: rogue.disturbed = false;
! 1967: rogue.automationActive = true;
! 1968:
! 1969: distanceMap = allocGrid();
! 1970: do {
! 1971: // fight any adjacent enemies
! 1972: dir = adjacentFightingDir();
! 1973: if (dir != NO_DIRECTION) {
! 1974: startFighting(dir, (player.status[STATUS_HALLUCINATING] ? true : false));
! 1975: if (rogue.disturbed) {
! 1976: madeProgress = true;
! 1977: continue;
! 1978: }
! 1979: }
! 1980: if (rogue.disturbed) {
! 1981: continue;
! 1982: }
! 1983:
! 1984: getExploreMap(distanceMap, headingToStairs);
! 1985:
! 1986: // hilite path
! 1987: steps = getPlayerPathOnMap(path, distanceMap, player.xLoc, player.yLoc);
! 1988: hilitePath(path, steps, false);
! 1989:
! 1990: // take a step
! 1991: dir = nextStep(distanceMap, player.xLoc, player.yLoc, NULL, false);
! 1992:
! 1993: if (!headingToStairs && rogue.autoPlayingLevel && dir == NO_DIRECTION) {
! 1994: headingToStairs = true;
! 1995: continue;
! 1996: }
! 1997:
! 1998: refreshSideBar(-1, -1, false);
! 1999:
! 2000: if (dir == NO_DIRECTION) {
! 2001: rogue.disturbed = true;
! 2002: } else if (!playerMoves(dir)) {
! 2003: rogue.disturbed = true;
! 2004: } else {
! 2005: madeProgress = true;
! 2006: if (pauseBrogue(frameDelay)) {
! 2007: rogue.disturbed = true;
! 2008: rogue.autoPlayingLevel = false;
! 2009: }
! 2010: }
! 2011: hilitePath(path, steps, true);
! 2012: } while (!rogue.disturbed);
! 2013: //clearCursorPath();
! 2014: rogue.automationActive = false;
! 2015: refreshSideBar(-1, -1, false);
! 2016: freeGrid(distanceMap);
! 2017: return madeProgress;
! 2018: }
! 2019:
! 2020: void autoPlayLevel(boolean fastForward) {
! 2021: boolean madeProgress;
! 2022:
! 2023: rogue.autoPlayingLevel = true;
! 2024:
! 2025: confirmMessages();
! 2026: message(KEYBOARD_LABELS ? "Playing... press any key to stop." : "Playing... touch anywhere to stop.", false);
! 2027:
! 2028: // explore until we are not making progress
! 2029: do {
! 2030: madeProgress = explore(fastForward ? 1 : 50);
! 2031: //refreshSideBar(-1, -1, false);
! 2032:
! 2033: if (!madeProgress && rogue.downLoc[0] == player.xLoc && rogue.downLoc[1] == player.yLoc) {
! 2034: useStairs(1);
! 2035: madeProgress = true;
! 2036: }
! 2037: } while (madeProgress && rogue.autoPlayingLevel);
! 2038:
! 2039: confirmMessages();
! 2040:
! 2041: rogue.autoPlayingLevel = false;
! 2042: }
! 2043:
! 2044: short directionOfKeypress(unsigned short ch) {
! 2045: switch (ch) {
! 2046: case LEFT_KEY:
! 2047: case LEFT_ARROW:
! 2048: case NUMPAD_4:
! 2049: return LEFT;
! 2050: case RIGHT_KEY:
! 2051: case RIGHT_ARROW:
! 2052: case NUMPAD_6:
! 2053: return RIGHT;
! 2054: case UP_KEY:
! 2055: case UP_ARROW:
! 2056: case NUMPAD_8:
! 2057: return UP;
! 2058: case DOWN_KEY:
! 2059: case DOWN_ARROW:
! 2060: case NUMPAD_2:
! 2061: return DOWN;
! 2062: case UPLEFT_KEY:
! 2063: case NUMPAD_7:
! 2064: return UPLEFT;
! 2065: case UPRIGHT_KEY:
! 2066: case NUMPAD_9:
! 2067: return UPRIGHT;
! 2068: case DOWNLEFT_KEY:
! 2069: case NUMPAD_1:
! 2070: return DOWNLEFT;
! 2071: case DOWNRIGHT_KEY:
! 2072: case NUMPAD_3:
! 2073: return DOWNRIGHT;
! 2074: default:
! 2075: return -1;
! 2076: }
! 2077: }
! 2078:
! 2079: boolean startFighting(enum directions dir, boolean tillDeath) {
! 2080: short x, y, expectedDamage;
! 2081: creature *monst;
! 2082:
! 2083: x = player.xLoc + nbDirs[dir][0];
! 2084: y = player.yLoc + nbDirs[dir][1];
! 2085: monst = monsterAtLoc(x, y);
! 2086: if (monst->info.flags & (MONST_IMMUNE_TO_WEAPONS | MONST_INVULNERABLE)) {
! 2087: return false;
! 2088: }
! 2089: expectedDamage = monst->info.damage.upperBound * monsterDamageAdjustmentAmount(monst) / FP_FACTOR;
! 2090: if (rogue.easyMode) {
! 2091: expectedDamage /= 5;
! 2092: }
! 2093: rogue.blockCombatText = true;
! 2094: rogue.disturbed = false;
! 2095: do {
! 2096: if (!playerMoves(dir)) {
! 2097: break;
! 2098: }
! 2099: if (pauseBrogue(1)) {
! 2100: break;
! 2101: }
! 2102: } while (!rogue.disturbed && !rogue.gameHasEnded && (tillDeath || player.currentHP > expectedDamage)
! 2103: && (pmap[x][y].flags & HAS_MONSTER) && monsterAtLoc(x, y) == monst);
! 2104:
! 2105: rogue.blockCombatText = false;
! 2106: return rogue.disturbed;
! 2107: }
! 2108:
! 2109: boolean isDisturbed(short x, short y) {
! 2110: short i;
! 2111: creature *monst;
! 2112: for (i=0; i< DIRECTION_COUNT; i++) {
! 2113: monst = monsterAtLoc(x + nbDirs[i][0], y + nbDirs[i][1]);
! 2114: if (pmap[x + nbDirs[i][0]][y + nbDirs[i][1]].flags & (HAS_ITEM)) {
! 2115: // Do not trigger for submerged or invisible or unseen monsters.
! 2116: return true;
! 2117: }
! 2118: if (monst
! 2119: && !(monst->creatureState == MONSTER_ALLY)
! 2120: && (canSeeMonster(monst) || monsterRevealed(monst))) {
! 2121: // Do not trigger for submerged or invisible or unseen monsters.
! 2122: return true;
! 2123: }
! 2124: }
! 2125: return false;
! 2126: }
! 2127:
! 2128: void discover(short x, short y) {
! 2129: enum dungeonLayers layer;
! 2130: dungeonFeature *feat;
! 2131: if (cellHasTMFlag(x, y, TM_IS_SECRET)) {
! 2132:
! 2133: for (layer = 0; layer < NUMBER_TERRAIN_LAYERS; layer++) {
! 2134: if (tileCatalog[pmap[x][y].layers[layer]].mechFlags & TM_IS_SECRET) {
! 2135: feat = &dungeonFeatureCatalog[tileCatalog[pmap[x][y].layers[layer]].discoverType];
! 2136: pmap[x][y].layers[layer] = (layer == DUNGEON ? FLOOR : NOTHING);
! 2137: spawnDungeonFeature(x, y, feat, true, false);
! 2138: }
! 2139: }
! 2140: refreshDungeonCell(x, y);
! 2141:
! 2142: if (playerCanSee(x, y)) {
! 2143: rogue.disturbed = true;
! 2144: }
! 2145: }
! 2146: }
! 2147:
! 2148: // returns true if found anything
! 2149: boolean search(short searchStrength) {
! 2150: short i, j, radius, x, y, percent;
! 2151: boolean foundSomething = false;
! 2152:
! 2153: radius = searchStrength / 10;
! 2154: x = player.xLoc;
! 2155: y = player.yLoc;
! 2156:
! 2157: for (i = x - radius; i <= x + radius; i++) {
! 2158: for (j = y - radius; j <= y + radius; j++) {
! 2159: if (coordinatesAreInMap(i, j)
! 2160: && playerCanDirectlySee(i, j)) {
! 2161:
! 2162: percent = searchStrength - distanceBetween(x, y, i, j) * 10;
! 2163: if (cellHasTerrainFlag(i, j, T_OBSTRUCTS_PASSABILITY)) {
! 2164: percent = percent * 2/3;
! 2165: }
! 2166: if (percent >= 100) {
! 2167: pmap[i][j].flags |= KNOWN_TO_BE_TRAP_FREE;
! 2168: }
! 2169: percent = min(percent, 100);
! 2170: if (cellHasTMFlag(i, j, TM_IS_SECRET)) {
! 2171: if (rand_percent(percent)) {
! 2172: discover(i, j);
! 2173: foundSomething = true;
! 2174: }
! 2175: }
! 2176: }
! 2177: }
! 2178: }
! 2179: return foundSomething;
! 2180: }
! 2181:
! 2182: boolean proposeOrConfirmLocation(short x, short y, char *failureMessage) {
! 2183: boolean retval = false;
! 2184: if (player.xLoc == x && player.yLoc == y) {
! 2185: message("you are already there.", false);
! 2186: } else if (pmap[x][y].flags & (DISCOVERED | MAGIC_MAPPED)) {
! 2187: if (rogue.cursorLoc[0] == x && rogue.cursorLoc[1] == y) {
! 2188: retval = true;
! 2189: } else {
! 2190: rogue.cursorLoc[0] = x;
! 2191: rogue.cursorLoc[1] = y;
! 2192: }
! 2193: } else {
! 2194: message(failureMessage, false);
! 2195: }
! 2196: return retval;
! 2197: }
! 2198:
! 2199: boolean useStairs(short stairDirection) {
! 2200: boolean succeeded = false;
! 2201: //cellDisplayBuffer fromBuf[COLS][ROWS], toBuf[COLS][ROWS];
! 2202:
! 2203: if (stairDirection == 1) {
! 2204: if (rogue.depthLevel < DEEPEST_LEVEL) {
! 2205: //copyDisplayBuffer(fromBuf, displayBuffer);
! 2206: rogue.cursorLoc[0] = rogue.cursorLoc[1] = -1;
! 2207: rogue.depthLevel++;
! 2208: message("You descend.", false);
! 2209: startLevel(rogue.depthLevel - 1, stairDirection);
! 2210: if (rogue.depthLevel > rogue.deepestLevel) {
! 2211: rogue.deepestLevel = rogue.depthLevel;
! 2212: }
! 2213: //copyDisplayBuffer(toBuf, displayBuffer);
! 2214: //irisFadeBetweenBuffers(fromBuf, toBuf, mapToWindowX(player.xLoc), mapToWindowY(player.yLoc), 20, false);
! 2215: } else if (numberOfMatchingPackItems(AMULET, 0, 0, false)) {
! 2216: victory(true);
! 2217: } else {
! 2218: confirmMessages();
! 2219: messageWithColor("the crystal archway repels you with a mysterious force!", &lightBlue, false);
! 2220: messageWithColor("(Only the bearer of the Amulet of Yendor may pass.)", &backgroundMessageColor, false);
! 2221: }
! 2222: succeeded = true;
! 2223: } else {
! 2224: if (rogue.depthLevel > 1 || numberOfMatchingPackItems(AMULET, 0, 0, false)) {
! 2225: rogue.cursorLoc[0] = rogue.cursorLoc[1] = -1;
! 2226: rogue.depthLevel--;
! 2227: if (rogue.depthLevel == 0) {
! 2228: victory(false);
! 2229: } else {
! 2230: //copyDisplayBuffer(fromBuf, displayBuffer);
! 2231: message("You ascend.", false);
! 2232: startLevel(rogue.depthLevel + 1, stairDirection);
! 2233: //copyDisplayBuffer(toBuf, displayBuffer);
! 2234: //irisFadeBetweenBuffers(fromBuf, toBuf, mapToWindowX(player.xLoc), mapToWindowY(player.yLoc), 20, true);
! 2235: }
! 2236: succeeded = true;
! 2237: } else {
! 2238: confirmMessages();
! 2239: messageWithColor("The dungeon exit is magically sealed!", &lightBlue, false);
! 2240: messageWithColor("(Only the bearer of the Amulet of Yendor may pass.)", &backgroundMessageColor, false);
! 2241: }
! 2242: }
! 2243:
! 2244: if (succeeded) {
! 2245: updatePlayerUnderwaterness();
! 2246: }
! 2247:
! 2248: return succeeded;
! 2249: }
! 2250:
! 2251: void storeMemories(const short x, const short y) {
! 2252: pmap[x][y].rememberedTerrainFlags = terrainFlags(x, y);
! 2253: pmap[x][y].rememberedTMFlags = terrainMechFlags(x, y);
! 2254: pmap[x][y].rememberedCellFlags = pmap[x][y].flags;
! 2255: pmap[x][y].rememberedTerrain = pmap[x][y].layers[highestPriorityLayer(x, y, false)];
! 2256: }
! 2257:
! 2258: void updateFieldOfViewDisplay(boolean updateDancingTerrain, boolean refreshDisplay) {
! 2259: short i, j;
! 2260: item *theItem;
! 2261: char buf[COLS*3], name[COLS*3];
! 2262:
! 2263: assureCosmeticRNG;
! 2264:
! 2265: for (i=0; i<DCOLS; i++) {
! 2266: for (j = DROWS-1; j >= 0; j--) {
! 2267: if (pmap[i][j].flags & IN_FIELD_OF_VIEW
! 2268: && (max(0, tmap[i][j].light[0])
! 2269: + max(0, tmap[i][j].light[1])
! 2270: + max(0, tmap[i][j].light[2]) > VISIBILITY_THRESHOLD)
! 2271: && !(pmap[i][j].flags & CLAIRVOYANT_DARKENED)) {
! 2272:
! 2273: pmap[i][j].flags |= VISIBLE;
! 2274: }
! 2275:
! 2276: if ((pmap[i][j].flags & VISIBLE) && !(pmap[i][j].flags & WAS_VISIBLE)) { // if the cell became visible this move
! 2277: if (!(pmap[i][j].flags & DISCOVERED) && rogue.automationActive) {
! 2278: if (pmap[i][j].flags & HAS_ITEM) {
! 2279: theItem = itemAtLoc(i, j);
! 2280: if (theItem && (theItem->category & KEY)) {
! 2281: itemName(theItem, name, false, true, NULL);
! 2282: sprintf(buf, "you see %s.", name);
! 2283: messageWithColor(buf, &itemMessageColor, false);
! 2284: }
! 2285: }
! 2286: if (!(pmap[i][j].flags & MAGIC_MAPPED)
! 2287: && cellHasTMFlag(i, j, TM_INTERRUPT_EXPLORATION_WHEN_SEEN)) {
! 2288:
! 2289: strcpy(name, tileCatalog[pmap[i][j].layers[layerWithTMFlag(i, j, TM_INTERRUPT_EXPLORATION_WHEN_SEEN)]].description);
! 2290: sprintf(buf, "you see %s.", name);
! 2291: messageWithColor(buf, &backgroundMessageColor, false);
! 2292: }
! 2293: }
! 2294: discoverCell(i, j);
! 2295: if (refreshDisplay) {
! 2296: refreshDungeonCell(i, j);
! 2297: }
! 2298: } else if (!(pmap[i][j].flags & VISIBLE) && (pmap[i][j].flags & WAS_VISIBLE)) { // if the cell ceased being visible this move
! 2299: storeMemories(i, j);
! 2300: if (refreshDisplay) {
! 2301: refreshDungeonCell(i, j);
! 2302: }
! 2303: } else if (!(pmap[i][j].flags & CLAIRVOYANT_VISIBLE) && (pmap[i][j].flags & WAS_CLAIRVOYANT_VISIBLE)) { // ceased being clairvoyantly visible
! 2304: storeMemories(i, j);
! 2305: if (refreshDisplay) {
! 2306: refreshDungeonCell(i, j);
! 2307: }
! 2308: } else if (!(pmap[i][j].flags & WAS_CLAIRVOYANT_VISIBLE) && (pmap[i][j].flags & CLAIRVOYANT_VISIBLE)) { // became clairvoyantly visible
! 2309: pmap[i][j].flags &= ~STABLE_MEMORY;
! 2310: if (refreshDisplay) {
! 2311: refreshDungeonCell(i, j);
! 2312: }
! 2313: } else if (!(pmap[i][j].flags & TELEPATHIC_VISIBLE) && (pmap[i][j].flags & WAS_TELEPATHIC_VISIBLE)) { // ceased being telepathically visible
! 2314: storeMemories(i, j);
! 2315: if (refreshDisplay) {
! 2316: refreshDungeonCell(i, j);
! 2317: }
! 2318: } else if (!(pmap[i][j].flags & WAS_TELEPATHIC_VISIBLE) && (pmap[i][j].flags & TELEPATHIC_VISIBLE)) { // became telepathically visible
! 2319: if (!(pmap[i][j].flags & DISCOVERED)
! 2320: && !cellHasTerrainFlag(i, j, T_PATHING_BLOCKER)) {
! 2321: rogue.xpxpThisTurn++;
! 2322: }
! 2323:
! 2324: pmap[i][j].flags &= ~STABLE_MEMORY;
! 2325: if (refreshDisplay) {
! 2326: refreshDungeonCell(i, j);
! 2327: }
! 2328: } else if (playerCanSeeOrSense(i, j)
! 2329: && (tmap[i][j].light[0] != tmap[i][j].oldLight[0] ||
! 2330: tmap[i][j].light[1] != tmap[i][j].oldLight[1] ||
! 2331: tmap[i][j].light[2] != tmap[i][j].oldLight[2])) { // if the cell's light color changed this move
! 2332:
! 2333: if (refreshDisplay) {
! 2334: refreshDungeonCell(i, j);
! 2335: }
! 2336: } else if (updateDancingTerrain
! 2337: && playerCanSee(i, j)
! 2338: && (!rogue.automationActive || !(rogue.playerTurnNumber % 5))
! 2339: && ((tileCatalog[pmap[i][j].layers[DUNGEON]].backColor) && tileCatalog[pmap[i][j].layers[DUNGEON]].backColor->colorDances
! 2340: || (tileCatalog[pmap[i][j].layers[DUNGEON]].foreColor) && tileCatalog[pmap[i][j].layers[DUNGEON]].foreColor->colorDances
! 2341: || (tileCatalog[pmap[i][j].layers[LIQUID]].backColor) && tileCatalog[pmap[i][j].layers[LIQUID]].backColor->colorDances
! 2342: || (tileCatalog[pmap[i][j].layers[LIQUID]].foreColor) && tileCatalog[pmap[i][j].layers[LIQUID]].foreColor->colorDances
! 2343: || (tileCatalog[pmap[i][j].layers[SURFACE]].backColor) && tileCatalog[pmap[i][j].layers[SURFACE]].backColor->colorDances
! 2344: || (tileCatalog[pmap[i][j].layers[SURFACE]].foreColor) && tileCatalog[pmap[i][j].layers[SURFACE]].foreColor->colorDances
! 2345: || (tileCatalog[pmap[i][j].layers[GAS]].backColor) && tileCatalog[pmap[i][j].layers[GAS]].backColor->colorDances
! 2346: || (tileCatalog[pmap[i][j].layers[GAS]].foreColor) && tileCatalog[pmap[i][j].layers[GAS]].foreColor->colorDances
! 2347: || player.status[STATUS_HALLUCINATING])) {
! 2348:
! 2349: pmap[i][j].flags &= ~STABLE_MEMORY;
! 2350: if (refreshDisplay) {
! 2351: refreshDungeonCell(i, j);
! 2352: }
! 2353: }
! 2354: }
! 2355: }
! 2356: restoreRNG;
! 2357: }
! 2358:
! 2359: // Octants: //
! 2360: // \7|8/ //
! 2361: // 6\|/1 //
! 2362: // --@-- //
! 2363: // 5/|\2 //
! 2364: // /4|3\ //
! 2365:
! 2366: void betweenOctant1andN(short *x, short *y, short x0, short y0, short n) {
! 2367: short x1 = *x, y1 = *y;
! 2368: short dx = x1 - x0, dy = y1 - y0;
! 2369: switch (n) {
! 2370: case 1:
! 2371: return;
! 2372: case 2:
! 2373: *y = y0 - dy;
! 2374: return;
! 2375: case 5:
! 2376: *x = x0 - dx;
! 2377: *y = y0 - dy;
! 2378: return;
! 2379: case 6:
! 2380: *x = x0 - dx;
! 2381: return;
! 2382: case 8:
! 2383: *x = x0 - dy;
! 2384: *y = y0 - dx;
! 2385: return;
! 2386: case 3:
! 2387: *x = x0 - dy;
! 2388: *y = y0 + dx;
! 2389: return;
! 2390: case 7:
! 2391: *x = x0 + dy;
! 2392: *y = y0 - dx;
! 2393: return;
! 2394: case 4:
! 2395: *x = x0 + dy;
! 2396: *y = y0 + dx;
! 2397: return;
! 2398: }
! 2399: }
! 2400:
! 2401: // Returns a boolean grid indicating whether each square is in the field of view of (xLoc, yLoc).
! 2402: // forbiddenTerrain is the set of terrain flags that will block vision (but the blocking cell itself is
! 2403: // illuminated); forbiddenFlags is the set of map flags that will block vision.
! 2404: // If cautiousOnWalls is set, we will not illuminate blocking tiles unless the tile one space closer to the origin
! 2405: // is visible to the player; this is to prevent lights from illuminating a wall when the player is on the other
! 2406: // side of the wall.
! 2407: void getFOVMask(char grid[DCOLS][DROWS], short xLoc, short yLoc, fixpt maxRadius,
! 2408: unsigned long forbiddenTerrain, unsigned long forbiddenFlags, boolean cautiousOnWalls) {
! 2409: short i;
! 2410:
! 2411: for (i=1; i<=8; i++) {
! 2412: scanOctantFOV(grid, xLoc, yLoc, i, maxRadius, 1, LOS_SLOPE_GRANULARITY * -1, 0,
! 2413: forbiddenTerrain, forbiddenFlags, cautiousOnWalls);
! 2414: }
! 2415: }
! 2416:
! 2417: // This is a custom implementation of recursive shadowcasting.
! 2418: void scanOctantFOV(char grid[DCOLS][DROWS], short xLoc, short yLoc, short octant, fixpt maxRadius,
! 2419: short columnsRightFromOrigin, long startSlope, long endSlope, unsigned long forbiddenTerrain,
! 2420: unsigned long forbiddenFlags, boolean cautiousOnWalls) {
! 2421:
! 2422: if (columnsRightFromOrigin * FP_FACTOR >= maxRadius) return;
! 2423:
! 2424: short i, a, b, iStart, iEnd, x, y, x2, y2; // x and y are temporary variables on which we do the octant transform
! 2425: long newStartSlope, newEndSlope;
! 2426: boolean cellObstructed;
! 2427:
! 2428: newStartSlope = startSlope;
! 2429:
! 2430: a = ((LOS_SLOPE_GRANULARITY / -2 + 1) + startSlope * columnsRightFromOrigin) / LOS_SLOPE_GRANULARITY;
! 2431: b = ((LOS_SLOPE_GRANULARITY / -2 + 1) + endSlope * columnsRightFromOrigin) / LOS_SLOPE_GRANULARITY;
! 2432:
! 2433: iStart = min(a, b);
! 2434: iEnd = max(a, b);
! 2435:
! 2436: // restrict vision to a circle of radius maxRadius
! 2437: if ((columnsRightFromOrigin*columnsRightFromOrigin + iEnd*iEnd) >= maxRadius*maxRadius / FP_FACTOR / FP_FACTOR) {
! 2438: return;
! 2439: }
! 2440: if ((columnsRightFromOrigin*columnsRightFromOrigin + iStart*iStart) >= maxRadius*maxRadius / FP_FACTOR / FP_FACTOR) {
! 2441: iStart = (int) (-1 * fp_sqrt((maxRadius*maxRadius / FP_FACTOR) - (columnsRightFromOrigin*columnsRightFromOrigin * FP_FACTOR)) / FP_FACTOR);
! 2442: }
! 2443:
! 2444: x = xLoc + columnsRightFromOrigin;
! 2445: y = yLoc + iStart;
! 2446: betweenOctant1andN(&x, &y, xLoc, yLoc, octant);
! 2447: boolean currentlyLit = coordinatesAreInMap(x, y) && !(cellHasTerrainFlag(x, y, forbiddenTerrain) ||
! 2448: (pmap[x][y].flags & forbiddenFlags));
! 2449: for (i = iStart; i <= iEnd; i++) {
! 2450: x = xLoc + columnsRightFromOrigin;
! 2451: y = yLoc + i;
! 2452: betweenOctant1andN(&x, &y, xLoc, yLoc, octant);
! 2453: if (!coordinatesAreInMap(x, y)) {
! 2454: // We're off the map -- here there be memory corruption.
! 2455: continue;
! 2456: }
! 2457: cellObstructed = (cellHasTerrainFlag(x, y, forbiddenTerrain) || (pmap[x][y].flags & forbiddenFlags));
! 2458: // if we're cautious on walls and this is a wall:
! 2459: if (cautiousOnWalls && cellObstructed) {
! 2460: // (x2, y2) is the tile one space closer to the origin from the tile we're on:
! 2461: x2 = xLoc + columnsRightFromOrigin - 1;
! 2462: y2 = yLoc + i;
! 2463: if (i < 0) {
! 2464: y2++;
! 2465: } else if (i > 0) {
! 2466: y2--;
! 2467: }
! 2468: betweenOctant1andN(&x2, &y2, xLoc, yLoc, octant);
! 2469:
! 2470: if (pmap[x2][y2].flags & IN_FIELD_OF_VIEW) {
! 2471: // previous tile is visible, so illuminate
! 2472: grid[x][y] = 1;
! 2473: }
! 2474: } else {
! 2475: // illuminate
! 2476: grid[x][y] = 1;
! 2477: }
! 2478: if (!cellObstructed && !currentlyLit) { // next column slope starts here
! 2479: newStartSlope = (long int) ((LOS_SLOPE_GRANULARITY * (i) - LOS_SLOPE_GRANULARITY / 2) / (columnsRightFromOrigin * 2 + 1) * 2);
! 2480: currentlyLit = true;
! 2481: } else if (cellObstructed && currentlyLit) { // next column slope ends here
! 2482: newEndSlope = (long int) ((LOS_SLOPE_GRANULARITY * (i) - LOS_SLOPE_GRANULARITY / 2)
! 2483: / (columnsRightFromOrigin * 2 - 1) * 2);
! 2484: if (newStartSlope <= newEndSlope) {
! 2485: // run next column
! 2486: scanOctantFOV(grid, xLoc, yLoc, octant, maxRadius, columnsRightFromOrigin + 1, newStartSlope, newEndSlope,
! 2487: forbiddenTerrain, forbiddenFlags, cautiousOnWalls);
! 2488: }
! 2489: currentlyLit = false;
! 2490: }
! 2491: }
! 2492: if (currentlyLit) { // got to the bottom of the scan while lit
! 2493: newEndSlope = endSlope;
! 2494: if (newStartSlope <= newEndSlope) {
! 2495: // run next column
! 2496: scanOctantFOV(grid, xLoc, yLoc, octant, maxRadius, columnsRightFromOrigin + 1, newStartSlope, newEndSlope,
! 2497: forbiddenTerrain, forbiddenFlags, cautiousOnWalls);
! 2498: }
! 2499: }
! 2500: }
! 2501:
! 2502: void addScentToCell(short x, short y, short distance) {
! 2503: unsigned short value;
! 2504: if (!cellHasTerrainFlag(x, y, T_OBSTRUCTS_SCENT) || !cellHasTerrainFlag(x, y, T_OBSTRUCTS_PASSABILITY)) {
! 2505: value = rogue.scentTurnNumber - distance;
! 2506: scentMap[x][y] = max(value, (unsigned short) scentMap[x][y]);
! 2507: }
! 2508: }
CVSweb
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to Movement.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [contributed] / brogue-ce / src / brogue