Annotation of brogue-ce/src/brogue/Monsters.c, Revision 1.1
1.1 ! rubenllo 1: /*
! 2: * Monsters.c
! 3: * Brogue
! 4: *
! 5: * Created by Brian Walker on 1/13/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 mutateMonster(creature *monst, short mutationIndex) {
! 28: monst->mutationIndex = mutationIndex;
! 29: const mutation *theMut = &(mutationCatalog[mutationIndex]);
! 30: monst->info.flags |= theMut->monsterFlags;
! 31: monst->info.abilityFlags |= theMut->monsterAbilityFlags;
! 32: monst->info.maxHP = monst->info.maxHP * theMut->healthFactor / 100;
! 33: monst->info.movementSpeed = monst->info.movementSpeed * theMut->moveSpeedFactor / 100;
! 34: monst->info.attackSpeed = monst->info.attackSpeed * theMut->attackSpeedFactor / 100;
! 35: monst->info.defense = monst->info.defense * theMut->defenseFactor / 100;
! 36: if (monst->info.damage.lowerBound > 0) {
! 37: monst->info.damage.lowerBound = monst->info.damage.lowerBound * theMut->damageFactor / 100;
! 38: monst->info.damage.lowerBound = max(monst->info.damage.lowerBound, 1);
! 39: }
! 40: if (monst->info.damage.upperBound > 0) {
! 41: monst->info.damage.upperBound = monst->info.damage.upperBound * theMut->damageFactor / 100;
! 42: monst->info.damage.upperBound = max(monst->info.damage.upperBound, (monst->info.abilityFlags & MA_POISONS) ? 2 : 1);
! 43: }
! 44: if (theMut->DFChance >= 0) {
! 45: monst->info.DFChance = theMut->DFChance;
! 46: }
! 47: if (theMut->DFType > 0) {
! 48: monst->info.DFType = theMut->DFType;
! 49: }
! 50: }
! 51:
! 52: // Allocates space, generates a creature of the given type,
! 53: // prepends it to the list of creatures, and returns a pointer to that creature. Note that the creature
! 54: // is not given a map location here!
! 55: creature *generateMonster(short monsterID, boolean itemPossible, boolean mutationPossible) {
! 56: short itemChance, mutationChance, i, mutationAttempt;
! 57: creature *monst;
! 58:
! 59: // 1.17^x * 10, with x from 1 to 13:
! 60: const int POW_DEEP_MUTATION[] = {11, 13, 16, 18, 21, 25, 30, 35, 41, 48, 56, 65, 76};
! 61:
! 62: monst = (creature *) malloc(sizeof(creature));
! 63: memset(monst, '\0', sizeof(creature));
! 64: clearStatus(monst);
! 65: monst->info = monsterCatalog[monsterID];
! 66:
! 67: monst->mutationIndex = -1;
! 68: if (mutationPossible
! 69: && !(monst->info.flags & MONST_NEVER_MUTATED)
! 70: && !(monst->info.abilityFlags & MA_NEVER_MUTATED)
! 71: && rogue.depthLevel > 10) {
! 72:
! 73:
! 74: if (rogue.depthLevel <= AMULET_LEVEL) {
! 75: mutationChance = clamp(rogue.depthLevel - 10, 1, 10);
! 76: } else {
! 77: mutationChance = POW_DEEP_MUTATION[min(rogue.depthLevel - AMULET_LEVEL, 12)];
! 78: mutationChance = min(mutationChance, 75);
! 79: }
! 80:
! 81: if (rand_percent(mutationChance)) {
! 82: mutationAttempt = rand_range(0, NUMBER_MUTATORS - 1);
! 83: if (!(monst->info.flags & mutationCatalog[mutationAttempt].forbiddenFlags)
! 84: && !(monst->info.abilityFlags & mutationCatalog[mutationAttempt].forbiddenAbilityFlags)) {
! 85:
! 86: mutateMonster(monst, mutationAttempt);
! 87: }
! 88: }
! 89: }
! 90:
! 91: monst->nextCreature = monsters->nextCreature;
! 92: monsters->nextCreature = monst;
! 93: monst->xLoc = monst->yLoc = 0;
! 94: monst->depth = rogue.depthLevel;
! 95: monst->bookkeepingFlags = 0;
! 96: monst->mapToMe = NULL;
! 97: monst->safetyMap = NULL;
! 98: monst->leader = NULL;
! 99: monst->carriedMonster = NULL;
! 100: monst->creatureState = (((monst->info.flags & MONST_NEVER_SLEEPS) || rand_percent(25))
! 101: ? MONSTER_TRACKING_SCENT : MONSTER_SLEEPING);
! 102: monst->creatureMode = MODE_NORMAL;
! 103: monst->currentHP = monst->info.maxHP;
! 104: monst->spawnDepth = rogue.depthLevel;
! 105: monst->ticksUntilTurn = monst->info.movementSpeed;
! 106: monst->info.turnsBetweenRegen *= 1000; // tracked as thousandths to prevent rounding errors
! 107: monst->turnsUntilRegen = monst->info.turnsBetweenRegen;
! 108: monst->regenPerTurn = 0;
! 109: monst->movementSpeed = monst->info.movementSpeed;
! 110: monst->attackSpeed = monst->info.attackSpeed;
! 111: monst->turnsSpentStationary = 0;
! 112: monst->xpxp = 0;
! 113: monst->machineHome = 0;
! 114: monst->newPowerCount = monst->totalPowerCount = 0;
! 115: monst->targetCorpseLoc[0] = monst->targetCorpseLoc[1] = 0;
! 116: monst->lastSeenPlayerAt[0] = monst->lastSeenPlayerAt[1] = -1;
! 117: monst->targetWaypointIndex = -1;
! 118: for (i=0; i < MAX_WAYPOINT_COUNT; i++) {
! 119: monst->waypointAlreadyVisited[i] = rand_range(0, 1);
! 120: }
! 121:
! 122: if (monst->info.flags & MONST_FIERY) {
! 123: monst->status[STATUS_BURNING] = monst->maxStatus[STATUS_BURNING] = 1000; // won't decrease
! 124: }
! 125: if (monst->info.flags & MONST_FLIES) {
! 126: monst->status[STATUS_LEVITATING] = monst->maxStatus[STATUS_LEVITATING] = 1000; // won't decrease
! 127: }
! 128: if (monst->info.flags & MONST_IMMUNE_TO_FIRE) {
! 129: monst->status[STATUS_IMMUNE_TO_FIRE] = monst->maxStatus[STATUS_IMMUNE_TO_FIRE] = 1000; // won't decrease
! 130: }
! 131: if (monst->info.flags & MONST_INVISIBLE) {
! 132: monst->status[STATUS_INVISIBLE] = monst->maxStatus[STATUS_INVISIBLE] = 1000; // won't decrease
! 133: }
! 134: monst->status[STATUS_NUTRITION] = monst->maxStatus[STATUS_NUTRITION] = 1000;
! 135:
! 136: if (monst->info.flags & MONST_CARRY_ITEM_100) {
! 137: itemChance = 100;
! 138: } else if (monst->info.flags & MONST_CARRY_ITEM_25) {
! 139: itemChance = 25;
! 140: } else {
! 141: itemChance = 0;
! 142: }
! 143:
! 144: if (ITEMS_ENABLED
! 145: && itemPossible
! 146: && (rogue.depthLevel <= AMULET_LEVEL)
! 147: && monsterItemsHopper->nextItem
! 148: && rand_percent(itemChance)) {
! 149:
! 150: monst->carriedItem = monsterItemsHopper->nextItem;
! 151: monsterItemsHopper->nextItem = monsterItemsHopper->nextItem->nextItem;
! 152: monst->carriedItem->nextItem = NULL;
! 153: monst->carriedItem->originDepth = rogue.depthLevel;
! 154: } else {
! 155: monst->carriedItem = NULL;
! 156: }
! 157:
! 158: initializeGender(monst);
! 159:
! 160: if (!(monst->info.flags & MONST_INANIMATE) && !monst->status[STATUS_LIFESPAN_REMAINING]) {
! 161: monst->bookkeepingFlags |= MB_HAS_SOUL;
! 162: }
! 163:
! 164: return monst;
! 165: }
! 166:
! 167: boolean monsterRevealed(creature *monst) {
! 168: if (monst == &player) {
! 169: return false;
! 170: } else if (monst->bookkeepingFlags & MB_TELEPATHICALLY_REVEALED) {
! 171: return true;
! 172: } else if (monst->status[STATUS_ENTRANCED]) {
! 173: return true;
! 174: } else if (player.status[STATUS_TELEPATHIC] && !(monst->info.flags & MONST_INANIMATE)) {
! 175: return true;
! 176: }
! 177: return false;
! 178: }
! 179:
! 180: boolean monsterHiddenBySubmersion(const creature *monst, const creature *observer) {
! 181: if (monst->bookkeepingFlags & MB_SUBMERGED) {
! 182: if (observer
! 183: && (terrainFlags(observer->xLoc, observer->yLoc) & T_IS_DEEP_WATER)
! 184: && !observer->status[STATUS_LEVITATING]) {
! 185: // observer is in deep water, so target is not hidden by water
! 186: return false;
! 187: } else {
! 188: // submerged and the observer is not in deep water.
! 189: return true;
! 190: }
! 191: }
! 192: return false;
! 193: }
! 194:
! 195: boolean monsterIsHidden(const creature *monst, const creature *observer) {
! 196: if (monst->bookkeepingFlags & MB_IS_DORMANT) {
! 197: return true;
! 198: }
! 199: if (observer && monstersAreTeammates(monst, observer)) {
! 200: // Teammates can always see each other.
! 201: return false;
! 202: }
! 203: if ((monst->status[STATUS_INVISIBLE] && !pmap[monst->xLoc][monst->yLoc].layers[GAS])) {
! 204: // invisible and not in gas
! 205: return true;
! 206: }
! 207: if (monsterHiddenBySubmersion(monst, observer)) {
! 208: return true;
! 209: }
! 210: return false;
! 211: }
! 212:
! 213: boolean canSeeMonster(creature *monst) {
! 214: if (monst == &player) {
! 215: return true;
! 216: }
! 217: if (!monsterIsHidden(monst, &player)
! 218: && (playerCanSee(monst->xLoc, monst->yLoc) || monsterRevealed(monst))) {
! 219: return true;
! 220: }
! 221: return false;
! 222: }
! 223:
! 224: // This is different from canSeeMonster() in that it counts only physical sight -- not clairvoyance or telepathy.
! 225: boolean canDirectlySeeMonster(creature *monst) {
! 226: if (monst == &player) {
! 227: return true;
! 228: }
! 229: if (playerCanDirectlySee(monst->xLoc, monst->yLoc) && !monsterIsHidden(monst, &player)) {
! 230: return true;
! 231: }
! 232: return false;
! 233: }
! 234:
! 235: void monsterName(char *buf, creature *monst, boolean includeArticle) {
! 236: short oldRNG;
! 237:
! 238: if (monst == &player) {
! 239: strcpy(buf, "you");
! 240: return;
! 241: }
! 242: if (canSeeMonster(monst) || rogue.playbackOmniscience) {
! 243: if (player.status[STATUS_HALLUCINATING] && !rogue.playbackOmniscience) {
! 244:
! 245: oldRNG = rogue.RNG;
! 246: rogue.RNG = RNG_COSMETIC;
! 247: //assureCosmeticRNG;
! 248: sprintf(buf, "%s%s", (includeArticle ? "the " : ""),
! 249: monsterCatalog[rand_range(1, NUMBER_MONSTER_KINDS - 1)].monsterName);
! 250: restoreRNG;
! 251:
! 252: return;
! 253: }
! 254: sprintf(buf, "%s%s", (includeArticle ? (monst->creatureState == MONSTER_ALLY ? "your " : "the ") : ""),
! 255: monst->info.monsterName);
! 256: //monsterText[monst->info.monsterID].name);
! 257: return;
! 258: } else {
! 259: strcpy(buf, "something");
! 260: return;
! 261: }
! 262: }
! 263:
! 264: boolean monsterIsInClass(const creature *monst, const short monsterClass) {
! 265: short i;
! 266: for (i = 0; monsterClassCatalog[monsterClass].memberList[i] != 0; i++) {
! 267: if (monsterClassCatalog[monsterClass].memberList[i] == monst->info.monsterID) {
! 268: return true;
! 269: }
! 270: }
! 271: return false;
! 272: }
! 273:
! 274: // Don't attack a revenant if you're not magical.
! 275: // Don't attack a monster embedded in obstruction crystal.
! 276: // Etc.
! 277: boolean attackWouldBeFutile(const creature *attacker, const creature *defender) {
! 278: if (cellHasTerrainFlag(defender->xLoc, defender->yLoc, T_OBSTRUCTS_PASSABILITY)
! 279: && !(defender->info.flags & MONST_ATTACKABLE_THRU_WALLS)) {
! 280: return true;
! 281: }
! 282: if (attacker == &player) {
! 283: // Let the player do what she wants, if it's possible.
! 284: return false;
! 285: }
! 286: if ((attacker->info.flags & MONST_RESTRICTED_TO_LIQUID)
! 287: && !(attacker->status[STATUS_LEVITATING])
! 288: && defender->status[STATUS_LEVITATING]) {
! 289: return true;
! 290: }
! 291: if (defender->info.flags & MONST_INVULNERABLE) {
! 292: return true;
! 293: }
! 294: if (defender->info.flags & MONST_IMMUNE_TO_WEAPONS
! 295: && !(attacker->info.abilityFlags & MA_POISONS)) {
! 296: return true;
! 297: }
! 298: return false;
! 299: }
! 300:
! 301: // This is a specific kind of willingness, bordering on ability.
! 302: // Intuition: if it swung an axe from that position, should it
! 303: // hit the defender? Or silently pass through it, as it does for
! 304: // allies?
! 305: boolean monsterWillAttackTarget(const creature *attacker, const creature *defender) {
! 306: if (attacker == defender || (defender->bookkeepingFlags & MB_IS_DYING)) {
! 307: return false;
! 308: }
! 309: if (attacker == &player
! 310: && defender->creatureState == MONSTER_ALLY) {
! 311:
! 312: return false;
! 313: }
! 314: if (attacker->status[STATUS_ENTRANCED]
! 315: && defender->creatureState != MONSTER_ALLY) {
! 316:
! 317: return true;
! 318: }
! 319: if (attacker->creatureState == MONSTER_ALLY
! 320: && attacker != &player
! 321: && defender->status[STATUS_ENTRANCED]) {
! 322:
! 323: return false;
! 324: }
! 325: if (defender->bookkeepingFlags & MB_CAPTIVE) {
! 326: return false;
! 327: }
! 328: if (attacker->status[STATUS_DISCORDANT]
! 329: || defender->status[STATUS_DISCORDANT]
! 330: || attacker->status[STATUS_CONFUSED]) {
! 331:
! 332: return true;
! 333: }
! 334: if (monstersAreEnemies(attacker, defender)
! 335: && !monstersAreTeammates(attacker, defender)) {
! 336: return true;
! 337: }
! 338: return false;
! 339: }
! 340:
! 341: boolean monstersAreTeammates(const creature *monst1, const creature *monst2) {
! 342: // if one follows the other, or the other follows the one, or they both follow the same
! 343: return ((((monst1->bookkeepingFlags & MB_FOLLOWER) && monst1->leader == monst2)
! 344: || ((monst2->bookkeepingFlags & MB_FOLLOWER) && monst2->leader == monst1)
! 345: || (monst1->creatureState == MONSTER_ALLY && monst2 == &player)
! 346: || (monst1 == &player && monst2->creatureState == MONSTER_ALLY)
! 347: || (monst1->creatureState == MONSTER_ALLY && monst2->creatureState == MONSTER_ALLY)
! 348: || ((monst1->bookkeepingFlags & MB_FOLLOWER) && (monst2->bookkeepingFlags & MB_FOLLOWER)
! 349: && monst1->leader == monst2->leader)) ? true : false);
! 350: }
! 351:
! 352: boolean monstersAreEnemies(const creature *monst1, const creature *monst2) {
! 353: if ((monst1->bookkeepingFlags | monst2->bookkeepingFlags) & MB_CAPTIVE) {
! 354: return false;
! 355: }
! 356: if (monst1 == monst2) {
! 357: return false; // Can't be enemies with yourself, even if discordant.
! 358: }
! 359: if (monst1->status[STATUS_DISCORDANT] || monst2->status[STATUS_DISCORDANT]) {
! 360: return true;
! 361: }
! 362: // eels and krakens attack anything in deep water
! 363: if (((monst1->info.flags & MONST_RESTRICTED_TO_LIQUID)
! 364: && !(monst2->info.flags & MONST_IMMUNE_TO_WATER)
! 365: && !(monst2->status[STATUS_LEVITATING])
! 366: && cellHasTerrainFlag(monst2->xLoc, monst2->yLoc, T_IS_DEEP_WATER))
! 367:
! 368: || ((monst2->info.flags & MONST_RESTRICTED_TO_LIQUID)
! 369: && !(monst1->info.flags & MONST_IMMUNE_TO_WATER)
! 370: && !(monst1->status[STATUS_LEVITATING])
! 371: && cellHasTerrainFlag(monst1->xLoc, monst1->yLoc, T_IS_DEEP_WATER))) {
! 372:
! 373: return true;
! 374: }
! 375: return ((monst1->creatureState == MONSTER_ALLY || monst1 == &player)
! 376: != (monst2->creatureState == MONSTER_ALLY || monst2 == &player));
! 377: }
! 378:
! 379:
! 380: void initializeGender(creature *monst) {
! 381: if ((monst->info.flags & MONST_MALE) && (monst->info.flags & MONST_FEMALE)) {
! 382: monst->info.flags &= ~(rand_percent(50) ? MONST_MALE : MONST_FEMALE);
! 383: }
! 384: }
! 385:
! 386: // Returns true if either string has a null terminator before they otherwise disagree.
! 387: boolean stringsMatch(const char *str1, const char *str2) {
! 388: short i;
! 389:
! 390: for (i=0; str1[i] && str2[i]; i++) {
! 391: if (str1[i] != str2[i]) {
! 392: return false;
! 393: }
! 394: }
! 395: return true;
! 396: }
! 397:
! 398: // Genders:
! 399: // 0 = [character escape sequence]
! 400: // 1 = you
! 401: // 2 = male
! 402: // 3 = female
! 403: // 4 = neuter
! 404: void resolvePronounEscapes(char *text, creature *monst) {
! 405: short pronounType, gender, i;
! 406: char *insert, *scan;
! 407: boolean capitalize;
! 408: // Note: Escape sequences MUST be longer than EACH of the possible replacements.
! 409: // That way, the string only contracts, and we don't need a buffer.
! 410: const char pronouns[4][5][20] = {
! 411: {"$HESHE", "you", "he", "she", "it"},
! 412: {"$HIMHER", "you", "him", "her", "it"},
! 413: {"$HISHER", "your", "his", "her", "its"},
! 414: {"$HIMSELFHERSELF", "yourself", "himself", "herself", "itself"}};
! 415:
! 416: if (monst == &player) {
! 417: gender = 1;
! 418: } else if (!canSeeMonster(monst) && !rogue.playbackOmniscience) {
! 419: gender = 4;
! 420: } else if (monst->info.flags & MONST_MALE) {
! 421: gender = 2;
! 422: } else if (monst->info.flags & MONST_FEMALE) {
! 423: gender = 3;
! 424: } else {
! 425: gender = 4;
! 426: }
! 427:
! 428: capitalize = false;
! 429:
! 430: for (insert = scan = text; *scan;) {
! 431: if (scan[0] == '$') {
! 432: for (pronounType=0; pronounType<4; pronounType++) {
! 433: if (stringsMatch(pronouns[pronounType][0], scan)) {
! 434: strcpy(insert, pronouns[pronounType][gender]);
! 435: if (capitalize) {
! 436: upperCase(insert);
! 437: capitalize = false;
! 438: }
! 439: scan += strlen(pronouns[pronounType][0]);
! 440: insert += strlen(pronouns[pronounType][gender]);
! 441: break;
! 442: }
! 443: }
! 444: if (pronounType == 4) {
! 445: // Started with a '$' but didn't match an escape sequence; just copy the character and move on.
! 446: *(insert++) = *(scan++);
! 447: }
! 448: } else if (scan[0] == COLOR_ESCAPE) {
! 449: for (i=0; i<4; i++) {
! 450: *(insert++) = *(scan++);
! 451: }
! 452: } else { // Didn't match any of the escape sequences; copy the character instead.
! 453: if (*scan == '.') {
! 454: capitalize = true;
! 455: } else if (*scan != ' ') {
! 456: capitalize = false;
! 457: }
! 458:
! 459: *(insert++) = *(scan++);
! 460: }
! 461: }
! 462: *insert = '\0';
! 463: }
! 464:
! 465: /*
! 466: Returns a random horde, weighted by spawn frequency, which has all requiredFlags
! 467: and does not have any forbiddenFlags. If summonerType is 0, all hordes valid on
! 468: the given depth are considered. (Depth 0 means current depth.) Otherwise, all
! 469: hordes with summonerType as a leader are considered.
! 470: */
! 471: short pickHordeType(short depth, enum monsterTypes summonerType, unsigned long forbiddenFlags, unsigned long requiredFlags) {
! 472: short i, index, possCount = 0;
! 473:
! 474: if (depth <= 0) {
! 475: depth = rogue.depthLevel;
! 476: }
! 477:
! 478: for (i=0; i<NUMBER_HORDES; i++) {
! 479: if (!(hordeCatalog[i].flags & forbiddenFlags)
! 480: && !(~(hordeCatalog[i].flags) & requiredFlags)
! 481: && ((!summonerType && hordeCatalog[i].minLevel <= depth && hordeCatalog[i].maxLevel >= depth)
! 482: || (summonerType && (hordeCatalog[i].flags & HORDE_IS_SUMMONED) && hordeCatalog[i].leaderType == summonerType))) {
! 483: possCount += hordeCatalog[i].frequency;
! 484: }
! 485: }
! 486:
! 487: if (possCount == 0) {
! 488: return -1;
! 489: }
! 490:
! 491: index = rand_range(1, possCount);
! 492:
! 493: for (i=0; i<NUMBER_HORDES; i++) {
! 494: if (!(hordeCatalog[i].flags & forbiddenFlags)
! 495: && !(~(hordeCatalog[i].flags) & requiredFlags)
! 496: && ((!summonerType && hordeCatalog[i].minLevel <= depth && hordeCatalog[i].maxLevel >= depth)
! 497: || (summonerType && (hordeCatalog[i].flags & HORDE_IS_SUMMONED) && hordeCatalog[i].leaderType == summonerType))) {
! 498: if (index <= hordeCatalog[i].frequency) {
! 499: return i;
! 500: }
! 501: index -= hordeCatalog[i].frequency;
! 502: }
! 503: }
! 504: return 0; // should never happen
! 505: }
! 506:
! 507: void empowerMonster(creature *monst) {
! 508: char theMonsterName[100], buf[200];
! 509: monst->info.maxHP += 12;
! 510: monst->info.defense += 10;
! 511: monst->info.accuracy += 10;
! 512: monst->info.damage.lowerBound += max(1, monst->info.damage.lowerBound / 10);
! 513: monst->info.damage.upperBound += max(1, monst->info.damage.upperBound / 10);
! 514: monst->newPowerCount++;
! 515: monst->totalPowerCount++;
! 516: heal(monst, 100, true);
! 517:
! 518: if (canSeeMonster(monst)) {
! 519: monsterName(theMonsterName, monst, true);
! 520: sprintf(buf, "%s looks stronger", theMonsterName);
! 521: combatMessage(buf, &advancementMessageColor);
! 522: }
! 523: }
! 524:
! 525: // If placeClone is false, the clone won't get a location
! 526: // and won't set any HAS_MONSTER flags or cause any refreshes;
! 527: // it's just generated and inserted into the chains.
! 528: creature *cloneMonster(creature *monst, boolean announce, boolean placeClone) {
! 529: creature *newMonst, *nextMonst, *parentMonst;
! 530: char buf[DCOLS], monstName[DCOLS];
! 531: short jellyCount;
! 532:
! 533: newMonst = generateMonster(monst->info.monsterID, false, false);
! 534: nextMonst = newMonst->nextCreature;
! 535: *newMonst = *monst; // boink!
! 536: newMonst->nextCreature = nextMonst;
! 537:
! 538: if (monst->carriedMonster) {
! 539: parentMonst = cloneMonster(monst->carriedMonster, false, false); // Also clone the carriedMonster
! 540: removeMonsterFromChain(parentMonst, monsters);
! 541: removeMonsterFromChain(parentMonst, dormantMonsters);
! 542: } else {
! 543: parentMonst = NULL;
! 544: }
! 545:
! 546: initializeGender(newMonst);
! 547: newMonst->bookkeepingFlags &= ~(MB_LEADER | MB_CAPTIVE | MB_HAS_SOUL);
! 548: newMonst->bookkeepingFlags |= MB_FOLLOWER;
! 549: newMonst->mapToMe = NULL;
! 550: newMonst->safetyMap = NULL;
! 551: newMonst->carriedItem = NULL;
! 552: newMonst->carriedMonster = parentMonst;
! 553: newMonst->ticksUntilTurn = 101;
! 554: if (!(monst->creatureState == MONSTER_ALLY)) {
! 555: newMonst->bookkeepingFlags &= ~MB_TELEPATHICALLY_REVEALED;
! 556: }
! 557: if (monst->leader) {
! 558: newMonst->leader = monst->leader;
! 559: } else {
! 560: newMonst->leader = monst;
! 561: monst->bookkeepingFlags |= MB_LEADER;
! 562: }
! 563:
! 564: if (monst->bookkeepingFlags & MB_CAPTIVE) {
! 565: // If you clone a captive, the clone will be your ally.
! 566: becomeAllyWith(newMonst);
! 567: }
! 568:
! 569: if (placeClone) {
! 570: // getQualifyingLocNear(loc, monst->xLoc, monst->yLoc, true, 0, forbiddenFlagsForMonster(&(monst->info)), (HAS_PLAYER | HAS_MONSTER), false, false);
! 571: // newMonst->xLoc = loc[0];
! 572: // newMonst->yLoc = loc[1];
! 573: getQualifyingPathLocNear(&(newMonst->xLoc), &(newMonst->yLoc), monst->xLoc, monst->yLoc, true,
! 574: T_DIVIDES_LEVEL & avoidedFlagsForMonster(&(newMonst->info)), HAS_PLAYER,
! 575: avoidedFlagsForMonster(&(newMonst->info)), (HAS_PLAYER | HAS_MONSTER | HAS_STAIRS), false);
! 576: pmap[newMonst->xLoc][newMonst->yLoc].flags |= HAS_MONSTER;
! 577: refreshDungeonCell(newMonst->xLoc, newMonst->yLoc);
! 578: if (announce && canSeeMonster(newMonst)) {
! 579: monsterName(monstName, newMonst, false);
! 580: sprintf(buf, "another %s appears!", monstName);
! 581: message(buf, false);
! 582: }
! 583: }
! 584:
! 585: if (monst == &player) { // Player managed to clone himself.
! 586: newMonst->info.foreColor = &gray;
! 587: newMonst->info.damage.lowerBound = 1;
! 588: newMonst->info.damage.upperBound = 2;
! 589: newMonst->info.damage.clumpFactor = 1;
! 590: newMonst->info.defense = 0;
! 591: strcpy(newMonst->info.monsterName, "clone");
! 592: newMonst->creatureState = MONSTER_ALLY;
! 593: }
! 594:
! 595: if (monst->creatureState == MONSTER_ALLY
! 596: && (monst->info.abilityFlags & MA_CLONE_SELF_ON_DEFEND)
! 597: && !rogue.featRecord[FEAT_JELLYMANCER]) {
! 598:
! 599: jellyCount = 0;
! 600: for (nextMonst = monsters->nextCreature; nextMonst != NULL; nextMonst = nextMonst->nextCreature) {
! 601: if (nextMonst->creatureState == MONSTER_ALLY
! 602: && (nextMonst->info.abilityFlags & MA_CLONE_SELF_ON_DEFEND)) {
! 603:
! 604: jellyCount++;
! 605: }
! 606: }
! 607: if (jellyCount >= 90) {
! 608: rogue.featRecord[FEAT_JELLYMANCER] = true;
! 609: }
! 610: }
! 611: return newMonst;
! 612: }
! 613:
! 614: unsigned long forbiddenFlagsForMonster(creatureType *monsterType) {
! 615: unsigned long flags;
! 616:
! 617: flags = T_PATHING_BLOCKER;
! 618: if (monsterType->flags & MONST_INVULNERABLE) {
! 619: flags &= ~(T_LAVA_INSTA_DEATH | T_SPONTANEOUSLY_IGNITES | T_IS_FIRE);
! 620: }
! 621: if (monsterType->flags & (MONST_IMMUNE_TO_FIRE | MONST_FLIES)) {
! 622: flags &= ~T_LAVA_INSTA_DEATH;
! 623: }
! 624: if (monsterType->flags & MONST_IMMUNE_TO_FIRE) {
! 625: flags &= ~(T_SPONTANEOUSLY_IGNITES | T_IS_FIRE);
! 626: }
! 627: if (monsterType->flags & (MONST_IMMUNE_TO_WATER | MONST_FLIES)) {
! 628: flags &= ~T_IS_DEEP_WATER;
! 629: }
! 630: if (monsterType->flags & (MONST_FLIES)) {
! 631: flags &= ~(T_AUTO_DESCENT | T_IS_DF_TRAP);
! 632: }
! 633: return flags;
! 634: }
! 635:
! 636: unsigned long avoidedFlagsForMonster(creatureType *monsterType) {
! 637: unsigned long flags;
! 638:
! 639: flags = forbiddenFlagsForMonster(monsterType) | T_HARMFUL_TERRAIN | T_SACRED;
! 640:
! 641: if (monsterType->flags & MONST_INVULNERABLE) {
! 642: flags &= ~(T_HARMFUL_TERRAIN | T_IS_DF_TRAP);
! 643: }
! 644: if (monsterType->flags & MONST_INANIMATE) {
! 645: flags &= ~(T_CAUSES_POISON | T_CAUSES_DAMAGE | T_CAUSES_PARALYSIS | T_CAUSES_CONFUSION);
! 646: }
! 647: if (monsterType->flags & MONST_IMMUNE_TO_FIRE) {
! 648: flags &= ~T_IS_FIRE;
! 649: }
! 650: if (monsterType->flags & MONST_FLIES) {
! 651: flags &= ~T_CAUSES_POISON;
! 652: }
! 653: return flags;
! 654: }
! 655:
! 656: boolean monsterCanSubmergeNow(creature *monst) {
! 657: return ((monst->info.flags & MONST_SUBMERGES)
! 658: && cellHasTMFlag(monst->xLoc, monst->yLoc, TM_ALLOWS_SUBMERGING)
! 659: && !cellHasTerrainFlag(monst->xLoc, monst->yLoc, T_OBSTRUCTS_PASSABILITY)
! 660: && !(monst->bookkeepingFlags & (MB_SEIZING | MB_SEIZED | MB_CAPTIVE))
! 661: && ((monst->info.flags & (MONST_IMMUNE_TO_FIRE | MONST_INVULNERABLE))
! 662: || monst->status[STATUS_IMMUNE_TO_FIRE]
! 663: || !cellHasTerrainFlag(monst->xLoc, monst->yLoc, T_LAVA_INSTA_DEATH)));
! 664: }
! 665:
! 666: // Returns true if at least one minion spawned.
! 667: boolean spawnMinions(short hordeID, creature *leader, boolean summoned) {
! 668: short iSpecies, iMember, count;
! 669: unsigned long forbiddenTerrainFlags;
! 670: hordeType *theHorde;
! 671: creature *monst;
! 672: short x, y;
! 673: short failsafe;
! 674: boolean atLeastOneMinion = false;
! 675:
! 676: x = leader->xLoc;
! 677: y = leader->yLoc;
! 678:
! 679: theHorde = &hordeCatalog[hordeID];
! 680:
! 681: for (iSpecies = 0; iSpecies < theHorde->numberOfMemberTypes; iSpecies++) {
! 682: count = randClump(theHorde->memberCount[iSpecies]);
! 683:
! 684: forbiddenTerrainFlags = forbiddenFlagsForMonster(&(monsterCatalog[theHorde->memberType[iSpecies]]));
! 685: if (hordeCatalog[hordeID].spawnsIn) {
! 686: forbiddenTerrainFlags &= ~(tileCatalog[hordeCatalog[hordeID].spawnsIn].flags);
! 687: }
! 688:
! 689: for (iMember = 0; iMember < count; iMember++) {
! 690: monst = generateMonster(theHorde->memberType[iSpecies], true, !summoned);
! 691: failsafe = 0;
! 692: do {
! 693: getQualifyingPathLocNear(&(monst->xLoc), &(monst->yLoc), x, y, summoned,
! 694: T_DIVIDES_LEVEL & forbiddenTerrainFlags, (HAS_PLAYER | HAS_STAIRS),
! 695: forbiddenTerrainFlags, HAS_MONSTER, false);
! 696: } while (theHorde->spawnsIn && !cellHasTerrainType(monst->xLoc, monst->yLoc, theHorde->spawnsIn) && failsafe++ < 20);
! 697: if (failsafe >= 20) {
! 698: // abort
! 699: killCreature(monst, true);
! 700: break;
! 701: }
! 702: if (monsterCanSubmergeNow(monst)) {
! 703: monst->bookkeepingFlags |= MB_SUBMERGED;
! 704: }
! 705: brogueAssert(!(pmap[monst->xLoc][monst->yLoc].flags & HAS_MONSTER));
! 706: pmap[monst->xLoc][monst->yLoc].flags |= HAS_MONSTER;
! 707: monst->bookkeepingFlags |= (MB_FOLLOWER | MB_JUST_SUMMONED);
! 708: monst->leader = leader;
! 709: monst->creatureState = leader->creatureState;
! 710: monst->mapToMe = NULL;
! 711: if (theHorde->flags & HORDE_DIES_ON_LEADER_DEATH) {
! 712: monst->bookkeepingFlags |= MB_BOUND_TO_LEADER;
! 713: }
! 714: if (hordeCatalog[hordeID].flags & HORDE_ALLIED_WITH_PLAYER) {
! 715: becomeAllyWith(monst);
! 716: }
! 717: atLeastOneMinion = true;
! 718: }
! 719: }
! 720:
! 721: if (atLeastOneMinion && !(theHorde->flags & HORDE_DIES_ON_LEADER_DEATH)) {
! 722: leader->bookkeepingFlags |= MB_LEADER;
! 723: }
! 724:
! 725: return atLeastOneMinion;
! 726: }
! 727:
! 728: boolean drawManacle(short x, short y, enum directions dir) {
! 729: enum tileType manacles[8] = {MANACLE_T, MANACLE_B, MANACLE_L, MANACLE_R, MANACLE_TL, MANACLE_BL, MANACLE_TR, MANACLE_BR};
! 730: short newX = x + nbDirs[dir][0];
! 731: short newY = y + nbDirs[dir][1];
! 732: if (coordinatesAreInMap(newX, newY)
! 733: && pmap[newX][newY].layers[DUNGEON] == FLOOR
! 734: && pmap[newX][newY].layers[LIQUID] == NOTHING) {
! 735:
! 736: pmap[x + nbDirs[dir][0]][y + nbDirs[dir][1]].layers[SURFACE] = manacles[dir];
! 737: return true;
! 738: }
! 739: return false;
! 740: }
! 741:
! 742: void drawManacles(short x, short y) {
! 743: enum directions fallback[4][3] = {{UPLEFT, UP, LEFT}, {DOWNLEFT, DOWN, LEFT}, {UPRIGHT, UP, RIGHT}, {DOWNRIGHT, DOWN, RIGHT}};
! 744: short i, j;
! 745: for (i = 0; i < 4; i++) {
! 746: for (j = 0; j < 3 && !drawManacle(x, y, fallback[i][j]); j++);
! 747: }
! 748: }
! 749:
! 750: // If hordeID is 0, it's randomly assigned based on the depth, with a 10% chance of an out-of-depth spawn from 1-5 levels deeper.
! 751: // If x is negative, location is random.
! 752: // Returns a pointer to the leader.
! 753: creature *spawnHorde(short hordeID, short x, short y, unsigned long forbiddenFlags, unsigned long requiredFlags) {
! 754: short loc[2];
! 755: short i, failsafe, depth;
! 756: hordeType *theHorde;
! 757: creature *leader, *preexistingMonst;
! 758: boolean tryAgain;
! 759:
! 760: if (rogue.depthLevel > 1 && rand_percent(10)) {
! 761: depth = rogue.depthLevel + rand_range(1, min(5, rogue.depthLevel / 2));
! 762: if (depth > AMULET_LEVEL) {
! 763: depth = max(rogue.depthLevel, AMULET_LEVEL);
! 764: }
! 765: forbiddenFlags |= HORDE_NEVER_OOD;
! 766: } else {
! 767: depth = rogue.depthLevel;
! 768: }
! 769:
! 770: if (hordeID <= 0) {
! 771: failsafe = 50;
! 772: do {
! 773: tryAgain = false;
! 774: hordeID = pickHordeType(depth, 0, forbiddenFlags, requiredFlags);
! 775: if (hordeID < 0) {
! 776: return NULL;
! 777: }
! 778: if (x >= 0 && y >= 0) {
! 779: if (cellHasTerrainFlag(x, y, T_PATHING_BLOCKER)
! 780: && (!hordeCatalog[hordeID].spawnsIn || !cellHasTerrainType(x, y, hordeCatalog[hordeID].spawnsIn))) {
! 781:
! 782: // don't spawn a horde in special terrain unless it's meant to spawn there
! 783: tryAgain = true;
! 784: }
! 785: if (hordeCatalog[hordeID].spawnsIn && !cellHasTerrainType(x, y, hordeCatalog[hordeID].spawnsIn)) {
! 786: // don't spawn a horde on normal terrain if it's meant for special terrain
! 787: tryAgain = true;
! 788: }
! 789: }
! 790: } while (--failsafe && tryAgain);
! 791: }
! 792:
! 793: failsafe = 50;
! 794:
! 795: if (x < 0 || y < 0) {
! 796: i = 0;
! 797: do {
! 798: while (!randomMatchingLocation(&(loc[0]), &(loc[1]), FLOOR, NOTHING, (hordeCatalog[hordeID].spawnsIn ? hordeCatalog[hordeID].spawnsIn : -1))
! 799: || passableArcCount(loc[0], loc[1]) > 1) {
! 800: if (!--failsafe) {
! 801: return NULL;
! 802: }
! 803: hordeID = pickHordeType(depth, 0, forbiddenFlags, 0);
! 804:
! 805: if (hordeID < 0) {
! 806: return NULL;
! 807: }
! 808: }
! 809: x = loc[0];
! 810: y = loc[1];
! 811: i++;
! 812:
! 813: // This "while" condition should contain IN_FIELD_OF_VIEW, since that is specifically
! 814: // calculated from the entry stairs when the level is generated, and will prevent monsters
! 815: // from spawning within FOV of the entry stairs.
! 816: } while (i < 25 && (pmap[x][y].flags & (ANY_KIND_OF_VISIBLE | IN_FIELD_OF_VIEW)));
! 817: }
! 818:
! 819: // if (hordeCatalog[hordeID].spawnsIn == DEEP_WATER && pmap[x][y].layers[LIQUID] != DEEP_WATER) {
! 820: // message("Waterborne monsters spawned on land!", true);
! 821: // }
! 822:
! 823: theHorde = &hordeCatalog[hordeID];
! 824:
! 825: if (theHorde->machine > 0) {
! 826: // Build the accompanying machine (e.g. a goblin encampment)
! 827: buildAMachine(theHorde->machine, x, y, 0, NULL, NULL, NULL);
! 828: }
! 829:
! 830: leader = generateMonster(theHorde->leaderType, true, true);
! 831: leader->xLoc = x;
! 832: leader->yLoc = y;
! 833:
! 834: if (hordeCatalog[hordeID].flags & HORDE_LEADER_CAPTIVE) {
! 835: leader->bookkeepingFlags |= MB_CAPTIVE;
! 836: leader->creatureState = MONSTER_WANDERING;
! 837: if (leader->info.turnsBetweenRegen > 0) {
! 838: leader->currentHP = leader->info.maxHP / 4 + 1;
! 839: }
! 840:
! 841: // Draw the manacles unless the horde spawns in weird terrain (e.g. cages).
! 842: if (!hordeCatalog[hordeID].spawnsIn) {
! 843: drawManacles(x, y);
! 844: }
! 845: } else if (hordeCatalog[hordeID].flags & HORDE_ALLIED_WITH_PLAYER) {
! 846: becomeAllyWith(leader);
! 847: }
! 848:
! 849: if (hordeCatalog[hordeID].flags & HORDE_SACRIFICE_TARGET) {
! 850: leader->bookkeepingFlags |= MB_MARKED_FOR_SACRIFICE;
! 851: leader->info.intrinsicLightType = SACRIFICE_MARK_LIGHT;
! 852: }
! 853:
! 854: if (rogue.patchVersion >= 3 && (theHorde->flags & HORDE_MACHINE_THIEF)) {
! 855: leader->safetyMap = allocGrid(); // Keep thieves from fleeing before they see the player
! 856: fillGrid(leader->safetyMap, 0);
! 857: }
! 858:
! 859: preexistingMonst = monsterAtLoc(x, y);
! 860: if (preexistingMonst) {
! 861: killCreature(preexistingMonst, true); // If there's already a monster here, quietly bury the body.
! 862: }
! 863:
! 864: brogueAssert(!(pmap[x][y].flags & HAS_MONSTER));
! 865:
! 866: pmap[x][y].flags |= HAS_MONSTER;
! 867: if (playerCanSeeOrSense(x, y)) {
! 868: refreshDungeonCell(x, y);
! 869: }
! 870: if (monsterCanSubmergeNow(leader)) {
! 871: leader->bookkeepingFlags |= MB_SUBMERGED;
! 872: }
! 873:
! 874: spawnMinions(hordeID, leader, false);
! 875:
! 876: return leader;
! 877: }
! 878:
! 879: void fadeInMonster(creature *monst) {
! 880: color fColor, bColor;
! 881: enum displayGlyph displayChar;
! 882: getCellAppearance(monst->xLoc, monst->yLoc, &displayChar, &fColor, &bColor);
! 883: flashMonster(monst, &bColor, 100);
! 884: }
! 885:
! 886: boolean removeMonsterFromChain(creature *monst, creature *theChain) {
! 887: creature *previousMonster;
! 888:
! 889: for (previousMonster = theChain;
! 890: previousMonster->nextCreature;
! 891: previousMonster = previousMonster->nextCreature) {
! 892: if (previousMonster->nextCreature == monst) {
! 893: previousMonster->nextCreature = monst->nextCreature;
! 894: return true;
! 895: }
! 896: }
! 897: return false;
! 898: }
! 899:
! 900: boolean summonMinions(creature *summoner) {
! 901: enum monsterTypes summonerType = summoner->info.monsterID;
! 902: const short hordeID = pickHordeType(0, summonerType, 0, 0);
! 903: short seenMinionCount = 0, x, y;
! 904: boolean atLeastOneMinion = false;
! 905: creature *monst, *host;
! 906: char buf[DCOLS];
! 907: char monstName[DCOLS];
! 908: short **grid;
! 909:
! 910: if (hordeID < 0) {
! 911: return false;
! 912: }
! 913:
! 914: host = NULL;
! 915:
! 916: if (summoner->info.abilityFlags & MA_ENTER_SUMMONS) {
! 917: pmap[summoner->xLoc][summoner->yLoc].flags &= ~HAS_MONSTER;
! 918: removeMonsterFromChain(summoner, monsters);
! 919: }
! 920:
! 921: atLeastOneMinion = spawnMinions(hordeID, summoner, true);
! 922:
! 923: if (hordeCatalog[hordeID].flags & HORDE_SUMMONED_AT_DISTANCE) {
! 924: // Create a grid where "1" denotes a valid summoning location: within DCOLS/2 pathing distance,
! 925: // not in harmful terrain, and outside of the player's field of view.
! 926: grid = allocGrid();
! 927: fillGrid(grid, 0);
! 928: calculateDistances(grid, summoner->xLoc, summoner->yLoc, (T_PATHING_BLOCKER | T_SACRED), NULL, true, true);
! 929: findReplaceGrid(grid, 1, DCOLS/2, 1);
! 930: findReplaceGrid(grid, 2, 30000, 0);
! 931: getTerrainGrid(grid, 0, (T_PATHING_BLOCKER | T_HARMFUL_TERRAIN), (IN_FIELD_OF_VIEW | CLAIRVOYANT_VISIBLE | HAS_PLAYER | HAS_MONSTER));
! 932: } else {
! 933: grid = NULL;
! 934: }
! 935:
! 936: for (monst = monsters->nextCreature; monst != NULL; monst = monst->nextCreature) {
! 937: if (monst != summoner && monstersAreTeammates(monst, summoner)
! 938: && (monst->bookkeepingFlags & MB_JUST_SUMMONED)) {
! 939:
! 940: if (hordeCatalog[hordeID].flags & HORDE_SUMMONED_AT_DISTANCE) {
! 941: x = y = -1;
! 942: randomLocationInGrid(grid, &x, &y, 1);
! 943: teleport(monst, x, y, true);
! 944: if (x != -1 && y != -1 && grid != NULL) {
! 945: grid[x][y] = 0;
! 946: }
! 947: }
! 948:
! 949: monst->bookkeepingFlags &= ~MB_JUST_SUMMONED;
! 950: if (canSeeMonster(monst)) {
! 951: seenMinionCount++;
! 952: refreshDungeonCell(monst->xLoc, monst->yLoc);
! 953: }
! 954: monst->ticksUntilTurn = 101;
! 955: monst->leader = summoner;
! 956: if (monst->carriedItem) {
! 957: deleteItem(monst->carriedItem);
! 958: monst->carriedItem = NULL;
! 959: }
! 960: fadeInMonster(monst);
! 961: host = monst;
! 962: }
! 963: }
! 964:
! 965: if (canSeeMonster(summoner)) {
! 966: monsterName(monstName, summoner, true);
! 967: if (monsterText[summoner->info.monsterID].summonMessage[0]) {
! 968: sprintf(buf, "%s %s", monstName, monsterText[summoner->info.monsterID].summonMessage);
! 969: } else {
! 970: sprintf(buf, "%s incants darkly!", monstName);
! 971: }
! 972: message(buf, false);
! 973: }
! 974:
! 975: if (summoner->info.abilityFlags & MA_ENTER_SUMMONS) {
! 976: if (atLeastOneMinion
! 977: && host) {
! 978:
! 979: host->carriedMonster = summoner;
! 980: demoteMonsterFromLeadership(summoner);
! 981: refreshDungeonCell(summoner->xLoc, summoner->yLoc);
! 982: } else {
! 983: pmap[summoner->xLoc][summoner->yLoc].flags |= HAS_MONSTER;
! 984: summoner->nextCreature = monsters->nextCreature;
! 985: monsters->nextCreature = summoner;
! 986: }
! 987: } else if (atLeastOneMinion) {
! 988: summoner->bookkeepingFlags |= MB_LEADER;
! 989: }
! 990: createFlare(summoner->xLoc, summoner->yLoc, SUMMONING_FLASH_LIGHT);
! 991:
! 992: if (grid) {
! 993: freeGrid(grid);
! 994: }
! 995:
! 996: return atLeastOneMinion;
! 997: }
! 998:
! 999: // Generates and places monsters for the level.
! 1000: void populateMonsters() {
! 1001: if (!MONSTERS_ENABLED) {
! 1002: return;
! 1003: }
! 1004:
! 1005: short i, numberOfMonsters = min(20, 6 + 3 * max(0, rogue.depthLevel - AMULET_LEVEL)); // almost always 6.
! 1006:
! 1007: while (rand_percent(60)) {
! 1008: numberOfMonsters++;
! 1009: }
! 1010: for (i=0; i<numberOfMonsters; i++) {
! 1011: spawnHorde(0, -1, -1, (HORDE_IS_SUMMONED | HORDE_MACHINE_ONLY), 0); // random horde type, random location
! 1012: }
! 1013: }
! 1014:
! 1015: boolean getRandomMonsterSpawnLocation(short *x, short *y) {
! 1016: short **grid;
! 1017:
! 1018: grid = allocGrid();
! 1019: fillGrid(grid, 0);
! 1020: calculateDistances(grid, player.xLoc, player.yLoc, T_DIVIDES_LEVEL, NULL, true, true);
! 1021: getTerrainGrid(grid, 0, (T_PATHING_BLOCKER | T_HARMFUL_TERRAIN), (HAS_PLAYER | HAS_MONSTER | HAS_STAIRS | IN_FIELD_OF_VIEW));
! 1022: findReplaceGrid(grid, -30000, DCOLS/2-1, 0);
! 1023: findReplaceGrid(grid, 30000, 30000, 0);
! 1024: findReplaceGrid(grid, DCOLS/2, 30000-1, 1);
! 1025: randomLocationInGrid(grid, x, y, 1);
! 1026: if (*x < 0 || *y < 0) {
! 1027: fillGrid(grid, 1);
! 1028: getTerrainGrid(grid, 0, (T_PATHING_BLOCKER | T_HARMFUL_TERRAIN), (HAS_PLAYER | HAS_MONSTER | HAS_STAIRS | IN_FIELD_OF_VIEW | IS_IN_MACHINE));
! 1029: randomLocationInGrid(grid, x, y, 1);
! 1030: }
! 1031: // DEBUG {
! 1032: // dumpLevelToScreen();
! 1033: // hiliteGrid(grid, &orange, 50);
! 1034: // plotCharWithColor('X', mapToWindowX(x), mapToWindowY(y), &black, &white);
! 1035: // temporaryMessage("Horde spawn location possibilities:", true);
! 1036: // }
! 1037: freeGrid(grid);
! 1038: if (*x < 0 || *y < 0) {
! 1039: return false;
! 1040: }
! 1041: return true;
! 1042: }
! 1043:
! 1044: void spawnPeriodicHorde() {
! 1045: creature *monst, *monst2;
! 1046: short x, y;
! 1047:
! 1048: if (!MONSTERS_ENABLED) {
! 1049: return;
! 1050: }
! 1051:
! 1052: if (getRandomMonsterSpawnLocation(&x, &y)) {
! 1053: monst = spawnHorde(0, x, y, (HORDE_IS_SUMMONED | HORDE_LEADER_CAPTIVE | HORDE_NO_PERIODIC_SPAWN | HORDE_MACHINE_ONLY), 0);
! 1054: if (monst) {
! 1055: monst->creatureState = MONSTER_WANDERING;
! 1056: for (monst2 = monsters->nextCreature; monst2 != NULL; monst2 = monst2->nextCreature) {
! 1057: if (monst2->leader == monst) {
! 1058: monst2->creatureState = MONSTER_WANDERING;
! 1059: }
! 1060: }
! 1061: }
! 1062: }
! 1063: }
! 1064:
! 1065: // x and y are optional.
! 1066: void teleport(creature *monst, short x, short y, boolean respectTerrainAvoidancePreferences) {
! 1067: short **grid, i, j;
! 1068: char monstFOV[DCOLS][DROWS];
! 1069:
! 1070: if (!coordinatesAreInMap(x, y)) {
! 1071: zeroOutGrid(monstFOV);
! 1072: getFOVMask(monstFOV, monst->xLoc, monst->yLoc, DCOLS * FP_FACTOR, T_OBSTRUCTS_VISION, 0, false);
! 1073: grid = allocGrid();
! 1074: fillGrid(grid, 0);
! 1075: calculateDistances(grid, monst->xLoc, monst->yLoc, forbiddenFlagsForMonster(&(monst->info)) & T_DIVIDES_LEVEL, NULL, true, false);
! 1076: findReplaceGrid(grid, -30000, DCOLS/2, 0);
! 1077: findReplaceGrid(grid, 2, 30000, 1);
! 1078: if (validLocationCount(grid, 1) < 1) {
! 1079: fillGrid(grid, 1);
! 1080: }
! 1081: if (respectTerrainAvoidancePreferences) {
! 1082: if (monst->info.flags & MONST_RESTRICTED_TO_LIQUID) {
! 1083: fillGrid(grid, 0);
! 1084: getTMGrid(grid, 1, TM_ALLOWS_SUBMERGING);
! 1085: }
! 1086: getTerrainGrid(grid, 0, avoidedFlagsForMonster(&(monst->info)), (IS_IN_MACHINE | HAS_PLAYER | HAS_MONSTER | HAS_STAIRS));
! 1087: } else {
! 1088: getTerrainGrid(grid, 0, forbiddenFlagsForMonster(&(monst->info)), (IS_IN_MACHINE | HAS_PLAYER | HAS_MONSTER | HAS_STAIRS));
! 1089: }
! 1090: for (i=0; i<DCOLS; i++) {
! 1091: for (j=0; j<DROWS; j++) {
! 1092: if (monstFOV[i][j]) {
! 1093: grid[i][j] = 0;
! 1094: }
! 1095: }
! 1096: }
! 1097: randomLocationInGrid(grid, &x, &y, 1);
! 1098: // DEBUG {
! 1099: // dumpLevelToScreen();
! 1100: // hiliteGrid(grid, &orange, 50);
! 1101: // plotCharWithColor('X', mapToWindowX(x), mapToWindowY(y), &white, &red);
! 1102: // temporaryMessage("Teleport candidate locations:", true);
! 1103: // }
! 1104: freeGrid(grid);
! 1105: if (x < 0 || y < 0) {
! 1106: return; // Failure!
! 1107: }
! 1108: }
! 1109: setMonsterLocation(monst, x, y);
! 1110: if (monst != &player) {
! 1111: chooseNewWanderDestination(monst);
! 1112: }
! 1113: }
! 1114:
! 1115: boolean isValidWanderDestination(creature *monst, short wpIndex) {
! 1116: return (wpIndex >= 0
! 1117: && wpIndex < rogue.wpCount
! 1118: && !monst->waypointAlreadyVisited[wpIndex]
! 1119: && rogue.wpDistance[wpIndex][monst->xLoc][monst->yLoc] >= 0
! 1120: && nextStep(rogue.wpDistance[wpIndex], monst->xLoc, monst->yLoc, monst, false) != NO_DIRECTION);
! 1121: }
! 1122:
! 1123: short closestWaypointIndex(creature *monst) {
! 1124: short i, closestDistance, closestIndex;
! 1125:
! 1126: closestDistance = DCOLS/2;
! 1127: closestIndex = -1;
! 1128: for (i=0; i < rogue.wpCount; i++) {
! 1129: if (isValidWanderDestination(monst, i)
! 1130: && rogue.wpDistance[i][monst->xLoc][monst->yLoc] < closestDistance) {
! 1131:
! 1132: closestDistance = rogue.wpDistance[i][monst->xLoc][monst->yLoc];
! 1133: closestIndex = i;
! 1134: }
! 1135: }
! 1136: return closestIndex;
! 1137: }
! 1138:
! 1139: void chooseNewWanderDestination(creature *monst) {
! 1140: short i;
! 1141:
! 1142: brogueAssert(monst->targetWaypointIndex < MAX_WAYPOINT_COUNT);
! 1143: brogueAssert(rogue.wpCount > 0 && rogue.wpCount <= MAX_WAYPOINT_COUNT);
! 1144:
! 1145: // Set two checkpoints at random to false (which equilibrates to 50% of checkpoints being active).
! 1146: monst->waypointAlreadyVisited[rand_range(0, rogue.wpCount - 1)] = false;
! 1147: monst->waypointAlreadyVisited[rand_range(0, rogue.wpCount - 1)] = false;
! 1148: // Set the targeted checkpoint to true.
! 1149: if (monst->targetWaypointIndex >= 0) {
! 1150: monst->waypointAlreadyVisited[monst->targetWaypointIndex] = true;
! 1151: }
! 1152:
! 1153: monst->targetWaypointIndex = closestWaypointIndex(monst); // Will be -1 if no waypoints were available.
! 1154: if (monst->targetWaypointIndex == -1) {
! 1155: for (i=0; i < rogue.wpCount; i++) {
! 1156: monst->waypointAlreadyVisited[i] = 0;
! 1157: }
! 1158: monst->targetWaypointIndex = closestWaypointIndex(monst);
! 1159: }
! 1160: }
! 1161:
! 1162: enum subseqDFTypes {
! 1163: SUBSEQ_PROMOTE = 0,
! 1164: SUBSEQ_BURN,
! 1165: SUBSEQ_DISCOVER,
! 1166: };
! 1167:
! 1168: // Returns the terrain flags of this tile after it's promoted according to the event corresponding to subseqDFTypes.
! 1169: unsigned long successorTerrainFlags(enum tileType tile, enum subseqDFTypes promotionType) {
! 1170: enum dungeonFeatureTypes DF = 0;
! 1171:
! 1172: switch (promotionType) {
! 1173: case SUBSEQ_PROMOTE:
! 1174: DF = tileCatalog[tile].promoteType;
! 1175: break;
! 1176: case SUBSEQ_BURN:
! 1177: DF = tileCatalog[tile].fireType;
! 1178: break;
! 1179: case SUBSEQ_DISCOVER:
! 1180: DF = tileCatalog[tile].discoverType;
! 1181: break;
! 1182: default:
! 1183: break;
! 1184: }
! 1185:
! 1186: if (DF) {
! 1187: return tileCatalog[dungeonFeatureCatalog[DF].tile].flags;
! 1188: } else {
! 1189: return 0;
! 1190: }
! 1191: }
! 1192:
! 1193: unsigned long burnedTerrainFlagsAtLoc(short x, short y) {
! 1194: short layer;
! 1195: unsigned long flags = 0;
! 1196:
! 1197: for (layer = 0; layer < NUMBER_TERRAIN_LAYERS; layer++) {
! 1198: if (tileCatalog[pmap[x][y].layers[layer]].flags & T_IS_FLAMMABLE) {
! 1199: flags |= successorTerrainFlags(pmap[x][y].layers[layer], SUBSEQ_BURN);
! 1200: if (tileCatalog[pmap[x][y].layers[layer]].mechFlags & TM_EXPLOSIVE_PROMOTE) {
! 1201: flags |= successorTerrainFlags(pmap[x][y].layers[layer], SUBSEQ_PROMOTE);
! 1202: }
! 1203: }
! 1204: }
! 1205:
! 1206: return flags;
! 1207: }
! 1208:
! 1209: unsigned long discoveredTerrainFlagsAtLoc(short x, short y) {
! 1210: short layer;
! 1211: unsigned long flags = 0;
! 1212:
! 1213: for (layer = 0; layer < NUMBER_TERRAIN_LAYERS; layer++) {
! 1214: if (tileCatalog[pmap[x][y].layers[layer]].mechFlags & TM_IS_SECRET) {
! 1215: flags |= successorTerrainFlags(pmap[x][y].layers[layer], SUBSEQ_DISCOVER);
! 1216: }
! 1217: }
! 1218:
! 1219: return flags;
! 1220: }
! 1221:
! 1222: boolean monsterAvoids(creature *monst, short x, short y) {
! 1223: unsigned long terrainImmunities;
! 1224: creature *defender;
! 1225: unsigned long tFlags, cFlags;
! 1226:
! 1227: getLocationFlags(x, y, &tFlags, NULL, &cFlags, monst == &player);
! 1228:
! 1229: // everyone but the player avoids the stairs
! 1230: if ((x == rogue.downLoc[0] && y == rogue.downLoc[1])
! 1231: || (x == rogue.upLoc[0] && y == rogue.upLoc[1])) {
! 1232:
! 1233: return monst != &player;
! 1234: }
! 1235:
! 1236: // dry land
! 1237: if (monst->info.flags & MONST_RESTRICTED_TO_LIQUID
! 1238: && !cellHasTMFlag(x, y, TM_ALLOWS_SUBMERGING)) {
! 1239: return true;
! 1240: }
! 1241:
! 1242: // non-allied monsters can always attack the player
! 1243: if (player.xLoc == x && player.yLoc == y && monst != &player && monst->creatureState != MONSTER_ALLY) {
! 1244: return false;
! 1245: }
! 1246:
! 1247: // walls
! 1248: if (tFlags & T_OBSTRUCTS_PASSABILITY) {
! 1249: if (monst != &player
! 1250: && cellHasTMFlag(x, y, TM_IS_SECRET)
! 1251: && !(discoveredTerrainFlagsAtLoc(x, y) & avoidedFlagsForMonster(&(monst->info)))) {
! 1252: // This is so monsters can use secret doors but won't embed themselves in secret levers.
! 1253: return false;
! 1254: }
! 1255: if (distanceBetween(monst->xLoc, monst->yLoc, x, y) <= 1) {
! 1256: defender = monsterAtLoc(x, y);
! 1257: if (defender
! 1258: && (defender->info.flags & MONST_ATTACKABLE_THRU_WALLS)) {
! 1259: return false;
! 1260: }
! 1261: }
! 1262: return true;
! 1263: }
! 1264:
! 1265: // Monsters can always attack unfriendly neighboring monsters,
! 1266: // unless it is immune to us for whatever reason.
! 1267: if (distanceBetween(monst->xLoc, monst->yLoc, x, y) <= 1) {
! 1268: defender = monsterAtLoc(x, y);
! 1269: if (defender
! 1270: && !(defender->bookkeepingFlags & MB_IS_DYING)
! 1271: && monsterWillAttackTarget(monst, defender)) {
! 1272:
! 1273: if (attackWouldBeFutile(monst, defender)) {
! 1274: return true;
! 1275: } else {
! 1276: return false;
! 1277: }
! 1278: }
! 1279: }
! 1280:
! 1281: // Monsters always avoid enemy monsters that we can't damage.
! 1282: defender = monsterAtLoc(x, y);
! 1283: if (defender
! 1284: && !(defender->bookkeepingFlags & MB_IS_DYING)
! 1285: && monstersAreEnemies(monst, defender)
! 1286: && attackWouldBeFutile(monst, defender)) {
! 1287:
! 1288: return true;
! 1289: }
! 1290:
! 1291: // hidden terrain
! 1292: if (cellHasTMFlag(x, y, TM_IS_SECRET) && monst == &player) {
! 1293: return false; // player won't avoid what he doesn't know about
! 1294: }
! 1295:
! 1296: // Determine invulnerabilities based only on monster characteristics.
! 1297: terrainImmunities = 0;
! 1298: if (monst->status[STATUS_IMMUNE_TO_FIRE]) {
! 1299: terrainImmunities |= (T_IS_FIRE | T_SPONTANEOUSLY_IGNITES | T_LAVA_INSTA_DEATH);
! 1300: }
! 1301: if (monst->info.flags & MONST_INVULNERABLE) {
! 1302: terrainImmunities |= T_HARMFUL_TERRAIN | T_ENTANGLES | T_SPONTANEOUSLY_IGNITES | T_LAVA_INSTA_DEATH;
! 1303: }
! 1304: if (monst->info.flags & MONST_INANIMATE) {
! 1305: terrainImmunities |= (T_CAUSES_DAMAGE | T_CAUSES_PARALYSIS | T_CAUSES_CONFUSION | T_CAUSES_NAUSEA | T_CAUSES_POISON);
! 1306: }
! 1307: if (monst->status[STATUS_LEVITATING]) {
! 1308: terrainImmunities |= (T_AUTO_DESCENT | T_CAUSES_POISON | T_IS_DEEP_WATER | T_IS_DF_TRAP | T_LAVA_INSTA_DEATH);
! 1309: }
! 1310: if (monst->info.flags & MONST_IMMUNE_TO_WEBS) {
! 1311: terrainImmunities |= T_ENTANGLES;
! 1312: }
! 1313: if (monst->info.flags & MONST_IMMUNE_TO_WATER) {
! 1314: terrainImmunities |= T_IS_DEEP_WATER;
! 1315: }
! 1316: if (monst == &player) {
! 1317: terrainImmunities |= T_SACRED;
! 1318: }
! 1319: if (monst == &player
! 1320: && rogue.armor
! 1321: && (rogue.armor->flags & ITEM_RUNIC)
! 1322: && rogue.armor->enchant2 == A_RESPIRATION) {
! 1323:
! 1324: terrainImmunities |= T_RESPIRATION_IMMUNITIES;
! 1325: }
! 1326:
! 1327: // sacred ground
! 1328: if ((tFlags & T_SACRED & ~terrainImmunities)) {
! 1329: return true;
! 1330: }
! 1331:
! 1332: // brimstone
! 1333: if (!(monst->status[STATUS_IMMUNE_TO_FIRE])
! 1334: && !(monst->info.flags & MONST_INVULNERABLE)
! 1335: && (tFlags & T_SPONTANEOUSLY_IGNITES)
! 1336: && !(cFlags & (HAS_MONSTER | HAS_PLAYER))
! 1337: && !cellHasTerrainFlag(monst->xLoc, monst->yLoc, T_IS_FIRE | T_SPONTANEOUSLY_IGNITES)
! 1338: && (monst == &player || (monst->creatureState != MONSTER_TRACKING_SCENT && monst->creatureState != MONSTER_FLEEING))) {
! 1339: return true;
! 1340: }
! 1341:
! 1342: // burning wandering monsters avoid flammable terrain out of common courtesy
! 1343: if (monst != &player
! 1344: && monst->creatureState == MONSTER_WANDERING
! 1345: && (monst->info.flags & MONST_FIERY)
! 1346: && (tFlags & T_IS_FLAMMABLE)) {
! 1347:
! 1348: return true;
! 1349: }
! 1350:
! 1351: // burning monsters avoid explosive terrain and steam-emitting terrain
! 1352: if (monst != &player
! 1353: && monst->status[STATUS_BURNING]
! 1354: && (burnedTerrainFlagsAtLoc(x, y) & (T_CAUSES_EXPLOSIVE_DAMAGE | T_CAUSES_DAMAGE | T_AUTO_DESCENT) & ~terrainImmunities)) {
! 1355:
! 1356: return true;
! 1357: }
! 1358:
! 1359: // fire
! 1360: if ((tFlags & T_IS_FIRE & ~terrainImmunities)
! 1361: && !cellHasTerrainFlag(monst->xLoc, monst->yLoc, T_IS_FIRE)
! 1362: && !(cFlags & (HAS_MONSTER | HAS_PLAYER))
! 1363: && (monst != &player || rogue.mapToShore[x][y] >= player.status[STATUS_IMMUNE_TO_FIRE])) {
! 1364: return true;
! 1365: }
! 1366:
! 1367: // non-fire harmful terrain
! 1368: if ((tFlags & T_HARMFUL_TERRAIN & ~T_IS_FIRE & ~terrainImmunities)
! 1369: && !cellHasTerrainFlag(monst->xLoc, monst->yLoc, (T_HARMFUL_TERRAIN & ~T_IS_FIRE))) {
! 1370: return true;
! 1371: }
! 1372:
! 1373: // chasms or trap doors
! 1374: if ((tFlags & T_AUTO_DESCENT & ~terrainImmunities)
! 1375: && (!(tFlags & T_ENTANGLES) || !(monst->info.flags & MONST_IMMUNE_TO_WEBS))) {
! 1376: return true;
! 1377: }
! 1378:
! 1379: // gas or other environmental traps
! 1380: if ((tFlags & T_IS_DF_TRAP & ~terrainImmunities)
! 1381: && !(cFlags & PRESSURE_PLATE_DEPRESSED)
! 1382: && (monst == &player || monst->creatureState == MONSTER_WANDERING
! 1383: || (monst->creatureState == MONSTER_ALLY && !(cellHasTMFlag(x, y, TM_IS_SECRET))))
! 1384: && !(monst->status[STATUS_ENTRANCED])
! 1385: && (!(tFlags & T_ENTANGLES) || !(monst->info.flags & MONST_IMMUNE_TO_WEBS))) {
! 1386: return true;
! 1387: }
! 1388:
! 1389: // lava
! 1390: if ((tFlags & T_LAVA_INSTA_DEATH & ~terrainImmunities)
! 1391: && (!(tFlags & T_ENTANGLES) || !(monst->info.flags & MONST_IMMUNE_TO_WEBS))
! 1392: && (monst != &player || rogue.mapToShore[x][y] >= max(player.status[STATUS_IMMUNE_TO_FIRE], player.status[STATUS_LEVITATING]))) {
! 1393: return true;
! 1394: }
! 1395:
! 1396: // deep water
! 1397: if ((tFlags & T_IS_DEEP_WATER & ~terrainImmunities)
! 1398: && (!(tFlags & T_ENTANGLES) || !(monst->info.flags & MONST_IMMUNE_TO_WEBS))
! 1399: && !cellHasTerrainFlag(monst->xLoc, monst->yLoc, T_IS_DEEP_WATER)) {
! 1400: return true; // avoid only if not already in it
! 1401: }
! 1402:
! 1403: // poisonous lichen
! 1404: if ((tFlags & T_CAUSES_POISON & ~terrainImmunities)
! 1405: && !cellHasTerrainFlag(monst->xLoc, monst->yLoc, T_CAUSES_POISON)
! 1406: && (monst == &player || monst->creatureState != MONSTER_TRACKING_SCENT || monst->currentHP < 10)) {
! 1407: return true;
! 1408: }
! 1409:
! 1410: // Smart monsters don't attack in corridors if they belong to a group and they can help it.
! 1411: if ((monst->info.abilityFlags & MA_AVOID_CORRIDORS)
! 1412: && monst->creatureState == MONSTER_TRACKING_SCENT
! 1413: && (monst->bookkeepingFlags & (MB_FOLLOWER | MB_LEADER))
! 1414: && passableArcCount(x, y) >= 2
! 1415: && passableArcCount(monst->xLoc, monst->yLoc) < 2
! 1416: && !cellHasTerrainFlag(monst->xLoc, monst->yLoc, (T_HARMFUL_TERRAIN & ~terrainImmunities))) {
! 1417: return true;
! 1418: }
! 1419:
! 1420: return false;
! 1421: }
! 1422:
! 1423: boolean moveMonsterPassivelyTowards(creature *monst, short targetLoc[2], boolean willingToAttackPlayer) {
! 1424: short x, y, dx, dy, newX, newY;
! 1425:
! 1426: x = monst->xLoc;
! 1427: y = monst->yLoc;
! 1428:
! 1429: if (targetLoc[0] == x) {
! 1430: dx = 0;
! 1431: } else {
! 1432: dx = (targetLoc[0] < x ? -1 : 1);
! 1433: }
! 1434: if (targetLoc[1] == y) {
! 1435: dy = 0;
! 1436: } else {
! 1437: dy = (targetLoc[1] < y ? -1 : 1);
! 1438: }
! 1439:
! 1440: if (dx == 0 && dy == 0) { // already at the destination
! 1441: return false;
! 1442: }
! 1443:
! 1444: newX = x + dx;
! 1445: newY = y + dy;
! 1446:
! 1447: if (!coordinatesAreInMap(newX, newY)) {
! 1448: return false;
! 1449: }
! 1450:
! 1451: if (monst->creatureState != MONSTER_TRACKING_SCENT && dx && dy) {
! 1452: if (abs(targetLoc[0] - x) > abs(targetLoc[1] - y) && rand_range(0, abs(targetLoc[0] - x)) > abs(targetLoc[1] - y)) {
! 1453: if (!(monsterAvoids(monst, newX, y) || (!willingToAttackPlayer && (pmap[newX][y].flags & HAS_PLAYER)) || !moveMonster(monst, dx, 0))) {
! 1454: return true;
! 1455: }
! 1456: } else if (abs(targetLoc[0] - x) < abs(targetLoc[1] - y) && rand_range(0, abs(targetLoc[1] - y)) > abs(targetLoc[0] - x)) {
! 1457: if (!(monsterAvoids(monst, x, newY) || (!willingToAttackPlayer && (pmap[x][newY].flags & HAS_PLAYER)) || !moveMonster(monst, 0, dy))) {
! 1458: return true;
! 1459: }
! 1460: }
! 1461: }
! 1462:
! 1463: // Try to move toward the goal diagonally if possible or else straight.
! 1464: // If that fails, try both directions for the shorter coordinate.
! 1465: // If they all fail, return false.
! 1466: if (monsterAvoids(monst, newX, newY) || (!willingToAttackPlayer && (pmap[newX][newY].flags & HAS_PLAYER)) || !moveMonster(monst, dx, dy)) {
! 1467: if (distanceBetween(x, y, targetLoc[0], targetLoc[1]) <= 1 && (dx == 0 || dy == 0)) { // cardinally adjacent
! 1468: return false; // destination is blocked
! 1469: }
! 1470: //abs(targetLoc[0] - x) < abs(targetLoc[1] - y)
! 1471: if ((max(targetLoc[0], x) - min(targetLoc[0], x)) < (max(targetLoc[1], y) - min(targetLoc[1], y))) {
! 1472: if (monsterAvoids(monst, x, newY) || (!willingToAttackPlayer && pmap[x][newY].flags & HAS_PLAYER) || !moveMonster(monst, 0, dy)) {
! 1473: if (monsterAvoids(monst, newX, y) || (!willingToAttackPlayer && pmap[newX][y].flags & HAS_PLAYER) || !moveMonster(monst, dx, 0)) {
! 1474: if (monsterAvoids(monst, x-1, newY) || (!willingToAttackPlayer && pmap[x-1][newY].flags & HAS_PLAYER) || !moveMonster(monst, -1, dy)) {
! 1475: if (monsterAvoids(monst, x+1, newY) || (!willingToAttackPlayer && pmap[x+1][newY].flags & HAS_PLAYER) || !moveMonster(monst, 1, dy)) {
! 1476: return false;
! 1477: }
! 1478: }
! 1479: }
! 1480: }
! 1481: } else {
! 1482: if (monsterAvoids(monst, newX, y) || (!willingToAttackPlayer && pmap[newX][y].flags & HAS_PLAYER) || !moveMonster(monst, dx, 0)) {
! 1483: if (monsterAvoids(monst, x, newY) || (!willingToAttackPlayer && pmap[x][newY].flags & HAS_PLAYER) || !moveMonster(monst, 0, dy)) {
! 1484: if (monsterAvoids(monst, newX, y-1) || (!willingToAttackPlayer && pmap[newX][y-1].flags & HAS_PLAYER) || !moveMonster(monst, dx, -1)) {
! 1485: if (monsterAvoids(monst, newX, y+1) || (!willingToAttackPlayer && pmap[newX][y+1].flags & HAS_PLAYER) || !moveMonster(monst, dx, 1)) {
! 1486: return false;
! 1487: }
! 1488: }
! 1489: }
! 1490: }
! 1491: }
! 1492: }
! 1493: return true;
! 1494: }
! 1495:
! 1496: short distanceBetween(short x1, short y1, short x2, short y2) {
! 1497: return max(abs(x1 - x2), abs(y1 - y2));
! 1498: }
! 1499:
! 1500: void alertMonster(creature *monst) {
! 1501: monst->creatureState = (monst->creatureMode == MODE_PERM_FLEEING ? MONSTER_FLEEING : MONSTER_TRACKING_SCENT);
! 1502: monst->lastSeenPlayerAt[0] = player.xLoc;
! 1503: monst->lastSeenPlayerAt[1] = player.yLoc;
! 1504: }
! 1505:
! 1506: void wakeUp(creature *monst) {
! 1507: creature *teammate;
! 1508:
! 1509: if (monst->creatureState != MONSTER_ALLY) {
! 1510: alertMonster(monst);
! 1511: }
! 1512: monst->ticksUntilTurn = 100;
! 1513: for (teammate = monsters->nextCreature; teammate != NULL; teammate = teammate->nextCreature) {
! 1514: if (monst != teammate && monstersAreTeammates(monst, teammate) && teammate->creatureMode == MODE_NORMAL) {
! 1515: if (teammate->creatureState == MONSTER_SLEEPING
! 1516: || teammate->creatureState == MONSTER_WANDERING) {
! 1517: teammate->ticksUntilTurn = max(100, teammate->ticksUntilTurn);
! 1518: }
! 1519: if (monst->creatureState != MONSTER_ALLY) {
! 1520: teammate->creatureState =
! 1521: (teammate->creatureMode == MODE_PERM_FLEEING ? MONSTER_FLEEING : MONSTER_TRACKING_SCENT);
! 1522: updateMonsterState(teammate);
! 1523: }
! 1524: }
! 1525: }
! 1526: }
! 1527:
! 1528: boolean monsterCanShootWebs(creature *monst) {
! 1529: short i;
! 1530: for (i=0; monst->info.bolts[i] != 0; i++) {
! 1531: const bolt *theBolt = &boltCatalog[monst->info.bolts[i]];
! 1532: if (theBolt->pathDF && (tileCatalog[dungeonFeatureCatalog[theBolt->pathDF].tile].flags & T_ENTANGLES)) {
! 1533: return true;
! 1534: }
! 1535: }
! 1536: return false;
! 1537: }
! 1538:
! 1539: // Assumes that observer is not the player.
! 1540: // Returns approximately double the actual (quasi-euclidian) distance.
! 1541: short awarenessDistance(creature *observer, creature *target) {
! 1542: long perceivedDistance;
! 1543:
! 1544: // start with base distance
! 1545: if ((observer->status[STATUS_LEVITATING]
! 1546: || (observer->info.flags & MONST_RESTRICTED_TO_LIQUID)
! 1547: || (observer->info.flags & MONST_IMMOBILE)
! 1548: || (observer->bookkeepingFlags & MB_SUBMERGED)
! 1549: || ((observer->info.flags & MONST_IMMUNE_TO_WEBS) && monsterCanShootWebs(observer)))
! 1550: && ((target == &player && (pmap[observer->xLoc][observer->yLoc].flags & IN_FIELD_OF_VIEW))
! 1551: || (target != &player && openPathBetween(observer->xLoc, observer->yLoc, target->xLoc, target->yLoc)))) {
! 1552: // if monster flies or is immobile or waterbound or underwater or can cross pits with webs,
! 1553: // use absolute distance.
! 1554: perceivedDistance = scentDistance(observer->xLoc, observer->yLoc, target->xLoc, target->yLoc);
! 1555: } else {
! 1556: perceivedDistance = (rogue.scentTurnNumber - scentMap[observer->xLoc][observer->yLoc]); // this value is double the apparent distance
! 1557: }
! 1558:
! 1559: perceivedDistance = min(perceivedDistance, 1000);
! 1560:
! 1561: if (perceivedDistance < 0) {
! 1562: perceivedDistance = 1000;
! 1563: }
! 1564: return ((short) perceivedDistance);
! 1565: }
! 1566:
! 1567: // yes or no -- observer is aware of the target as of this new turn.
! 1568: // takes into account whether it is ALREADY aware of the target.
! 1569: boolean awareOfTarget(creature *observer, creature *target) {
! 1570: short perceivedDistance = awarenessDistance(observer, target);
! 1571: short awareness = rogue.aggroRange * 2;
! 1572: boolean retval;
! 1573:
! 1574: brogueAssert(perceivedDistance >= 0 && awareness >= 0);
! 1575:
! 1576: if (observer->info.flags & MONST_ALWAYS_HUNTING) {
! 1577: retval = true;
! 1578: } else if (observer->info.flags & MONST_IMMOBILE) {
! 1579: // Turrets and totems are aware of you iff they are within stealth range.
! 1580: // The only exception is mirror totems; they're always ready to shoot because they have "always hunting" set.
! 1581: retval = perceivedDistance <= awareness;
! 1582: } else if (perceivedDistance > awareness * 3) {
! 1583: // out of awareness range, even if hunting
! 1584: retval = false;
! 1585: } else if (observer->creatureState == MONSTER_TRACKING_SCENT) {
! 1586: // already aware of the target, lose track 3% of the time if outside of stealth range.
! 1587: if (perceivedDistance > awareness) {
! 1588: retval = rand_percent(97);
! 1589: } else {
! 1590: retval = true;
! 1591: }
! 1592: } else if (target == &player
! 1593: && !(pmap[observer->xLoc][observer->yLoc].flags & IN_FIELD_OF_VIEW)) {
! 1594: // observer not hunting and player-target not in field of view
! 1595: retval = false;
! 1596: } else if (perceivedDistance <= awareness) {
! 1597: // within range but currently unaware
! 1598: retval = rand_percent(25);
! 1599: } else {
! 1600: retval = false;
! 1601: }
! 1602: return retval;
! 1603: }
! 1604:
! 1605: short closestWaypointIndexTo(const short x, const short y) {
! 1606: short i, closestDistance, closestIndex;
! 1607:
! 1608: closestDistance = 1000;
! 1609: closestIndex = -1;
! 1610: for (i=0; i < rogue.wpCount; i++) {
! 1611: if (rogue.wpDistance[i][x][y] < closestDistance) {
! 1612: closestDistance = rogue.wpDistance[i][x][y];
! 1613: closestIndex = i;
! 1614: }
! 1615: }
! 1616: return closestIndex;
! 1617: }
! 1618:
! 1619: void wanderToward(creature *monst, const short x, const short y) {
! 1620: if (coordinatesAreInMap(x, y)) {
! 1621: const short theWaypointIndex = closestWaypointIndexTo(x, y);
! 1622: if (theWaypointIndex != -1) {
! 1623: monst->waypointAlreadyVisited[theWaypointIndex] = false;
! 1624: monst->targetWaypointIndex = theWaypointIndex;
! 1625: }
! 1626: }
! 1627: }
! 1628:
! 1629: void updateMonsterState(creature *monst) {
! 1630: short x, y, closestFearedEnemy;
! 1631: boolean awareOfPlayer;
! 1632: creature *monst2;
! 1633:
! 1634: x = monst->xLoc;
! 1635: y = monst->yLoc;
! 1636:
! 1637: if ((monst->info.flags & MONST_ALWAYS_HUNTING)
! 1638: && monst->creatureState != MONSTER_ALLY) {
! 1639:
! 1640: monst->creatureState = MONSTER_TRACKING_SCENT;
! 1641: return;
! 1642: }
! 1643:
! 1644: awareOfPlayer = awareOfTarget(monst, &player);
! 1645:
! 1646: if ((monst->info.flags & MONST_IMMOBILE)
! 1647: && monst->creatureState != MONSTER_ALLY) {
! 1648:
! 1649: if (awareOfPlayer) {
! 1650: monst->creatureState = MONSTER_TRACKING_SCENT;
! 1651: } else {
! 1652: monst->creatureState = MONSTER_SLEEPING;
! 1653: }
! 1654: return;
! 1655: }
! 1656:
! 1657: if (monst->creatureMode == MODE_PERM_FLEEING
! 1658: && (monst->creatureState == MONSTER_WANDERING || monst->creatureState == MONSTER_TRACKING_SCENT)) {
! 1659:
! 1660: monst->creatureState = MONSTER_FLEEING;
! 1661: }
! 1662:
! 1663: closestFearedEnemy = DCOLS+DROWS;
! 1664: CYCLE_MONSTERS_AND_PLAYERS(monst2) {
! 1665: if (monsterFleesFrom(monst, monst2)
! 1666: && distanceBetween(x, y, monst2->xLoc, monst2->yLoc) < closestFearedEnemy
! 1667: && traversiblePathBetween(monst2, x, y)
! 1668: && openPathBetween(x, y, monst2->xLoc, monst2->yLoc)) {
! 1669:
! 1670: closestFearedEnemy = distanceBetween(x, y, monst2->xLoc, monst2->yLoc);
! 1671: }
! 1672: }
! 1673:
! 1674: if ((monst->creatureState == MONSTER_WANDERING)
! 1675: && awareOfPlayer
! 1676: && (pmap[player.xLoc][player.yLoc].flags & IN_FIELD_OF_VIEW)) {
! 1677: // If wandering and you notice the player, start tracking the scent.
! 1678: alertMonster(monst);
! 1679: } else if (monst->creatureState == MONSTER_SLEEPING) {
! 1680: // if sleeping, the monster has a chance to awaken
! 1681: if (awareOfPlayer) {
! 1682: wakeUp(monst); // wakes up the whole horde if necessary
! 1683: }
! 1684: } else if (monst->creatureState == MONSTER_TRACKING_SCENT && !awareOfPlayer) {
! 1685: // if tracking scent, but the scent is weaker than the scent detection threshold, begin wandering.
! 1686: monst->creatureState = MONSTER_WANDERING;
! 1687: wanderToward(monst, monst->lastSeenPlayerAt[0], monst->lastSeenPlayerAt[1]);
! 1688: } else if (monst->creatureState == MONSTER_TRACKING_SCENT
! 1689: && closestFearedEnemy < 3) {
! 1690: monst->creatureState = MONSTER_FLEEING;
! 1691: } else if (monst->creatureState != MONSTER_ALLY
! 1692: && (monst->info.flags & MONST_FLEES_NEAR_DEATH)
! 1693: && monst->currentHP <= 3 * monst->info.maxHP / 4) {
! 1694:
! 1695: if (monst->creatureState == MONSTER_FLEEING
! 1696: || monst->currentHP <= monst->info.maxHP / 4) {
! 1697:
! 1698: monst->creatureState = MONSTER_FLEEING;
! 1699: }
! 1700: } else if (monst->creatureMode == MODE_NORMAL
! 1701: && monst->creatureState == MONSTER_FLEEING
! 1702: && !(monst->status[STATUS_MAGICAL_FEAR])
! 1703: && closestFearedEnemy >= 3) {
! 1704:
! 1705: monst->creatureState = MONSTER_TRACKING_SCENT;
! 1706: } else if (monst->creatureMode == MODE_PERM_FLEEING
! 1707: && monst->creatureState == MONSTER_FLEEING
! 1708: && (monst->info.abilityFlags & MA_HIT_STEAL_FLEE)
! 1709: && !(monst->status[STATUS_MAGICAL_FEAR])
! 1710: && !(monst->carriedItem)) {
! 1711:
! 1712: monst->creatureMode = MODE_NORMAL;
! 1713: alertMonster(monst);
! 1714: } else if (monst->creatureMode == MODE_NORMAL
! 1715: && monst->creatureState == MONSTER_FLEEING
! 1716: && (monst->info.flags & MONST_FLEES_NEAR_DEATH)
! 1717: && !(monst->status[STATUS_MAGICAL_FEAR])
! 1718: && monst->currentHP >= monst->info.maxHP * 3 / 4) {
! 1719:
! 1720: if ((monst->bookkeepingFlags & MB_FOLLOWER) && monst->leader == &player) {
! 1721: monst->creatureState = MONSTER_ALLY;
! 1722: } else {
! 1723: alertMonster(monst);
! 1724: }
! 1725: }
! 1726:
! 1727: if (awareOfPlayer) {
! 1728: if (monst->creatureState == MONSTER_FLEEING
! 1729: || monst->creatureState == MONSTER_TRACKING_SCENT) {
! 1730:
! 1731: monst->lastSeenPlayerAt[0] = player.xLoc;
! 1732: monst->lastSeenPlayerAt[1] = player.yLoc;
! 1733: }
! 1734: }
! 1735: }
! 1736:
! 1737: void decrementMonsterStatus(creature *monst) {
! 1738: short i, damage;
! 1739: char buf[COLS], buf2[COLS];
! 1740:
! 1741: monst->bookkeepingFlags &= ~MB_JUST_SUMMONED;
! 1742:
! 1743: if (monst->currentHP < monst->info.maxHP
! 1744: && monst->info.turnsBetweenRegen > 0
! 1745: && !monst->status[STATUS_POISONED]) {
! 1746:
! 1747: if ((monst->turnsUntilRegen -= 1000) <= 0) {
! 1748: monst->currentHP++;
! 1749: monst->previousHealthPoints++;
! 1750: monst->turnsUntilRegen += monst->info.turnsBetweenRegen;
! 1751: }
! 1752: }
! 1753:
! 1754: for (i=0; i<NUMBER_OF_STATUS_EFFECTS; i++) {
! 1755: switch (i) {
! 1756: case STATUS_LEVITATING:
! 1757: if (monst->status[i] && !(monst->info.flags & MONST_FLIES)) {
! 1758: monst->status[i]--;
! 1759: }
! 1760: break;
! 1761: case STATUS_SLOWED:
! 1762: if (monst->status[i] && !--monst->status[i]) {
! 1763: monst->movementSpeed = monst->info.movementSpeed;
! 1764: monst->attackSpeed = monst->info.attackSpeed;
! 1765: }
! 1766: break;
! 1767: case STATUS_WEAKENED:
! 1768: if (monst->status[i] && !--monst->status[i]) {
! 1769: monst->weaknessAmount = 0;
! 1770: }
! 1771: break;
! 1772: case STATUS_HASTED:
! 1773: if (monst->status[i]) {
! 1774: if (!--monst->status[i]) {
! 1775: monst->movementSpeed = monst->info.movementSpeed;
! 1776: monst->attackSpeed = monst->info.attackSpeed;
! 1777: }
! 1778: }
! 1779: break;
! 1780: case STATUS_BURNING:
! 1781: if (monst->status[i]) {
! 1782: if (!(monst->info.flags & MONST_FIERY)) {
! 1783: monst->status[i]--;
! 1784: }
! 1785: damage = rand_range(1, 3);
! 1786: if (!(monst->status[STATUS_IMMUNE_TO_FIRE])
! 1787: && !(monst->info.flags & MONST_INVULNERABLE)
! 1788: && inflictDamage(NULL, monst, damage, &orange, true)) {
! 1789:
! 1790: if (canSeeMonster(monst)) {
! 1791: monsterName(buf, monst, true);
! 1792: sprintf(buf2, "%s burns %s.",
! 1793: buf,
! 1794: (monst->info.flags & MONST_INANIMATE) ? "up" : "to death");
! 1795: messageWithColor(buf2, messageColorFromVictim(monst), false);
! 1796: }
! 1797: return;
! 1798: }
! 1799: if (monst->status[i] <= 0) {
! 1800: extinguishFireOnCreature(monst);
! 1801: }
! 1802: }
! 1803: break;
! 1804: case STATUS_LIFESPAN_REMAINING:
! 1805: if (monst->status[i]) {
! 1806: monst->status[i]--;
! 1807: if (monst->status[i] <= 0) {
! 1808: killCreature(monst, false);
! 1809: if (canSeeMonster(monst)) {
! 1810: monsterName(buf, monst, true);
! 1811: sprintf(buf2, "%s dissipates into thin air.", buf);
! 1812: messageWithColor(buf2, &white, false);
! 1813: }
! 1814: return;
! 1815: }
! 1816: }
! 1817: break;
! 1818: case STATUS_POISONED:
! 1819: if (monst->status[i]) {
! 1820: monst->status[i]--;
! 1821: if (inflictDamage(NULL, monst, monst->poisonAmount, &green, true)) {
! 1822: if (canSeeMonster(monst)) {
! 1823: monsterName(buf, monst, true);
! 1824: sprintf(buf2, "%s dies of poison.", buf);
! 1825: messageWithColor(buf2, messageColorFromVictim(monst), false);
! 1826: }
! 1827: return;
! 1828: }
! 1829: if (!monst->status[i]) {
! 1830: monst->poisonAmount = 0;
! 1831: }
! 1832: }
! 1833: break;
! 1834: case STATUS_STUCK:
! 1835: if (monst->status[i] && !cellHasTerrainFlag(monst->xLoc, monst->yLoc, T_ENTANGLES)) {
! 1836: monst->status[i] = 0;
! 1837: }
! 1838: break;
! 1839: case STATUS_DISCORDANT:
! 1840: if (monst->status[i] && !--monst->status[i]) {
! 1841: if (monst->creatureState == MONSTER_FLEEING
! 1842: && !monst->status[STATUS_MAGICAL_FEAR]
! 1843: && monst->leader == &player) {
! 1844:
! 1845: monst->creatureState = MONSTER_ALLY;
! 1846: if (monst->carriedItem) {
! 1847: makeMonsterDropItem(monst);
! 1848: }
! 1849: }
! 1850: }
! 1851: break;
! 1852: case STATUS_MAGICAL_FEAR:
! 1853: if (monst->status[i]) {
! 1854: if (!--monst->status[i]) {
! 1855: monst->creatureState = (monst->leader == &player ? MONSTER_ALLY : MONSTER_TRACKING_SCENT);
! 1856: }
! 1857: }
! 1858: break;
! 1859: case STATUS_SHIELDED:
! 1860: monst->status[i] -= monst->maxStatus[i] / 20;
! 1861: if (monst->status[i] <= 0) {
! 1862: monst->status[i] = monst->maxStatus[i] = 0;
! 1863: }
! 1864: break;
! 1865: case STATUS_IMMUNE_TO_FIRE:
! 1866: if (monst->status[i] && !(monst->info.flags & MONST_IMMUNE_TO_FIRE)) {
! 1867: monst->status[i]--;
! 1868: }
! 1869: break;
! 1870: case STATUS_INVISIBLE:
! 1871: if (monst->status[i]
! 1872: && !(monst->info.flags & MONST_INVISIBLE)
! 1873: && !--monst->status[i]
! 1874: && playerCanSee(monst->xLoc, monst->yLoc)) {
! 1875:
! 1876: refreshDungeonCell(monst->xLoc, monst->yLoc);
! 1877: }
! 1878: break;
! 1879: default:
! 1880: if (monst->status[i]) {
! 1881: monst->status[i]--;
! 1882: }
! 1883: break;
! 1884: }
! 1885: }
! 1886:
! 1887: if (monsterCanSubmergeNow(monst) && !(monst->bookkeepingFlags & MB_SUBMERGED)) {
! 1888: if (rand_percent(20)) {
! 1889: monst->bookkeepingFlags |= MB_SUBMERGED;
! 1890: if (!monst->status[STATUS_MAGICAL_FEAR]
! 1891: && monst->creatureState == MONSTER_FLEEING
! 1892: && (!(monst->info.flags & MONST_FLEES_NEAR_DEATH) || monst->currentHP >= monst->info.maxHP * 3 / 4)) {
! 1893:
! 1894: monst->creatureState = MONSTER_TRACKING_SCENT;
! 1895: }
! 1896: refreshDungeonCell(monst->xLoc, monst->yLoc);
! 1897: } else if (monst->info.flags & (MONST_RESTRICTED_TO_LIQUID)
! 1898: && monst->creatureState != MONSTER_ALLY) {
! 1899: monst->creatureState = MONSTER_FLEEING;
! 1900: }
! 1901: }
! 1902: }
! 1903:
! 1904: boolean traversiblePathBetween(creature *monst, short x2, short y2) {
! 1905: short coords[DCOLS][2], i, x, y, n;
! 1906: short originLoc[2] = {monst->xLoc, monst->yLoc};
! 1907: short targetLoc[2] = {x2, y2};
! 1908:
! 1909: n = getLineCoordinates(coords, originLoc, targetLoc);
! 1910:
! 1911: for (i=0; i<n; i++) {
! 1912: x = coords[i][0];
! 1913: y = coords[i][1];
! 1914: if (x == x2 && y == y2) {
! 1915: return true;
! 1916: }
! 1917: if (monsterAvoids(monst, x, y)) {
! 1918: return false;
! 1919: }
! 1920: }
! 1921: brogueAssert(false);
! 1922: return true; // should never get here
! 1923: }
! 1924:
! 1925: boolean specifiedPathBetween(short x1, short y1, short x2, short y2,
! 1926: unsigned long blockingTerrain, unsigned long blockingFlags) {
! 1927: short coords[DCOLS][2], i, x, y, n;
! 1928: short originLoc[2] = {x1, y1};
! 1929: short targetLoc[2] = {x2, y2};
! 1930: n = getLineCoordinates(coords, originLoc, targetLoc);
! 1931:
! 1932: for (i=0; i<n; i++) {
! 1933: x = coords[i][0];
! 1934: y = coords[i][1];
! 1935: if (cellHasTerrainFlag(x, y, blockingTerrain) || (pmap[x][y].flags & blockingFlags)) {
! 1936: return false;
! 1937: }
! 1938: if (x == x2 && y == y2) {
! 1939: return true;
! 1940: }
! 1941: }
! 1942: brogueAssert(false);
! 1943: return true; // should never get here
! 1944: }
! 1945:
! 1946: boolean openPathBetween(short x1, short y1, short x2, short y2) {
! 1947: short returnLoc[2], startLoc[2] = {x1, y1}, targetLoc[2] = {x2, y2};
! 1948:
! 1949: getImpactLoc(returnLoc, startLoc, targetLoc, DCOLS, false);
! 1950: if (returnLoc[0] == targetLoc[0] && returnLoc[1] == targetLoc[1]) {
! 1951: return true;
! 1952: }
! 1953: return false;
! 1954: }
! 1955:
! 1956: // will return the player if the player is at (x, y).
! 1957: creature *monsterAtLoc(short x, short y) {
! 1958: creature *monst;
! 1959: if (!(pmap[x][y].flags & (HAS_MONSTER | HAS_PLAYER))) {
! 1960: return NULL;
! 1961: }
! 1962: if (player.xLoc == x && player.yLoc == y) {
! 1963: return &player;
! 1964: }
! 1965: for (monst = monsters->nextCreature; monst != NULL && (monst->xLoc != x || monst->yLoc != y); monst = monst->nextCreature);
! 1966: return monst;
! 1967: }
! 1968:
! 1969: creature *dormantMonsterAtLoc(short x, short y) {
! 1970: creature *monst;
! 1971: if (!(pmap[x][y].flags & HAS_DORMANT_MONSTER)) {
! 1972: return NULL;
! 1973: }
! 1974: for (monst = dormantMonsters->nextCreature; monst != NULL && (monst->xLoc != x || monst->yLoc != y); monst = monst->nextCreature);
! 1975: return monst;
! 1976: }
! 1977:
! 1978: enum boltType monsterHasBoltEffect(creature *monst, enum boltEffects boltEffectIndex) {
! 1979: short i;
! 1980: for (i=0; monst->info.bolts[i] != 0; i++) {
! 1981: if (boltCatalog[monst->info.bolts[i]].boltEffect == boltEffectIndex) {
! 1982: return monst->info.bolts[i];
! 1983: }
! 1984: }
! 1985: return BOLT_NONE;
! 1986: }
! 1987:
! 1988: void pathTowardCreature(creature *monst, creature *target) {
! 1989: short targetLoc[2], dir;
! 1990:
! 1991: if (traversiblePathBetween(monst, target->xLoc, target->yLoc)) {
! 1992: if (distanceBetween(monst->xLoc, monst->yLoc, target->xLoc, target->yLoc) <= 2) {
! 1993: monst->bookkeepingFlags &= ~MB_GIVEN_UP_ON_SCENT;
! 1994: }
! 1995: targetLoc[0] = target->xLoc;
! 1996: targetLoc[1] = target->yLoc;
! 1997: moveMonsterPassivelyTowards(monst, targetLoc, (monst->creatureState != MONSTER_ALLY));
! 1998: return;
! 1999: }
! 2000:
! 2001: // is the target missing his map altogether?
! 2002: if (!target->mapToMe) {
! 2003: target->mapToMe = allocGrid();
! 2004: fillGrid(target->mapToMe, 0);
! 2005: calculateDistances(target->mapToMe, target->xLoc, target->yLoc, 0, monst, true, false);
! 2006: }
! 2007:
! 2008: // is the target map out of date?
! 2009: if (target->mapToMe[target->xLoc][target->yLoc] > 3) {
! 2010: // it is. recalculate the map.
! 2011: calculateDistances(target->mapToMe, target->xLoc, target->yLoc, 0, monst, true, false);
! 2012: }
! 2013:
! 2014: // blink to the target?
! 2015: if (distanceBetween(monst->xLoc, monst->yLoc, target->xLoc, target->yLoc) > 10
! 2016: || monstersAreEnemies(monst, target)) {
! 2017:
! 2018: if (monsterBlinkToPreferenceMap(monst, target->mapToMe, false)) { // if it blinked
! 2019: monst->ticksUntilTurn = monst->attackSpeed * (monst->info.flags & MONST_CAST_SPELLS_SLOWLY ? 2 : 1);
! 2020: return;
! 2021: }
! 2022: }
! 2023:
! 2024: // follow the map.
! 2025: dir = nextStep(target->mapToMe, monst->xLoc, monst->yLoc, monst, true);
! 2026: if (dir == NO_DIRECTION) {
! 2027: dir = randValidDirectionFrom(monst, monst->xLoc, monst->yLoc, true);
! 2028: }
! 2029: if (dir == NO_DIRECTION) {
! 2030: return; // monster is blocked
! 2031: }
! 2032: targetLoc[0] = monst->xLoc + nbDirs[dir][0];
! 2033: targetLoc[1] = monst->yLoc + nbDirs[dir][1];
! 2034:
! 2035: moveMonsterPassivelyTowards(monst, targetLoc, (monst->creatureState != MONSTER_ALLY));
! 2036: }
! 2037:
! 2038: boolean creatureEligibleForSwarming(creature *monst) {
! 2039: if ((monst->info.flags & (MONST_IMMOBILE | MONST_GETS_TURN_ON_ACTIVATION | MONST_MAINTAINS_DISTANCE))
! 2040: || monst->status[STATUS_ENTRANCED]
! 2041: || monst->status[STATUS_CONFUSED]
! 2042: || monst->status[STATUS_STUCK]
! 2043: || monst->status[STATUS_PARALYZED]
! 2044: || monst->status[STATUS_MAGICAL_FEAR]
! 2045: || monst->status[STATUS_LIFESPAN_REMAINING] == 1
! 2046: || (monst->bookkeepingFlags & (MB_SEIZED | MB_SEIZING))) {
! 2047:
! 2048: return false;
! 2049: }
! 2050: if (monst != &player
! 2051: && monst->creatureState != MONSTER_ALLY
! 2052: && monst->creatureState != MONSTER_TRACKING_SCENT) {
! 2053:
! 2054: return false;
! 2055: }
! 2056: return true;
! 2057: }
! 2058:
! 2059: // Swarming behavior.
! 2060: // If you’re adjacent to an enemy and about to strike it, and you’re adjacent to a hunting-mode tribemate
! 2061: // who is not adjacent to another enemy, and there is no empty space adjacent to the tribemate AND the enemy,
! 2062: // and there is an empty space adjacent to you AND the enemy, then move into that last space.
! 2063: // (In each case, "adjacent" excludes diagonal tiles obstructed by corner walls.)
! 2064: enum directions monsterSwarmDirection(creature *monst, creature *enemy) {
! 2065: short newX, newY, i;
! 2066: enum directions dir, targetDir;
! 2067: short dirList[8] = {0, 1, 2, 3, 4, 5, 6, 7};
! 2068: boolean alternateDirectionExists;
! 2069: creature *ally, *otherEnemy;
! 2070:
! 2071: if (monst == &player || !creatureEligibleForSwarming(monst)) {
! 2072: return NO_DIRECTION;
! 2073: }
! 2074:
! 2075: if (distanceBetween(monst->xLoc, monst->yLoc, enemy->xLoc, enemy->yLoc) != 1
! 2076: || (diagonalBlocked(monst->xLoc, monst->yLoc, enemy->xLoc, enemy->yLoc, false) || (enemy->info.flags & MONST_ATTACKABLE_THRU_WALLS))
! 2077: || !monstersAreEnemies(monst, enemy)) {
! 2078:
! 2079: return NO_DIRECTION; // Too far from the enemy, diagonally blocked, or not enemies with it.
! 2080: }
! 2081:
! 2082: // Find a location that is adjacent to you and to the enemy.
! 2083: targetDir = NO_DIRECTION;
! 2084: shuffleList(dirList, 4);
! 2085: shuffleList(&(dirList[4]), 4);
! 2086: for (i=0; i<8 && targetDir == NO_DIRECTION; i++) {
! 2087: dir = dirList[i];
! 2088: newX = monst->xLoc + nbDirs[dir][0];
! 2089: newY = monst->yLoc + nbDirs[dir][1];
! 2090: if (coordinatesAreInMap(newX, newY)
! 2091: && distanceBetween(enemy->xLoc, enemy->yLoc, newX, newY) == 1
! 2092: && !(pmap[newX][newY].flags & (HAS_PLAYER | HAS_MONSTER))
! 2093: && !diagonalBlocked(monst->xLoc, monst->yLoc, newX, newY, false)
! 2094: && (!diagonalBlocked(enemy->xLoc, enemy->yLoc, newX, newY, false) || (enemy->info.flags & MONST_ATTACKABLE_THRU_WALLS))
! 2095: && !monsterAvoids(monst, newX, newY)) {
! 2096:
! 2097: targetDir = dir;
! 2098: }
! 2099: }
! 2100: if (targetDir == NO_DIRECTION) {
! 2101: return NO_DIRECTION; // No open location next to both you and the enemy.
! 2102: }
! 2103:
! 2104: // OK, now we have a place to move toward. Let's analyze the teammates around us to make sure that
! 2105: // one of them could take advantage of the space we open.
! 2106: CYCLE_MONSTERS_AND_PLAYERS(ally) {
! 2107: if (ally != monst
! 2108: && ally != enemy
! 2109: && monstersAreTeammates(monst, ally)
! 2110: && monstersAreEnemies(ally, enemy)
! 2111: && creatureEligibleForSwarming(ally)
! 2112: && distanceBetween(monst->xLoc, monst->yLoc, ally->xLoc, ally->yLoc) == 1
! 2113: && !diagonalBlocked(monst->xLoc, monst->yLoc, ally->xLoc, ally->yLoc, false)
! 2114: && !monsterAvoids(ally, monst->xLoc, monst->yLoc)
! 2115: && (distanceBetween(enemy->xLoc, enemy->yLoc, ally->xLoc, ally->yLoc) > 1 || diagonalBlocked(enemy->xLoc, enemy->yLoc, ally->xLoc, ally->yLoc, false))) {
! 2116:
! 2117: // Found a prospective ally.
! 2118: // Check that there isn't already an open space from which to attack the enemy that is accessible to the ally.
! 2119: alternateDirectionExists = false;
! 2120: for (dir=0; dir< DIRECTION_COUNT && !alternateDirectionExists; dir++) {
! 2121: newX = ally->xLoc + nbDirs[dir][0];
! 2122: newY = ally->yLoc + nbDirs[dir][1];
! 2123: if (coordinatesAreInMap(newX, newY)
! 2124: && !(pmap[newX][newY].flags & (HAS_PLAYER | HAS_MONSTER))
! 2125: && distanceBetween(enemy->xLoc, enemy->yLoc, newX, newY) == 1
! 2126: && !diagonalBlocked(enemy->xLoc, enemy->yLoc, newX, newY, false)
! 2127: && !diagonalBlocked(ally->xLoc, ally->yLoc, newX, newY, false)
! 2128: && !monsterAvoids(ally, newX, newY)) {
! 2129:
! 2130: alternateDirectionExists = true;
! 2131: }
! 2132: }
! 2133: if (!alternateDirectionExists) {
! 2134: // OK, no alternative open spaces exist.
! 2135: // Check that the ally isn't already occupied with an enemy of its own.
! 2136: CYCLE_MONSTERS_AND_PLAYERS(otherEnemy) {
! 2137: if (ally != otherEnemy
! 2138: && monst != otherEnemy
! 2139: && enemy != otherEnemy
! 2140: && monstersAreEnemies(ally, otherEnemy)
! 2141: && distanceBetween(ally->xLoc, ally->yLoc, otherEnemy->xLoc, otherEnemy->yLoc) == 1
! 2142: && (!diagonalBlocked(ally->xLoc, ally->yLoc, otherEnemy->xLoc, otherEnemy->yLoc, false) || (otherEnemy->info.flags & MONST_ATTACKABLE_THRU_WALLS))) {
! 2143:
! 2144: break; // Ally is already occupied.
! 2145: }
! 2146: }
! 2147: if (otherEnemy == NULL) {
! 2148: // Success!
! 2149: return targetDir;
! 2150: }
! 2151: }
! 2152: }
! 2153: }
! 2154: return NO_DIRECTION; // Failure!
! 2155: }
! 2156:
! 2157: // Isomorphs a number in [0, 39] to coordinates along the square of radius 5 surrounding (0,0).
! 2158: // This is used as the sample space for bolt target coordinates, e.g. when reflecting or when
! 2159: // monsters are deciding where to blink.
! 2160: void perimeterCoords(short returnCoords[2], short n) {
! 2161: if (n <= 10) { // top edge, left to right
! 2162: returnCoords[0] = n - 5;
! 2163: returnCoords[1] = -5;
! 2164: } else if (n <= 21) { // bottom edge, left to right
! 2165: returnCoords[0] = (n - 11) - 5;
! 2166: returnCoords[1] = 5;
! 2167: } else if (n <= 30) { // left edge, top to bottom
! 2168: returnCoords[0] = -5;
! 2169: returnCoords[1] = (n - 22) - 4;
! 2170: } else if (n <= 39) { // right edge, top to bottom
! 2171: returnCoords[0] = 5;
! 2172: returnCoords[1] = (n - 31) - 4;
! 2173: } else {
! 2174: message("ERROR! Bad perimeter coordinate request!", true);
! 2175: returnCoords[0] = returnCoords[1] = 0; // garbage in, garbage out
! 2176: }
! 2177: }
! 2178:
! 2179: // Tries to make the monster blink to the most desirable square it can aim at, according to the
! 2180: // preferenceMap argument. "blinkUphill" determines whether it's aiming for higher or lower numbers on
! 2181: // the preference map -- true means higher. Returns true if the monster blinked; false if it didn't.
! 2182: boolean monsterBlinkToPreferenceMap(creature *monst, short **preferenceMap, boolean blinkUphill) {
! 2183: short i, bestTarget[2], bestPreference, nowPreference, maxDistance, target[2], impact[2], origin[2];
! 2184: boolean gotOne;
! 2185: char monstName[DCOLS];
! 2186: char buf[DCOLS];
! 2187: enum boltType theBoltType;
! 2188: bolt theBolt;
! 2189:
! 2190: theBoltType = monsterHasBoltEffect(monst, BE_BLINKING);
! 2191: if (!theBoltType) {
! 2192: return false;
! 2193: }
! 2194:
! 2195: maxDistance = staffBlinkDistance(5 * FP_FACTOR);
! 2196: gotOne = false;
! 2197:
! 2198: origin[0] = monst->xLoc;
! 2199: origin[1] = monst->yLoc;
! 2200:
! 2201: bestTarget[0] = 0;
! 2202: bestTarget[1] = 0;
! 2203: bestPreference = preferenceMap[monst->xLoc][monst->yLoc];
! 2204:
! 2205: // make sure that we beat the four cardinal neighbors
! 2206: for (i = 0; i < 4; i++) {
! 2207: nowPreference = preferenceMap[monst->xLoc + nbDirs[i][0]][monst->yLoc + nbDirs[i][1]];
! 2208:
! 2209: if (((blinkUphill && nowPreference > bestPreference) || (!blinkUphill && nowPreference < bestPreference))
! 2210: && !monsterAvoids(monst, monst->xLoc + nbDirs[i][0], monst->yLoc + nbDirs[i][1])) {
! 2211:
! 2212: bestPreference = nowPreference;
! 2213: }
! 2214: }
! 2215:
! 2216: for (i=0; i<40; i++) {
! 2217: perimeterCoords(target, i);
! 2218: target[0] += monst->xLoc;
! 2219: target[1] += monst->yLoc;
! 2220:
! 2221: getImpactLoc(impact, origin, target, maxDistance, true);
! 2222: nowPreference = preferenceMap[impact[0]][impact[1]];
! 2223:
! 2224: if (((blinkUphill && (nowPreference > bestPreference))
! 2225: || (!blinkUphill && (nowPreference < bestPreference)))
! 2226: && !monsterAvoids(monst, impact[0], impact[1])) {
! 2227:
! 2228: bestTarget[0] = target[0];
! 2229: bestTarget[1] = target[1];
! 2230: bestPreference = nowPreference;
! 2231:
! 2232: if ((abs(impact[0] - origin[0]) > 1 || abs(impact[1] - origin[1]) > 1)
! 2233: || (cellHasTerrainFlag(impact[0], origin[1], T_OBSTRUCTS_PASSABILITY))
! 2234: || (cellHasTerrainFlag(origin[0], impact[1], T_OBSTRUCTS_PASSABILITY))) {
! 2235: gotOne = true;
! 2236: } else {
! 2237: gotOne = false;
! 2238: }
! 2239: }
! 2240: }
! 2241:
! 2242: if (gotOne) {
! 2243: if (canDirectlySeeMonster(monst)) {
! 2244: monsterName(monstName, monst, true);
! 2245: sprintf(buf, "%s blinks", monstName);
! 2246: combatMessage(buf, 0);
! 2247: }
! 2248: monst->ticksUntilTurn = monst->attackSpeed * (monst->info.flags & MONST_CAST_SPELLS_SLOWLY ? 2 : 1);
! 2249: theBolt = boltCatalog[theBoltType];
! 2250: zap(origin, bestTarget, &theBolt, false);
! 2251: return true;
! 2252: }
! 2253: return false;
! 2254: }
! 2255:
! 2256: boolean fleeingMonsterAwareOfPlayer(creature *monst) {
! 2257: if (player.status[STATUS_INVISIBLE]) {
! 2258: return (distanceBetween(monst->xLoc, monst->yLoc, player.xLoc, player.yLoc) <= 1);
! 2259: } else {
! 2260: return (pmap[monst->xLoc][monst->yLoc].flags & IN_FIELD_OF_VIEW) ? true : false;
! 2261: }
! 2262: }
! 2263:
! 2264: // returns whether the monster did something (and therefore ended its turn)
! 2265: boolean monsterBlinkToSafety(creature *monst) {
! 2266: short **blinkSafetyMap;
! 2267:
! 2268: if (monst->creatureState == MONSTER_ALLY) {
! 2269: if (!rogue.updatedAllySafetyMapThisTurn) {
! 2270: updateAllySafetyMap();
! 2271: }
! 2272: blinkSafetyMap = allySafetyMap;
! 2273: } else if (fleeingMonsterAwareOfPlayer(monst)) {
! 2274: if (monst->safetyMap) {
! 2275: freeGrid(monst->safetyMap);
! 2276: monst->safetyMap = NULL;
! 2277: }
! 2278: if (!rogue.updatedSafetyMapThisTurn) {
! 2279: updateSafetyMap();
! 2280: }
! 2281: blinkSafetyMap = safetyMap;
! 2282: } else {
! 2283: if (!monst->safetyMap) {
! 2284: if (!rogue.updatedSafetyMapThisTurn) {
! 2285: updateSafetyMap();
! 2286: }
! 2287: monst->safetyMap = allocGrid();
! 2288: copyGrid(monst->safetyMap, safetyMap);
! 2289: }
! 2290: blinkSafetyMap = monst->safetyMap;
! 2291: }
! 2292:
! 2293: return monsterBlinkToPreferenceMap(monst, blinkSafetyMap, false);
! 2294: }
! 2295:
! 2296: boolean monsterSummons(creature *monst, boolean alwaysUse) {
! 2297: creature *target;
! 2298: short minionCount = 0;
! 2299:
! 2300: if (monst->info.abilityFlags & (MA_CAST_SUMMON)) {
! 2301: // Count existing minions.
! 2302: for (target = monsters->nextCreature; target != NULL; target = target->nextCreature) {
! 2303: if (monst->creatureState == MONSTER_ALLY) {
! 2304: if (target->creatureState == MONSTER_ALLY) {
! 2305: minionCount++; // Allied summoners count all allies.
! 2306: }
! 2307: } else if ((target->bookkeepingFlags & MB_FOLLOWER) && target->leader == monst) {
! 2308: minionCount++; // Enemy summoners count only direct followers, not teammates.
! 2309: }
! 2310: }
! 2311: if (monst->creatureState == MONSTER_ALLY) { // Allied summoners also count monsters on the previous and next depths.
! 2312: if (rogue.depthLevel > 1) {
! 2313: for (target = levels[rogue.depthLevel - 2].monsters; target != NULL; target = target->nextCreature) {
! 2314: if (target->creatureState == MONSTER_ALLY && !(target->info.flags & MONST_WILL_NOT_USE_STAIRS)) {
! 2315: minionCount++;
! 2316: }
! 2317: }
! 2318: }
! 2319: if (rogue.depthLevel < DEEPEST_LEVEL) {
! 2320: for (target = levels[rogue.depthLevel].monsters; target != NULL; target = target->nextCreature) {
! 2321: if (target->creatureState == MONSTER_ALLY && !(target->info.flags & MONST_WILL_NOT_USE_STAIRS)) {
! 2322: minionCount++;
! 2323: }
! 2324: }
! 2325: }
! 2326: }
! 2327: if (alwaysUse && minionCount < 50) {
! 2328: summonMinions(monst);
! 2329: return true;
! 2330: } else if (monst->info.abilityFlags & MA_ENTER_SUMMONS) {
! 2331: if (!rand_range(0, 7)) {
! 2332: summonMinions(monst);
! 2333: return true;
! 2334: }
! 2335: } else if ((monst->creatureState != MONSTER_ALLY || minionCount < 5)
! 2336: && !rand_range(0, minionCount * minionCount * 3 + 1)) {
! 2337:
! 2338: summonMinions(monst);
! 2339: return true;
! 2340: }
! 2341: }
! 2342: return false;
! 2343: }
! 2344:
! 2345: // Some monsters never make good targets irrespective of what bolt we're contemplating.
! 2346: // Return false for those. Otherwise, return true.
! 2347: boolean generallyValidBoltTarget(creature *caster, creature *target) {
! 2348: if (caster == target) {
! 2349: // Can't target yourself; that's the fundamental theorem of Brogue bolts.
! 2350: return false;
! 2351: }
! 2352: if (rogue.patchVersion >= 3
! 2353: && caster->status[STATUS_DISCORDANT]
! 2354: && caster->creatureState == MONSTER_WANDERING
! 2355: && target == &player) {
! 2356: // Discordant monsters always try to cast spells regardless of whether
! 2357: // they're hunting the player, so that they cast at other monsters. This
! 2358: // by bypasses the usual awareness checks, so the player and any allies
! 2359: // can be hit when far away. Hence, we don't target the player with
! 2360: // bolts if we're discordant and wandering.
! 2361: return false;
! 2362: }
! 2363: if (monsterIsHidden(target, caster)
! 2364: || (target->bookkeepingFlags & MB_SUBMERGED)) {
! 2365: // No bolt will affect a submerged creature. Can't shoot at invisible creatures unless it's in gas.
! 2366: return false;
! 2367: }
! 2368: return openPathBetween(caster->xLoc, caster->yLoc, target->xLoc, target->yLoc);
! 2369: }
! 2370:
! 2371: boolean targetEligibleForCombatBuff(creature *caster, creature *target) {
! 2372: creature *enemy;
! 2373:
! 2374: if (caster->creatureState == MONSTER_ALLY) {
! 2375: if (canDirectlySeeMonster(caster)) {
! 2376: CYCLE_MONSTERS_AND_PLAYERS(enemy) {
! 2377: if (monstersAreEnemies(&player, enemy)
! 2378: && canSeeMonster(enemy)
! 2379: && (pmap[enemy->xLoc][enemy->yLoc].flags & IN_FIELD_OF_VIEW)) {
! 2380:
! 2381: return true;
! 2382: }
! 2383: }
! 2384: }
! 2385: return false;
! 2386: } else {
! 2387: return (target->creatureState == MONSTER_TRACKING_SCENT);
! 2388: }
! 2389: }
! 2390:
! 2391: // Make a decision as to whether the given caster should fire the given bolt at the given target.
! 2392: // Assumes that the conditions in generallyValidBoltTarget have already been satisfied.
! 2393: boolean specificallyValidBoltTarget(creature *caster, creature *target, enum boltType theBoltType) {
! 2394:
! 2395: if ((boltCatalog[theBoltType].flags & BF_TARGET_ALLIES)
! 2396: && (!monstersAreTeammates(caster, target) || monstersAreEnemies(caster, target))) {
! 2397:
! 2398: return false;
! 2399: }
! 2400: if ((boltCatalog[theBoltType].flags & BF_TARGET_ENEMIES)
! 2401: && (!monstersAreEnemies(caster, target))) {
! 2402:
! 2403: return false;
! 2404: }
! 2405: if ((boltCatalog[theBoltType].flags & BF_TARGET_ENEMIES)
! 2406: && (target->info.flags & MONST_INVULNERABLE)) {
! 2407:
! 2408: return false;
! 2409: }
! 2410: if ((target->info.flags & MONST_REFLECT_4)
! 2411: && target->creatureState != MONSTER_ALLY
! 2412: && !(boltCatalog[theBoltType].flags & (BF_NEVER_REFLECTS | BF_HALTS_BEFORE_OBSTRUCTION))) {
! 2413: // Don't fire a reflectable bolt at a reflective target unless it's your ally.
! 2414: return false;
! 2415: }
! 2416: if (boltCatalog[theBoltType].forbiddenMonsterFlags & target->info.flags) {
! 2417: // Don't fire a bolt at a creature type that it won't affect.
! 2418: return false;
! 2419: }
! 2420: if ((boltCatalog[theBoltType].flags & BF_FIERY)
! 2421: && target->status[STATUS_IMMUNE_TO_FIRE]) {
! 2422: // Don't shoot fireballs at fire-immune creatures.
! 2423: return false;
! 2424: }
! 2425: if ((boltCatalog[theBoltType].flags & BF_FIERY)
! 2426: && burnedTerrainFlagsAtLoc(caster->xLoc, caster->yLoc) & avoidedFlagsForMonster(&(caster->info))) {
! 2427: // Don't shoot fireballs if you're standing on a tile that could combust into something that harms you.
! 2428: return false;
! 2429: }
! 2430:
! 2431: // Rules specific to bolt effects:
! 2432: switch (boltCatalog[theBoltType].boltEffect) {
! 2433: case BE_BECKONING:
! 2434: if (distanceBetween(caster->xLoc, caster->yLoc, target->xLoc, target->yLoc) <= 1) {
! 2435: return false;
! 2436: }
! 2437: break;
! 2438: case BE_ATTACK:
! 2439: if (cellHasTerrainFlag(target->xLoc, target->yLoc, T_OBSTRUCTS_PASSABILITY)
! 2440: && !(target->info.flags & MONST_ATTACKABLE_THRU_WALLS)) {
! 2441: // Don't shoot an arrow at an embedded creature.
! 2442: return false;
! 2443: }
! 2444: // continue to BE_DAMAGE below
! 2445: case BE_DAMAGE:
! 2446: if (target->status[STATUS_ENTRANCED]
! 2447: && monstersAreEnemies(caster, target)) {
! 2448: // Don't break your enemies' entrancement.
! 2449: return false;
! 2450: }
! 2451: break;
! 2452: case BE_NONE:
! 2453: // BE_NONE bolts are always going to be all about the terrain effects,
! 2454: // so our logic has to follow from the terrain parameters of the bolt's target DF.
! 2455: if (boltCatalog[theBoltType].targetDF) {
! 2456: const unsigned long terrainFlags = tileCatalog[dungeonFeatureCatalog[boltCatalog[theBoltType].targetDF].tile].flags;
! 2457: if ((terrainFlags & T_ENTANGLES)
! 2458: && target->status[STATUS_STUCK]) {
! 2459: // Don't try to entangle a creature that is already entangled.
! 2460: return false;
! 2461: }
! 2462: if ((boltCatalog[theBoltType].flags & BF_TARGET_ENEMIES)
! 2463: && !(terrainFlags & avoidedFlagsForMonster(&(target->info)))
! 2464: && (!(terrainFlags & T_ENTANGLES) || (target->info.flags & MONST_IMMUNE_TO_WEBS))) {
! 2465:
! 2466: return false;
! 2467: }
! 2468: }
! 2469: break;
! 2470: case BE_DISCORD:
! 2471: if (target->status[STATUS_DISCORDANT]
! 2472: || target == &player) {
! 2473: // Don't cast discord if the target is already discordant, or if it is the player.
! 2474: // (Players should never be intentionally targeted by discord. It's just a fact of monster psychology.)
! 2475: return false;
! 2476: }
! 2477: break;
! 2478: case BE_NEGATION:
! 2479: if (monstersAreEnemies(caster, target)) {
! 2480: if (target->status[STATUS_HASTED] || target->status[STATUS_TELEPATHIC] || target->status[STATUS_SHIELDED]) {
! 2481: // Dispel haste, telepathy, protection.
! 2482: return true;
! 2483: }
! 2484: if (target->info.flags & (MONST_DIES_IF_NEGATED | MONST_IMMUNE_TO_WEAPONS)) {
! 2485: // Dispel magic creatures; strip weapon invulnerability from revenants.
! 2486: return true;
! 2487: }
! 2488: if ((target->status[STATUS_IMMUNE_TO_FIRE] || target->status[STATUS_LEVITATING])
! 2489: && cellHasTerrainFlag(target->xLoc, target->yLoc, (T_LAVA_INSTA_DEATH | T_IS_DEEP_WATER | T_AUTO_DESCENT))) {
! 2490: // Drop the target into lava or a chasm if opportunity knocks.
! 2491: return true;
! 2492: }
! 2493: if (monstersAreTeammates(caster, target)
! 2494: && target->status[STATUS_DISCORDANT]
! 2495: && !(target->info.flags & MONST_DIES_IF_NEGATED)) {
! 2496: // Dispel discord from allies unless it would destroy them.
! 2497: return true;
! 2498: }
! 2499: } else if (monstersAreTeammates(caster, target)) {
! 2500: if (target == &player && rogue.armor && (rogue.armor->flags & ITEM_RUNIC) && (rogue.armor->flags & ITEM_RUNIC_IDENTIFIED)
! 2501: && rogue.armor->enchant2 == A_REFLECTION && netEnchant(rogue.armor) > 0) {
! 2502: // Allies shouldn't cast negation on the player if she's knowingly wearing armor of reflection.
! 2503: // Too much risk of negating themselves in the process.
! 2504: return false;
! 2505: }
! 2506: if (target->info.flags & MONST_DIES_IF_NEGATED) {
! 2507: // Never cast negation if it would destroy an allied creature.
! 2508: return false;
! 2509: }
! 2510: if (target->status[STATUS_ENTRANCED]
! 2511: && caster->creatureState != MONSTER_ALLY) {
! 2512: // Non-allied monsters will dispel entrancement on their own kind.
! 2513: return true;
! 2514: }
! 2515: if (target->status[STATUS_MAGICAL_FEAR]) {
! 2516: // Dispel magical fear.
! 2517: return true;
! 2518: }
! 2519: }
! 2520: return false; // Don't cast negation unless there's a good reason.
! 2521: break;
! 2522: case BE_SLOW:
! 2523: if (target->status[STATUS_SLOWED]) {
! 2524: return false;
! 2525: }
! 2526: break;
! 2527: case BE_HASTE:
! 2528: if (target->status[STATUS_HASTED]) {
! 2529: return false;
! 2530: }
! 2531: if (!targetEligibleForCombatBuff(caster, target)) {
! 2532: return false;
! 2533: }
! 2534: break;
! 2535: case BE_SHIELDING:
! 2536: if (target->status[STATUS_SHIELDED]) {
! 2537: return false;
! 2538: }
! 2539: if (!targetEligibleForCombatBuff(caster, target)) {
! 2540: return false;
! 2541: }
! 2542: break;
! 2543: case BE_HEALING:
! 2544: if (target->currentHP >= target->info.maxHP) {
! 2545: // Don't heal a creature already at full health.
! 2546: return false;
! 2547: }
! 2548: break;
! 2549: case BE_TUNNELING:
! 2550: case BE_OBSTRUCTION:
! 2551: // Monsters will never cast these.
! 2552: return false;
! 2553: break;
! 2554: default:
! 2555: break;
! 2556: }
! 2557: return true;
! 2558: }
! 2559:
! 2560: void monsterCastSpell(creature *caster, creature *target, enum boltType boltIndex) {
! 2561: bolt theBolt;
! 2562: short originLoc[2], targetLoc[2];
! 2563: char buf[200], monstName[100];
! 2564:
! 2565: if (canDirectlySeeMonster(caster)) {
! 2566: monsterName(monstName, caster, true);
! 2567: sprintf(buf, "%s %s", monstName, boltCatalog[boltIndex].description);
! 2568: resolvePronounEscapes(buf, caster);
! 2569: combatMessage(buf, 0);
! 2570: }
! 2571:
! 2572: theBolt = boltCatalog[boltIndex];
! 2573: originLoc[0] = caster->xLoc;
! 2574: originLoc[1] = caster->yLoc;
! 2575: targetLoc[0] = target->xLoc;
! 2576: targetLoc[1] = target->yLoc;
! 2577: zap(originLoc, targetLoc, &theBolt, false);
! 2578:
! 2579: if (player.currentHP <= 0) {
! 2580: gameOver(monsterCatalog[caster->info.monsterID].monsterName, false);
! 2581: }
! 2582: }
! 2583:
! 2584: // returns whether the monster cast a bolt.
! 2585: boolean monstUseBolt(creature *monst) {
! 2586: creature *target;
! 2587: short i;
! 2588:
! 2589: if (!monst->info.bolts[0]) {
! 2590: return false; // Don't waste time with monsters that can't cast anything.
! 2591: }
! 2592:
! 2593: CYCLE_MONSTERS_AND_PLAYERS(target) {
! 2594: if (generallyValidBoltTarget(monst, target)) {
! 2595: for (i = 0; monst->info.bolts[i]; i++) {
! 2596: if (boltCatalog[monst->info.bolts[i]].boltEffect == BE_BLINKING) {
! 2597: continue; // Blinking is handled elsewhere.
! 2598: }
! 2599: if (specificallyValidBoltTarget(monst, target, monst->info.bolts[i])) {
! 2600: if ((monst->info.flags & MONST_ALWAYS_USE_ABILITY)
! 2601: || rand_percent(30)) {
! 2602:
! 2603: monsterCastSpell(monst, target, monst->info.bolts[i]);
! 2604: return true;
! 2605: }
! 2606: }
! 2607: }
! 2608: }
! 2609: }
! 2610: return false;
! 2611: }
! 2612:
! 2613: // returns whether the monster did something (and therefore ended its turn)
! 2614: boolean monstUseMagic(creature *monst) {
! 2615: if (monsterSummons(monst, (monst->info.flags & MONST_ALWAYS_USE_ABILITY))) {
! 2616: return true;
! 2617: } else if (monstUseBolt(monst)) {
! 2618: return true;
! 2619: }
! 2620: return false;
! 2621: }
! 2622:
! 2623: boolean isLocalScentMaximum(short x, short y) {
! 2624: enum directions dir;
! 2625: short newX, newY;
! 2626:
! 2627: const short baselineScent = scentMap[x][y];
! 2628:
! 2629: for (dir=0; dir< DIRECTION_COUNT; dir++) {
! 2630: newX = x + nbDirs[dir][0];
! 2631: newY = y + nbDirs[dir][1];
! 2632: if (coordinatesAreInMap(newX, newY)
! 2633: && (scentMap[newX][newY] > baselineScent)
! 2634: && !cellHasTerrainFlag(newX, newY, T_OBSTRUCTS_PASSABILITY)
! 2635: && !diagonalBlocked(x, y, newX, newY, false)) {
! 2636:
! 2637: return false;
! 2638: }
! 2639: }
! 2640: return true;
! 2641: }
! 2642:
! 2643: // Returns the direction the player's scent points to from a given cell. Returns -1 if the nose comes up blank.
! 2644: enum directions scentDirection(creature *monst) {
! 2645: short newX, newY, x, y, newestX, newestY;
! 2646: enum directions bestDirection = NO_DIRECTION, dir, dir2;
! 2647: unsigned short bestNearbyScent = 0;
! 2648: boolean canTryAgain = true;
! 2649: creature *otherMonst;
! 2650:
! 2651: x = monst->xLoc;
! 2652: y = monst->yLoc;
! 2653:
! 2654: for (;;) {
! 2655:
! 2656: for (dir=0; dir< DIRECTION_COUNT; dir++) {
! 2657: newX = x + nbDirs[dir][0];
! 2658: newY = y + nbDirs[dir][1];
! 2659: otherMonst = monsterAtLoc(newX, newY);
! 2660: if (coordinatesAreInMap(newX, newY)
! 2661: && (scentMap[newX][newY] > bestNearbyScent)
! 2662: && (!(pmap[newX][newY].flags & HAS_MONSTER) || (otherMonst && canPass(monst, otherMonst)))
! 2663: && !cellHasTerrainFlag(newX, newY, T_OBSTRUCTS_PASSABILITY)
! 2664: && !diagonalBlocked(x, y, newX, newY, false)
! 2665: && !monsterAvoids(monst, newX, newY)) {
! 2666:
! 2667: bestNearbyScent = scentMap[newX][newY];
! 2668: bestDirection = dir;
! 2669: }
! 2670: }
! 2671:
! 2672: if (bestDirection >= 0 && bestNearbyScent > scentMap[x][y]) {
! 2673: return bestDirection;
! 2674: }
! 2675:
! 2676: if (canTryAgain) {
! 2677: // Okay, the monster may be stuck in some irritating diagonal.
! 2678: // If so, we can diffuse the scent into the offending kink and solve the problem.
! 2679: // There's a possibility he's stuck for some other reason, though, so we'll only
! 2680: // try once per his move -- hence the failsafe.
! 2681: canTryAgain = false;
! 2682: for (dir=0; dir<4; dir++) {
! 2683: newX = x + nbDirs[dir][0];
! 2684: newY = y + nbDirs[dir][1];
! 2685: for (dir2=0; dir2<4; dir2++) {
! 2686: newestX = newX + nbDirs[dir2][0];
! 2687: newestY = newY + nbDirs[dir2][1];
! 2688: if (coordinatesAreInMap(newX, newY) && coordinatesAreInMap(newestX, newestY)) {
! 2689: scentMap[newX][newY] = max(scentMap[newX][newY], scentMap[newestX][newestY] - 1);
! 2690: }
! 2691: }
! 2692: }
! 2693: } else {
! 2694: return NO_DIRECTION; // failure!
! 2695: }
! 2696: }
! 2697: }
! 2698:
! 2699: // returns true if the resurrection was successful.
! 2700: boolean resurrectAlly(const short x, const short y) {
! 2701: boolean success;
! 2702: creature *monst;
! 2703: monst = purgatory->nextCreature;
! 2704: if (monst) {
! 2705: // Remove from purgatory and insert into the mortal plane.
! 2706: purgatory->nextCreature = purgatory->nextCreature->nextCreature;
! 2707: monst->nextCreature = monsters->nextCreature;
! 2708: monsters->nextCreature = monst;
! 2709: getQualifyingPathLocNear(&monst->xLoc, &monst->yLoc, x, y, true,
! 2710: (T_PATHING_BLOCKER | T_HARMFUL_TERRAIN), 0,
! 2711: 0, (HAS_PLAYER | HAS_MONSTER), false);
! 2712: pmap[monst->xLoc][monst->yLoc].flags |= HAS_MONSTER;
! 2713:
! 2714: // Restore health etc.
! 2715: monst->bookkeepingFlags &= ~(MB_IS_DYING | MB_IS_FALLING);
! 2716: if (!(monst->info.flags & MONST_FIERY)
! 2717: && monst->status[STATUS_BURNING]) {
! 2718:
! 2719: monst->status[STATUS_BURNING] = 0;
! 2720: }
! 2721: monst->status[STATUS_DISCORDANT] = 0;
! 2722: heal(monst, 100, true);
! 2723:
! 2724: success = true;
! 2725: } else {
! 2726: success = false;
! 2727: }
! 2728: return success;
! 2729: }
! 2730:
! 2731: void unAlly(creature *monst) {
! 2732: if (monst->creatureState == MONSTER_ALLY) {
! 2733: monst->creatureState = MONSTER_TRACKING_SCENT;
! 2734: monst->bookkeepingFlags &= ~(MB_FOLLOWER | MB_TELEPATHICALLY_REVEALED);
! 2735: monst->leader = NULL;
! 2736: }
! 2737: }
! 2738:
! 2739: boolean monsterFleesFrom(creature *monst, creature *defender) {
! 2740: const short x = monst->xLoc;
! 2741: const short y = monst->yLoc;
! 2742:
! 2743: if (!monsterWillAttackTarget(defender, monst)) {
! 2744: return false;
! 2745: }
! 2746:
! 2747: if (distanceBetween(x, y, defender->xLoc, defender->yLoc) >= 4) {
! 2748: return false;
! 2749: }
! 2750:
! 2751: if ((defender->info.flags & (MONST_IMMUNE_TO_WEAPONS | MONST_INVULNERABLE))
! 2752: && !(defender->info.flags & MONST_IMMOBILE)) {
! 2753: // Don't charge if the monster is damage-immune and is NOT immobile;
! 2754: // i.e., keep distance from revenants and stone guardians but not mirror totems.
! 2755: return true;
! 2756: }
! 2757:
! 2758: if ((monst->info.flags & MONST_MAINTAINS_DISTANCE)
! 2759: || (defender->info.abilityFlags & MA_KAMIKAZE)) {
! 2760:
! 2761: // Don't charge if you maintain distance or if it's a kamikaze monster.
! 2762: return true;
! 2763: }
! 2764:
! 2765: if (monst->info.abilityFlags & MA_POISONS
! 2766: && defender->status[STATUS_POISONED] * defender->poisonAmount > defender->currentHP) {
! 2767:
! 2768: return true;
! 2769: }
! 2770:
! 2771: return false;
! 2772: }
! 2773:
! 2774: boolean allyFlees(creature *ally, creature *closestEnemy) {
! 2775: const short x = ally->xLoc;
! 2776: const short y = ally->yLoc;
! 2777:
! 2778: if (!closestEnemy) {
! 2779: return false; // No one to flee from.
! 2780: }
! 2781:
! 2782: if (ally->info.maxHP <= 1 || (ally->status[STATUS_LIFESPAN_REMAINING]) > 0) { // Spectral blades and timed allies should never flee.
! 2783: return false;
! 2784: }
! 2785:
! 2786: if (distanceBetween(x, y, closestEnemy->xLoc, closestEnemy->yLoc) < 10
! 2787: && (100 * ally->currentHP / ally->info.maxHP <= 33)
! 2788: && ally->info.turnsBetweenRegen > 0
! 2789: && !ally->carriedMonster
! 2790: && ((ally->info.flags & MONST_FLEES_NEAR_DEATH) || (100 * ally->currentHP / ally->info.maxHP * 2 < 100 * player.currentHP / player.info.maxHP))) {
! 2791: // Flee if you're within 10 spaces, your HP is under 1/3, you're not a phoenix or lich or vampire in bat form,
! 2792: // and you either flee near death or your health fraction is less than half of the player's.
! 2793: return true;
! 2794: }
! 2795:
! 2796: // so do allies that keep their distance or while in the presence of damage-immune or kamikaze enemies
! 2797: if (monsterFleesFrom(ally, closestEnemy)) {
! 2798: // Flee if you're within 3 spaces and you either flee near death or the closest enemy is a bloat, revenant or guardian.
! 2799: return true;
! 2800: }
! 2801:
! 2802: return false;
! 2803: }
! 2804:
! 2805: void monsterMillAbout(creature *monst, short movementChance) {
! 2806: enum directions dir;
! 2807: short targetLoc[2];
! 2808:
! 2809: const short x = monst->xLoc;
! 2810: const short y = monst->yLoc;
! 2811:
! 2812: if (rand_percent(movementChance)) {
! 2813: dir = randValidDirectionFrom(monst, x, y, true);
! 2814: if (dir != -1) {
! 2815: targetLoc[0] = x + nbDirs[dir][0];
! 2816: targetLoc[1] = y + nbDirs[dir][1];
! 2817: moveMonsterPassivelyTowards(monst, targetLoc, false);
! 2818: }
! 2819: }
! 2820: }
! 2821:
! 2822: void moveAlly(creature *monst) {
! 2823: creature *target, *closestMonster = NULL;
! 2824: short i, j, x, y, dir, shortestDistance, targetLoc[2], leashLength;
! 2825: short **enemyMap, **costMap;
! 2826: char buf[DCOLS], monstName[DCOLS];
! 2827:
! 2828: x = monst->xLoc;
! 2829: y = monst->yLoc;
! 2830:
! 2831: targetLoc[0] = targetLoc[1] = 0;
! 2832:
! 2833: if (!(monst->leader)) {
! 2834: monst->leader = &player;
! 2835: monst->bookkeepingFlags |= MB_FOLLOWER;
! 2836: }
! 2837:
! 2838: // If we're standing in harmful terrain and there is a way to escape it, spend this turn escaping it.
! 2839: if (cellHasTerrainFlag(x, y, (T_HARMFUL_TERRAIN & ~(T_IS_FIRE | T_CAUSES_DAMAGE | T_CAUSES_PARALYSIS | T_CAUSES_CONFUSION)))
! 2840: || (cellHasTerrainFlag(x, y, T_IS_FIRE) && !monst->status[STATUS_IMMUNE_TO_FIRE])
! 2841: || (cellHasTerrainFlag(x, y, T_CAUSES_DAMAGE | T_CAUSES_PARALYSIS | T_CAUSES_CONFUSION) && !(monst->info.flags & (MONST_INANIMATE | MONST_INVULNERABLE)))) {
! 2842:
! 2843: if (!rogue.updatedMapToSafeTerrainThisTurn) {
! 2844: updateSafeTerrainMap();
! 2845: }
! 2846:
! 2847: if (monsterBlinkToPreferenceMap(monst, rogue.mapToSafeTerrain, false)) {
! 2848: monst->ticksUntilTurn = monst->attackSpeed * (monst->info.flags & MONST_CAST_SPELLS_SLOWLY ? 2 : 1);
! 2849: return;
! 2850: }
! 2851:
! 2852: dir = nextStep(rogue.mapToSafeTerrain, x, y, monst, true);
! 2853: if (dir != -1) {
! 2854: targetLoc[0] = x + nbDirs[dir][0];
! 2855: targetLoc[1] = y + nbDirs[dir][1];
! 2856: if (moveMonsterPassivelyTowards(monst, targetLoc, false)) {
! 2857: return;
! 2858: }
! 2859: }
! 2860: }
! 2861:
! 2862: // Look around for enemies; shortestDistance will be the distance to the nearest.
! 2863: shortestDistance = max(DROWS, DCOLS);
! 2864: for (target = monsters->nextCreature; target != NULL; target = target->nextCreature) {
! 2865: if (target != monst
! 2866: && (!(target->bookkeepingFlags & MB_SUBMERGED) || (monst->bookkeepingFlags & MB_SUBMERGED))
! 2867: && monsterWillAttackTarget(monst, target)
! 2868: && distanceBetween(x, y, target->xLoc, target->yLoc) < shortestDistance
! 2869: && traversiblePathBetween(monst, target->xLoc, target->yLoc)
! 2870: && (!cellHasTerrainFlag(target->xLoc, target->yLoc, T_OBSTRUCTS_PASSABILITY) || (target->info.flags & MONST_ATTACKABLE_THRU_WALLS))
! 2871: && (!target->status[STATUS_INVISIBLE] || rand_percent(33))) {
! 2872:
! 2873: shortestDistance = distanceBetween(x, y, target->xLoc, target->yLoc);
! 2874: closestMonster = target;
! 2875: }
! 2876: }
! 2877:
! 2878: // Weak allies in the presence of enemies seek safety;
! 2879: if (allyFlees(monst, closestMonster)) {
! 2880: if (monsterHasBoltEffect(monst, BE_BLINKING)
! 2881: && ((monst->info.flags & MONST_ALWAYS_USE_ABILITY) || rand_percent(30))
! 2882: && monsterBlinkToSafety(monst)) {
! 2883:
! 2884: return;
! 2885: }
! 2886: if (monsterSummons(monst, (monst->info.flags & MONST_ALWAYS_USE_ABILITY))) {
! 2887: return;
! 2888: }
! 2889: if (!rogue.updatedAllySafetyMapThisTurn) {
! 2890: updateAllySafetyMap();
! 2891: }
! 2892: dir = nextStep(allySafetyMap, monst->xLoc, monst->yLoc, monst, true);
! 2893: if (dir != -1) {
! 2894: targetLoc[0] = x + nbDirs[dir][0];
! 2895: targetLoc[1] = y + nbDirs[dir][1];
! 2896: }
! 2897: if (dir == -1
! 2898: || (allySafetyMap[targetLoc[0]][targetLoc[1]] >= allySafetyMap[x][y])
! 2899: || (!moveMonster(monst, nbDirs[dir][0], nbDirs[dir][1]) && !moveMonsterPassivelyTowards(monst, targetLoc, true))) {
! 2900: // ally can't flee; continue below
! 2901: } else {
! 2902: return;
! 2903: }
! 2904: }
! 2905:
! 2906: // Magic users sometimes cast spells.
! 2907: if (monstUseMagic(monst)) { // if he actually cast a spell
! 2908: monst->ticksUntilTurn = monst->attackSpeed * (monst->info.flags & MONST_CAST_SPELLS_SLOWLY ? 2 : 1);
! 2909: return;
! 2910: }
! 2911:
! 2912: if (monst->bookkeepingFlags & MB_SEIZED) {
! 2913: leashLength = max(DCOLS, DROWS); // Ally will never be prevented from attacking while seized.
! 2914: } else if (rogue.justRested || rogue.justSearched) {
! 2915: leashLength = 10;
! 2916: } else {
! 2917: leashLength = 4;
! 2918: }
! 2919: if (shortestDistance == 1) {
! 2920: if (closestMonster->movementSpeed < monst->movementSpeed
! 2921: && !(closestMonster->info.flags & (MONST_FLITS | MONST_IMMOBILE))
! 2922: && closestMonster->creatureState == MONSTER_TRACKING_SCENT) {
! 2923: // Never try to flee from combat with a faster enemy.
! 2924: leashLength = max(DCOLS, DROWS);
! 2925: } else {
! 2926: leashLength++; // If the ally is adjacent to a monster at the end of its leash, it shouldn't be prevented from attacking.
! 2927: }
! 2928: }
! 2929:
! 2930: if (closestMonster
! 2931: && (distanceBetween(x, y, player.xLoc, player.yLoc) < leashLength || (monst->bookkeepingFlags & MB_DOES_NOT_TRACK_LEADER))
! 2932: && !(monst->info.flags & MONST_MAINTAINS_DISTANCE)
! 2933: && !attackWouldBeFutile(monst, closestMonster)) {
! 2934:
! 2935: // Blink toward an enemy?
! 2936: if (monsterHasBoltEffect(monst, BE_BLINKING)
! 2937: && ((monst->info.flags & MONST_ALWAYS_USE_ABILITY) || rand_percent(30))) {
! 2938:
! 2939: enemyMap = allocGrid();
! 2940: costMap = allocGrid();
! 2941:
! 2942: for (i=0; i<DCOLS; i++) {
! 2943: for (j=0; j<DROWS; j++) {
! 2944: if (cellHasTerrainFlag(i, j, T_OBSTRUCTS_PASSABILITY)) {
! 2945: costMap[i][j] = cellHasTerrainFlag(i, j, T_OBSTRUCTS_DIAGONAL_MOVEMENT) ? PDS_OBSTRUCTION : PDS_FORBIDDEN;
! 2946: enemyMap[i][j] = 0; // safeguard against OOS
! 2947: } else if (monsterAvoids(monst, i, j)) {
! 2948: costMap[i][j] = PDS_FORBIDDEN;
! 2949: enemyMap[i][j] = 0; // safeguard against OOS
! 2950: } else {
! 2951: costMap[i][j] = 1;
! 2952: enemyMap[i][j] = 10000;
! 2953: }
! 2954: }
! 2955: }
! 2956:
! 2957: for (target = monsters->nextCreature; target != NULL; target = target->nextCreature) {
! 2958: if (target != monst
! 2959: && (!(target->bookkeepingFlags & MB_SUBMERGED) || (monst->bookkeepingFlags & MB_SUBMERGED))
! 2960: && monsterWillAttackTarget(monst, target)
! 2961: && distanceBetween(x, y, target->xLoc, target->yLoc) < shortestDistance
! 2962: && traversiblePathBetween(monst, target->xLoc, target->yLoc)
! 2963: && (!monsterAvoids(monst, target->xLoc, target->yLoc) || (target->info.flags & MONST_ATTACKABLE_THRU_WALLS))
! 2964: && (!target->status[STATUS_INVISIBLE] || ((monst->info.flags & MONST_ALWAYS_USE_ABILITY) || rand_percent(33)))) {
! 2965:
! 2966: enemyMap[target->xLoc][target->yLoc] = 0;
! 2967: costMap[target->xLoc][target->yLoc] = 1;
! 2968: }
! 2969: }
! 2970:
! 2971: dijkstraScan(enemyMap, costMap, true);
! 2972: freeGrid(costMap);
! 2973:
! 2974: if (monsterBlinkToPreferenceMap(monst, enemyMap, false)) {
! 2975: monst->ticksUntilTurn = monst->attackSpeed * (monst->info.flags & MONST_CAST_SPELLS_SLOWLY ? 2 : 1);
! 2976: freeGrid(enemyMap);
! 2977: return;
! 2978: }
! 2979: freeGrid(enemyMap);
! 2980: }
! 2981:
! 2982: targetLoc[0] = closestMonster->xLoc;
! 2983: targetLoc[1] = closestMonster->yLoc;
! 2984: moveMonsterPassivelyTowards(monst, targetLoc, false);
! 2985: } else if (monst->targetCorpseLoc[0]
! 2986: && !monst->status[STATUS_POISONED]
! 2987: && (!monst->status[STATUS_BURNING] || monst->status[STATUS_IMMUNE_TO_FIRE])) { // Going to start eating a corpse.
! 2988: moveMonsterPassivelyTowards(monst, monst->targetCorpseLoc, false);
! 2989: if (monst->xLoc == monst->targetCorpseLoc[0]
! 2990: && monst->yLoc == monst->targetCorpseLoc[1]
! 2991: && !(monst->bookkeepingFlags & MB_ABSORBING)) {
! 2992: if (canSeeMonster(monst)) {
! 2993: monsterName(monstName, monst, true);
! 2994: sprintf(buf, "%s begins %s the fallen %s.", monstName, monsterText[monst->info.monsterID].absorbing, monst->targetCorpseName);
! 2995: messageWithColor(buf, &goodMessageColor, false);
! 2996: }
! 2997: monst->corpseAbsorptionCounter = 20;
! 2998: monst->bookkeepingFlags |= MB_ABSORBING;
! 2999: }
! 3000: } else if ((monst->bookkeepingFlags & MB_DOES_NOT_TRACK_LEADER)
! 3001: || (distanceBetween(x, y, player.xLoc, player.yLoc) < 3 && (pmap[x][y].flags & IN_FIELD_OF_VIEW))) {
! 3002:
! 3003: monst->bookkeepingFlags &= ~MB_GIVEN_UP_ON_SCENT;
! 3004: monsterMillAbout(monst, 30);
! 3005: } else {
! 3006: if (!(monst->bookkeepingFlags & MB_GIVEN_UP_ON_SCENT)
! 3007: && distanceBetween(x, y, player.xLoc, player.yLoc) > 10
! 3008: && monsterBlinkToPreferenceMap(monst, scentMap, true)) {
! 3009:
! 3010: monst->ticksUntilTurn = monst->attackSpeed * (monst->info.flags & MONST_CAST_SPELLS_SLOWLY ? 2 : 1);
! 3011: return;
! 3012: }
! 3013: dir = scentDirection(monst);
! 3014: if (dir == -1 || (monst->bookkeepingFlags & MB_GIVEN_UP_ON_SCENT)) {
! 3015: monst->bookkeepingFlags |= MB_GIVEN_UP_ON_SCENT;
! 3016: pathTowardCreature(monst, monst->leader);
! 3017: } else {
! 3018: targetLoc[0] = x + nbDirs[dir][0];
! 3019: targetLoc[1] = y + nbDirs[dir][1];
! 3020: moveMonsterPassivelyTowards(monst, targetLoc, false);
! 3021: }
! 3022: }
! 3023: }
! 3024:
! 3025: // Returns whether to abort the turn.
! 3026: boolean updateMonsterCorpseAbsorption(creature *monst) {
! 3027: short i;
! 3028: char buf[COLS], buf2[COLS];
! 3029:
! 3030: if (monst->xLoc == monst->targetCorpseLoc[0]
! 3031: && monst->yLoc == monst->targetCorpseLoc[1]
! 3032: && (monst->bookkeepingFlags & MB_ABSORBING)) {
! 3033:
! 3034: if (--monst->corpseAbsorptionCounter <= 0) {
! 3035: monst->targetCorpseLoc[0] = monst->targetCorpseLoc[1] = 0;
! 3036: if (monst->absorptionBolt != BOLT_NONE) {
! 3037: for (i=0; monst->info.bolts[i] != BOLT_NONE; i++);
! 3038: monst->info.bolts[i] = monst->absorptionBolt;
! 3039: } else if (monst->absorbBehavior) {
! 3040: monst->info.flags |= monst->absorptionFlags;
! 3041: } else {
! 3042: monst->info.abilityFlags |= monst->absorptionFlags;
! 3043: }
! 3044: monst->newPowerCount--;
! 3045: monst->bookkeepingFlags &= ~MB_ABSORBING;
! 3046:
! 3047: if (monst->info.flags & MONST_FIERY) {
! 3048: monst->status[STATUS_BURNING] = monst->maxStatus[STATUS_BURNING] = 1000; // won't decrease
! 3049: }
! 3050: if (monst->info.flags & MONST_FLIES) {
! 3051: monst->status[STATUS_LEVITATING] = monst->maxStatus[STATUS_LEVITATING] = 1000; // won't decrease
! 3052: monst->info.flags &= ~(MONST_RESTRICTED_TO_LIQUID | MONST_SUBMERGES);
! 3053: monst->bookkeepingFlags &= ~(MB_SUBMERGED);
! 3054: }
! 3055: if (monst->info.flags & MONST_IMMUNE_TO_FIRE) {
! 3056: monst->status[STATUS_IMMUNE_TO_FIRE] = monst->maxStatus[STATUS_IMMUNE_TO_FIRE] = 1000; // won't decrease
! 3057: }
! 3058: if (monst->info.flags & MONST_INVISIBLE) {
! 3059: monst->status[STATUS_INVISIBLE] = monst->maxStatus[STATUS_INVISIBLE] = 1000; // won't decrease
! 3060: }
! 3061: if (canSeeMonster(monst)) {
! 3062: monsterName(buf2, monst, true);
! 3063: sprintf(buf, "%s finished %s the %s.", buf2, monsterText[monst->info.monsterID].absorbing, monst->targetCorpseName);
! 3064: messageWithColor(buf, &goodMessageColor, false);
! 3065: if (monst->absorptionBolt != BOLT_NONE) {
! 3066: sprintf(buf, "%s %s!", buf2, boltCatalog[monst->absorptionBolt].abilityDescription);
! 3067: } else if (monst->absorbBehavior) {
! 3068: sprintf(buf, "%s now %s!", buf2, monsterBehaviorFlagDescriptions[unflag(monst->absorptionFlags)]);
! 3069: } else {
! 3070: sprintf(buf, "%s now %s!", buf2, monsterAbilityFlagDescriptions[unflag(monst->absorptionFlags)]);
! 3071: }
! 3072: resolvePronounEscapes(buf, monst);
! 3073: messageWithColor(buf, &advancementMessageColor, false);
! 3074: }
! 3075: monst->absorptionFlags = 0;
! 3076: monst->absorptionBolt = BOLT_NONE;
! 3077: }
! 3078: monst->ticksUntilTurn = 100;
! 3079: return true;
! 3080: } else if (--monst->corpseAbsorptionCounter <= 0) {
! 3081: monst->targetCorpseLoc[0] = monst->targetCorpseLoc[1] = 0; // lost its chance
! 3082: monst->bookkeepingFlags &= ~MB_ABSORBING;
! 3083: monst->absorptionFlags = 0;
! 3084: monst->absorptionBolt = BOLT_NONE;
! 3085: } else if (monst->bookkeepingFlags & MB_ABSORBING) {
! 3086: monst->bookkeepingFlags &= ~MB_ABSORBING; // absorbing but not on the corpse
! 3087: if (monst->corpseAbsorptionCounter <= 15) {
! 3088: monst->targetCorpseLoc[0] = monst->targetCorpseLoc[1] = 0; // lost its chance
! 3089: monst->absorptionFlags = 0;
! 3090: monst->absorptionBolt = BOLT_NONE;
! 3091: }
! 3092: }
! 3093: return false;
! 3094: }
! 3095:
! 3096: void monstersTurn(creature *monst) {
! 3097: short x, y, playerLoc[2], targetLoc[2], dir, shortestDistance;
! 3098: boolean alreadyAtBestScent;
! 3099: creature *ally, *target, *closestMonster;
! 3100:
! 3101: monst->turnsSpentStationary++;
! 3102:
! 3103: if (monst->corpseAbsorptionCounter >= 0 && updateMonsterCorpseAbsorption(monst)) {
! 3104: return;
! 3105: }
! 3106:
! 3107: if (monst->info.DFChance
! 3108: && (monst->info.flags & MONST_GETS_TURN_ON_ACTIVATION)
! 3109: && rand_percent(monst->info.DFChance)) {
! 3110:
! 3111: spawnDungeonFeature(monst->xLoc, monst->yLoc, &dungeonFeatureCatalog[monst->info.DFType], true, false);
! 3112: }
! 3113:
! 3114: applyInstantTileEffectsToCreature(monst); // Paralysis, confusion etc. take effect before the monster can move.
! 3115:
! 3116: // if the monster is paralyzed, entranced or chained, this is where its turn ends.
! 3117: if (monst->status[STATUS_PARALYZED] || monst->status[STATUS_ENTRANCED] || (monst->bookkeepingFlags & MB_CAPTIVE)) {
! 3118: monst->ticksUntilTurn = monst->movementSpeed;
! 3119: if ((monst->bookkeepingFlags & MB_CAPTIVE) && monst->carriedItem) {
! 3120: makeMonsterDropItem(monst);
! 3121: }
! 3122: return;
! 3123: }
! 3124:
! 3125: if (monst->bookkeepingFlags & MB_IS_DYING) {
! 3126: return;
! 3127: }
! 3128:
! 3129: monst->ticksUntilTurn = monst->movementSpeed / 3; // will be later overwritten by movement or attack
! 3130:
! 3131: x = monst->xLoc;
! 3132: y = monst->yLoc;
! 3133:
! 3134: // Sleepers can awaken, but it takes a whole turn.
! 3135: if (monst->creatureState == MONSTER_SLEEPING) {
! 3136: monst->ticksUntilTurn = monst->movementSpeed;
! 3137: updateMonsterState(monst);
! 3138: return;
! 3139: }
! 3140:
! 3141: // Update creature state if appropriate.
! 3142: updateMonsterState(monst);
! 3143:
! 3144: if (monst->creatureState == MONSTER_SLEEPING) {
! 3145: monst->ticksUntilTurn = monst->movementSpeed;
! 3146: return;
! 3147: }
! 3148:
! 3149: // and move the monster.
! 3150:
! 3151: // immobile monsters can only use special abilities:
! 3152: if (monst->info.flags & MONST_IMMOBILE) {
! 3153: if (monstUseMagic(monst)) { // if he actually cast a spell
! 3154: monst->ticksUntilTurn = monst->attackSpeed * (monst->info.flags & MONST_CAST_SPELLS_SLOWLY ? 2 : 1);
! 3155: return;
! 3156: }
! 3157: monst->ticksUntilTurn = monst->attackSpeed;
! 3158: return;
! 3159: }
! 3160:
! 3161: // discordant monsters
! 3162: if (monst->status[STATUS_DISCORDANT] && monst->creatureState != MONSTER_FLEEING) {
! 3163: shortestDistance = max(DROWS, DCOLS);
! 3164: closestMonster = NULL;
! 3165: CYCLE_MONSTERS_AND_PLAYERS(target) {
! 3166: if (target != monst
! 3167: && (!(target->bookkeepingFlags & MB_SUBMERGED) || (monst->bookkeepingFlags & MB_SUBMERGED))
! 3168: && monsterWillAttackTarget(monst, target)
! 3169: && distanceBetween(x, y, target->xLoc, target->yLoc) < shortestDistance
! 3170: && traversiblePathBetween(monst, target->xLoc, target->yLoc)
! 3171: && (!monsterAvoids(monst, target->xLoc, target->yLoc) || (target->info.flags & MONST_ATTACKABLE_THRU_WALLS))
! 3172: && (!target->status[STATUS_INVISIBLE] || rand_percent(33))) {
! 3173:
! 3174: shortestDistance = distanceBetween(x, y, target->xLoc, target->yLoc);
! 3175: closestMonster = target;
! 3176: }
! 3177: }
! 3178: if (closestMonster && monstUseMagic(monst)) {
! 3179: monst->ticksUntilTurn = monst->attackSpeed * (monst->info.flags & MONST_CAST_SPELLS_SLOWLY ? 2 : 1);
! 3180: return;
! 3181: }
! 3182: if (closestMonster && !(monst->info.flags & MONST_MAINTAINS_DISTANCE)) {
! 3183: targetLoc[0] = closestMonster->xLoc;
! 3184: targetLoc[1] = closestMonster->yLoc;
! 3185: if (moveMonsterPassivelyTowards(monst, targetLoc, monst->creatureState == MONSTER_ALLY)) {
! 3186: return;
! 3187: }
! 3188: }
! 3189: }
! 3190:
! 3191: // hunting
! 3192: if ((monst->creatureState == MONSTER_TRACKING_SCENT
! 3193: || (monst->creatureState == MONSTER_ALLY && monst->status[STATUS_DISCORDANT]))
! 3194: // eels don't charge if you're not in the water
! 3195: && (!(monst->info.flags & MONST_RESTRICTED_TO_LIQUID) || cellHasTMFlag(player.xLoc, player.yLoc, TM_ALLOWS_SUBMERGING))) {
! 3196:
! 3197: // magic users sometimes cast spells
! 3198: if (monstUseMagic(monst)
! 3199: || (monsterHasBoltEffect(monst, BE_BLINKING)
! 3200: && ((monst->info.flags & MONST_ALWAYS_USE_ABILITY) || rand_percent(30))
! 3201: && monsterBlinkToPreferenceMap(monst, scentMap, true))) { // if he actually cast a spell
! 3202:
! 3203: monst->ticksUntilTurn = monst->attackSpeed * (monst->info.flags & MONST_CAST_SPELLS_SLOWLY ? 2 : 1);
! 3204: return;
! 3205: }
! 3206:
! 3207: // if the monster is adjacent to an ally and not adjacent to the player, attack the ally
! 3208: if (distanceBetween(x, y, player.xLoc, player.yLoc) > 1
! 3209: || diagonalBlocked(x, y, player.xLoc, player.yLoc, false)) {
! 3210: for (ally = monsters->nextCreature; ally != NULL; ally = ally->nextCreature) {
! 3211: if (monsterWillAttackTarget(monst, ally)
! 3212: && distanceBetween(x, y, ally->xLoc, ally->yLoc) == 1
! 3213: && (!ally->status[STATUS_INVISIBLE] || rand_percent(33))) {
! 3214:
! 3215: targetLoc[0] = ally->xLoc;
! 3216: targetLoc[1] = ally->yLoc;
! 3217: if (moveMonsterPassivelyTowards(monst, targetLoc, true)) { // attack
! 3218: return;
! 3219: }
! 3220: }
! 3221: }
! 3222: }
! 3223:
! 3224: if ((monst->status[STATUS_LEVITATING] || (monst->info.flags & MONST_RESTRICTED_TO_LIQUID) || (monst->bookkeepingFlags & MB_SUBMERGED)
! 3225: || ((monst->info.flags & (MONST_IMMUNE_TO_WEBS | MONST_INVULNERABLE) && monsterCanShootWebs(monst))))
! 3226: && pmap[x][y].flags & IN_FIELD_OF_VIEW) {
! 3227:
! 3228: playerLoc[0] = player.xLoc;
! 3229: playerLoc[1] = player.yLoc;
! 3230: moveMonsterPassivelyTowards(monst, playerLoc, true); // attack
! 3231: return;
! 3232: }
! 3233: if ((monst->info.flags & MONST_ALWAYS_HUNTING)
! 3234: && (monst->bookkeepingFlags & MB_GIVEN_UP_ON_SCENT)) {
! 3235:
! 3236: pathTowardCreature(monst, &player);
! 3237: return;
! 3238: }
! 3239:
! 3240: dir = scentDirection(monst);
! 3241: if (dir == NO_DIRECTION) {
! 3242: alreadyAtBestScent = isLocalScentMaximum(monst->xLoc, monst->yLoc);
! 3243: if (alreadyAtBestScent && monst->creatureState != MONSTER_ALLY) {
! 3244: if (monst->info.flags & MONST_ALWAYS_HUNTING) {
! 3245: pathTowardCreature(monst, &player);
! 3246: monst->bookkeepingFlags |= MB_GIVEN_UP_ON_SCENT;
! 3247: return;
! 3248: }
! 3249: monst->creatureState = MONSTER_WANDERING;
! 3250: chooseNewWanderDestination(monst);
! 3251: }
! 3252: } else {
! 3253: moveMonster(monst, nbDirs[dir][0], nbDirs[dir][1]);
! 3254: }
! 3255: } else if (monst->creatureState == MONSTER_FLEEING) {
! 3256: // fleeing
! 3257: if (monsterHasBoltEffect(monst, BE_BLINKING)
! 3258: && ((monst->info.flags & MONST_ALWAYS_USE_ABILITY) || rand_percent(30))
! 3259: && monsterBlinkToSafety(monst)) {
! 3260:
! 3261: return;
! 3262: }
! 3263:
! 3264: if (monsterSummons(monst, (monst->info.flags & MONST_ALWAYS_USE_ABILITY))) {
! 3265: return;
! 3266: }
! 3267:
! 3268: if (fleeingMonsterAwareOfPlayer(monst)) {
! 3269: if (monst->safetyMap) {
! 3270: freeGrid(monst->safetyMap);
! 3271: monst->safetyMap = NULL;
! 3272: }
! 3273: if (!rogue.updatedSafetyMapThisTurn) {
! 3274: updateSafetyMap();
! 3275: }
! 3276: dir = nextStep(safetyMap, monst->xLoc, monst->yLoc, NULL, true);
! 3277: } else {
! 3278: if (!monst->safetyMap) {
! 3279: if (rogue.patchVersion >= 3 && !rogue.updatedSafetyMapThisTurn) {
! 3280: updateSafetyMap();
! 3281: }
! 3282: monst->safetyMap = allocGrid();
! 3283: copyGrid(monst->safetyMap, safetyMap);
! 3284: }
! 3285: dir = nextStep(monst->safetyMap, monst->xLoc, monst->yLoc, NULL, true);
! 3286: }
! 3287: if (dir != -1) {
! 3288: targetLoc[0] = x + nbDirs[dir][0];
! 3289: targetLoc[1] = y + nbDirs[dir][1];
! 3290: }
! 3291: if (dir == -1 || (!moveMonster(monst, nbDirs[dir][0], nbDirs[dir][1]) && !moveMonsterPassivelyTowards(monst, targetLoc, true))) {
! 3292: CYCLE_MONSTERS_AND_PLAYERS(ally) {
! 3293: if (!monst->status[STATUS_MAGICAL_FEAR] // Fearful monsters will never attack.
! 3294: && monsterWillAttackTarget(monst, ally)
! 3295: && distanceBetween(x, y, ally->xLoc, ally->yLoc) <= 1) {
! 3296:
! 3297: moveMonster(monst, ally->xLoc - x, ally->yLoc - y); // attack the player if cornered
! 3298: return;
! 3299: }
! 3300: }
! 3301: }
! 3302: return;
! 3303: } else if (monst->creatureState == MONSTER_WANDERING
! 3304: // eels wander if you're not in water
! 3305: || ((monst->info.flags & MONST_RESTRICTED_TO_LIQUID) && !cellHasTMFlag(player.xLoc, player.yLoc, TM_ALLOWS_SUBMERGING))) {
! 3306:
! 3307: // if we're standing in harmful terrain and there is a way to escape it, spend this turn escaping it.
! 3308: if (cellHasTerrainFlag(x, y, (T_HARMFUL_TERRAIN & ~T_IS_FIRE))
! 3309: || (cellHasTerrainFlag(x, y, T_IS_FIRE) && !monst->status[STATUS_IMMUNE_TO_FIRE] && !(monst->info.flags & MONST_INVULNERABLE))) {
! 3310: if (!rogue.updatedMapToSafeTerrainThisTurn) {
! 3311: updateSafeTerrainMap();
! 3312: }
! 3313:
! 3314: if (monsterBlinkToPreferenceMap(monst, rogue.mapToSafeTerrain, false)) {
! 3315: monst->ticksUntilTurn = monst->attackSpeed * (monst->info.flags & MONST_CAST_SPELLS_SLOWLY ? 2 : 1);
! 3316: return;
! 3317: }
! 3318:
! 3319: dir = nextStep(rogue.mapToSafeTerrain, x, y, monst, true);
! 3320: if (dir != -1) {
! 3321: targetLoc[0] = x + nbDirs[dir][0];
! 3322: targetLoc[1] = y + nbDirs[dir][1];
! 3323: if (moveMonsterPassivelyTowards(monst, targetLoc, true)) {
! 3324: return;
! 3325: }
! 3326: }
! 3327: }
! 3328:
! 3329: // if a captive leader is captive, regenerative and healthy enough to withstand an attack,
! 3330: // and we're not poisonous, then approach or attack him.
! 3331: if ((monst->bookkeepingFlags & MB_FOLLOWER)
! 3332: && (monst->leader->bookkeepingFlags & MB_CAPTIVE)
! 3333: && monst->leader->currentHP > (int) (monst->info.damage.upperBound * monsterDamageAdjustmentAmount(monst) / FP_FACTOR)
! 3334: && monst->leader->info.turnsBetweenRegen > 0
! 3335: && !(monst->info.abilityFlags & MA_POISONS)
! 3336: && !diagonalBlocked(monst->xLoc, monst->yLoc, monst->leader->xLoc, monst->leader->yLoc, false)) {
! 3337:
! 3338: if (distanceBetween(monst->xLoc, monst->yLoc, monst->leader->xLoc, monst->leader->yLoc) == 1) {
! 3339: // Attack if adjacent.
! 3340: monst->ticksUntilTurn = monst->attackSpeed;
! 3341: attack(monst, monst->leader, false);
! 3342: return;
! 3343: } else {
! 3344: // Otherwise, approach.
! 3345: pathTowardCreature(monst, monst->leader);
! 3346: return;
! 3347: }
! 3348: }
! 3349:
! 3350: // if the monster is adjacent to an ally and not fleeing, attack the ally
! 3351: if (monst->creatureState == MONSTER_WANDERING) {
! 3352: for (ally = monsters->nextCreature; ally != NULL; ally = ally->nextCreature) {
! 3353: if (monsterWillAttackTarget(monst, ally)
! 3354: && distanceBetween(x, y, ally->xLoc, ally->yLoc) == 1
! 3355: && (!ally->status[STATUS_INVISIBLE] || rand_percent(33))) {
! 3356:
! 3357: targetLoc[0] = ally->xLoc;
! 3358: targetLoc[1] = ally->yLoc;
! 3359: if (moveMonsterPassivelyTowards(monst, targetLoc, true)) {
! 3360: return;
! 3361: }
! 3362: }
! 3363: }
! 3364: }
! 3365:
! 3366: // if you're a follower, don't get separated from the pack
! 3367: if (monst->bookkeepingFlags & MB_FOLLOWER) {
! 3368: if (distanceBetween(x, y, monst->leader->xLoc, monst->leader->yLoc) > 2) {
! 3369: pathTowardCreature(monst, monst->leader);
! 3370: } else if (monst->leader->info.flags & MONST_IMMOBILE) {
! 3371: monsterMillAbout(monst, 100); // Worshipers will pace frenetically.
! 3372: } else if (monst->leader->bookkeepingFlags & MB_CAPTIVE) {
! 3373: monsterMillAbout(monst, 10); // Captors are languid.
! 3374: } else {
! 3375: monsterMillAbout(monst, 30); // Other followers mill about like your allies do.
! 3376: }
! 3377: } else {
! 3378: // Step toward the chosen waypoint.
! 3379: dir = NO_DIRECTION;
! 3380: if (isValidWanderDestination(monst, monst->targetWaypointIndex)) {
! 3381: dir = nextStep(rogue.wpDistance[monst->targetWaypointIndex], monst->xLoc, monst->yLoc, monst, false);
! 3382: }
! 3383: // If there's no path forward, call that waypoint finished and pick a new one.
! 3384: if (!isValidWanderDestination(monst, monst->targetWaypointIndex)
! 3385: || dir == NO_DIRECTION) {
! 3386:
! 3387: chooseNewWanderDestination(monst);
! 3388: if (isValidWanderDestination(monst, monst->targetWaypointIndex)) {
! 3389: dir = nextStep(rogue.wpDistance[monst->targetWaypointIndex], monst->xLoc, monst->yLoc, monst, false);
! 3390: }
! 3391: }
! 3392: // If there's still no path forward, step randomly as though flitting.
! 3393: // (This is how eels wander in deep water.)
! 3394: if (dir == NO_DIRECTION) {
! 3395: dir = randValidDirectionFrom(monst, x, y, true);
! 3396: }
! 3397: if (dir != NO_DIRECTION) {
! 3398: targetLoc[0] = x + nbDirs[dir][0];
! 3399: targetLoc[1] = y + nbDirs[dir][1];
! 3400: if (moveMonsterPassivelyTowards(monst, targetLoc, true)) {
! 3401: return;
! 3402: }
! 3403: }
! 3404: }
! 3405: } else if (monst->creatureState == MONSTER_ALLY) {
! 3406: moveAlly(monst);
! 3407: }
! 3408: }
! 3409:
! 3410: boolean canPass(creature *mover, creature *blocker) {
! 3411:
! 3412: if (blocker == &player) {
! 3413: return false;
! 3414: }
! 3415:
! 3416: if (blocker->status[STATUS_CONFUSED]
! 3417: || blocker->status[STATUS_STUCK]
! 3418: || blocker->status[STATUS_PARALYZED]
! 3419: || blocker->status[STATUS_ENTRANCED]
! 3420: || mover->status[STATUS_ENTRANCED]) {
! 3421:
! 3422: return false;
! 3423: }
! 3424:
! 3425: if ((blocker->bookkeepingFlags & (MB_CAPTIVE | MB_ABSORBING))
! 3426: || (blocker->info.flags & MONST_IMMOBILE)) {
! 3427: return false;
! 3428: }
! 3429:
! 3430: if (monstersAreEnemies(mover, blocker)) {
! 3431: return false;
! 3432: }
! 3433:
! 3434: if (blocker->leader == mover) {
! 3435: return true;
! 3436: }
! 3437:
! 3438: if (mover->leader == blocker) {
! 3439: return false;
! 3440: }
! 3441:
! 3442: return (monstersAreTeammates(mover, blocker)
! 3443: && blocker->currentHP < mover->currentHP);
! 3444: }
! 3445:
! 3446: boolean isPassableOrSecretDoor(short x, short y) {
! 3447: return (!cellHasTerrainFlag(x, y, T_OBSTRUCTS_PASSABILITY)
! 3448: || (cellHasTMFlag(x, y, TM_IS_SECRET) && !(discoveredTerrainFlagsAtLoc(x, y) & T_OBSTRUCTS_PASSABILITY)));
! 3449: }
! 3450:
! 3451: boolean knownToPlayerAsPassableOrSecretDoor(short x, short y) {
! 3452: unsigned long tFlags, TMFlags;
! 3453: getLocationFlags(x, y, &tFlags, &TMFlags, NULL, true);
! 3454: return (!(tFlags & T_OBSTRUCTS_PASSABILITY)
! 3455: || ((TMFlags & TM_IS_SECRET) && !(discoveredTerrainFlagsAtLoc(x, y) & T_OBSTRUCTS_PASSABILITY)));
! 3456: }
! 3457:
! 3458: void setMonsterLocation(creature *monst, short newX, short newY) {
! 3459: unsigned long creatureFlag = (monst == &player ? HAS_PLAYER : HAS_MONSTER);
! 3460: pmap[monst->xLoc][monst->yLoc].flags &= ~creatureFlag;
! 3461: refreshDungeonCell(monst->xLoc, monst->yLoc);
! 3462: monst->turnsSpentStationary = 0;
! 3463: monst->xLoc = newX;
! 3464: monst->yLoc = newY;
! 3465: pmap[newX][newY].flags |= creatureFlag;
! 3466: if ((monst->bookkeepingFlags & MB_SUBMERGED) && !cellHasTMFlag(newX, newY, TM_ALLOWS_SUBMERGING)) {
! 3467: monst->bookkeepingFlags &= ~MB_SUBMERGED;
! 3468: }
! 3469: if (playerCanSee(newX, newY)
! 3470: && cellHasTMFlag(newX, newY, TM_IS_SECRET)
! 3471: && cellHasTerrainFlag(newX, newY, T_OBSTRUCTS_PASSABILITY)) {
! 3472:
! 3473: discover(newX, newY); // if you see a monster use a secret door, you discover it
! 3474: }
! 3475: refreshDungeonCell(newX, newY);
! 3476: applyInstantTileEffectsToCreature(monst);
! 3477: if (monst == &player) {
! 3478: updateVision(true);
! 3479: // get any items at the destination location
! 3480: if (pmap[player.xLoc][player.yLoc].flags & HAS_ITEM) {
! 3481: pickUpItemAt(player.xLoc, player.yLoc);
! 3482: }
! 3483: }
! 3484: }
! 3485:
! 3486: // Tries to move the given monster in the given vector; returns true if the move was legal
! 3487: // (including attacking player, vomiting or struggling in vain)
! 3488: // Be sure that dx, dy are both in the range [-1, 1] or the move will sometimes fail due to the diagonal check.
! 3489: boolean moveMonster(creature *monst, short dx, short dy) {
! 3490: short x = monst->xLoc, y = monst->yLoc;
! 3491: short newX, newY;
! 3492: short i;
! 3493: short confusedDirection, swarmDirection;
! 3494: creature *defender = NULL;
! 3495: creature *hitList[16] = {NULL};
! 3496: enum directions dir;
! 3497:
! 3498: if (dx == 0 && dy == 0) {
! 3499: return false;
! 3500: }
! 3501:
! 3502: newX = x + dx;
! 3503: newY = y + dy;
! 3504:
! 3505: if (!coordinatesAreInMap(newX, newY)) {
! 3506: //DEBUG printf("\nProblem! Monster trying to move more than one space at a time.");
! 3507: return false;
! 3508: }
! 3509:
! 3510: // vomiting
! 3511: if (monst->status[STATUS_NAUSEOUS] && rand_percent(25)) {
! 3512: vomit(monst);
! 3513: monst->ticksUntilTurn = monst->movementSpeed;
! 3514: return true;
! 3515: }
! 3516:
! 3517: // move randomly?
! 3518: if (!monst->status[STATUS_ENTRANCED]) {
! 3519: if (monst->status[STATUS_CONFUSED]) {
! 3520: confusedDirection = randValidDirectionFrom(monst, x, y, false);
! 3521: if (confusedDirection != -1) {
! 3522: dx = nbDirs[confusedDirection][0];
! 3523: dy = nbDirs[confusedDirection][1];
! 3524: }
! 3525: } else if ((monst->info.flags & MONST_FLITS) && !(monst->bookkeepingFlags & MB_SEIZING) && rand_percent(33)) {
! 3526: confusedDirection = randValidDirectionFrom(monst, x, y, true);
! 3527: if (confusedDirection != -1) {
! 3528: dx = nbDirs[confusedDirection][0];
! 3529: dy = nbDirs[confusedDirection][1];
! 3530: }
! 3531: }
! 3532: }
! 3533:
! 3534: newX = x + dx;
! 3535: newY = y + dy;
! 3536:
! 3537: // Liquid-based monsters should never move or attack outside of liquid.
! 3538: if ((monst->info.flags & MONST_RESTRICTED_TO_LIQUID) && !cellHasTMFlag(newX, newY, TM_ALLOWS_SUBMERGING)) {
! 3539: return false;
! 3540: }
! 3541:
! 3542: // Caught in spiderweb?
! 3543: if (monst->status[STATUS_STUCK] && !(pmap[newX][newY].flags & (HAS_PLAYER | HAS_MONSTER))
! 3544: && cellHasTerrainFlag(x, y, T_ENTANGLES) && !(monst->info.flags & MONST_IMMUNE_TO_WEBS)) {
! 3545: if (!(monst->info.flags & MONST_INVULNERABLE)
! 3546: && --monst->status[STATUS_STUCK]) {
! 3547:
! 3548: monst->ticksUntilTurn = monst->movementSpeed;
! 3549: return true;
! 3550: } else if (tileCatalog[pmap[x][y].layers[SURFACE]].flags & T_ENTANGLES) {
! 3551: pmap[x][y].layers[SURFACE] = NOTHING;
! 3552: }
! 3553: }
! 3554:
! 3555: if (pmap[newX][newY].flags & (HAS_MONSTER | HAS_PLAYER)) {
! 3556: defender = monsterAtLoc(newX, newY);
! 3557: } else {
! 3558: if (monst->bookkeepingFlags & MB_SEIZED) {
! 3559: for (defender = monsters->nextCreature; defender != NULL; defender = defender->nextCreature) {
! 3560: if ((defender->bookkeepingFlags & MB_SEIZING)
! 3561: && monstersAreEnemies(monst, defender)
! 3562: && distanceBetween(monst->xLoc, monst->yLoc, defender->xLoc, defender->yLoc) == 1
! 3563: && !diagonalBlocked(monst->xLoc, monst->yLoc, defender->xLoc, defender->yLoc, false)) {
! 3564:
! 3565: monst->ticksUntilTurn = monst->movementSpeed;
! 3566: return true;
! 3567: }
! 3568: }
! 3569: monst->bookkeepingFlags &= ~MB_SEIZED; // failsafe
! 3570: }
! 3571: if (monst->bookkeepingFlags & MB_SEIZING) {
! 3572: monst->bookkeepingFlags &= ~MB_SEIZING;
! 3573: }
! 3574: }
! 3575:
! 3576:
! 3577: for (dir = 0; dir < DIRECTION_COUNT; dir++) {
! 3578: if (dx == nbDirs[dir][0]
! 3579: && dy == nbDirs[dir][1]) {
! 3580:
! 3581: break;
! 3582: }
! 3583: }
! 3584: brogueAssert(dir != NO_DIRECTION);
! 3585: if (handleWhipAttacks(monst, dir, NULL)
! 3586: || handleSpearAttacks(monst, dir, NULL)) {
! 3587:
! 3588: monst->ticksUntilTurn = monst->attackSpeed;
! 3589: return true;
! 3590: }
! 3591:
! 3592: if (((defender && (defender->info.flags & MONST_ATTACKABLE_THRU_WALLS))
! 3593: || (isPassableOrSecretDoor(newX, newY)
! 3594: && !diagonalBlocked(x, y, newX, newY, false)
! 3595: && isPassableOrSecretDoor(x, y)))
! 3596: && (!defender || canPass(monst, defender) || monsterWillAttackTarget(monst, defender))) {
! 3597: // if it's a legal move
! 3598:
! 3599: if (defender) {
! 3600: if (canPass(monst, defender)) {
! 3601:
! 3602: // swap places
! 3603: pmap[defender->xLoc][defender->yLoc].flags &= ~HAS_MONSTER;
! 3604: refreshDungeonCell(defender->xLoc, defender->yLoc);
! 3605:
! 3606: pmap[monst->xLoc][monst->yLoc].flags &= ~HAS_MONSTER;
! 3607: refreshDungeonCell(monst->xLoc, monst->yLoc);
! 3608:
! 3609: monst->xLoc = newX;
! 3610: monst->yLoc = newY;
! 3611: pmap[monst->xLoc][monst->yLoc].flags |= HAS_MONSTER;
! 3612:
! 3613: if (monsterAvoids(defender, x, y)) { // don't want a flying monster to swap a non-flying monster into lava!
! 3614: getQualifyingPathLocNear(&(defender->xLoc), &(defender->yLoc), x, y, true,
! 3615: forbiddenFlagsForMonster(&(defender->info)), HAS_PLAYER,
! 3616: forbiddenFlagsForMonster(&(defender->info)), (HAS_PLAYER | HAS_MONSTER | HAS_STAIRS), false);
! 3617: } else {
! 3618: defender->xLoc = x;
! 3619: defender->yLoc = y;
! 3620: }
! 3621: pmap[defender->xLoc][defender->yLoc].flags |= HAS_MONSTER;
! 3622:
! 3623: refreshDungeonCell(monst->xLoc, monst->yLoc);
! 3624: refreshDungeonCell(defender->xLoc, defender->yLoc);
! 3625:
! 3626: monst->ticksUntilTurn = monst->movementSpeed;
! 3627: return true;
! 3628: }
! 3629:
! 3630: // Sights are set on an enemy monster. Would we rather swarm than attack?
! 3631: swarmDirection = monsterSwarmDirection(monst, defender);
! 3632: if (swarmDirection != NO_DIRECTION) {
! 3633: newX = monst->xLoc + nbDirs[swarmDirection][0];
! 3634: newY = monst->yLoc + nbDirs[swarmDirection][1];
! 3635: setMonsterLocation(monst, newX, newY);
! 3636: monst->ticksUntilTurn = monst->movementSpeed;
! 3637: return true;
! 3638: } else {
! 3639: // attacking another monster!
! 3640: monst->ticksUntilTurn = monst->attackSpeed;
! 3641: if (!((monst->info.abilityFlags & MA_SEIZES) && !(monst->bookkeepingFlags & MB_SEIZING))) {
! 3642: // Bog monsters and krakens won't surface on the turn that they seize their target.
! 3643: monst->bookkeepingFlags &= ~MB_SUBMERGED;
! 3644: }
! 3645: refreshDungeonCell(x, y);
! 3646:
! 3647: buildHitList(hitList, monst, defender,
! 3648: (monst->info.abilityFlags & MA_ATTACKS_ALL_ADJACENT) ? true : false);
! 3649: // Attack!
! 3650: for (i=0; i<16; i++) {
! 3651: if (hitList[i]
! 3652: && monsterWillAttackTarget(monst, hitList[i])
! 3653: && !(hitList[i]->bookkeepingFlags & MB_IS_DYING)
! 3654: && !rogue.gameHasEnded) {
! 3655:
! 3656: attack(monst, hitList[i], false);
! 3657: }
! 3658: }
! 3659: }
! 3660: return true;
! 3661: } else {
! 3662: // okay we're moving!
! 3663: setMonsterLocation(monst, newX, newY);
! 3664: monst->ticksUntilTurn = monst->movementSpeed;
! 3665: return true;
! 3666: }
! 3667: }
! 3668: return false;
! 3669: }
! 3670:
! 3671: void clearStatus(creature *monst) {
! 3672: short i;
! 3673:
! 3674: for (i=0; i<NUMBER_OF_STATUS_EFFECTS; i++) {
! 3675: monst->status[i] = monst->maxStatus[i] = 0;
! 3676: }
! 3677: }
! 3678:
! 3679: // Bumps a creature to a random nearby hospitable cell.
! 3680: void findAlternativeHomeFor(creature *monst, short *x, short *y, boolean chooseRandomly) {
! 3681: short sCols[DCOLS], sRows[DROWS], i, j, maxPermissibleDifference, dist;
! 3682:
! 3683: fillSequentialList(sCols, DCOLS);
! 3684: fillSequentialList(sRows, DROWS);
! 3685: if (chooseRandomly) {
! 3686: shuffleList(sCols, DCOLS);
! 3687: shuffleList(sRows, DROWS);
! 3688: }
! 3689:
! 3690: for (maxPermissibleDifference = 1; maxPermissibleDifference < max(DCOLS, DROWS); maxPermissibleDifference++) {
! 3691: for (i=0; i < DCOLS; i++) {
! 3692: for (j=0; j<DROWS; j++) {
! 3693: dist = abs(sCols[i] - monst->xLoc) + abs(sRows[j] - monst->yLoc);
! 3694: if (dist <= maxPermissibleDifference
! 3695: && dist > 0
! 3696: && !(pmap[sCols[i]][sRows[j]].flags & (HAS_PLAYER | HAS_MONSTER))
! 3697: && !monsterAvoids(monst, sCols[i], sRows[j])
! 3698: && !(monst == &player && cellHasTerrainFlag(sCols[i], sRows[j], T_PATHING_BLOCKER))) {
! 3699:
! 3700: // Success!
! 3701: *x = sCols[i];
! 3702: *y = sRows[j];
! 3703: return;
! 3704: }
! 3705: }
! 3706: }
! 3707: }
! 3708: // Failure!
! 3709: *x = *y = -1;
! 3710: }
! 3711:
! 3712: // blockingMap is optional
! 3713: boolean getQualifyingLocNear(short loc[2],
! 3714: short x, short y,
! 3715: boolean hallwaysAllowed,
! 3716: char blockingMap[DCOLS][DROWS],
! 3717: unsigned long forbiddenTerrainFlags,
! 3718: unsigned long forbiddenMapFlags,
! 3719: boolean forbidLiquid,
! 3720: boolean deterministic) {
! 3721: short i, j, k, candidateLocs, randIndex;
! 3722:
! 3723: candidateLocs = 0;
! 3724:
! 3725: // count up the number of candidate locations
! 3726: for (k=0; k<max(DROWS, DCOLS) && !candidateLocs; k++) {
! 3727: for (i = x-k; i <= x+k; i++) {
! 3728: for (j = y-k; j <= y+k; j++) {
! 3729: if (coordinatesAreInMap(i, j)
! 3730: && (i == x-k || i == x+k || j == y-k || j == y+k)
! 3731: && (!blockingMap || !blockingMap[i][j])
! 3732: && !cellHasTerrainFlag(i, j, forbiddenTerrainFlags)
! 3733: && !(pmap[i][j].flags & forbiddenMapFlags)
! 3734: && (!forbidLiquid || pmap[i][j].layers[LIQUID] == NOTHING)
! 3735: && (hallwaysAllowed || passableArcCount(i, j) < 2)) {
! 3736: candidateLocs++;
! 3737: }
! 3738: }
! 3739: }
! 3740: }
! 3741:
! 3742: if (candidateLocs == 0) {
! 3743: return false;
! 3744: }
! 3745:
! 3746: // and pick one
! 3747: if (deterministic) {
! 3748: randIndex = 1 + candidateLocs / 2;
! 3749: } else {
! 3750: randIndex = rand_range(1, candidateLocs);
! 3751: }
! 3752:
! 3753: for (k=0; k<max(DROWS, DCOLS); k++) {
! 3754: for (i = x-k; i <= x+k; i++) {
! 3755: for (j = y-k; j <= y+k; j++) {
! 3756: if (coordinatesAreInMap(i, j)
! 3757: && (i == x-k || i == x+k || j == y-k || j == y+k)
! 3758: && (!blockingMap || !blockingMap[i][j])
! 3759: && !cellHasTerrainFlag(i, j, forbiddenTerrainFlags)
! 3760: && !(pmap[i][j].flags & forbiddenMapFlags)
! 3761: && (!forbidLiquid || pmap[i][j].layers[LIQUID] == NOTHING)
! 3762: && (hallwaysAllowed || passableArcCount(i, j) < 2)) {
! 3763: if (--randIndex == 0) {
! 3764: loc[0] = i;
! 3765: loc[1] = j;
! 3766: return true;
! 3767: }
! 3768: }
! 3769: }
! 3770: }
! 3771: }
! 3772:
! 3773: brogueAssert(false);
! 3774: return false; // should never reach this point
! 3775: }
! 3776:
! 3777: boolean getQualifyingGridLocNear(short loc[2],
! 3778: short x, short y,
! 3779: boolean grid[DCOLS][DROWS],
! 3780: boolean deterministic) {
! 3781: short i, j, k, candidateLocs, randIndex;
! 3782:
! 3783: candidateLocs = 0;
! 3784:
! 3785: // count up the number of candidate locations
! 3786: for (k=0; k<max(DROWS, DCOLS) && !candidateLocs; k++) {
! 3787: for (i = x-k; i <= x+k; i++) {
! 3788: for (j = y-k; j <= y+k; j++) {
! 3789: if (coordinatesAreInMap(i, j)
! 3790: && (i == x-k || i == x+k || j == y-k || j == y+k)
! 3791: && grid[i][j]) {
! 3792:
! 3793: candidateLocs++;
! 3794: }
! 3795: }
! 3796: }
! 3797: }
! 3798:
! 3799: if (candidateLocs == 0) {
! 3800: return false;
! 3801: }
! 3802:
! 3803: // and pick one
! 3804: if (deterministic) {
! 3805: randIndex = 1 + candidateLocs / 2;
! 3806: } else {
! 3807: randIndex = rand_range(1, candidateLocs);
! 3808: }
! 3809:
! 3810: for (k=0; k<max(DROWS, DCOLS); k++) {
! 3811: for (i = x-k; i <= x+k; i++) {
! 3812: for (j = y-k; j <= y+k; j++) {
! 3813: if (coordinatesAreInMap(i, j)
! 3814: && (i == x-k || i == x+k || j == y-k || j == y+k)
! 3815: && grid[i][j]) {
! 3816:
! 3817: if (--randIndex == 0) {
! 3818: loc[0] = i;
! 3819: loc[1] = j;
! 3820: return true;
! 3821: }
! 3822: }
! 3823: }
! 3824: }
! 3825: }
! 3826:
! 3827: brogueAssert(false);
! 3828: return false; // should never reach this point
! 3829: }
! 3830:
! 3831: void makeMonsterDropItem(creature *monst) {
! 3832: short x, y;
! 3833: getQualifyingPathLocNear(&x, &y, monst->xLoc, monst->yLoc, true,
! 3834: (T_DIVIDES_LEVEL), 0,
! 3835: T_OBSTRUCTS_ITEMS, (HAS_PLAYER | HAS_STAIRS | HAS_ITEM), false);
! 3836: placeItem(monst->carriedItem, x, y);
! 3837: monst->carriedItem = NULL;
! 3838: refreshDungeonCell(x, y);
! 3839: }
! 3840:
! 3841: void checkForContinuedLeadership(creature *monst) {
! 3842: creature *follower;
! 3843: boolean maintainLeadership = false;
! 3844:
! 3845: if (monst->bookkeepingFlags & MB_LEADER) {
! 3846: for (follower = monsters->nextCreature; follower != NULL; follower = follower->nextCreature) {
! 3847: if (follower->leader == monst && monst != follower) {
! 3848: maintainLeadership = true;
! 3849: break;
! 3850: }
! 3851: }
! 3852: }
! 3853: if (!maintainLeadership) {
! 3854: monst->bookkeepingFlags &= ~MB_LEADER;
! 3855: }
! 3856: }
! 3857:
! 3858: void demoteMonsterFromLeadership(creature *monst) {
! 3859: creature *follower, *newLeader = NULL;
! 3860: boolean atLeastOneNewFollower = false;
! 3861:
! 3862: monst->bookkeepingFlags &= ~MB_LEADER;
! 3863: if (monst->mapToMe) {
! 3864: freeGrid(monst->mapToMe);
! 3865: monst->mapToMe = NULL;
! 3866: }
! 3867:
! 3868: for (int level = 0; level <= DEEPEST_LEVEL; level++) {
! 3869: if (rogue.patchVersion < 1 && level > 0) break; // to play back 1.9.0 recordings, skip other levels
! 3870: // we'll work on this level's monsters first, so that the new leader is preferably on the same level
! 3871: creature *firstMonster = (level == 0 ? monsters->nextCreature : levels[level-1].monsters);
! 3872: for (follower = firstMonster; follower != NULL; follower = follower->nextCreature) {
! 3873: if (follower == monst || follower->leader != monst) continue;
! 3874: if (follower->bookkeepingFlags & MB_BOUND_TO_LEADER) {
! 3875: // gonna die in playerTurnEnded().
! 3876: follower->leader = NULL;
! 3877: follower->bookkeepingFlags &= ~MB_FOLLOWER;
! 3878: } else if (newLeader) {
! 3879: follower->leader = newLeader;
! 3880: atLeastOneNewFollower = true;
! 3881: follower->targetWaypointIndex = monst->targetWaypointIndex;
! 3882: if (follower->targetWaypointIndex >= 0) {
! 3883: follower->waypointAlreadyVisited[follower->targetWaypointIndex] = false;
! 3884: }
! 3885: } else {
! 3886: newLeader = follower;
! 3887: follower->bookkeepingFlags |= MB_LEADER;
! 3888: follower->bookkeepingFlags &= ~MB_FOLLOWER;
! 3889: follower->leader = NULL;
! 3890: }
! 3891: }
! 3892: }
! 3893:
! 3894: if (newLeader
! 3895: && !atLeastOneNewFollower) {
! 3896: newLeader->bookkeepingFlags &= ~MB_LEADER;
! 3897: }
! 3898:
! 3899: for (int level = 0; level <= DEEPEST_LEVEL; level++) {
! 3900: if (rogue.patchVersion < 1 && level > 0) break;
! 3901: creature *firstMonster = (level == 0 ? dormantMonsters->nextCreature : levels[level-1].dormantMonsters);
! 3902: for (follower = firstMonster; follower != NULL; follower = follower->nextCreature) {
! 3903: if (follower == monst || follower->leader != monst) continue;
! 3904: follower->leader = NULL;
! 3905: follower->bookkeepingFlags &= ~MB_FOLLOWER;
! 3906: }
! 3907: }
! 3908: }
! 3909:
! 3910: // Makes a monster dormant, or awakens it from that state
! 3911: void toggleMonsterDormancy(creature *monst) {
! 3912: creature *prevMonst;
! 3913: //short loc[2] = {0, 0};
! 3914:
! 3915: for (prevMonst = dormantMonsters; prevMonst != NULL; prevMonst = prevMonst->nextCreature) {
! 3916: if (prevMonst->nextCreature == monst) {
! 3917: // Found it! It's dormant. Wake it up.
! 3918:
! 3919: // Remove it from the dormant chain.
! 3920: prevMonst->nextCreature = monst->nextCreature;
! 3921:
! 3922: // Add it to the normal chain.
! 3923: monst->nextCreature = monsters->nextCreature;
! 3924: monsters->nextCreature = monst;
! 3925:
! 3926: pmap[monst->xLoc][monst->yLoc].flags &= ~HAS_DORMANT_MONSTER;
! 3927:
! 3928: // Does it need a new location?
! 3929: if (pmap[monst->xLoc][monst->yLoc].flags & (HAS_MONSTER | HAS_PLAYER)) { // Occupied!
! 3930: getQualifyingPathLocNear(&(monst->xLoc), &(monst->yLoc), monst->xLoc, monst->yLoc, true,
! 3931: T_DIVIDES_LEVEL & avoidedFlagsForMonster(&(monst->info)), HAS_PLAYER,
! 3932: avoidedFlagsForMonster(&(monst->info)), (HAS_PLAYER | HAS_MONSTER | HAS_STAIRS), false);
! 3933: // getQualifyingLocNear(loc, monst->xLoc, monst->yLoc, true, 0, T_PATHING_BLOCKER, (HAS_PLAYER | HAS_MONSTER), false, false);
! 3934: // monst->xLoc = loc[0];
! 3935: // monst->yLoc = loc[1];
! 3936: }
! 3937:
! 3938: if (monst->bookkeepingFlags & MB_MARKED_FOR_SACRIFICE) {
! 3939: monst->bookkeepingFlags |= MB_TELEPATHICALLY_REVEALED;
! 3940: if (monst->carriedItem) {
! 3941: makeMonsterDropItem(monst);
! 3942: }
! 3943: }
! 3944:
! 3945: // Miscellaneous transitional tasks.
! 3946: // Don't want it to move before the player has a chance to react.
! 3947: monst->ticksUntilTurn = 200;
! 3948:
! 3949: pmap[monst->xLoc][monst->yLoc].flags |= HAS_MONSTER;
! 3950: monst->bookkeepingFlags &= ~MB_IS_DORMANT;
! 3951: fadeInMonster(monst);
! 3952: return;
! 3953: }
! 3954: }
! 3955:
! 3956: for (prevMonst = monsters; prevMonst != NULL; prevMonst = prevMonst->nextCreature) {
! 3957: if (prevMonst->nextCreature == monst) {
! 3958: // Found it! It's alive. Put it into dormancy.
! 3959: // Remove it from the monsters chain.
! 3960: prevMonst->nextCreature = monst->nextCreature;
! 3961: // Add it to the dormant chain.
! 3962: monst->nextCreature = dormantMonsters->nextCreature;
! 3963: dormantMonsters->nextCreature = monst;
! 3964: // Miscellaneous transitional tasks.
! 3965: pmap[monst->xLoc][monst->yLoc].flags &= ~HAS_MONSTER;
! 3966: pmap[monst->xLoc][monst->yLoc].flags |= HAS_DORMANT_MONSTER;
! 3967: monst->bookkeepingFlags |= MB_IS_DORMANT;
! 3968: return;
! 3969: }
! 3970: }
! 3971: }
! 3972:
! 3973: boolean staffOrWandEffectOnMonsterDescription(char *newText, item *theItem, creature *monst) {
! 3974: char theItemName[COLS], monstName[COLS];
! 3975: boolean successfulDescription = false;
! 3976: fixpt enchant = netEnchant(theItem);
! 3977:
! 3978: if ((theItem->category & (STAFF | WAND))
! 3979: && tableForItemCategory(theItem->category, NULL)[theItem->kind].identified) {
! 3980:
! 3981: monsterName(monstName, monst, true);
! 3982: itemName(theItem, theItemName, false, false, NULL);
! 3983:
! 3984: switch (boltEffectForItem(theItem)) {
! 3985: case BE_DAMAGE:
! 3986: if ((boltCatalog[boltForItem(theItem)].flags & BF_FIERY) && (monst->status[STATUS_IMMUNE_TO_FIRE])
! 3987: || (monst->info.flags & MONST_INVULNERABLE)) {
! 3988:
! 3989: sprintf(newText, "\n Your %s (%c) will not harm %s.",
! 3990: theItemName,
! 3991: theItem->inventoryLetter,
! 3992: monstName);
! 3993: successfulDescription = true;
! 3994: } else if (theItem->flags & (ITEM_MAX_CHARGES_KNOWN | ITEM_IDENTIFIED)) {
! 3995: if (staffDamageLow(enchant) >= monst->currentHP) {
! 3996: sprintf(newText, "\n Your %s (%c) will %s the %s in one hit.",
! 3997: theItemName,
! 3998: theItem->inventoryLetter,
! 3999: (monst->info.flags & MONST_INANIMATE) ? "destroy" : "kill",
! 4000: monstName);
! 4001: } else {
! 4002: sprintf(newText, "\n Your %s (%c) will hit %s for between %i%% and %i%% of $HISHER current health.",
! 4003: theItemName,
! 4004: theItem->inventoryLetter,
! 4005: monstName,
! 4006: 100 * staffDamageLow(enchant) / monst->currentHP,
! 4007: 100 * staffDamageHigh(enchant) / monst->currentHP);
! 4008: }
! 4009: successfulDescription = true;
! 4010: }
! 4011: break;
! 4012: case BE_POISON:
! 4013: if (monst->info.flags & (MONST_INANIMATE | MONST_INVULNERABLE)) {
! 4014: sprintf(newText, "\n Your %s (%c) will not affect %s.",
! 4015: theItemName,
! 4016: theItem->inventoryLetter,
! 4017: monstName);
! 4018: } else {
! 4019: sprintf(newText, "\n Your %s (%c) will poison %s for %i%% of $HISHER current health.",
! 4020: theItemName,
! 4021: theItem->inventoryLetter,
! 4022: monstName,
! 4023: 100 * staffPoison(enchant) / monst->currentHP);
! 4024: }
! 4025: successfulDescription = true;
! 4026: break;
! 4027: case BE_DOMINATION:
! 4028: if (monst->creatureState != MONSTER_ALLY) {
! 4029: if (monst->info.flags & MONST_INANIMATE) {
! 4030: sprintf(newText, "\n A wand of domination will have no effect on objects like %s.",
! 4031: monstName);
! 4032: } else if (monst->info.flags & MONST_INVULNERABLE) {
! 4033: sprintf(newText, "\n A wand of domination will not affect %s.",
! 4034: monstName);
! 4035: } else if (wandDominate(monst) <= 0) {
! 4036: sprintf(newText, "\n A wand of domination will fail at %s's current health level.",
! 4037: monstName);
! 4038: } else if (wandDominate(monst) >= 100) {
! 4039: sprintf(newText, "\n A wand of domination will always succeed at %s's current health level.",
! 4040: monstName);
! 4041: } else {
! 4042: sprintf(newText, "\n A wand of domination will have a %i%% chance of success at %s's current health level.",
! 4043: wandDominate(monst),
! 4044: monstName);
! 4045: }
! 4046: successfulDescription = true;
! 4047: }
! 4048: break;
! 4049: default:
! 4050: strcpy(newText, "");
! 4051: break;
! 4052: }
! 4053: }
! 4054: return successfulDescription;
! 4055: }
! 4056:
! 4057: void monsterDetails(char buf[], creature *monst) {
! 4058: char monstName[COLS], capMonstName[COLS], theItemName[COLS * 3], newText[20*COLS];
! 4059: short i, j, combatMath, combatMath2, playerKnownAverageDamage, playerKnownMaxDamage, commaCount, realArmorValue;
! 4060: boolean anyFlags, alreadyDisplayedDominationText = false;
! 4061: item *theItem;
! 4062:
! 4063: buf[0] = '\0';
! 4064: commaCount = 0;
! 4065:
! 4066: monsterName(monstName, monst, true);
! 4067: strcpy(capMonstName, monstName);
! 4068: upperCase(capMonstName);
! 4069:
! 4070: if (!(monst->info.flags & MONST_RESTRICTED_TO_LIQUID)
! 4071: || cellHasTMFlag(monst->xLoc, monst->yLoc, TM_ALLOWS_SUBMERGING)) {
! 4072: // If the monster is not a beached whale, print the ordinary flavor text.
! 4073: sprintf(newText, " %s\n ", monsterText[monst->info.monsterID].flavorText);
! 4074: strcat(buf, newText);
! 4075: }
! 4076:
! 4077: if (monst->mutationIndex >= 0) {
! 4078: i = strlen(buf);
! 4079: i = encodeMessageColor(buf, i, mutationCatalog[monst->mutationIndex].textColor);
! 4080: strcpy(newText, mutationCatalog[monst->mutationIndex].description);
! 4081: resolvePronounEscapes(newText, monst);
! 4082: upperCase(newText);
! 4083: strcat(newText, "\n ");
! 4084: strcat(buf, newText);
! 4085: i = strlen(buf);
! 4086: i = encodeMessageColor(buf, i, &white);
! 4087: }
! 4088:
! 4089: if (!(monst->info.flags & MONST_ATTACKABLE_THRU_WALLS)
! 4090: && cellHasTerrainFlag(monst->xLoc, monst->yLoc, T_OBSTRUCTS_PASSABILITY)) {
! 4091: // If the monster is trapped in impassible terrain, explain as much.
! 4092: sprintf(newText, "%s is trapped %s %s.\n ",
! 4093: capMonstName,
! 4094: (tileCatalog[pmap[monst->xLoc][monst->yLoc].layers[layerWithFlag(monst->xLoc, monst->yLoc, T_OBSTRUCTS_PASSABILITY)]].mechFlags & TM_STAND_IN_TILE) ? "in" : "on",
! 4095: tileCatalog[pmap[monst->xLoc][monst->yLoc].layers[layerWithFlag(monst->xLoc, monst->yLoc, T_OBSTRUCTS_PASSABILITY)]].description);
! 4096: strcat(buf, newText);
! 4097: }
! 4098:
! 4099: // Allegiance and ability slots
! 4100: newText[0] = '\0';
! 4101: if (monst->creatureState == MONSTER_ALLY) {
! 4102: i = strlen(buf);
! 4103: i = encodeMessageColor(buf, i, &goodMessageColor);
! 4104:
! 4105: sprintf(newText, "%s is your ally.\n ", capMonstName);
! 4106: strcat(buf, newText);
! 4107: if (monst->newPowerCount > 0) {
! 4108: i = strlen(buf);
! 4109: i = encodeMessageColor(buf, i, &advancementMessageColor);
! 4110:
! 4111: if (monst->newPowerCount == 1) {
! 4112: sprintf(newText, "$HESHE seems ready to learn something new.\n ");
! 4113: } else {
! 4114: sprintf(newText, "$HESHE seems ready to learn %i new talents.\n ", monst->newPowerCount);
! 4115: }
! 4116: resolvePronounEscapes(newText, monst); // So that it gets capitalized appropriately.
! 4117: upperCase(newText);
! 4118: strcat(buf, newText);
! 4119: }
! 4120: }
! 4121:
! 4122: if (!rogue.armor || (rogue.armor->flags & ITEM_IDENTIFIED)) {
! 4123: combatMath2 = hitProbability(monst, &player);
! 4124: } else {
! 4125: realArmorValue = player.info.defense;
! 4126: player.info.defense = (armorTable[rogue.armor->kind].range.upperBound + armorTable[rogue.armor->kind].range.lowerBound) / 2;
! 4127: player.info.defense += 10 * strengthModifier(rogue.armor) / FP_FACTOR;
! 4128: combatMath2 = hitProbability(monst, &player);
! 4129: player.info.defense = realArmorValue;
! 4130: }
! 4131:
! 4132: // Combat info for the monster attacking the player
! 4133: if ((monst->info.flags & MONST_RESTRICTED_TO_LIQUID) && !cellHasTMFlag(monst->xLoc, monst->yLoc, TM_ALLOWS_SUBMERGING)) {
! 4134: sprintf(newText, " %s writhes helplessly on dry land.\n ", capMonstName);
! 4135: } else if (rogue.armor
! 4136: && (rogue.armor->flags & ITEM_RUNIC)
! 4137: && (rogue.armor->flags & ITEM_RUNIC_IDENTIFIED)
! 4138: && rogue.armor->enchant2 == A_IMMUNITY
! 4139: && monsterIsInClass(monst, rogue.armor->vorpalEnemy)) {
! 4140:
! 4141: itemName(rogue.armor, theItemName, false, false, NULL);
! 4142: sprintf(newText, "Your %s renders you immune to %s.\n ", theItemName, monstName);
! 4143: } else if (monst->info.damage.upperBound * monsterDamageAdjustmentAmount(monst) / FP_FACTOR == 0) {
! 4144: sprintf(newText, "%s deals no direct damage.\n ", capMonstName);
! 4145: } else {
! 4146: i = strlen(buf);
! 4147: i = encodeMessageColor(buf, i, &badMessageColor);
! 4148: if (monst->info.abilityFlags & MA_POISONS) {
! 4149: combatMath = player.status[STATUS_POISONED]; // combatMath is poison duration
! 4150: for (i = 0; combatMath * (player.poisonAmount + i) < player.currentHP; i++) {
! 4151: combatMath += monst->info.damage.upperBound * monsterDamageAdjustmentAmount(monst) / FP_FACTOR;
! 4152: }
! 4153: if (i == 0) {
! 4154: // Already fatally poisoned.
! 4155: sprintf(newText, "%s has a %i%% chance to poison you and typically poisons for %i turns.\n ",
! 4156: capMonstName,
! 4157: combatMath2,
! 4158: (int) ((monst->info.damage.lowerBound + monst->info.damage.upperBound) * monsterDamageAdjustmentAmount(monst) / 2 / FP_FACTOR));
! 4159: } else {
! 4160: sprintf(newText, "%s has a %i%% chance to poison you, typically poisons for %i turns, and at worst, could fatally poison you in %i hit%s.\n ",
! 4161: capMonstName,
! 4162: combatMath2,
! 4163: (int) ((monst->info.damage.lowerBound + monst->info.damage.upperBound) * monsterDamageAdjustmentAmount(monst) / 2 / FP_FACTOR),
! 4164: i,
! 4165: (i > 1 ? "s" : ""));
! 4166: }
! 4167: } else {
! 4168: combatMath = ((player.currentHP + (monst->info.damage.upperBound * monsterDamageAdjustmentAmount(monst) / FP_FACTOR) - 1) * FP_FACTOR)
! 4169: / (monst->info.damage.upperBound * monsterDamageAdjustmentAmount(monst));
! 4170: if (combatMath < 1) {
! 4171: combatMath = 1;
! 4172: }
! 4173: sprintf(newText, "%s has a %i%% chance to hit you, typically hits for %i%% of your current health, and at worst, could defeat you in %i hit%s.\n ",
! 4174: capMonstName,
! 4175: combatMath2,
! 4176: (int) (100 * (monst->info.damage.lowerBound + monst->info.damage.upperBound) * monsterDamageAdjustmentAmount(monst) / 2 / player.currentHP / FP_FACTOR),
! 4177: combatMath,
! 4178: (combatMath > 1 ? "s" : ""));
! 4179: }
! 4180: }
! 4181: upperCase(newText);
! 4182: strcat(buf, newText);
! 4183:
! 4184: if (!rogue.weapon || (rogue.weapon->flags & ITEM_IDENTIFIED)) {
! 4185: playerKnownAverageDamage = (player.info.damage.upperBound + player.info.damage.lowerBound) / 2;
! 4186: playerKnownMaxDamage = player.info.damage.upperBound;
! 4187: } else {
! 4188: fixpt strengthFactor = damageFraction(strengthModifier(rogue.weapon));
! 4189: short tempLow = rogue.weapon->damage.lowerBound * strengthFactor / FP_FACTOR;
! 4190: short tempHigh = rogue.weapon->damage.upperBound * strengthFactor / FP_FACTOR;
! 4191:
! 4192: playerKnownAverageDamage = max(1, (tempLow + tempHigh) / 2);
! 4193: playerKnownMaxDamage = max(1, tempHigh);
! 4194: }
! 4195:
! 4196: // Combat info for the player attacking the monster (or whether it's captive)
! 4197: if (playerKnownMaxDamage == 0) {
! 4198: i = strlen(buf);
! 4199: i = encodeMessageColor(buf, i, &white);
! 4200:
! 4201: sprintf(newText, "You deal no direct damage.");
! 4202: } else if (rogue.weapon
! 4203: && (rogue.weapon->flags & ITEM_RUNIC)
! 4204: && (rogue.weapon->flags & ITEM_RUNIC_IDENTIFIED)
! 4205: && rogue.weapon->enchant2 == W_SLAYING
! 4206: && monsterIsInClass(monst, rogue.weapon->vorpalEnemy)) {
! 4207:
! 4208: i = strlen(buf);
! 4209: i = encodeMessageColor(buf, i, &goodMessageColor);
! 4210: itemName(rogue.weapon, theItemName, false, false, NULL);
! 4211: sprintf(newText, "Your %s will slay %s in one stroke.", theItemName, monstName);
! 4212: } else if (monst->info.flags & (MONST_INVULNERABLE | MONST_IMMUNE_TO_WEAPONS)) {
! 4213: i = strlen(buf);
! 4214: i = encodeMessageColor(buf, i, &white);
! 4215: sprintf(newText, "%s is immune to your attacks.", monstName);
! 4216: } else if (monst->bookkeepingFlags & MB_CAPTIVE) {
! 4217: i = strlen(buf);
! 4218: i = encodeMessageColor(buf, i, &goodMessageColor);
! 4219:
! 4220: sprintf(newText, "%s is being held captive.", capMonstName);
! 4221: } else {
! 4222: i = strlen(buf);
! 4223: i = encodeMessageColor(buf, i, &goodMessageColor);
! 4224:
! 4225: combatMath = (monst->currentHP + playerKnownMaxDamage - 1) / playerKnownMaxDamage;
! 4226: if (combatMath < 1) {
! 4227: combatMath = 1;
! 4228: }
! 4229: if (rogue.weapon && !(rogue.weapon->flags & ITEM_IDENTIFIED)) {
! 4230: realArmorValue = rogue.weapon->enchant1;
! 4231: rogue.weapon->enchant1 = 0;
! 4232: combatMath2 = hitProbability(&player, monst);
! 4233: rogue.weapon->enchant1 = realArmorValue;
! 4234: } else {
! 4235: combatMath2 = hitProbability(&player, monst);
! 4236: }
! 4237: sprintf(newText, "You have a %i%% chance to hit %s, typically hit for %i%% of $HISHER current health, and at best, could defeat $HIMHER in %i hit%s.",
! 4238: combatMath2,
! 4239: monstName,
! 4240: 100 * playerKnownAverageDamage / monst->currentHP,
! 4241: combatMath,
! 4242: (combatMath > 1 ? "s" : ""));
! 4243: }
! 4244: upperCase(newText);
! 4245: strcat(buf, newText);
! 4246:
! 4247: for (theItem = packItems->nextItem; theItem != NULL; theItem = theItem->nextItem) {
! 4248: if (staffOrWandEffectOnMonsterDescription(newText, theItem, monst)) {
! 4249: if (boltEffectForItem(theItem) == BE_DOMINATION) {
! 4250: if (alreadyDisplayedDominationText) {
! 4251: continue;
! 4252: } else {
! 4253: alreadyDisplayedDominationText = true;
! 4254: }
! 4255: }
! 4256: i = strlen(buf);
! 4257: i = encodeMessageColor(buf, i, &itemMessageColor);
! 4258: strcat(buf, newText);
! 4259: }
! 4260: }
! 4261:
! 4262: if (monst->carriedItem) {
! 4263: i = strlen(buf);
! 4264: i = encodeMessageColor(buf, i, &itemMessageColor);
! 4265: itemName(monst->carriedItem, theItemName, true, true, NULL);
! 4266: sprintf(newText, "%s has %s.", capMonstName, theItemName);
! 4267: upperCase(newText);
! 4268: strcat(buf, "\n ");
! 4269: strcat(buf, newText);
! 4270: }
! 4271:
! 4272: strcat(buf, "\n ");
! 4273:
! 4274: i = strlen(buf);
! 4275: i = encodeMessageColor(buf, i, &white);
! 4276:
! 4277: anyFlags = false;
! 4278: sprintf(newText, "%s ", capMonstName);
! 4279:
! 4280: if (monst->attackSpeed < 100) {
! 4281: strcat(newText, "attacks quickly");
! 4282: anyFlags = true;
! 4283: } else if (monst->attackSpeed > 100) {
! 4284: strcat(newText, "attacks slowly");
! 4285: anyFlags = true;
! 4286: }
! 4287:
! 4288: if (monst->movementSpeed < 100) {
! 4289: if (anyFlags) {
! 4290: strcat(newText, "& ");
! 4291: commaCount++;
! 4292: }
! 4293: strcat(newText, "moves quickly");
! 4294: anyFlags = true;
! 4295: } else if (monst->movementSpeed > 100) {
! 4296: if (anyFlags) {
! 4297: strcat(newText, "& ");
! 4298: commaCount++;
! 4299: }
! 4300: strcat(newText, "moves slowly");
! 4301: anyFlags = true;
! 4302: }
! 4303:
! 4304: if (monst->info.turnsBetweenRegen == 0) {
! 4305: if (anyFlags) {
! 4306: strcat(newText, "& ");
! 4307: commaCount++;
! 4308: }
! 4309: strcat(newText, "does not regenerate");
! 4310: anyFlags = true;
! 4311: } else if (monst->info.turnsBetweenRegen < 5000) {
! 4312: if (anyFlags) {
! 4313: strcat(newText, "& ");
! 4314: commaCount++;
! 4315: }
! 4316: strcat(newText, "regenerates quickly");
! 4317: anyFlags = true;
! 4318: }
! 4319:
! 4320: // bolt flags
! 4321: for (i = 0; monst->info.bolts[i] != BOLT_NONE; i++) {
! 4322: if (boltCatalog[monst->info.bolts[i]].abilityDescription[0]) {
! 4323: if (anyFlags) {
! 4324: strcat(newText, "& ");
! 4325: commaCount++;
! 4326: }
! 4327: strcat(newText, boltCatalog[monst->info.bolts[i]].abilityDescription);
! 4328: anyFlags = true;
! 4329: }
! 4330: }
! 4331:
! 4332: // ability flags
! 4333: for (i=0; i<32; i++) {
! 4334: if ((monst->info.abilityFlags & (Fl(i)))
! 4335: && monsterAbilityFlagDescriptions[i][0]) {
! 4336: if (anyFlags) {
! 4337: strcat(newText, "& ");
! 4338: commaCount++;
! 4339: }
! 4340: strcat(newText, monsterAbilityFlagDescriptions[i]);
! 4341: anyFlags = true;
! 4342: }
! 4343: }
! 4344:
! 4345: // behavior flags
! 4346: for (i=0; i<32; i++) {
! 4347: if ((monst->info.flags & (Fl(i)))
! 4348: && monsterBehaviorFlagDescriptions[i][0]) {
! 4349: if (anyFlags) {
! 4350: strcat(newText, "& ");
! 4351: commaCount++;
! 4352: }
! 4353: strcat(newText, monsterBehaviorFlagDescriptions[i]);
! 4354: anyFlags = true;
! 4355: }
! 4356: }
! 4357:
! 4358: // bookkeeping flags
! 4359: for (i=0; i<32; i++) {
! 4360: if ((monst->bookkeepingFlags & (Fl(i)))
! 4361: && monsterBookkeepingFlagDescriptions[i][0]) {
! 4362: if (anyFlags) {
! 4363: strcat(newText, "& ");
! 4364: commaCount++;
! 4365: }
! 4366: strcat(newText, monsterBookkeepingFlagDescriptions[i]);
! 4367: anyFlags = true;
! 4368: }
! 4369: }
! 4370:
! 4371: if (anyFlags) {
! 4372: strcat(newText, ". ");
! 4373: //strcat(buf, "\n\n");
! 4374: j = strlen(buf);
! 4375: for (i=0; newText[i] != '\0'; i++) {
! 4376: if (newText[i] == '&') {
! 4377: if (!--commaCount) {
! 4378: buf[j] = '\0';
! 4379: strcat(buf, " and");
! 4380: j += 4;
! 4381: } else {
! 4382: buf[j++] = ',';
! 4383: }
! 4384: } else {
! 4385: buf[j++] = newText[i];
! 4386: }
! 4387: }
! 4388: buf[j] = '\0';
! 4389: }
! 4390: resolvePronounEscapes(buf, monst);
! 4391: }
CVSweb
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to Monsters.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [contributed] / brogue-ce / src / brogue