Annotation of brogue-ce/src/brogue/Combat.c, Revision 1.1
1.1 ! rubenllo 1: /*
! 2: * Combat.c
! 3: * Brogue
! 4: *
! 5: * Created by Brian Walker on 6/11/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:
! 28: /* Combat rules:
! 29: * Each combatant has an accuracy rating. This is the percentage of their attacks that will ordinarily hit;
! 30: * higher numbers are better for them. Numbers over 100 are permitted.
! 31: *
! 32: * Each combatant also has a defense rating. The "hit probability" is calculated as given by this formula:
! 33: *
! 34: * hit probability = (accuracy) * 0.987 ^ (defense)
! 35: *
! 36: * when hit determinations are made. Negative numbers and numbers over 100 are permitted.
! 37: * The hit is then randomly determined according to this final percentage.
! 38: *
! 39: * Some environmental factors can modify these numbers. An unaware, sleeping, stuck or paralyzed
! 40: * combatant is always hit. An unaware, sleeping or paralyzed combatant also takes treble damage.
! 41: *
! 42: * If the hit lands, damage is calculated in the range provided. However, the clumping factor affects the
! 43: * probability distribution. If the range is 0-10 with a clumping factor of 1, it's a uniform distribution.
! 44: * With a clumping factor of 2, it's calculated as 2d5 (with d5 meaing a die numbered from 0 through 5).
! 45: * With 3, it's 3d3, and so on. Note that a range not divisible by the clumping factor is defective,
! 46: * as it will never be resolved in the top few numbers of the range. In fact, the top
! 47: * (rangeWidth % clumpingFactor) will never succeed. Thus we increment the maximum of the first
! 48: * (rangeWidth % clumpingFactor) die by 1, so that in fact 0-10 with a CF of 3 would be 1d4 + 2d3. Similarly,
! 49: * 0-10 with CF 4 would be 2d3 + 2d2. By playing with the numbers, one can approximate a gaussian
! 50: * distribution of any mean and standard deviation.
! 51: *
! 52: * Player combatants take their base defense value of their actual armor. Their accuracy is a combination of weapon, armor
! 53: * and strength.
! 54: *
! 55: * Players have a base accuracy value of 100 throughout the game. Each point of weapon enchantment (net of
! 56: * strength penalty/benefit) increases
! 57: */
! 58:
! 59: fixpt strengthModifier(item *theItem) {
! 60: int difference = (rogue.strength - player.weaknessAmount) - theItem->strengthRequired;
! 61: if (difference > 0) {
! 62: return difference * FP_FACTOR / 4; // 0.25x
! 63: } else {
! 64: return difference * FP_FACTOR * 5/2; // 2.5x
! 65: }
! 66: }
! 67:
! 68: fixpt netEnchant(item *theItem) {
! 69: fixpt retval = theItem->enchant1 * FP_FACTOR;
! 70: if (theItem->category & (WEAPON | ARMOR)) {
! 71: retval += strengthModifier(theItem);
! 72: }
! 73: // Clamp all net enchantment values to [-20, 50].
! 74: return clamp(retval, -20 * FP_FACTOR, 50 * FP_FACTOR);
! 75: }
! 76:
! 77: fixpt monsterDamageAdjustmentAmount(const creature *monst) {
! 78: if (monst == &player) {
! 79: // Handled through player strength routines elsewhere.
! 80: return FP_FACTOR;
! 81: } else {
! 82: return damageFraction(monst->weaknessAmount * FP_FACTOR * -3/2);
! 83: }
! 84: }
! 85:
! 86: short monsterDefenseAdjusted(const creature *monst) {
! 87: short retval;
! 88: if (monst == &player) {
! 89: // Weakness is already taken into account in recalculateEquipmentBonuses() for the player.
! 90: retval = monst->info.defense;
! 91: } else {
! 92: retval = monst->info.defense - 25 * monst->weaknessAmount;
! 93: }
! 94: return max(retval, 0);
! 95: }
! 96:
! 97: short monsterAccuracyAdjusted(const creature *monst) {
! 98: short retval = monst->info.accuracy * accuracyFraction(monst->weaknessAmount * FP_FACTOR * -3/2) / FP_FACTOR;
! 99: return max(retval, 0);
! 100: }
! 101:
! 102: // does NOT account for auto-hit from sleeping or unaware defenders; does account for auto-hit from
! 103: // stuck or captive defenders and from weapons of slaying.
! 104: short hitProbability(creature *attacker, creature *defender) {
! 105: short accuracy = monsterAccuracyAdjusted(attacker);
! 106: short defense = monsterDefenseAdjusted(defender);
! 107: short hitProbability;
! 108:
! 109: if (defender->status[STATUS_STUCK] || (defender->bookkeepingFlags & MB_CAPTIVE)) {
! 110: return 100;
! 111: }
! 112: if ((defender->bookkeepingFlags & MB_SEIZED)
! 113: && (attacker->bookkeepingFlags & MB_SEIZING)) {
! 114:
! 115: return 100;
! 116: }
! 117: if (attacker == &player && rogue.weapon) {
! 118: if ((rogue.weapon->flags & ITEM_RUNIC)
! 119: && rogue.weapon->enchant2 == W_SLAYING
! 120: && monsterIsInClass(defender, rogue.weapon->vorpalEnemy)) {
! 121:
! 122: return 100;
! 123: }
! 124: accuracy = player.info.accuracy * accuracyFraction(netEnchant(rogue.weapon)) / FP_FACTOR;
! 125: }
! 126: hitProbability = accuracy * defenseFraction(defense * FP_FACTOR) / FP_FACTOR;
! 127: if (hitProbability > 100) {
! 128: hitProbability = 100;
! 129: } else if (hitProbability < 0) {
! 130: hitProbability = 0;
! 131: }
! 132: return hitProbability;
! 133: }
! 134:
! 135: boolean attackHit(creature *attacker, creature *defender) {
! 136: // automatically hit if the monster is sleeping or captive or stuck in a web
! 137: if (defender->status[STATUS_STUCK]
! 138: || defender->status[STATUS_PARALYZED]
! 139: || (defender->bookkeepingFlags & MB_CAPTIVE)) {
! 140:
! 141: return true;
! 142: }
! 143:
! 144: return rand_percent(hitProbability(attacker, defender));
! 145: }
! 146:
! 147: void addMonsterToContiguousMonsterGrid(short x, short y, creature *monst, char grid[DCOLS][DROWS]) {
! 148: short newX, newY;
! 149: enum directions dir;
! 150: creature *tempMonst;
! 151:
! 152: grid[x][y] = true;
! 153: for (dir=0; dir<4; dir++) {
! 154: newX = x + nbDirs[dir][0];
! 155: newY = y + nbDirs[dir][1];
! 156:
! 157: if (coordinatesAreInMap(newX, newY) && !grid[newX][newY]) {
! 158: tempMonst = monsterAtLoc(newX, newY);
! 159: if (tempMonst && monstersAreTeammates(monst, tempMonst)) {
! 160: addMonsterToContiguousMonsterGrid(newX, newY, monst, grid);
! 161: }
! 162: }
! 163: }
! 164: }
! 165:
! 166: // Splits a monster in half.
! 167: // The split occurs only if there is a spot adjacent to the contiguous
! 168: // group of monsters that the monster would not avoid.
! 169: // The contiguous group is supplemented with the given (x, y) coordinates, if any;
! 170: // this is so that jellies et al. can spawn behind the player in a hallway.
! 171: void splitMonster(creature *monst, short x, short y) {
! 172: short i, j, b, dir, newX, newY, eligibleLocationCount, randIndex;
! 173: char buf[DCOLS * 3];
! 174: char monstName[DCOLS];
! 175: char monsterGrid[DCOLS][DROWS], eligibleGrid[DCOLS][DROWS];
! 176: creature *clone;
! 177:
! 178: zeroOutGrid(monsterGrid);
! 179: zeroOutGrid(eligibleGrid);
! 180: eligibleLocationCount = 0;
! 181:
! 182: // Add the (x, y) location to the contiguous group, if any.
! 183: if (x > 0 && y > 0) {
! 184: monsterGrid[x][y] = true;
! 185: }
! 186:
! 187: // Find the contiguous group of monsters.
! 188: addMonsterToContiguousMonsterGrid(monst->xLoc, monst->yLoc, monst, monsterGrid);
! 189:
! 190: // Find the eligible edges around the group of monsters.
! 191: for (i=0; i<DCOLS; i++) {
! 192: for (j=0; j<DROWS; j++) {
! 193: if (monsterGrid[i][j]) {
! 194: for (dir=0; dir<4; dir++) {
! 195: newX = i + nbDirs[dir][0];
! 196: newY = j + nbDirs[dir][1];
! 197: if (coordinatesAreInMap(newX, newY)
! 198: && !eligibleGrid[newX][newY]
! 199: && !monsterGrid[newX][newY]
! 200: && !(pmap[newX][newY].flags & (HAS_PLAYER | HAS_MONSTER))
! 201: && !monsterAvoids(monst, newX, newY)) {
! 202:
! 203: eligibleGrid[newX][newY] = true;
! 204: eligibleLocationCount++;
! 205: }
! 206: }
! 207: }
! 208: }
! 209: }
! 210: // DEBUG {
! 211: // hiliteCharGrid(eligibleGrid, &green, 75);
! 212: // hiliteCharGrid(monsterGrid, &blue, 75);
! 213: // temporaryMessage("Jelly spawn possibilities (green = eligible, blue = monster):", true);
! 214: // displayLevel();
! 215: // }
! 216:
! 217: // Pick a random location on the eligibleGrid and add the clone there.
! 218: if (eligibleLocationCount) {
! 219: randIndex = rand_range(1, eligibleLocationCount);
! 220: for (i=0; i<DCOLS; i++) {
! 221: for (j=0; j<DROWS; j++) {
! 222: if (eligibleGrid[i][j] && !--randIndex) {
! 223: // Found the spot!
! 224:
! 225: monsterName(monstName, monst, true);
! 226: monst->currentHP = (monst->currentHP + 1) / 2;
! 227: clone = cloneMonster(monst, false, false);
! 228:
! 229: // Split monsters don't inherit the learnings of their parents.
! 230: // Sorry, but self-healing jelly armies are too much.
! 231: // Mutation effects can be inherited, however; they're not learned abilities.
! 232: if (monst->mutationIndex >= 0) {
! 233: clone->info.flags &= (monsterCatalog[clone->info.monsterID].flags | mutationCatalog[monst->mutationIndex].monsterFlags);
! 234: clone->info.abilityFlags &= (monsterCatalog[clone->info.monsterID].abilityFlags | mutationCatalog[monst->mutationIndex].monsterAbilityFlags);
! 235: } else {
! 236: clone->info.flags &= monsterCatalog[clone->info.monsterID].flags;
! 237: clone->info.abilityFlags &= monsterCatalog[clone->info.monsterID].abilityFlags;
! 238: }
! 239: for (b = 0; b < 20; b++) {
! 240: clone->info.bolts[b] = monsterCatalog[clone->info.monsterID].bolts[b];
! 241: }
! 242:
! 243: if (!(clone->info.flags & MONST_FLIES)
! 244: && clone->status[STATUS_LEVITATING] == 1000) {
! 245:
! 246: clone->status[STATUS_LEVITATING] = 0;
! 247: }
! 248:
! 249: clone->xLoc = i;
! 250: clone->yLoc = j;
! 251: pmap[i][j].flags |= HAS_MONSTER;
! 252: clone->ticksUntilTurn = max(clone->ticksUntilTurn, 101);
! 253: fadeInMonster(clone);
! 254: refreshSideBar(-1, -1, false);
! 255:
! 256: if (canDirectlySeeMonster(monst)) {
! 257: sprintf(buf, "%s splits in two!", monstName);
! 258: message(buf, false);
! 259: }
! 260:
! 261: return;
! 262: }
! 263: }
! 264: }
! 265: }
! 266: }
! 267:
! 268: short alliedCloneCount(creature *monst) {
! 269: short count;
! 270: creature *temp;
! 271:
! 272: count = 0;
! 273: for (temp = monsters->nextCreature; temp != NULL; temp = temp->nextCreature) {
! 274: if (temp != monst
! 275: && temp->info.monsterID == monst->info.monsterID
! 276: && monstersAreTeammates(temp, monst)) {
! 277:
! 278: count++;
! 279: }
! 280: }
! 281: if (rogue.depthLevel > 1) {
! 282: for (temp = levels[rogue.depthLevel - 2].monsters; temp != NULL; temp = temp->nextCreature) {
! 283: if (temp != monst
! 284: && temp->info.monsterID == monst->info.monsterID
! 285: && monstersAreTeammates(temp, monst)) {
! 286:
! 287: count++;
! 288: }
! 289: }
! 290: }
! 291: if (rogue.depthLevel < DEEPEST_LEVEL) {
! 292: for (temp = levels[rogue.depthLevel].monsters; temp != NULL; temp = temp->nextCreature) {
! 293: if (temp != monst
! 294: && temp->info.monsterID == monst->info.monsterID
! 295: && monstersAreTeammates(temp, monst)) {
! 296:
! 297: count++;
! 298: }
! 299: }
! 300: }
! 301: return count;
! 302: }
! 303:
! 304: // This function is called whenever one creature acts aggressively against another in a way that directly causes damage.
! 305: // This can be things like melee attacks, fire/lightning attacks or throwing a weapon.
! 306: void moralAttack(creature *attacker, creature *defender) {
! 307:
! 308: if (attacker == &player && canSeeMonster(defender)) {
! 309: rogue.featRecord[FEAT_PACIFIST] = false;
! 310: if (defender->creatureState != MONSTER_TRACKING_SCENT) {
! 311: rogue.featRecord[FEAT_PALADIN] = false;
! 312: }
! 313: }
! 314:
! 315: if (defender->currentHP > 0
! 316: && !(defender->bookkeepingFlags & MB_IS_DYING)) {
! 317:
! 318: if (defender->status[STATUS_PARALYZED]) {
! 319: defender->status[STATUS_PARALYZED] = 0;
! 320: // Paralyzed creature gets a turn to react before the attacker moves again.
! 321: defender->ticksUntilTurn = min(attacker->attackSpeed, 100) - 1;
! 322: }
! 323: if (defender->status[STATUS_MAGICAL_FEAR]) {
! 324: defender->status[STATUS_MAGICAL_FEAR] = 1;
! 325: }
! 326: defender->status[STATUS_ENTRANCED] = 0;
! 327:
! 328: if (attacker == &player
! 329: && defender->creatureState == MONSTER_ALLY
! 330: && !defender->status[STATUS_DISCORDANT]
! 331: && !attacker->status[STATUS_CONFUSED]
! 332: && !(attacker->bookkeepingFlags & MB_IS_DYING)) {
! 333:
! 334: unAlly(defender);
! 335: }
! 336:
! 337: if ((attacker == &player || attacker->creatureState == MONSTER_ALLY)
! 338: && defender != &player
! 339: && defender->creatureState != MONSTER_ALLY) {
! 340:
! 341: alertMonster(defender); // this alerts the monster that you're nearby
! 342: }
! 343:
! 344: if ((defender->info.abilityFlags & MA_CLONE_SELF_ON_DEFEND) && alliedCloneCount(defender) < 100) {
! 345: if (distanceBetween(defender->xLoc, defender->yLoc, attacker->xLoc, attacker->yLoc) <= 1) {
! 346: splitMonster(defender, attacker->xLoc, attacker->yLoc);
! 347: } else {
! 348: splitMonster(defender, 0, 0);
! 349: }
! 350: }
! 351: }
! 352: }
! 353:
! 354: boolean playerImmuneToMonster(creature *monst) {
! 355: if (monst != &player
! 356: && rogue.armor
! 357: && (rogue.armor->flags & ITEM_RUNIC)
! 358: && (rogue.armor->enchant2 == A_IMMUNITY)
! 359: && monsterIsInClass(monst, rogue.armor->vorpalEnemy)) {
! 360:
! 361: return true;
! 362: } else {
! 363: return false;
! 364: }
! 365: }
! 366:
! 367: void specialHit(creature *attacker, creature *defender, short damage) {
! 368: short itemCandidates, randItemIndex, stolenQuantity;
! 369: item *theItem = NULL, *itemFromTopOfStack;
! 370: char buf[COLS], buf2[COLS], buf3[COLS];
! 371:
! 372: if (!(attacker->info.abilityFlags & SPECIAL_HIT)) {
! 373: return;
! 374: }
! 375:
! 376: // Special hits that can affect only the player:
! 377: if (defender == &player) {
! 378: if (playerImmuneToMonster(attacker)) {
! 379: return;
! 380: }
! 381:
! 382: if (attacker->info.abilityFlags & MA_HIT_DEGRADE_ARMOR
! 383: && defender == &player
! 384: && rogue.armor
! 385: && !(rogue.armor->flags & ITEM_PROTECTED)
! 386: && (rogue.armor->enchant1 + rogue.armor->armor/10 > -10)) {
! 387:
! 388: rogue.armor->enchant1--;
! 389: equipItem(rogue.armor, true);
! 390: itemName(rogue.armor, buf2, false, false, NULL);
! 391: sprintf(buf, "your %s weakens!", buf2);
! 392: messageWithColor(buf, &itemMessageColor, false);
! 393: checkForDisenchantment(rogue.armor);
! 394: }
! 395: if (attacker->info.abilityFlags & MA_HIT_HALLUCINATE) {
! 396: if (!player.status[STATUS_HALLUCINATING]) {
! 397: combatMessage("you begin to hallucinate", 0);
! 398: }
! 399: if (!player.status[STATUS_HALLUCINATING]) {
! 400: player.maxStatus[STATUS_HALLUCINATING] = 0;
! 401: }
! 402: player.status[STATUS_HALLUCINATING] += 20;
! 403: player.maxStatus[STATUS_HALLUCINATING] = max(player.maxStatus[STATUS_HALLUCINATING], player.status[STATUS_HALLUCINATING]);
! 404: }
! 405: if (attacker->info.abilityFlags & MA_HIT_BURN
! 406: && !defender->status[STATUS_IMMUNE_TO_FIRE]) {
! 407:
! 408: exposeCreatureToFire(defender);
! 409: }
! 410:
! 411: if (attacker->info.abilityFlags & MA_HIT_STEAL_FLEE
! 412: && !(attacker->carriedItem)
! 413: && (packItems->nextItem)
! 414: && attacker->currentHP > 0
! 415: && !attacker->status[STATUS_CONFUSED] // No stealing from the player if you bump him while confused.
! 416: && attackHit(attacker, defender)) {
! 417:
! 418: itemCandidates = numberOfMatchingPackItems(ALL_ITEMS, 0, (ITEM_EQUIPPED), false);
! 419: if (itemCandidates) {
! 420: randItemIndex = rand_range(1, itemCandidates);
! 421: for (theItem = packItems->nextItem; theItem != NULL; theItem = theItem->nextItem) {
! 422: if (!(theItem->flags & (ITEM_EQUIPPED))) {
! 423: if (randItemIndex == 1) {
! 424: break;
! 425: } else {
! 426: randItemIndex--;
! 427: }
! 428: }
! 429: }
! 430: if (theItem) {
! 431: if (theItem->category & WEAPON) { // Monkeys will steal half of a stack of weapons, and one of any other stack.
! 432: if (theItem->quantity > 3) {
! 433: stolenQuantity = (theItem->quantity + 1) / 2;
! 434: } else {
! 435: stolenQuantity = theItem->quantity;
! 436: }
! 437: } else {
! 438: stolenQuantity = 1;
! 439: }
! 440: if (stolenQuantity < theItem->quantity) { // Peel off stolen item(s).
! 441: itemFromTopOfStack = generateItem(ALL_ITEMS, -1);
! 442: *itemFromTopOfStack = *theItem; // Clone the item.
! 443: theItem->quantity -= stolenQuantity;
! 444: itemFromTopOfStack->quantity = stolenQuantity;
! 445: theItem = itemFromTopOfStack; // Redirect pointer.
! 446: } else {
! 447: removeItemFromChain(theItem, packItems);
! 448: }
! 449: theItem->flags &= ~ITEM_PLAYER_AVOIDS; // Explore will seek the item out if it ends up on the floor again.
! 450: attacker->carriedItem = theItem;
! 451: attacker->creatureMode = MODE_PERM_FLEEING;
! 452: attacker->creatureState = MONSTER_FLEEING;
! 453: monsterName(buf2, attacker, true);
! 454: itemName(theItem, buf3, false, true, NULL);
! 455: sprintf(buf, "%s stole %s!", buf2, buf3);
! 456: messageWithColor(buf, &badMessageColor, false);
! 457: }
! 458: }
! 459: }
! 460: }
! 461: if ((attacker->info.abilityFlags & MA_POISONS)
! 462: && damage > 0
! 463: && !(defender->info.flags & (MONST_INANIMATE | MONST_INVULNERABLE))) {
! 464:
! 465: addPoison(defender, damage, 1);
! 466: }
! 467: if ((attacker->info.abilityFlags & MA_CAUSES_WEAKNESS)
! 468: && damage > 0
! 469: && !(defender->info.flags & (MONST_INANIMATE | MONST_INVULNERABLE))) {
! 470:
! 471: weaken(defender, 300);
! 472: }
! 473: if (attacker->info.abilityFlags & MA_ATTACKS_STAGGER) {
! 474: processStaggerHit(attacker, defender);
! 475: }
! 476: }
! 477:
! 478: boolean forceWeaponHit(creature *defender, item *theItem) {
! 479: short oldLoc[2], newLoc[2], forceDamage;
! 480: char buf[DCOLS*3], buf2[COLS], monstName[DCOLS];
! 481: creature *otherMonster = NULL;
! 482: boolean knowFirstMonsterDied = false, autoID = false;
! 483: bolt theBolt;
! 484:
! 485: monsterName(monstName, defender, true);
! 486:
! 487: oldLoc[0] = defender->xLoc;
! 488: oldLoc[1] = defender->yLoc;
! 489: newLoc[0] = defender->xLoc + clamp(defender->xLoc - player.xLoc, -1, 1);
! 490: newLoc[1] = defender->yLoc + clamp(defender->yLoc - player.yLoc, -1, 1);
! 491: if (canDirectlySeeMonster(defender)
! 492: && !cellHasTerrainFlag(newLoc[0], newLoc[1], T_OBSTRUCTS_PASSABILITY | T_OBSTRUCTS_VISION)
! 493: && !(pmap[newLoc[0]][newLoc[1]].flags & (HAS_MONSTER | HAS_PLAYER))) {
! 494: sprintf(buf, "you launch %s backward with the force of your blow", monstName);
! 495: buf[DCOLS] = '\0';
! 496: combatMessage(buf, messageColorFromVictim(defender));
! 497: autoID = true;
! 498: }
! 499: theBolt = boltCatalog[BOLT_BLINKING];
! 500: theBolt.magnitude = max(1, netEnchant(theItem) / FP_FACTOR);
! 501: zap(oldLoc, newLoc, &theBolt, false);
! 502: if (!(defender->bookkeepingFlags & MB_IS_DYING)
! 503: && distanceBetween(oldLoc[0], oldLoc[1], defender->xLoc, defender->yLoc) > 0
! 504: && distanceBetween(oldLoc[0], oldLoc[1], defender->xLoc, defender->yLoc) < weaponForceDistance(netEnchant(theItem))) {
! 505:
! 506: if (pmap[defender->xLoc + newLoc[0] - oldLoc[0]][defender->yLoc + newLoc[1] - oldLoc[1]].flags & (HAS_MONSTER | HAS_PLAYER)) {
! 507: otherMonster = monsterAtLoc(defender->xLoc + newLoc[0] - oldLoc[0], defender->yLoc + newLoc[1] - oldLoc[1]);
! 508: monsterName(buf2, otherMonster, true);
! 509: } else {
! 510: otherMonster = NULL;
! 511: strcpy(buf2, tileCatalog[pmap[defender->xLoc + newLoc[0] - oldLoc[0]][defender->yLoc + newLoc[1] - oldLoc[1]].layers[highestPriorityLayer(defender->xLoc + newLoc[0] - oldLoc[0], defender->yLoc + newLoc[1] - oldLoc[1], true)]].description);
! 512: }
! 513:
! 514: forceDamage = distanceBetween(oldLoc[0], oldLoc[1], defender->xLoc, defender->yLoc);
! 515:
! 516: if (!(defender->info.flags & (MONST_IMMUNE_TO_WEAPONS | MONST_INVULNERABLE))
! 517: && inflictDamage(NULL, defender, forceDamage, &white, false)) {
! 518:
! 519: if (canDirectlySeeMonster(defender)) {
! 520: knowFirstMonsterDied = true;
! 521: sprintf(buf, "%s %s on impact with %s",
! 522: monstName,
! 523: (defender->info.flags & MONST_INANIMATE) ? "is destroyed" : "dies",
! 524: buf2);
! 525: buf[DCOLS] = '\0';
! 526: combatMessage(buf, messageColorFromVictim(defender));
! 527: autoID = true;
! 528: }
! 529: } else {
! 530: if (canDirectlySeeMonster(defender)) {
! 531: sprintf(buf, "%s slams against %s",
! 532: monstName,
! 533: buf2);
! 534: buf[DCOLS] = '\0';
! 535: combatMessage(buf, messageColorFromVictim(defender));
! 536: autoID = true;
! 537: }
! 538: }
! 539: moralAttack(&player, defender);
! 540:
! 541: if (otherMonster
! 542: && !(defender->info.flags & (MONST_IMMUNE_TO_WEAPONS | MONST_INVULNERABLE))) {
! 543:
! 544: if (inflictDamage(NULL, otherMonster, forceDamage, &white, false)) {
! 545: if (canDirectlySeeMonster(otherMonster)) {
! 546: sprintf(buf, "%s %s%s when %s slams into $HIMHER",
! 547: buf2,
! 548: (knowFirstMonsterDied ? "also " : ""),
! 549: (defender->info.flags & MONST_INANIMATE) ? "is destroyed" : "dies",
! 550: monstName);
! 551: resolvePronounEscapes(buf, otherMonster);
! 552: buf[DCOLS] = '\0';
! 553: combatMessage(buf, messageColorFromVictim(otherMonster));
! 554: autoID = true;
! 555: }
! 556: }
! 557: if (otherMonster->creatureState != MONSTER_ALLY) {
! 558: // Allies won't defect if you throw another monster at them, even though it hurts.
! 559: moralAttack(&player, otherMonster);
! 560: }
! 561: }
! 562: }
! 563: return autoID;
! 564: }
! 565:
! 566: void magicWeaponHit(creature *defender, item *theItem, boolean backstabbed) {
! 567: char buf[DCOLS*3], monstName[DCOLS], theItemName[DCOLS];
! 568:
! 569: color *effectColors[NUMBER_WEAPON_RUNIC_KINDS] = {&white, &black,
! 570: &yellow, &pink, &green, &confusionGasColor, NULL, NULL, &darkRed, &rainbow};
! 571: // W_SPEED, W_QUIETUS, W_PARALYSIS, W_MULTIPLICITY, W_SLOWING, W_CONFUSION, W_FORCE, W_SLAYING, W_MERCY, W_PLENTY
! 572: short chance, i;
! 573: fixpt enchant;
! 574: enum weaponEnchants enchantType = theItem->enchant2;
! 575: creature *newMonst;
! 576: boolean autoID = false;
! 577:
! 578: // If the defender is already dead, proceed only if the runic is speed or multiplicity.
! 579: // (Everything else acts on the victim, which would literally be overkill.)
! 580: if ((defender->bookkeepingFlags & MB_IS_DYING)
! 581: && theItem->enchant2 != W_SPEED
! 582: && theItem->enchant2 != W_MULTIPLICITY) {
! 583: return;
! 584: }
! 585:
! 586: enchant = netEnchant(theItem);
! 587:
! 588: if (theItem->enchant2 == W_SLAYING) {
! 589: chance = (monsterIsInClass(defender, theItem->vorpalEnemy) ? 100 : 0);
! 590: } else if (defender->info.flags & (MONST_INANIMATE | MONST_INVULNERABLE)) {
! 591: chance = 0;
! 592: } else {
! 593: chance = runicWeaponChance(theItem, false, 0);
! 594: if (backstabbed && chance < 100) {
! 595: chance = min(chance * 2, (chance + 100) / 2);
! 596: }
! 597: }
! 598: if (chance > 0 && rand_percent(chance)) {
! 599: if (!(defender->bookkeepingFlags & MB_SUBMERGED)) {
! 600: switch (enchantType) {
! 601: case W_SPEED:
! 602: createFlare(player.xLoc, player.yLoc, SCROLL_ENCHANTMENT_LIGHT);
! 603: break;
! 604: case W_QUIETUS:
! 605: createFlare(defender->xLoc, defender->yLoc, QUIETUS_FLARE_LIGHT);
! 606: break;
! 607: case W_SLAYING:
! 608: createFlare(defender->xLoc, defender->yLoc, SLAYING_FLARE_LIGHT);
! 609: break;
! 610: default:
! 611: flashMonster(defender, effectColors[enchantType], 100);
! 612: break;
! 613: }
! 614: autoID = true;
! 615: }
! 616: rogue.disturbed = true;
! 617: monsterName(monstName, defender, true);
! 618: itemName(theItem, theItemName, false, false, NULL);
! 619:
! 620: switch (enchantType) {
! 621: case W_SPEED:
! 622: if (player.ticksUntilTurn != -1) {
! 623: sprintf(buf, "your %s trembles and time freezes for a moment", theItemName);
! 624: buf[DCOLS] = '\0';
! 625: combatMessage(buf, 0);
! 626: player.ticksUntilTurn = -1; // free turn!
! 627: autoID = true;
! 628: }
! 629: break;
! 630: case W_SLAYING:
! 631: case W_QUIETUS:
! 632: inflictLethalDamage(&player, defender);
! 633: sprintf(buf, "%s suddenly %s",
! 634: monstName,
! 635: (defender->info.flags & MONST_INANIMATE) ? "shatters" : "dies");
! 636: buf[DCOLS] = '\0';
! 637: combatMessage(buf, messageColorFromVictim(defender));
! 638: autoID = true;
! 639: break;
! 640: case W_PARALYSIS:
! 641: defender->status[STATUS_PARALYZED] = max(defender->status[STATUS_PARALYZED], weaponParalysisDuration(enchant));
! 642: defender->maxStatus[STATUS_PARALYZED] = defender->status[STATUS_PARALYZED];
! 643: if (canDirectlySeeMonster(defender)) {
! 644: sprintf(buf, "%s is frozen in place", monstName);
! 645: buf[DCOLS] = '\0';
! 646: combatMessage(buf, messageColorFromVictim(defender));
! 647: autoID = true;
! 648: }
! 649: break;
! 650: case W_MULTIPLICITY:
! 651: sprintf(buf, "Your %s emits a flash of light, and %sspectral duplicate%s appear%s!",
! 652: theItemName,
! 653: (weaponImageCount(enchant) == 1 ? "a " : ""),
! 654: (weaponImageCount(enchant) == 1 ? "" : "s"),
! 655: (weaponImageCount(enchant) == 1 ? "s" : ""));
! 656: buf[DCOLS] = '\0';
! 657:
! 658: for (i = 0; i < (weaponImageCount(enchant)); i++) {
! 659: newMonst = generateMonster(MK_SPECTRAL_IMAGE, true, false);
! 660: getQualifyingPathLocNear(&(newMonst->xLoc), &(newMonst->yLoc), defender->xLoc, defender->yLoc, true,
! 661: T_DIVIDES_LEVEL & avoidedFlagsForMonster(&(newMonst->info)), HAS_PLAYER,
! 662: avoidedFlagsForMonster(&(newMonst->info)), (HAS_PLAYER | HAS_MONSTER | HAS_STAIRS), false);
! 663: newMonst->bookkeepingFlags |= (MB_FOLLOWER | MB_BOUND_TO_LEADER | MB_DOES_NOT_TRACK_LEADER | MB_TELEPATHICALLY_REVEALED);
! 664: newMonst->bookkeepingFlags &= ~MB_JUST_SUMMONED;
! 665: newMonst->leader = &player;
! 666: newMonst->creatureState = MONSTER_ALLY;
! 667: if (theItem->flags & ITEM_ATTACKS_STAGGER) {
! 668: newMonst->info.attackSpeed *= 2;
! 669: newMonst->info.abilityFlags |= MA_ATTACKS_STAGGER;
! 670: }
! 671: if (theItem->flags & ITEM_ATTACKS_QUICKLY) {
! 672: newMonst->info.attackSpeed /= 2;
! 673: }
! 674: if (theItem->flags & ITEM_ATTACKS_PENETRATE) {
! 675: newMonst->info.abilityFlags |= MA_ATTACKS_PENETRATE;
! 676: }
! 677: if (theItem->flags & ITEM_ATTACKS_ALL_ADJACENT) {
! 678: newMonst->info.abilityFlags |= MA_ATTACKS_ALL_ADJACENT;
! 679: }
! 680: if (theItem->flags & ITEM_ATTACKS_EXTEND) {
! 681: newMonst->info.abilityFlags |= MA_ATTACKS_EXTEND;
! 682: }
! 683: newMonst->ticksUntilTurn = 100;
! 684: newMonst->info.accuracy = player.info.accuracy + (5 * netEnchant(theItem) / FP_FACTOR);
! 685: newMonst->info.damage = player.info.damage;
! 686: newMonst->status[STATUS_LIFESPAN_REMAINING] = newMonst->maxStatus[STATUS_LIFESPAN_REMAINING] = weaponImageDuration(enchant);
! 687: if (strLenWithoutEscapes(theItemName) <= 8) {
! 688: sprintf(newMonst->info.monsterName, "spectral %s", theItemName);
! 689: } else {
! 690: switch (rogue.weapon->kind) {
! 691: case BROADSWORD:
! 692: strcpy(newMonst->info.monsterName, "spectral sword");
! 693: break;
! 694: case HAMMER:
! 695: strcpy(newMonst->info.monsterName, "spectral hammer");
! 696: break;
! 697: case PIKE:
! 698: strcpy(newMonst->info.monsterName, "spectral pike");
! 699: break;
! 700: case WAR_AXE:
! 701: strcpy(newMonst->info.monsterName, "spectral axe");
! 702: break;
! 703: default:
! 704: strcpy(newMonst->info.monsterName, "spectral weapon");
! 705: break;
! 706: }
! 707: }
! 708: pmap[newMonst->xLoc][newMonst->yLoc].flags |= HAS_MONSTER;
! 709: fadeInMonster(newMonst);
! 710: }
! 711: updateVision(true);
! 712:
! 713: message(buf, false);
! 714: autoID = true;
! 715: break;
! 716: case W_SLOWING:
! 717: slow(defender, weaponSlowDuration(enchant));
! 718: if (canDirectlySeeMonster(defender)) {
! 719: sprintf(buf, "%s slows down", monstName);
! 720: buf[DCOLS] = '\0';
! 721: combatMessage(buf, messageColorFromVictim(defender));
! 722: autoID = true;
! 723: }
! 724: break;
! 725: case W_CONFUSION:
! 726: defender->status[STATUS_CONFUSED] = max(defender->status[STATUS_CONFUSED], weaponConfusionDuration(enchant));
! 727: defender->maxStatus[STATUS_CONFUSED] = defender->status[STATUS_CONFUSED];
! 728: if (canDirectlySeeMonster(defender)) {
! 729: sprintf(buf, "%s looks very confused", monstName);
! 730: buf[DCOLS] = '\0';
! 731: combatMessage(buf, messageColorFromVictim(defender));
! 732: autoID = true;
! 733: }
! 734: break;
! 735: case W_FORCE:
! 736: autoID = forceWeaponHit(defender, theItem);
! 737: break;
! 738: case W_MERCY:
! 739: heal(defender, 50, false);
! 740: if (canSeeMonster(defender)) {
! 741: autoID = true;
! 742: }
! 743: break;
! 744: case W_PLENTY:
! 745: newMonst = cloneMonster(defender, true, true);
! 746: if (newMonst) {
! 747: flashMonster(newMonst, effectColors[enchantType], 100);
! 748: if (canSeeMonster(newMonst)) {
! 749: autoID = true;
! 750: }
! 751: }
! 752: break;
! 753: default:
! 754: break;
! 755: }
! 756: }
! 757: if (autoID) {
! 758: autoIdentify(theItem);
! 759: }
! 760: }
! 761:
! 762: void attackVerb(char returnString[DCOLS], creature *attacker, short hitPercentile) {
! 763: short verbCount, increment;
! 764:
! 765: if (attacker != &player && (player.status[STATUS_HALLUCINATING] || !canSeeMonster(attacker))) {
! 766: strcpy(returnString, "hits");
! 767: return;
! 768: }
! 769:
! 770: if (attacker == &player && !rogue.weapon) {
! 771: strcpy(returnString, "punch");
! 772: return;
! 773: }
! 774:
! 775: for (verbCount = 0; verbCount < 4 && monsterText[attacker->info.monsterID].attack[verbCount + 1][0] != '\0'; verbCount++);
! 776: increment = (100 / (verbCount + 1));
! 777: hitPercentile = max(0, min(hitPercentile, increment * (verbCount + 1) - 1));
! 778: strcpy(returnString, monsterText[attacker->info.monsterID].attack[hitPercentile / increment]);
! 779: resolvePronounEscapes(returnString, attacker);
! 780: }
! 781:
! 782: void applyArmorRunicEffect(char returnString[DCOLS], creature *attacker, short *damage, boolean melee) {
! 783: char armorName[DCOLS], attackerName[DCOLS], monstName[DCOLS], buf[DCOLS * 3];
! 784: boolean runicKnown;
! 785: boolean runicDiscovered;
! 786: short newDamage, dir, newX, newY, count, i;
! 787: fixpt enchant;
! 788: creature *monst, *hitList[8];
! 789:
! 790: returnString[0] = '\0';
! 791:
! 792: if (!(rogue.armor && rogue.armor->flags & ITEM_RUNIC)) {
! 793: return; // just in case
! 794: }
! 795:
! 796: enchant = netEnchant(rogue.armor);
! 797:
! 798: runicKnown = rogue.armor->flags & ITEM_RUNIC_IDENTIFIED;
! 799: runicDiscovered = false;
! 800:
! 801: itemName(rogue.armor, armorName, false, false, NULL);
! 802:
! 803: monsterName(attackerName, attacker, true);
! 804:
! 805: switch (rogue.armor->enchant2) {
! 806: case A_MULTIPLICITY:
! 807: if (melee && !(attacker->info.flags & (MONST_INANIMATE | MONST_INVULNERABLE)) && rand_percent(33)) {
! 808: for (i = 0; i < armorImageCount(enchant); i++) {
! 809: monst = cloneMonster(attacker, false, true);
! 810: monst->bookkeepingFlags |= (MB_FOLLOWER | MB_BOUND_TO_LEADER | MB_DOES_NOT_TRACK_LEADER | MB_TELEPATHICALLY_REVEALED);
! 811: monst->info.flags |= MONST_DIES_IF_NEGATED;
! 812: monst->bookkeepingFlags &= ~(MB_JUST_SUMMONED | MB_SEIZED | MB_SEIZING);
! 813: monst->info.abilityFlags &= ~(MA_CAST_SUMMON | MA_DF_ON_DEATH); // No summoning by spectral images. Gotta draw the line!
! 814: // Also no exploding or infecting by spectral clones.
! 815: monst->leader = &player;
! 816: monst->creatureState = MONSTER_ALLY;
! 817: monst->status[STATUS_DISCORDANT] = 0; // Otherwise things can get out of control...
! 818: monst->ticksUntilTurn = 100;
! 819: monst->info.monsterID = MK_SPECTRAL_IMAGE;
! 820: if (monst->carriedMonster) {
! 821: killCreature(monst->carriedMonster, true); // Otherwise you can get infinite phoenices from a discordant phoenix.
! 822: monst->carriedMonster = NULL;
! 823: }
! 824:
! 825: // Give it the glowy red light and color.
! 826: monst->info.intrinsicLightType = SPECTRAL_IMAGE_LIGHT;
! 827: monst->info.foreColor = &spectralImageColor;
! 828:
! 829: // Temporary guest!
! 830: monst->status[STATUS_LIFESPAN_REMAINING] = monst->maxStatus[STATUS_LIFESPAN_REMAINING] = 3;
! 831: monst->currentHP = monst->info.maxHP = 1;
! 832: monst->info.defense = 0;
! 833:
! 834: if (strLenWithoutEscapes(attacker->info.monsterName) <= 6) {
! 835: sprintf(monst->info.monsterName, "spectral %s", attacker->info.monsterName);
! 836: } else {
! 837: strcpy(monst->info.monsterName, "spectral clone");
! 838: }
! 839: fadeInMonster(monst);
! 840: }
! 841: updateVision(true);
! 842:
! 843: runicDiscovered = true;
! 844: sprintf(returnString, "Your %s flashes, and spectral images of %s appear!", armorName, attackerName);
! 845: }
! 846: break;
! 847: case A_MUTUALITY:
! 848: if (*damage > 0) {
! 849: count = 0;
! 850: for (i=0; i<8; i++) {
! 851: hitList[i] = NULL;
! 852: dir = i % 8;
! 853: newX = player.xLoc + nbDirs[dir][0];
! 854: newY = player.yLoc + nbDirs[dir][1];
! 855: if (coordinatesAreInMap(newX, newY) && (pmap[newX][newY].flags & HAS_MONSTER)) {
! 856: monst = monsterAtLoc(newX, newY);
! 857: if (monst
! 858: && monst != attacker
! 859: && monstersAreEnemies(&player, monst)
! 860: && !(monst->info.flags & (MONST_IMMUNE_TO_WEAPONS | MONST_INVULNERABLE))
! 861: && !(monst->bookkeepingFlags & MB_IS_DYING)) {
! 862:
! 863: hitList[i] = monst;
! 864: count++;
! 865: }
! 866: }
! 867: }
! 868: if (count) {
! 869: for (i=0; i<8; i++) {
! 870: if (hitList[i] && !(hitList[i]->bookkeepingFlags & MB_IS_DYING)) {
! 871: monsterName(monstName, hitList[i], true);
! 872: if (inflictDamage(&player, hitList[i], (*damage + count) / (count + 1), &blue, true)
! 873: && canSeeMonster(hitList[i])) {
! 874:
! 875: sprintf(buf, "%s %s", monstName, ((hitList[i]->info.flags & MONST_INANIMATE) ? "is destroyed" : "dies"));
! 876: combatMessage(buf, messageColorFromVictim(hitList[i]));
! 877: }
! 878: }
! 879: }
! 880: runicDiscovered = true;
! 881: if (!runicKnown) {
! 882: sprintf(returnString, "Your %s pulses, and the damage is shared with %s!",
! 883: armorName,
! 884: (count == 1 ? monstName : "the other adjacent enemies"));
! 885: }
! 886: *damage = (*damage + count) / (count + 1);
! 887: }
! 888: }
! 889: break;
! 890: case A_ABSORPTION:
! 891: *damage -= rand_range(0, armorAbsorptionMax(enchant));
! 892: if (*damage <= 0) {
! 893: *damage = 0;
! 894: runicDiscovered = true;
! 895: if (!runicKnown) {
! 896: sprintf(returnString, "your %s pulses and absorbs the blow!", armorName);
! 897: }
! 898: }
! 899: break;
! 900: case A_REPRISAL:
! 901: if (melee && !(attacker->info.flags & (MONST_INANIMATE | MONST_INVULNERABLE))) {
! 902: newDamage = max(1, armorReprisalPercent(enchant) * (*damage) / 100); // 5% reprisal per armor level
! 903: if (inflictDamage(&player, attacker, newDamage, &blue, true)) {
! 904: if (canSeeMonster(attacker)) {
! 905: sprintf(returnString, "your %s pulses and %s drops dead!", armorName, attackerName);
! 906: runicDiscovered = true;
! 907: }
! 908: } else if (!runicKnown) {
! 909: if (canSeeMonster(attacker)) {
! 910: sprintf(returnString, "your %s pulses and %s shudders in pain!", armorName, attackerName);
! 911: runicDiscovered = true;
! 912: }
! 913: }
! 914: }
! 915: break;
! 916: case A_IMMUNITY:
! 917: if (monsterIsInClass(attacker, rogue.armor->vorpalEnemy)) {
! 918: *damage = 0;
! 919: runicDiscovered = true;
! 920: }
! 921: break;
! 922: case A_BURDEN:
! 923: if (rand_percent(10)) {
! 924: rogue.armor->strengthRequired++;
! 925: sprintf(returnString, "your %s suddenly feels heavier!", armorName);
! 926: equipItem(rogue.armor, true);
! 927: runicDiscovered = true;
! 928: }
! 929: break;
! 930: case A_VULNERABILITY:
! 931: *damage *= 2;
! 932: if (!runicKnown) {
! 933: sprintf(returnString, "your %s pulses and you are wracked with pain!", armorName);
! 934: runicDiscovered = true;
! 935: }
! 936: break;
! 937: case A_IMMOLATION:
! 938: if (rand_percent(10)) {
! 939: sprintf(returnString, "flames suddenly explode out of your %s!", armorName);
! 940: message(returnString, !runicKnown);
! 941: returnString[0] = '\0';
! 942: spawnDungeonFeature(player.xLoc, player.yLoc, &(dungeonFeatureCatalog[DF_ARMOR_IMMOLATION]), true, false);
! 943: runicDiscovered = true;
! 944: }
! 945: default:
! 946: break;
! 947: }
! 948:
! 949: if (runicDiscovered && !runicKnown) {
! 950: autoIdentify(rogue.armor);
! 951: }
! 952: }
! 953:
! 954: void decrementWeaponAutoIDTimer() {
! 955: char buf[COLS*3], buf2[COLS*3];
! 956:
! 957: if (rogue.weapon
! 958: && !(rogue.weapon->flags & ITEM_IDENTIFIED)
! 959: && !--rogue.weapon->charges) {
! 960:
! 961: rogue.weapon->flags |= ITEM_IDENTIFIED;
! 962: updateIdentifiableItems();
! 963: messageWithColor("you are now familiar enough with your weapon to identify it.", &itemMessageColor, false);
! 964: itemName(rogue.weapon, buf2, true, true, NULL);
! 965: sprintf(buf, "%s %s.", (rogue.weapon->quantity > 1 ? "they are" : "it is"), buf2);
! 966: messageWithColor(buf, &itemMessageColor, false);
! 967: }
! 968: }
! 969:
! 970: void processStaggerHit(creature *attacker, creature *defender) {
! 971: if ((defender->info.flags & (MONST_INVULNERABLE | MONST_IMMOBILE | MONST_INANIMATE))
! 972: || (defender->bookkeepingFlags & MB_CAPTIVE)
! 973: || cellHasTerrainFlag(defender->xLoc, defender->yLoc, T_OBSTRUCTS_PASSABILITY)) {
! 974:
! 975: return;
! 976: }
! 977: short newX = clamp(defender->xLoc - attacker->xLoc, -1, 1) + defender->xLoc;
! 978: short newY = clamp(defender->yLoc - attacker->yLoc, -1, 1) + defender->yLoc;
! 979: if (coordinatesAreInMap(newX, newY)
! 980: && !cellHasTerrainFlag(newX, newY, T_OBSTRUCTS_PASSABILITY)
! 981: && !(pmap[newX][newY].flags & (HAS_MONSTER | HAS_PLAYER))) {
! 982:
! 983: setMonsterLocation(defender, newX, newY);
! 984: }
! 985: }
! 986:
! 987: // returns whether the attack hit
! 988: boolean attack(creature *attacker, creature *defender, boolean lungeAttack) {
! 989: short damage, specialDamage, poisonDamage;
! 990: char buf[COLS*2], buf2[COLS*2], attackerName[COLS], defenderName[COLS], verb[DCOLS], explicationClause[DCOLS] = "", armorRunicString[DCOLS*3];
! 991: boolean sneakAttack, defenderWasAsleep, defenderWasParalyzed, degradesAttackerWeapon, sightUnseen;
! 992:
! 993: if (attacker == &player && canSeeMonster(defender)) {
! 994: rogue.featRecord[FEAT_PURE_MAGE] = false;
! 995: }
! 996:
! 997: if (attacker->info.abilityFlags & MA_KAMIKAZE) {
! 998: killCreature(attacker, false);
! 999: return true;
! 1000: }
! 1001:
! 1002: armorRunicString[0] = '\0';
! 1003:
! 1004: poisonDamage = 0;
! 1005:
! 1006: degradesAttackerWeapon = (defender->info.flags & MONST_DEFEND_DEGRADE_WEAPON ? true : false);
! 1007:
! 1008: sightUnseen = !canSeeMonster(attacker) && !canSeeMonster(defender);
! 1009:
! 1010: if (defender->status[STATUS_LEVITATING] && (attacker->info.flags & MONST_RESTRICTED_TO_LIQUID)) {
! 1011: return false; // aquatic or other liquid-bound monsters cannot attack flying opponents
! 1012: }
! 1013:
! 1014: if ((attacker == &player || defender == &player) && !rogue.blockCombatText) {
! 1015: rogue.disturbed = true;
! 1016: }
! 1017:
! 1018: defender->status[STATUS_ENTRANCED] = 0;
! 1019: if (defender->status[STATUS_MAGICAL_FEAR]) {
! 1020: defender->status[STATUS_MAGICAL_FEAR] = 1;
! 1021: }
! 1022:
! 1023: if (attacker == &player
! 1024: && defender->creatureState != MONSTER_TRACKING_SCENT) {
! 1025:
! 1026: rogue.featRecord[FEAT_PALADIN] = false;
! 1027: }
! 1028:
! 1029: if (attacker != &player && defender == &player && attacker->creatureState == MONSTER_WANDERING) {
! 1030: attacker->creatureState = MONSTER_TRACKING_SCENT;
! 1031: }
! 1032:
! 1033: if (defender->info.flags & MONST_INANIMATE) {
! 1034: sneakAttack = false;
! 1035: defenderWasAsleep = false;
! 1036: defenderWasParalyzed = false;
! 1037: } else {
! 1038: sneakAttack = (defender != &player && attacker == &player && (defender->creatureState == MONSTER_WANDERING) ? true : false);
! 1039: defenderWasAsleep = (defender != &player && (defender->creatureState == MONSTER_SLEEPING) ? true : false);
! 1040: defenderWasParalyzed = defender->status[STATUS_PARALYZED] > 0;
! 1041: }
! 1042:
! 1043: monsterName(attackerName, attacker, true);
! 1044: monsterName(defenderName, defender, true);
! 1045:
! 1046: if ((attacker->info.abilityFlags & MA_SEIZES)
! 1047: && (!(attacker->bookkeepingFlags & MB_SEIZING) || !(defender->bookkeepingFlags & MB_SEIZED))
! 1048: && (rogue.patchVersion < 2 ||
! 1049: (distanceBetween(attacker->xLoc, attacker->yLoc, defender->xLoc, defender->yLoc) == 1
! 1050: && !diagonalBlocked(attacker->xLoc, attacker->yLoc, defender->xLoc, defender->yLoc, false)))) {
! 1051:
! 1052: attacker->bookkeepingFlags |= MB_SEIZING;
! 1053: defender->bookkeepingFlags |= MB_SEIZED;
! 1054: if (canSeeMonster(attacker) || canSeeMonster(defender)) {
! 1055: sprintf(buf, "%s seizes %s!", attackerName, (defender == &player ? "your legs" : defenderName));
! 1056: messageWithColor(buf, &white, false);
! 1057: }
! 1058: return false;
! 1059: }
! 1060:
! 1061: if (sneakAttack || defenderWasAsleep || defenderWasParalyzed || lungeAttack || attackHit(attacker, defender)) {
! 1062: // If the attack hit:
! 1063: damage = (defender->info.flags & (MONST_IMMUNE_TO_WEAPONS | MONST_INVULNERABLE)
! 1064: ? 0 : randClump(attacker->info.damage) * monsterDamageAdjustmentAmount(attacker) / FP_FACTOR);
! 1065:
! 1066: if (sneakAttack || defenderWasAsleep || defenderWasParalyzed) {
! 1067: if (defender != &player) {
! 1068: // The non-player defender doesn't hit back this turn because it's still flat-footed.
! 1069: defender->ticksUntilTurn += max(defender->movementSpeed, defender->attackSpeed);
! 1070: if (defender->creatureState != MONSTER_ALLY) {
! 1071: defender->creatureState = MONSTER_TRACKING_SCENT; // Wake up!
! 1072: }
! 1073: }
! 1074: }
! 1075: if (sneakAttack || defenderWasAsleep || defenderWasParalyzed || lungeAttack) {
! 1076: if (attacker == &player
! 1077: && rogue.weapon
! 1078: && (rogue.weapon->flags & ITEM_SNEAK_ATTACK_BONUS)) {
! 1079:
! 1080: damage *= 5; // 5x damage for dagger sneak attacks.
! 1081: } else {
! 1082: damage *= 3; // Treble damage for general sneak attacks.
! 1083: }
! 1084: }
! 1085:
! 1086: if (defender == &player && rogue.armor && (rogue.armor->flags & ITEM_RUNIC)) {
! 1087: applyArmorRunicEffect(armorRunicString, attacker, &damage, true);
! 1088: }
! 1089:
! 1090: if (attacker == &player
! 1091: && rogue.reaping
! 1092: && !(defender->info.flags & (MONST_INANIMATE | MONST_INVULNERABLE))) {
! 1093:
! 1094: specialDamage = min(damage, defender->currentHP) * rogue.reaping; // Maximum reaped damage can't exceed the victim's remaining health.
! 1095: if (rogue.reaping > 0) {
! 1096: specialDamage = rand_range(0, specialDamage);
! 1097: } else {
! 1098: specialDamage = rand_range(specialDamage, 0);
! 1099: }
! 1100: if (specialDamage) {
! 1101: rechargeItemsIncrementally(specialDamage);
! 1102: }
! 1103: }
! 1104:
! 1105: if (damage == 0) {
! 1106: sprintf(explicationClause, " but %s no damage", (attacker == &player ? "do" : "does"));
! 1107: if (attacker == &player) {
! 1108: rogue.disturbed = true;
! 1109: }
! 1110: } else if (lungeAttack) {
! 1111: strcpy(explicationClause, " with a vicious lunge attack");
! 1112: } else if (defenderWasParalyzed) {
! 1113: sprintf(explicationClause, " while $HESHE %s paralyzed", (defender == &player ? "are" : "is"));
! 1114: } else if (defenderWasAsleep) {
! 1115: strcpy(explicationClause, " in $HISHER sleep");
! 1116: } else if (sneakAttack) {
! 1117: strcpy(explicationClause, ", catching $HIMHER unaware");
! 1118: } else if (defender->status[STATUS_STUCK] || defender->bookkeepingFlags & MB_CAPTIVE) {
! 1119: sprintf(explicationClause, " while %s dangle%s helplessly",
! 1120: (canSeeMonster(defender) ? "$HESHE" : "it"),
! 1121: (defender == &player ? "" : "s"));
! 1122: }
! 1123: resolvePronounEscapes(explicationClause, defender);
! 1124:
! 1125: if ((attacker->info.abilityFlags & MA_POISONS) && damage > 0) {
! 1126: poisonDamage = damage;
! 1127: damage = 1;
! 1128: }
! 1129:
! 1130: if (inflictDamage(attacker, defender, damage, &red, false)) { // if the attack killed the defender
! 1131: if (defenderWasAsleep || sneakAttack || defenderWasParalyzed || lungeAttack) {
! 1132: sprintf(buf, "%s %s %s%s", attackerName,
! 1133: ((defender->info.flags & MONST_INANIMATE) ? "destroyed" : "dispatched"),
! 1134: defenderName,
! 1135: explicationClause);
! 1136: } else {
! 1137: sprintf(buf, "%s %s %s%s",
! 1138: attackerName,
! 1139: ((defender->info.flags & MONST_INANIMATE) ? "destroyed" : "defeated"),
! 1140: defenderName,
! 1141: explicationClause);
! 1142: }
! 1143: if (sightUnseen) {
! 1144: if (defender->info.flags & MONST_INANIMATE) {
! 1145: combatMessage("you hear something get destroyed in combat", 0);
! 1146: } else {
! 1147: combatMessage("you hear something die in combat", 0);
! 1148: }
! 1149: } else {
! 1150: combatMessage(buf, (damage > 0 ? messageColorFromVictim(defender) : &white));
! 1151: }
! 1152: if (&player == defender) {
! 1153: gameOver(attacker->info.monsterName, false);
! 1154: return true;
! 1155: } else if (&player == attacker
! 1156: && defender->info.monsterID == MK_DRAGON) {
! 1157:
! 1158: rogue.featRecord[FEAT_DRAGONSLAYER] = true;
! 1159: }
! 1160: } else { // if the defender survived
! 1161: if (!rogue.blockCombatText && (canSeeMonster(attacker) || canSeeMonster(defender))) {
! 1162: attackVerb(verb, attacker, max(damage - (attacker->info.damage.lowerBound * monsterDamageAdjustmentAmount(attacker) / FP_FACTOR), 0) * 100
! 1163: / max(1, (attacker->info.damage.upperBound - attacker->info.damage.lowerBound) * monsterDamageAdjustmentAmount(attacker) / FP_FACTOR));
! 1164: sprintf(buf, "%s %s %s%s", attackerName, verb, defenderName, explicationClause);
! 1165: if (sightUnseen) {
! 1166: if (!rogue.heardCombatThisTurn) {
! 1167: rogue.heardCombatThisTurn = true;
! 1168: combatMessage("you hear combat in the distance", 0);
! 1169: }
! 1170: } else {
! 1171: combatMessage(buf, messageColorFromVictim(defender));
! 1172: }
! 1173: }
! 1174: if (attacker == &player && rogue.weapon && (rogue.weapon->flags & ITEM_ATTACKS_STAGGER)) {
! 1175: processStaggerHit(attacker, defender);
! 1176: }
! 1177: if (attacker->info.abilityFlags & SPECIAL_HIT) {
! 1178: specialHit(attacker, defender, (attacker->info.abilityFlags & MA_POISONS) ? poisonDamage : damage);
! 1179: }
! 1180: if (armorRunicString[0]) {
! 1181: message(armorRunicString, false);
! 1182: if (rogue.armor && (rogue.armor->flags & ITEM_RUNIC) && rogue.armor->enchant2 == A_BURDEN) {
! 1183: strengthCheck(rogue.armor);
! 1184: }
! 1185: }
! 1186: }
! 1187:
! 1188: moralAttack(attacker, defender);
! 1189:
! 1190: if (attacker == &player && rogue.weapon && (rogue.weapon->flags & ITEM_RUNIC)) {
! 1191: magicWeaponHit(defender, rogue.weapon, sneakAttack || defenderWasAsleep || defenderWasParalyzed);
! 1192: }
! 1193:
! 1194: if (attacker == &player
! 1195: && (defender->bookkeepingFlags & MB_IS_DYING)
! 1196: && (defender->bookkeepingFlags & MB_HAS_SOUL)) {
! 1197:
! 1198: decrementWeaponAutoIDTimer();
! 1199: }
! 1200:
! 1201: if (degradesAttackerWeapon
! 1202: && attacker == &player
! 1203: && rogue.weapon
! 1204: && !(rogue.weapon->flags & ITEM_PROTECTED)
! 1205: // Can't damage a Weapon of Acid Mound Slaying by attacking an acid mound... just ain't right!
! 1206: && !((rogue.weapon->flags & ITEM_RUNIC) && rogue.weapon->enchant2 == W_SLAYING && monsterIsInClass(defender, rogue.weapon->vorpalEnemy))
! 1207: && rogue.weapon->enchant1 >= -10) {
! 1208:
! 1209: rogue.weapon->enchant1--;
! 1210: if (rogue.weapon->quiverNumber) {
! 1211: rogue.weapon->quiverNumber = rand_range(1, 60000);
! 1212: }
! 1213: equipItem(rogue.weapon, true);
! 1214: itemName(rogue.weapon, buf2, false, false, NULL);
! 1215: sprintf(buf, "your %s weakens!", buf2);
! 1216: messageWithColor(buf, &itemMessageColor, false);
! 1217: checkForDisenchantment(rogue.weapon);
! 1218: }
! 1219:
! 1220: return true;
! 1221: } else { // if the attack missed
! 1222: if (!rogue.blockCombatText) {
! 1223: if (sightUnseen) {
! 1224: if (!rogue.heardCombatThisTurn) {
! 1225: rogue.heardCombatThisTurn = true;
! 1226: combatMessage("you hear combat in the distance", 0);
! 1227: }
! 1228: } else {
! 1229: sprintf(buf, "%s missed %s", attackerName, defenderName);
! 1230: combatMessage(buf, 0);
! 1231: }
! 1232: }
! 1233: return false;
! 1234: }
! 1235: }
! 1236:
! 1237: // Gets the length of a string without the four-character color escape sequences, since those aren't displayed.
! 1238: short strLenWithoutEscapes(const char *str) {
! 1239: short i, count;
! 1240:
! 1241: count = 0;
! 1242: for (i=0; str[i];) {
! 1243: if (str[i] == COLOR_ESCAPE) {
! 1244: i += 4;
! 1245: continue;
! 1246: }
! 1247: count++;
! 1248: i++;
! 1249: }
! 1250: return count;
! 1251: }
! 1252:
! 1253: void combatMessage(char *theMsg, color *theColor) {
! 1254: char newMsg[COLS * 2];
! 1255:
! 1256: if (theColor == 0) {
! 1257: theColor = &white;
! 1258: }
! 1259:
! 1260: newMsg[0] = '\0';
! 1261: encodeMessageColor(newMsg, 0, theColor);
! 1262: strcat(newMsg, theMsg);
! 1263:
! 1264: if (strLenWithoutEscapes(combatText) + strLenWithoutEscapes(newMsg) + 3 > DCOLS) {
! 1265: // the "3" is for the semicolon, space and period that get added to conjoined combat texts.
! 1266: displayCombatText();
! 1267: }
! 1268:
! 1269: if (combatText[0]) {
! 1270: strcat(combatText, "; ");
! 1271: strcat(combatText, newMsg);
! 1272: } else {
! 1273: strcpy(combatText, newMsg);
! 1274: }
! 1275: }
! 1276:
! 1277: void displayCombatText() {
! 1278: char buf[COLS];
! 1279:
! 1280: if (combatText[0]) {
! 1281: sprintf(buf, "%s.", combatText);
! 1282: combatText[0] = '\0';
! 1283: message(buf, rogue.cautiousMode);
! 1284: rogue.cautiousMode = false;
! 1285: }
! 1286: }
! 1287:
! 1288: void flashMonster(creature *monst, const color *theColor, short strength) {
! 1289: if (!theColor) {
! 1290: return;
! 1291: }
! 1292: if (!(monst->bookkeepingFlags & MB_WILL_FLASH) || monst->flashStrength < strength) {
! 1293: monst->bookkeepingFlags |= MB_WILL_FLASH;
! 1294: monst->flashStrength = strength;
! 1295: monst->flashColor = *theColor;
! 1296: rogue.creaturesWillFlashThisTurn = true;
! 1297: }
! 1298: }
! 1299:
! 1300: boolean canAbsorb(creature *ally, boolean ourBolts[NUMBER_BOLT_KINDS], creature *prey, short **grid) {
! 1301: short i;
! 1302:
! 1303: if (ally->creatureState == MONSTER_ALLY
! 1304: && ally->newPowerCount > 0
! 1305: && (ally->targetCorpseLoc[0] <= 0)
! 1306: && !((ally->info.flags | prey->info.flags) & (MONST_INANIMATE | MONST_IMMOBILE))
! 1307: && !monsterAvoids(ally, prey->xLoc, prey->yLoc)
! 1308: && grid[ally->xLoc][ally->yLoc] <= 10) {
! 1309:
! 1310: if (~(ally->info.abilityFlags) & prey->info.abilityFlags & LEARNABLE_ABILITIES) {
! 1311: return true;
! 1312: } else if (~(ally->info.flags) & prey->info.flags & LEARNABLE_BEHAVIORS) {
! 1313: return true;
! 1314: } else {
! 1315: for (i = 0; i < NUMBER_BOLT_KINDS; i++) {
! 1316: ourBolts[i] = false;
! 1317: }
! 1318: for (i = 0; ally->info.bolts[i] != BOLT_NONE; i++) {
! 1319: ourBolts[ally->info.bolts[i]] = true;
! 1320: }
! 1321:
! 1322: for (i=0; prey->info.bolts[i] != BOLT_NONE; i++) {
! 1323: if (!(boltCatalog[prey->info.bolts[i]].flags & BF_NOT_LEARNABLE)
! 1324: && !ourBolts[prey->info.bolts[i]]) {
! 1325:
! 1326: return true;
! 1327: }
! 1328: }
! 1329: }
! 1330: }
! 1331: return false;
! 1332: }
! 1333:
! 1334: boolean anyoneWantABite(creature *decedent) {
! 1335: short candidates, randIndex, i;
! 1336: short **grid;
! 1337: creature *ally;
! 1338: boolean success = false;
! 1339: boolean ourBolts[NUMBER_BOLT_KINDS] = {false};
! 1340:
! 1341: candidates = 0;
! 1342: if ((!(decedent->info.abilityFlags & LEARNABLE_ABILITIES)
! 1343: && !(decedent->info.flags & LEARNABLE_BEHAVIORS)
! 1344: && decedent->info.bolts[0] == BOLT_NONE)
! 1345: || (cellHasTerrainFlag(decedent->xLoc, decedent->yLoc, T_PATHING_BLOCKER))
! 1346: || decedent->info.monsterID == MK_SPECTRAL_IMAGE
! 1347: || (decedent->info.flags & (MONST_INANIMATE | MONST_IMMOBILE))) {
! 1348:
! 1349: return false;
! 1350: }
! 1351:
! 1352: grid = allocGrid();
! 1353: fillGrid(grid, 0);
! 1354: calculateDistances(grid, decedent->xLoc, decedent->yLoc, T_PATHING_BLOCKER, NULL, true, true);
! 1355: for (ally = monsters->nextCreature; ally != NULL; ally = ally->nextCreature) {
! 1356: if (canAbsorb(ally, ourBolts, decedent, grid)) {
! 1357: candidates++;
! 1358: }
! 1359: }
! 1360: if (candidates > 0) {
! 1361: randIndex = rand_range(1, candidates);
! 1362: for (ally = monsters->nextCreature; ally != NULL; ally = ally->nextCreature) {
! 1363: // CanAbsorb() populates ourBolts if it returns true and there are no learnable behaviors or flags:
! 1364: if (canAbsorb(ally, ourBolts, decedent, grid) && !--randIndex) {
! 1365: break;
! 1366: }
! 1367: }
! 1368: if (ally) {
! 1369: ally->targetCorpseLoc[0] = decedent->xLoc;
! 1370: ally->targetCorpseLoc[1] = decedent->yLoc;
! 1371: strcpy(ally->targetCorpseName, decedent->info.monsterName);
! 1372: ally->corpseAbsorptionCounter = 20; // 20 turns to get there and start eating before he loses interest
! 1373:
! 1374: // Choose a superpower.
! 1375: // First, select from among learnable ability or behavior flags, if one is available.
! 1376: candidates = 0;
! 1377: for (i=0; i<32; i++) {
! 1378: if (Fl(i) & ~(ally->info.abilityFlags) & decedent->info.abilityFlags & LEARNABLE_ABILITIES) {
! 1379: candidates++;
! 1380: }
! 1381: }
! 1382: for (i=0; i<32; i++) {
! 1383: if (Fl(i) & ~(ally->info.flags) & decedent->info.flags & LEARNABLE_BEHAVIORS) {
! 1384: candidates++;
! 1385: }
! 1386: }
! 1387: if (candidates > 0) {
! 1388: randIndex = rand_range(1, candidates);
! 1389: for (i=0; i<32; i++) {
! 1390: if ((Fl(i) & ~(ally->info.abilityFlags) & decedent->info.abilityFlags & LEARNABLE_ABILITIES)
! 1391: && !--randIndex) {
! 1392:
! 1393: ally->absorptionFlags = Fl(i);
! 1394: ally->absorbBehavior = false;
! 1395: success = true;
! 1396: break;
! 1397: }
! 1398: }
! 1399: for (i=0; i<32 && !success; i++) {
! 1400: if ((Fl(i) & ~(ally->info.flags) & decedent->info.flags & LEARNABLE_BEHAVIORS)
! 1401: && !--randIndex) {
! 1402:
! 1403: ally->absorptionFlags = Fl(i);
! 1404: ally->absorbBehavior = true;
! 1405: success = true;
! 1406: break;
! 1407: }
! 1408: }
! 1409: } else if (decedent->info.bolts[0] != BOLT_NONE) {
! 1410: // If there are no learnable ability or behavior flags, pick a learnable bolt.
! 1411: candidates = 0;
! 1412: for (i=0; decedent->info.bolts[i] != BOLT_NONE; i++) {
! 1413: if (!(boltCatalog[decedent->info.bolts[i]].flags & BF_NOT_LEARNABLE)
! 1414: && !ourBolts[decedent->info.bolts[i]]) {
! 1415:
! 1416: candidates++;
! 1417: }
! 1418: }
! 1419: if (candidates > 0) {
! 1420: randIndex = rand_range(1, candidates);
! 1421: for (i=0; decedent->info.bolts[i] != BOLT_NONE; i++) {
! 1422: if (!(boltCatalog[decedent->info.bolts[i]].flags & BF_NOT_LEARNABLE)
! 1423: && !ourBolts[decedent->info.bolts[i]]
! 1424: && !--randIndex) {
! 1425:
! 1426: ally->absorptionBolt = decedent->info.bolts[i];
! 1427: success = true;
! 1428: break;
! 1429: }
! 1430: }
! 1431: }
! 1432: }
! 1433: }
! 1434: }
! 1435: freeGrid(grid);
! 1436: return success;
! 1437: }
! 1438:
! 1439: #define MIN_FLASH_STRENGTH 50
! 1440:
! 1441: void inflictLethalDamage(creature *attacker, creature *defender) {
! 1442: inflictDamage(attacker, defender, defender->currentHP, NULL, true);
! 1443: }
! 1444:
! 1445: // returns true if this was a killing stroke; does NOT free the pointer, but DOES remove it from the monster chain
! 1446: // flashColor indicates the color that the damage will cause the creature to flash
! 1447: boolean inflictDamage(creature *attacker, creature *defender,
! 1448: short damage, const color *flashColor, boolean ignoresProtectionShield) {
! 1449:
! 1450: boolean killed = false;
! 1451: dungeonFeature theBlood;
! 1452: short transferenceAmount;
! 1453:
! 1454: if (damage == 0
! 1455: || (defender->info.flags & MONST_INVULNERABLE)) {
! 1456:
! 1457: return false;
! 1458: }
! 1459:
! 1460: if (!ignoresProtectionShield
! 1461: && defender->status[STATUS_SHIELDED]) {
! 1462:
! 1463: if (defender->status[STATUS_SHIELDED] > damage * 10) {
! 1464: defender->status[STATUS_SHIELDED] -= damage * 10;
! 1465: damage = 0;
! 1466: } else {
! 1467: damage -= (defender->status[STATUS_SHIELDED] + 9) / 10;
! 1468: defender->status[STATUS_SHIELDED] = defender->maxStatus[STATUS_SHIELDED] = 0;
! 1469: }
! 1470: }
! 1471:
! 1472: defender->bookkeepingFlags &= ~MB_ABSORBING; // Stop eating a corpse if you are getting hurt.
! 1473:
! 1474: // bleed all over the place, proportionately to damage inflicted:
! 1475: if (damage > 0 && defender->info.bloodType) {
! 1476: theBlood = dungeonFeatureCatalog[defender->info.bloodType];
! 1477: theBlood.startProbability = (theBlood.startProbability * (15 + min(damage, defender->currentHP) * 3 / 2) / 100);
! 1478: if (theBlood.layer == GAS) {
! 1479: theBlood.startProbability *= 100;
! 1480: }
! 1481: spawnDungeonFeature(defender->xLoc, defender->yLoc, &theBlood, true, false);
! 1482: }
! 1483:
! 1484: if (defender != &player && defender->creatureState == MONSTER_SLEEPING) {
! 1485: wakeUp(defender);
! 1486: }
! 1487:
! 1488: if (defender == &player
! 1489: && rogue.easyMode
! 1490: && damage > 0) {
! 1491: damage = max(1, damage/5);
! 1492: }
! 1493:
! 1494: if (((attacker == &player && rogue.transference) || (attacker && attacker != &player && (attacker->info.abilityFlags & MA_TRANSFERENCE)))
! 1495: && !(defender->info.flags & (MONST_INANIMATE | MONST_INVULNERABLE))) {
! 1496:
! 1497: transferenceAmount = min(damage, defender->currentHP); // Maximum transferred damage can't exceed the victim's remaining health.
! 1498:
! 1499: if (attacker == &player) {
! 1500: transferenceAmount = transferenceAmount * rogue.transference / 20;
! 1501: if (transferenceAmount == 0) {
! 1502: transferenceAmount = ((rogue.transference > 0) ? 1 : -1);
! 1503: }
! 1504: } else if (attacker->creatureState == MONSTER_ALLY) {
! 1505: transferenceAmount = transferenceAmount * 4 / 10; // allies get 40% recovery rate
! 1506: } else {
! 1507: transferenceAmount = transferenceAmount * 9 / 10; // enemies get 90% recovery rate, deal with it
! 1508: }
! 1509:
! 1510: attacker->currentHP += transferenceAmount;
! 1511:
! 1512: if (attacker == &player && player.currentHP <= 0) {
! 1513: gameOver("Drained by a cursed ring", true);
! 1514: return false;
! 1515: }
! 1516: }
! 1517:
! 1518: if (defender->currentHP <= damage) { // killed
! 1519: killCreature(defender, false);
! 1520: anyoneWantABite(defender);
! 1521: killed = true;
! 1522: } else { // survived
! 1523: if (damage < 0 && defender->currentHP - damage > defender->info.maxHP) {
! 1524: defender->currentHP = max(defender->currentHP, defender->info.maxHP);
! 1525: } else {
! 1526: defender->currentHP -= damage; // inflict the damage!
! 1527: if (defender == &player && damage > 0) {
! 1528: rogue.featRecord[FEAT_INDOMITABLE] = false;
! 1529: }
! 1530: }
! 1531:
! 1532: if (defender != &player && defender->creatureState != MONSTER_ALLY
! 1533: && defender->info.flags & MONST_FLEES_NEAR_DEATH
! 1534: && defender->info.maxHP / 4 >= defender->currentHP) {
! 1535:
! 1536: defender->creatureState = MONSTER_FLEEING;
! 1537: }
! 1538: if (flashColor && damage > 0) {
! 1539: flashMonster(defender, flashColor, MIN_FLASH_STRENGTH + (100 - MIN_FLASH_STRENGTH) * damage / defender->info.maxHP);
! 1540: }
! 1541: }
! 1542:
! 1543: refreshSideBar(-1, -1, false);
! 1544: return killed;
! 1545: }
! 1546:
! 1547: void addPoison(creature *monst, short durationIncrement, short concentrationIncrement) {
! 1548: extern const color poisonColor;
! 1549: if (durationIncrement > 0) {
! 1550: if (monst == &player && !player.status[STATUS_POISONED]) {
! 1551: combatMessage("scalding poison fills your veins", &badMessageColor);
! 1552: }
! 1553: if (!monst->status[STATUS_POISONED]) {
! 1554: monst->maxStatus[STATUS_POISONED] = 0;
! 1555: }
! 1556: monst->poisonAmount += concentrationIncrement;
! 1557: if (monst->poisonAmount == 0) {
! 1558: monst->poisonAmount = 1;
! 1559: }
! 1560: monst->status[STATUS_POISONED] += durationIncrement;
! 1561: monst->maxStatus[STATUS_POISONED] = monst->info.maxHP / monst->poisonAmount;
! 1562:
! 1563: if (canSeeMonster(monst)) {
! 1564: flashMonster(monst, &poisonColor, 100);
! 1565: }
! 1566: }
! 1567: }
! 1568:
! 1569:
! 1570: // Removes the decedent from the screen and from the monster chain; inserts it into the graveyard chain; does NOT free the memory.
! 1571: // Or, if the decedent is a player ally at the moment of death, insert it into the purgatory chain for possible future resurrection.
! 1572: // Use "administrativeDeath" if the monster is being deleted for administrative purposes, as opposed to dying as a result of physical actions.
! 1573: // AdministrativeDeath means the monster simply disappears, with no messages, dropped item, DFs or other effect.
! 1574: void killCreature(creature *decedent, boolean administrativeDeath) {
! 1575: short x, y;
! 1576: char monstName[DCOLS], buf[DCOLS * 3];
! 1577:
! 1578: if (decedent->bookkeepingFlags & MB_IS_DYING) {
! 1579: // monster has already been killed; let's avoid overkill
! 1580: return;
! 1581: }
! 1582:
! 1583: if (decedent != &player) {
! 1584: decedent->bookkeepingFlags |= MB_IS_DYING;
! 1585: }
! 1586:
! 1587: if (rogue.lastTarget == decedent) {
! 1588: rogue.lastTarget = NULL;
! 1589: }
! 1590: if (rogue.yendorWarden == decedent) {
! 1591: rogue.yendorWarden = NULL;
! 1592: }
! 1593:
! 1594: if (decedent->carriedItem) {
! 1595: if (administrativeDeath) {
! 1596: deleteItem(decedent->carriedItem);
! 1597: decedent->carriedItem = NULL;
! 1598: } else {
! 1599: makeMonsterDropItem(decedent);
! 1600: }
! 1601: }
! 1602:
! 1603: if (!administrativeDeath && (decedent->info.abilityFlags & MA_DF_ON_DEATH)
! 1604: && ((rogue.patchVersion < 3) || !(decedent->bookkeepingFlags & MB_IS_FALLING))) {
! 1605: spawnDungeonFeature(decedent->xLoc, decedent->yLoc, &dungeonFeatureCatalog[decedent->info.DFType], true, false);
! 1606:
! 1607: if (monsterText[decedent->info.monsterID].DFMessage[0] && canSeeMonster(decedent)) {
! 1608: monsterName(monstName, decedent, true);
! 1609: snprintf(buf, DCOLS * 3, "%s %s", monstName, monsterText[decedent->info.monsterID].DFMessage);
! 1610: resolvePronounEscapes(buf, decedent);
! 1611: message(buf, false);
! 1612: }
! 1613: }
! 1614:
! 1615: if (decedent == &player) { // the player died
! 1616: // game over handled elsewhere
! 1617: } else {
! 1618: if (!administrativeDeath
! 1619: && decedent->creatureState == MONSTER_ALLY
! 1620: && !canSeeMonster(decedent)
! 1621: && !(decedent->info.flags & MONST_INANIMATE)
! 1622: && !(decedent->bookkeepingFlags & MB_BOUND_TO_LEADER)
! 1623: && !decedent->carriedMonster) {
! 1624:
! 1625: messageWithColor("you feel a sense of loss.", &badMessageColor, false);
! 1626: }
! 1627: x = decedent->xLoc;
! 1628: y = decedent->yLoc;
! 1629: if (decedent->bookkeepingFlags & MB_IS_DORMANT) {
! 1630: pmap[x][y].flags &= ~HAS_DORMANT_MONSTER;
! 1631: } else {
! 1632: pmap[x][y].flags &= ~HAS_MONSTER;
! 1633: }
! 1634: removeMonsterFromChain(decedent, dormantMonsters);
! 1635: removeMonsterFromChain(decedent, monsters);
! 1636:
! 1637: if (decedent->leader == &player
! 1638: && !(decedent->info.flags & MONST_INANIMATE)
! 1639: && (decedent->bookkeepingFlags & MB_HAS_SOUL)
! 1640: && !administrativeDeath) {
! 1641:
! 1642: decedent->nextCreature = purgatory->nextCreature;
! 1643: purgatory->nextCreature = decedent;
! 1644: } else {
! 1645: decedent->nextCreature = graveyard->nextCreature;
! 1646: graveyard->nextCreature = decedent;
! 1647: }
! 1648:
! 1649: if (!administrativeDeath && !(decedent->bookkeepingFlags & MB_IS_DORMANT)) {
! 1650: // Was there another monster inside?
! 1651: if (decedent->carriedMonster) {
! 1652: // Insert it into the chain.
! 1653: decedent->carriedMonster->nextCreature = monsters->nextCreature;
! 1654: monsters->nextCreature = decedent->carriedMonster;
! 1655: decedent->carriedMonster->xLoc = x;
! 1656: decedent->carriedMonster->yLoc = y;
! 1657: decedent->carriedMonster->ticksUntilTurn = 200;
! 1658: pmap[x][y].flags |= HAS_MONSTER;
! 1659: fadeInMonster(decedent->carriedMonster);
! 1660:
! 1661: if (canSeeMonster(decedent->carriedMonster)) {
! 1662: monsterName(monstName, decedent->carriedMonster, true);
! 1663: sprintf(buf, "%s appears", monstName);
! 1664: combatMessage(buf, NULL);
! 1665: }
! 1666:
! 1667: applyInstantTileEffectsToCreature(decedent->carriedMonster);
! 1668: decedent->carriedMonster = NULL;
! 1669: }
! 1670: refreshDungeonCell(x, y);
! 1671: }
! 1672: }
! 1673: decedent->currentHP = 0;
! 1674: demoteMonsterFromLeadership(decedent);
! 1675: if (decedent->leader) {
! 1676: checkForContinuedLeadership(decedent->leader);
! 1677: }
! 1678: }
! 1679:
! 1680: void buildHitList(creature **hitList, const creature *attacker, creature *defender, const boolean sweep) {
! 1681: short i, x, y, newX, newY, newestX, newestY;
! 1682: enum directions dir, newDir;
! 1683:
! 1684: x = attacker->xLoc;
! 1685: y = attacker->yLoc;
! 1686: newX = defender->xLoc;
! 1687: newY = defender->yLoc;
! 1688:
! 1689: dir = NO_DIRECTION;
! 1690: for (i = 0; i < DIRECTION_COUNT; i++) {
! 1691: if (nbDirs[i][0] == newX - x
! 1692: && nbDirs[i][1] == newY - y) {
! 1693:
! 1694: dir = i;
! 1695: break;
! 1696: }
! 1697: }
! 1698:
! 1699: if (sweep) {
! 1700: if (dir == NO_DIRECTION) {
! 1701: dir = UP; // Just pick one.
! 1702: }
! 1703: for (i=0; i<8; i++) {
! 1704: newDir = (dir + i) % DIRECTION_COUNT;
! 1705: newestX = x + cDirs[newDir][0];
! 1706: newestY = y + cDirs[newDir][1];
! 1707: if (coordinatesAreInMap(newestX, newestY) && (pmap[newestX][newestY].flags & (HAS_MONSTER | HAS_PLAYER))) {
! 1708: defender = monsterAtLoc(newestX, newestY);
! 1709: if (defender
! 1710: && monsterWillAttackTarget(attacker, defender)
! 1711: && (!cellHasTerrainFlag(defender->xLoc, defender->yLoc, T_OBSTRUCTS_PASSABILITY) || (defender->info.flags & MONST_ATTACKABLE_THRU_WALLS))) {
! 1712:
! 1713: hitList[i] = defender;
! 1714: }
! 1715: }
! 1716: }
! 1717: } else {
! 1718: hitList[0] = defender;
! 1719: }
! 1720: }
CVSweb
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to Combat.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [contributed] / brogue-ce / src / brogue