mirror of
https://github.com/zenorogue/hyperrogue.git
synced 2024-12-23 16:50:27 +00:00
1368 lines
46 KiB
C++
1368 lines
46 KiB
C++
// Copyright (C) 2011-2019 Zeno Rogue, see 'hyper.cpp' for details
|
|
|
|
/** \file gameutil.cpp
|
|
* \brief routines related to attacking and killing
|
|
*/
|
|
|
|
#include "hyper.h"
|
|
|
|
namespace hr {
|
|
|
|
/** how many instances of each monster type has been killed */
|
|
EX array<int, motypes> kills;
|
|
|
|
int* killtable[] = {
|
|
&kills[moYeti], &kills[moWolf], &
|
|
kills[moRanger], &kills[moTroll], &kills[moGoblin], &
|
|
kills[moWorm], &kills[moDesertman], &kills[moIvyRoot], &
|
|
kills[moMonkey], &kills[moEagle], &kills[moSlime], &kills[moSeep], &
|
|
kills[moRunDog], &
|
|
kills[moCultist], &kills[moTentacle], &kills[moPyroCultist], &
|
|
kills[moLesser], &kills[moGreater], &
|
|
kills[moZombie], &kills[moGhost], &kills[moNecromancer], &
|
|
kills[moHedge], &kills[moFireFairy], &
|
|
kills[moCrystalSage], &kills[moShark], &kills[moGreaterShark], &
|
|
kills[moMiner], &kills[moFlailer], &kills[moLancer], &
|
|
kills[moVineSpirit], &kills[moVineBeast], &
|
|
kills[moBug0], &kills[moBug1], &kills[moBug2], &
|
|
kills[moDarkTroll], &kills[moEarthElemental], &
|
|
kills[moWitch], &kills[moEvilGolem], &kills[moWitchFlash], &kills[moWitchFire], &
|
|
kills[moWitchWinter], &kills[moWitchSpeed], &
|
|
kills[moCultistLeader], &
|
|
kills[moPirate], &kills[moCShark], &kills[moParrot], &
|
|
kills[moHexSnake], &kills[moRedTroll], &
|
|
kills[moPalace], &kills[moSkeleton], &kills[moFatGuard], &kills[moVizier], &
|
|
kills[moViking], &kills[moFjordTroll], &kills[moWaterElemental], &
|
|
kills[moAlbatross], &kills[moBomberbird], &
|
|
kills[moAirElemental], &kills[moFireElemental], &
|
|
kills[moGargoyle], &kills[moFamiliar], &kills[moOrangeDog], &
|
|
items[itMutant], &kills[moMetalBeast], &kills[moMetalBeast2], &
|
|
kills[moOutlaw], &kills[moForestTroll], &kills[moStormTroll], &
|
|
kills[moRedFox], &kills[moWindCrow], &
|
|
kills[moFalsePrincess], &kills[moRoseLady], &
|
|
kills[moRoseBeauty], &
|
|
kills[moRatling], &kills[moRatlingAvenger], &
|
|
kills[moDragonHead], &
|
|
kills[moGadfly], &kills[moSparrowhawk], &kills[moResearcher],
|
|
&kills[moKrakenH], &kills[moDraugr],
|
|
&kills[moBat], &kills[moReptile],
|
|
&kills[moHerdBull], &kills[moSleepBull], &kills[moRagingBull],
|
|
&kills[moButterfly],
|
|
&kills[moNarciss], &kills[moMirrorSpirit],
|
|
&kills[moHunterDog], &kills[moIceGolem], &kills[moVoidBeast],
|
|
&kills[moJiangshi], &kills[moTerraWarrior],
|
|
&kills[moSalamander], &kills[moLavaWolf],
|
|
&kills[moSwitch1], &kills[moSwitch2],
|
|
&kills[moMonk], &kills[moCrusher], &kills[moHexDemon], &kills[moAltDemon], &kills[moPair],
|
|
&kills[moBrownBug], &kills[moAcidBird],
|
|
&kills[moFallingDog], &kills[moVariantWarrior], &kills[moWestHawk],
|
|
&kills[moPike], &kills[moRusalka], &kills[moFrog], &kills[moPhaser], &kills[moVaulter],
|
|
&kills[moHexer], &kills[moAnimatedDie], &kills[moAngryDie],
|
|
NULL
|
|
};
|
|
|
|
EX int tkills() {
|
|
int res = 0;
|
|
for(int i=0; killtable[i]; i++) res += killtable[i][0];
|
|
return res;
|
|
}
|
|
|
|
EX int killtypes() {
|
|
int res = 0;
|
|
for(int i=0; killtable[i]; i++) if(killtable[i][0]) res++;
|
|
return res;
|
|
}
|
|
|
|
|
|
EX bool arrow_stuns(eMonster m) {
|
|
return among(m, moCrusher, moMonk, moAltDemon, moHexDemon, moGreater, moGreaterM, moHedge);
|
|
}
|
|
|
|
EX bool canAttack(cell *c1, eMonster m1, cell *c2, eMonster m2, flagtype flags) {
|
|
|
|
// cannot eat worms
|
|
if((flags & AF_EAT) && isWorm(m2)) return false;
|
|
|
|
if(m1 == passive_switch || m2 == passive_switch) return false;
|
|
|
|
if((flags & AF_GETPLAYER) && isPlayerOn(c2)) m2 = moPlayer;
|
|
|
|
if(!m2) return false;
|
|
|
|
if(m2 == moPlayer && peace::on) return false;
|
|
|
|
if((flags & AF_WEAK) && isIvy(c2)) return false;
|
|
|
|
if((flags & AF_MUSTKILL) && attackJustStuns(c2, flags, m1))
|
|
return false;
|
|
|
|
if((flags & AF_ONLY_FRIEND) && m2 != moPlayer && !isFriendly(c2)) return false;
|
|
if((flags & AF_ONLY_FBUG) && m2 != moPlayer && !isFriendlyOrBug(c2)) return false;
|
|
if((flags & AF_ONLY_ENEMY) && (m2 == moPlayer || isFriendlyOrBug(c2))) return false;
|
|
|
|
if(isFriendly(c2) && markOrb(itOrbEmpathy) && (flags & (AF_STAB | AF_MAGIC | AF_HORNS | AF_SWORD | AF_SWORD_INTO | AF_SIDE | AF_PLAGUE)))
|
|
return false;
|
|
|
|
if(m1 == moArrowTrap && arrow_stuns(m2)) return true;
|
|
|
|
if(isDie(m2) && !(flags & (AF_MAGIC | AF_CRUSH))) return false;
|
|
|
|
if(among(m2, moAltDemon, moHexDemon, moPair, moCrusher, moNorthPole, moSouthPole, moMonk) && !(flags & (AF_EAT | AF_MAGIC | AF_BULL | AF_CRUSH)))
|
|
return false;
|
|
|
|
if(m2 == moHedge && !(flags & (AF_STAB | AF_TOUGH | AF_EAT | AF_MAGIC | AF_LANCE | AF_SWORD_INTO | AF_HORNS | AF_BULL | AF_CRUSH)))
|
|
if(!checkOrb(m1, itOrbThorns)) return false;
|
|
|
|
// krakens do not try to fight even with Discord
|
|
if((m1 == moKrakenT || m1 == moKrakenH) &&
|
|
(m2 == moKrakenT || m2 == moKrakenH))
|
|
return false;
|
|
|
|
if(m2 == moDraugr && !(flags & (AF_SWORD | AF_MAGIC | AF_SWORD_INTO | AF_HORNS | AF_CRUSH))) return false;
|
|
|
|
// if(m2 == moHerdBull && !(flags & AF_MAGIC)) return false;
|
|
if(isBull(m2) && !(flags & (AF_MAGIC | AF_HORNS | AF_SWORD_INTO | AF_CRUSH))) return false;
|
|
if(m2 == moButterfly && !(flags & (AF_MAGIC | AF_BULL | AF_HORNS | AF_SWORD_INTO | AF_CRUSH))) return false;
|
|
|
|
if(!(flags & AF_NOSHIELD) && ((flags & AF_NEXTTURN) ? checkOrb2 : checkOrb)(m2, itOrbShield)) return false;
|
|
|
|
if((flags & AF_STAB) && m2 != moHedge)
|
|
if(!checkOrb(m1, itOrbThorns)) return false;
|
|
|
|
if(flags & AF_BACK) {
|
|
if(m2 == moFlailer && !c2->stuntime) flags |= AF_IGNORE_UNARMED;
|
|
else if(m2 == moVizier && !isUnarmed(m1)) ;
|
|
else return false;
|
|
}
|
|
|
|
if(flags & AF_APPROACH) {
|
|
if(m2 == moLancer) ;
|
|
else if((flags & AF_HORNS) && checkOrb(m1, itOrbHorns)) ;
|
|
else return false;
|
|
}
|
|
|
|
if(!(flags & AF_IGNORE_UNARMED) && isUnarmed(m1)) return false;
|
|
|
|
if(m2 == moGreater || m2 == moGreaterM)
|
|
if(!(flags & (AF_MAGIC | AF_SWORD_INTO | AF_HORNS | AF_CRUSH))) return false;
|
|
|
|
if(!(flags & (AF_GUN | AF_SWORD | AF_SWORD_INTO | AF_MAGIC | AF_PLAGUE)))
|
|
if(c1 != c2 && !logical_adjacent(c1, m1, c2)) return false;
|
|
|
|
if(!(flags & (AF_LANCE | AF_STAB | AF_BACK | AF_APPROACH | AF_GUN | AF_MAGIC | AF_PLAGUE | AF_SIDE)))
|
|
if(c1 && c2 && againstRose(c1, c2) && !ignoresSmell(m1))
|
|
return false;
|
|
|
|
if(m2 == moShadow && !(flags & (AF_SWORD | AF_SWORD_INTO | AF_CRUSH))) return false;
|
|
if(isWorm(m2) && m2 != moTentacleGhost && !isDragon(m2)) return false;
|
|
|
|
// dragon can't attack itself, or player who mounted it
|
|
if(c1 && c2 && isWorm(c1->monst) && isWorm(c2->monst) && wormhead(c1) == wormhead(c2)
|
|
&& m1 != moTentacleGhost && m2 != moTentacleGhost)
|
|
return false;
|
|
|
|
// if(m2 == moTortoise && !(flags & AF_MAGIC)) return false;
|
|
|
|
if(m2 == moRoseBeauty)
|
|
if(!(flags & (AF_MAGIC | AF_LANCE | AF_GUN | AF_SWORD_INTO | AF_BULL | AF_CRUSH)))
|
|
if(!isMimic(m1))
|
|
if(!checkOrb(m1, itOrbBeauty) && !checkOrb(m1, itOrbAether) && !checkOrb(m1, itOrbShield))
|
|
if(!c1 || !c2 || !withRose(c1,c2))
|
|
return false;
|
|
|
|
if(m2 == moFlailer && !c2->stuntime)
|
|
if(!(flags & (AF_MAGIC | AF_TOUGH | AF_EAT | AF_HORNS | AF_LANCE | AF_BACK | AF_SWORD_INTO | AF_BULL | AF_CRUSH))) return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
EX bool petrify(cell *c, eWall walltype, eMonster m) {
|
|
destroyHalfvine(c);
|
|
destroyTrapsOn(c);
|
|
playSound(c, "die-troll");
|
|
|
|
if(walltype == waIcewall && !isIcyLand(c->land))
|
|
return false;
|
|
|
|
if(c->land == laWestWall) return false;
|
|
|
|
if(isWateryOrBoat(c) && c->land == laWhirlpool) {
|
|
c->wall = waSea;
|
|
return false;
|
|
}
|
|
|
|
if(c->wall == waRoundTable) return false;
|
|
|
|
if(walltype == waGargoyle && cellUnstableOrChasm(c))
|
|
walltype = waGargoyleFloor;
|
|
else if(walltype == waGargoyle && isWatery(c))
|
|
walltype = waGargoyleBridge;
|
|
else if(walltype == waPetrified && isWatery(c))
|
|
walltype = waPetrifiedBridge;
|
|
else if((c->wall == waTempBridge || c->wall == waTempBridgeBlocked) && c->land == laWhirlpool) {
|
|
c->wall = waTempBridgeBlocked;
|
|
return true;
|
|
}
|
|
else if(!doesnotFall(c)) {
|
|
fallingFloorAnimation(c, walltype, m);
|
|
return true;
|
|
}
|
|
|
|
if(isReptile(c->wall)) kills[moReptile]++;
|
|
destroyHalfvine(c);
|
|
c->wall = walltype;
|
|
c->wparam = m;
|
|
c->item = itNone;
|
|
return true;
|
|
}
|
|
|
|
EX void killIvy(cell *c, eMonster who) {
|
|
if(c->monst == moIvyDead) return;
|
|
changes.ccell(c);
|
|
if(checkOrb(who, itOrbStone)) petrify(c, waPetrified, c->monst);
|
|
c->monst = moIvyDead; // NEWYEARFIX
|
|
for(int i=0; i<c->type; i++) if(c->move(i))
|
|
if(isIvy(c->move(i)) && c->move(i)->mondir == c->c.spin(i))
|
|
killIvy(c->move(i), who), kills[moIvyDead]++;
|
|
}
|
|
|
|
struct spillinfo {
|
|
eWall orig;
|
|
int spill_a, spill_b;
|
|
spillinfo() { spill_a = spill_b = 0; }
|
|
};
|
|
|
|
map<cell*, spillinfo> spillinfos;
|
|
|
|
EX void reset_spill() {
|
|
spillinfos.clear();
|
|
}
|
|
|
|
EX void record_spillinfo(cell *c, eWall t) {
|
|
if(!isAlchAny(t)) return;
|
|
auto& si = spillinfos[c];
|
|
if(si.spill_a == 0 && si.spill_b == 0) si.orig = c->wall;
|
|
if(si.spill_a == 0 && si.spill_b == 0) si.orig = c->wall;
|
|
if(t == waFloorA) si.spill_a++;
|
|
if(t == waFloorB) si.spill_b++;
|
|
}
|
|
|
|
EX void prespill(cell* c, eWall t, int rad, cell *from) {
|
|
if(againstWind(c, from)) return;
|
|
changes.ccell(c);
|
|
// these monsters block spilling
|
|
if(c->monst == moSeep || c->monst == moVineSpirit || c->monst == moShark ||
|
|
c->monst == moGreaterShark || c->monst == moParrot || c->monst == moCShark)
|
|
return;
|
|
// turn statues into Slimes!
|
|
if(among(c->wall, waBigStatue, waTerraWarrior) && t != waNone) {
|
|
c->wall = waNone;
|
|
c->monst = moSlimeNextTurn;
|
|
}
|
|
// slimedeath spill
|
|
if((c->monst == moSlime || c->monst == moSlimeNextTurn) && t == waNone) {
|
|
c->wall = waNone; attackMonster(c, 0, moNone);
|
|
}
|
|
if(c->wall == waClosedGate) {
|
|
c->wall = waPalace;
|
|
return;
|
|
}
|
|
// no slime in Whirlpool
|
|
if(c->land == laWhirlpool) return;
|
|
// these walls block spilling completely
|
|
if(c->wall == waIcewall || c->wall == waBarrier || c->wall == waWarpGate ||
|
|
c->wall == waDeadTroll || c->wall == waDeadTroll2 ||
|
|
c->wall == waDune || c->wall == waAncientGrave ||
|
|
c->wall == waThumperOff || c->wall == waThumperOn ||
|
|
c->wall == waFreshGrave || c->wall == waColumn || c->wall == waPartialFire ||
|
|
c->wall == waDeadwall || c->wall == waWaxWall || c->wall == waCamelot || c->wall == waRoundTable ||
|
|
c->wall == waBigStatue || c->wall == waRed1 || c->wall == waRed2 || c->wall == waRed3 ||
|
|
c->wall == waTower ||
|
|
c->wall == waPalace ||
|
|
c->wall == waPlatform || c->wall == waStone || c->wall == waTempWall ||
|
|
c->wall == waTempFloor || c->wall == waTempBridge || c->wall == waPetrifiedBridge || c->wall == waTempBridgeBlocked ||
|
|
c->wall == waSandstone || c->wall == waCharged || c->wall == waGrounded ||
|
|
c->wall == waMetal || c->wall == waSaloon || c->wall == waFan ||
|
|
c->wall == waBarrowDig || c->wall == waBarrowWall ||
|
|
c->wall == waMirrorWall)
|
|
return;
|
|
if(c->wall == waFireTrap) {
|
|
if(c->wparam == 0) c->wparam = 1;
|
|
return;
|
|
}
|
|
if(c->wall == waExplosiveBarrel)
|
|
explodeBarrel(c);
|
|
destroyTrapsOn(c);
|
|
// these walls block further spilling
|
|
if(c->wall == waCavewall || cellUnstable(c) || c->wall == waSulphur ||
|
|
c->wall == waSulphurC || c->wall == waLake || c->wall == waChasm ||
|
|
c->wall == waBigTree || c->wall == waSmallTree || c->wall == waTemporary ||
|
|
c->wall == waVinePlant || isFire(c) || c->wall == waBonfireOff || c->wall == waVineHalfA || c->wall == waVineHalfB ||
|
|
c->wall == waCamelotMoat || c->wall == waSea || c->wall == waCTree ||
|
|
c->wall == waRubble || c->wall == waGargoyleFloor || c->wall == waGargoyle ||
|
|
c->wall == waRose || c->wall == waPetrified || c->wall == waPetrifiedBridge || c->wall == waRuinWall ||
|
|
among(c->wall, waDeepWater, waShallow)) {
|
|
record_spillinfo(c, t);
|
|
t = waTemporary;
|
|
}
|
|
|
|
if(c->wall == waSulphur) {
|
|
// remove the center as it would not look good
|
|
for(int i=0; i<c->type; i++) if(c->move(i) && c->move(i)->wall == waSulphurC)
|
|
c->move(i)->wall = waSulphur;
|
|
}
|
|
|
|
if(isReptile(c->wall)) {
|
|
if(c->monst || isPlayerOn(c)) kills[moReptile]++;
|
|
else c->monst = moReptile, c->stuntime = 3, c->hitpoints = 3;
|
|
}
|
|
|
|
destroyHalfvine(c);
|
|
if(c->wall == waTerraWarrior) kills[waTerraWarrior]++;
|
|
record_spillinfo(c, t);
|
|
c->wall = t;
|
|
// destroy items...
|
|
c->item = itNone;
|
|
// block spill
|
|
if(t == waTemporary) return;
|
|
// cwt.at->item = itNone;
|
|
if(rad) for(auto p: adj_minefield_cells_full(c)) {
|
|
prespill(p.c, conditional_flip_slime(p.mirrored, t), rad-1, c);
|
|
}
|
|
}
|
|
|
|
EX eWall conditional_flip_slime(bool flip, eWall t) {
|
|
if(flip && t == waFloorA) return waFloorB;
|
|
if(flip && t == waFloorB) return waFloorA;
|
|
return t;
|
|
}
|
|
|
|
EX void spillfix(cell* c, eWall t, int rad) {
|
|
if(c->wall == waTemporary) {
|
|
changes.ccell(c);
|
|
c->wall = t;
|
|
}
|
|
if(rad) for(auto p: adj_minefield_cells_full(c)) {
|
|
spillfix(p.c, conditional_flip_slime(p.mirrored, t), rad-1);
|
|
}
|
|
}
|
|
|
|
EX void spill(cell* c, eWall t, int rad) {
|
|
if(isAlchAny(c) && (spillinfos[c].spill_a || spillinfos[c].spill_b) && isAlchAny(spillinfos[c].orig))
|
|
t = spillinfos[c].orig;
|
|
prespill(c,t,rad, c);
|
|
spillfix(c,t,rad);
|
|
for(auto si: spillinfos) {
|
|
if(si.second.spill_a && si.second.spill_b)
|
|
si.first->wall =
|
|
si.second.spill_a > si.second.spill_b ? waFloorA :
|
|
si.second.spill_b > si.second.spill_a ? waFloorB :
|
|
isAlchAny(si.second.orig) ? si.second.orig :
|
|
waNone;
|
|
}
|
|
}
|
|
|
|
EX void degradeDemons() {
|
|
addMessage(XLAT("You feel more experienced in demon fighting!"));
|
|
playSound(cwt.at, "levelup");
|
|
int dcs = isize(dcal);
|
|
for(int i=0; i<dcs; i++) {
|
|
cell *c = dcal[i];
|
|
if(c->monst == moGreaterM || c->monst == moGreater) {
|
|
changes.ccell(c);
|
|
achievement_gain_once("DEMONSLAYER");
|
|
if(c->monst == moGreaterM) c->monst = moLesserM;
|
|
if(c->monst == moGreater) c->monst = moLesser;
|
|
}
|
|
}
|
|
shmup::degradeDemons();
|
|
}
|
|
|
|
EX void stunMonster(cell *c2, eMonster killer, flagtype flags) {
|
|
int newtime = (
|
|
c2->monst == moFatGuard ? 2 :
|
|
c2->monst == moSkeleton && c2->land != laPalace && c2->land != laHalloween ? 7 :
|
|
c2->monst == moTerraWarrior ? min(int(c2->stuntime + 8 - c2->hitpoints), 7) :
|
|
isMetalBeast(c2->monst) ? 7 :
|
|
c2->monst == moTortoise ? 7 :
|
|
c2->monst == moWorldTurtle ? 7 :
|
|
c2->monst == moReptile ? 7 :
|
|
isPrincess(c2->monst) ? 6 :
|
|
// spear stunning
|
|
isBull(c2->monst) ? 3 :
|
|
(c2->monst == moGreater || c2->monst == moGreaterM) ? 5 :
|
|
c2->monst == moButterfly ? 2 :
|
|
c2->monst == moDraugr ? 1 :
|
|
c2->monst == moVizier ? 0 :
|
|
c2->monst == moHedge ? 1 :
|
|
c2->monst == moFlailer ? 1 :
|
|
c2->monst == moSalamander ? 6 :
|
|
c2->monst == moBrownBug ? 3 :
|
|
((flags & AF_WEAK) && !attackJustStuns(c2, flags &~ AF_WEAK, killer)) ? min(5+c2->stuntime, 15) :
|
|
3);
|
|
if(killer == moArrowTrap) newtime = min(newtime + 3, 7);
|
|
if(!(flags & AF_WEAK) && !isMetalBeast(c2->monst) && !among(c2->monst, moSkeleton, moReptile, moSalamander, moTortoise, moWorldTurtle, moBrownBug)) {
|
|
c2->hitpoints--;
|
|
if(c2->monst == moPrincess)
|
|
playSound(c2, princessgender() ? "hit-princess" : "hit-prince");
|
|
}
|
|
if(c2->stuntime < newtime) c2->stuntime = newtime;
|
|
if(isBull(c2->monst)) c2->mondir = NODIR;
|
|
checkStunKill(c2);
|
|
}
|
|
|
|
EX bool attackJustStuns(cell *c2, flagtype f, eMonster attacker) {
|
|
if(f & AF_WEAK)
|
|
return true;
|
|
if(f & AF_HORNS)
|
|
return hornStuns(c2);
|
|
else if(attacker == moArrowTrap && arrow_stuns(c2->monst))
|
|
return true;
|
|
else if((f & AF_SWORD) && c2->monst == moSkeleton)
|
|
return false;
|
|
else if(f & (AF_CRUSH | AF_MAGIC | AF_FALL | AF_EAT | AF_GUN | AF_PSI))
|
|
return false;
|
|
else
|
|
return isStunnable(c2->monst) && c2->hitpoints > 1;
|
|
}
|
|
|
|
EX void minerEffect(cell *c) {
|
|
changes.ccell(c);
|
|
eWall ow = c->wall;
|
|
if(c->wall == waOpenGate || c->wall == waFrozenLake || c->wall == waBoat ||
|
|
c->wall == waStrandedBoat ||
|
|
c->wall == waCIsland || c->wall == waCIsland2 || c->wall == waTrapdoor ||
|
|
c->wall == waGiantRug) ;
|
|
else if(c->wall == waMineUnknown || c->wall == waMineMine || c->wall == waMineOpen)
|
|
c->wall = waMineOpen;
|
|
else if(c->wall == waRed2) c->wall = waRed1;
|
|
else if(c->wall == waRed3) c->wall = waRed2;
|
|
else if(isReptile(c->wall))
|
|
c->wparam = 1; // wake up next turn
|
|
else if(c->wall == waTempFloor) c->wall = waChasm;
|
|
else if(c->wall == waTempBridge || c->wall == waPetrifiedBridge || c->wall == waTempBridgeBlocked)
|
|
placeWater(c, NULL);
|
|
else if(doesFall(c))
|
|
ow = waNone;
|
|
else
|
|
c->wall = waNone;
|
|
if(c->wall != ow && ow) drawParticles(c, winf[ow].color, 16);
|
|
}
|
|
|
|
EX void killMutantIvy(cell *c, eMonster who) {
|
|
if(checkOrb(who, itOrbStone)) petrify(c, waPetrified, moMutant);
|
|
changes.ccell(c);
|
|
removeIvy(c);
|
|
for(int i=0; i<c->type; i++)
|
|
if(c->move(i) && c->move(i)->mondir == c->c.spin(i) && (isMutantIvy(c->move(i)) || c->move(i)->monst == moFriendlyIvy))
|
|
kills[c->move(i)->monst]++, killMutantIvy(c->move(i), who);
|
|
if(c->land == laClearing) clearing::imput(c);
|
|
}
|
|
|
|
EX bignum ivy_total() {
|
|
return kills[moMutant] + kills[moFriendlyIvy] +
|
|
kills[moIvyRoot] + kills[moIvyHead] + kills[moIvyBranch] + kills[moIvyWait] + kills[moIvyDead]
|
|
+ clearing::imputed;
|
|
}
|
|
|
|
EX void killMonster(cell *c, eMonster who, flagtype deathflags IS(0)) {
|
|
eMonster m = c->monst;
|
|
DEBBI(DF_TURN, ("killmonster ", dnameof(m)));
|
|
|
|
if(!m) return;
|
|
|
|
if(m == moKrakenH) return;
|
|
if(m == moKrakenT) {
|
|
if(c->hitpoints && m == moKrakenT) kills[moKrakenT]++;
|
|
c->hitpoints = 0;
|
|
c->stuntime = 1;
|
|
cell *head = kraken::head(c);
|
|
if(kraken::totalhp(head) == 0) {
|
|
kraken::kill(head, who);
|
|
playSound(head, "die-kraken");
|
|
}
|
|
return;
|
|
}
|
|
|
|
if(isDragon(m)) {
|
|
if(c->hitpoints && m != moDragonHead) kills[moDragonTail]++;
|
|
c->hitpoints = 0;
|
|
c->stuntime = 1;
|
|
cell *head = dragon::findhead(c);
|
|
if(dragon::totalhp(head) == 0) dragon::kill(head, who);
|
|
return;
|
|
}
|
|
if(isWorm(c) && m != moTentacleGhost) return;
|
|
|
|
bool fallanim = (deathflags & AF_FALL) && m != moMimic;
|
|
|
|
int pcount = fallanim ? 0 : 16;
|
|
if(m == moShadow)
|
|
kill_shadow_at(c);
|
|
|
|
#if CAP_HISTORY
|
|
if(!isBug(m) && !isAnyIvy(m)) {
|
|
history::killhistory.push_back(make_pair(c,m));
|
|
}
|
|
#endif
|
|
|
|
if(m == moGolemMoved) m = moGolem;
|
|
if(m == moKnightMoved) m = moKnight;
|
|
if(m == moSlimeNextTurn) m = moSlime;
|
|
if(m == moLesserM) m = moLesser;
|
|
if(m == moGreater) m = moLesser;
|
|
if(m == moGreaterM) m = moLesser;
|
|
if(isPrincess(m)) m = moPrincess;
|
|
if(m == moTentacleGhost) m = moGhost;
|
|
if(m == moHunterGuard) m = moHunterDog;
|
|
if(m == moHunterChanging) m = moHunterDog;
|
|
if(m == moWolfMoved) m = moWolf;
|
|
if(!isBulletType(m) && m != moIvyDead) kills[m]++;
|
|
|
|
if(saved_tortoise_on(c)) c->item = itNone;
|
|
|
|
if(!c->item) if(m == moButterfly && (deathflags & AF_BULL))
|
|
c->item = itBull;
|
|
|
|
if(isRatling(m) && c->wall == waBoat) {
|
|
bool avenge = false;
|
|
for(int i=0; i<c->type; i++) if(!isWarpedType(c->move(i)->land))
|
|
avenge = true;
|
|
if(avenge)
|
|
changes.value_add(avengers, 2);
|
|
}
|
|
|
|
if(m == moMirrorSpirit && who != moMimic && !(deathflags & (AF_MAGIC | AF_CRUSH))) {
|
|
kills[m]--;
|
|
changes.value_inc(mirrorspirits);
|
|
}
|
|
|
|
if(isMutantIvy(m) || m == moFriendlyIvy) {
|
|
pcount = 0;
|
|
if(isMutantIvy(m)) changes.at_commit([] { clearing::direct++; });
|
|
changes.value_keep(clearing::imputed);
|
|
bignum s = ivy_total() - 1;
|
|
killMutantIvy(c, who);
|
|
s = ivy_total() - s;
|
|
if(vid.bubbles_special && s > bignum(1))
|
|
drawBubble(c, 0xFFFF00, s.get_str(100), .5);
|
|
if(isize(clearing::imputed.digits) > 11)
|
|
achievement_gain_once("KILLMUTANT");
|
|
}
|
|
|
|
if(m == moPrincess) {
|
|
princess::info *i = princess::getPrincessInfo(c);
|
|
if(i) {
|
|
changes.value_keep(*i);
|
|
i->princess = NULL;
|
|
if(i->bestdist == OUT_OF_PALACE) {
|
|
items[itSavedPrincess]--;
|
|
if(items[itSavedPrincess] < 0) {
|
|
printf("princess below 0\n");
|
|
items[itSavedPrincess] = 0;
|
|
}
|
|
if(items[itSavedPrincess] == 0 && !inv::on) {
|
|
items[itOrbLove] = 0;
|
|
changes.value_keep(princess::reviveAt);
|
|
princess::reviveAt = gold(NO_LOVE) + 20;
|
|
}
|
|
}
|
|
if(princess::challenge) changes.at_commit([] { showMissionScreen(); });
|
|
}
|
|
}
|
|
|
|
if(m == moGargoyle && c->wall != waMineMine) {
|
|
bool connected = false;
|
|
|
|
if(isGravityLand(c->land)) {
|
|
for(int i=0; i<c->type; i++) {
|
|
cell *c2 = c->move(i);
|
|
if(c2->wall == waPlatform || c2->wall == waGargoyle || c2->wall == waBarrier ||
|
|
c2->wall == waDeadTroll || c2->wall == waDeadTroll2 || c2->wall == waTrunk ||
|
|
c2->wall == waPetrified || isAlchAny(c2->wall))
|
|
connected = true;
|
|
}
|
|
}
|
|
else {
|
|
for(int i=0; i<c->type; i++) {
|
|
cell *c2 = c->move(i);
|
|
if(!cellUnstableOrChasm(c2) && !isWatery(c2)) connected = true;
|
|
}
|
|
}
|
|
|
|
if(connected) petrify(c, waGargoyle, m), pcount = 0;
|
|
}
|
|
|
|
if(m == moIceGolem) {
|
|
if(petrify(c, waIcewall, m)) pcount = 0;
|
|
heat::affect(c, -1);
|
|
forCellEx(c2, c) {
|
|
changes.ccell(c2);
|
|
heat::affect(c2, -.5);
|
|
}
|
|
}
|
|
|
|
if(m == moTroll) {
|
|
petrify(c, waDeadTroll, m); pcount = 0;
|
|
forCellEx(c1, c) {
|
|
changes.ccell(c1);
|
|
c1->item = itNone;
|
|
if(c1->wall == waDeadwall) c1->wall = waCavewall;
|
|
if(c1->wall == waDeadfloor2 && !c1->monst && !isPlayerOn(c1)) c1->wall = waCavewall;
|
|
if(c1->wall == waDeadfloor) c1->wall = waCavefloor;
|
|
}
|
|
}
|
|
if(m == moFjordTroll || m == moForestTroll || m == moStormTroll) {
|
|
petrify(c, waDeadTroll2, m);
|
|
}
|
|
if(m == moMiner) {
|
|
pcount = 32;
|
|
playSound(c, "splash" + pick12());
|
|
destroyHalfvine(c);
|
|
minerEffect(c);
|
|
#if CAP_COMPLEX2
|
|
brownian::dissolve_brownian(c, 1);
|
|
#endif
|
|
forCellEx(c1, c) if(passable(c1, c, P_MONSTER | P_MIRROR | P_CLIMBUP | P_CLIMBDOWN)) {
|
|
changes.ccell(c1);
|
|
destroyHalfvine(c1);
|
|
minerEffect(c1);
|
|
#if CAP_COMPLEX2
|
|
brownian::dissolve_brownian(c1, 1);
|
|
#endif
|
|
if(c1->monst == moSlime || c1->monst == moSlimeNextTurn)
|
|
killMonster(c1, who);
|
|
}
|
|
forCellEx(c2, c) {
|
|
changes.ccell(c2);
|
|
if(c2->wall == waPalace) c2->wall = waRubble;
|
|
if(c2->wall == waDeadwall) c2->wall = waDeadfloor2;
|
|
if(c2->wall == waExplosiveBarrel) explodeBarrel(c2);
|
|
}
|
|
}
|
|
if(m == moOrangeDog) {
|
|
if(pcount) for(int i=0; i<8; i++) {
|
|
drawParticle(c, 0xFFFFFF);
|
|
drawParticle(c, 0x202020);
|
|
}
|
|
pcount = 0;
|
|
}
|
|
if(m == moDraugr) {
|
|
if(pcount) drawParticles(c, 0x804000, 8);
|
|
pcount = 0;
|
|
}
|
|
if(m == moPalace) {
|
|
if(pcount) {
|
|
pcount = 4;
|
|
for(int i=0; i<12; i++) drawParticle(c, 0x20C020);
|
|
}
|
|
}
|
|
if(m == moPrincess) {
|
|
playSound(c, princessgender() ? "die-princess" : "die-prince");
|
|
}
|
|
if(m == moVineBeast)
|
|
petrify(c, waVinePlant, m), pcount = 0;
|
|
if(isBird(m)) moveEffect(movei(c, FALL), moDeadBird);
|
|
if(m == moAcidBird) {
|
|
playSound(c, "die-bomberbird");
|
|
pcount = 64;
|
|
#if CAP_COMPLEX2
|
|
brownian::dissolve(c, 1);
|
|
#endif
|
|
}
|
|
if(m == moBomberbird || m == moTameBomberbird) {
|
|
pcount = 0;
|
|
playSound(c, "die-bomberbird");
|
|
if(c->wall == waNone || c->wall == waMineUnknown || c->wall == waMineOpen ||
|
|
c->wall == waCavefloor || c->wall == waDeadfloor || c->wall == waDeadfloor2 ||
|
|
c->wall == waRubble || c->wall == waGargoyleFloor ||
|
|
c->wall == waCIsland || c->wall == waCIsland2 ||
|
|
c->wall == waStrandedBoat || c->wall == waRed1 || c->wall == waGiantRug) {
|
|
c->wall = waMineMine;
|
|
if(c->item) explodeMine(c);
|
|
else if(c->land == laMinefield) c->landparam = 1;
|
|
}
|
|
else if(c->wall == waFrozenLake)
|
|
c->wall = waLake;
|
|
else if(c->wall == waGargoyleBridge)
|
|
placeWater(c, c);
|
|
else if(c->wall == waRed3 || c->wall == waRed2) {
|
|
c->wall = waRed1;
|
|
for(int i=0; i<c->type; i++) if(c->move(i)->wall == waRed3)
|
|
c->move(i)->wall = waRed2;
|
|
c->item = itNone;
|
|
}
|
|
eWall w = c->wall;
|
|
if(isFire(c) || c->wall == waRose || isReptile(c->wall)) {
|
|
c->wall = waMineMine;
|
|
explodeMine(c);
|
|
if(isReptile(w)) kills[moReptile]++;
|
|
if(w == waReptile) c->wall = waChasm;
|
|
if(w == waReptileBridge) placeWater(c, NULL);
|
|
}
|
|
}
|
|
if(m == moVineSpirit) {
|
|
pcount = 32;
|
|
playSound(c, "die-vinespirit");
|
|
destroyHalfvine(c);
|
|
if(!isFire(c)) c->wall = waNone;
|
|
}
|
|
if(m == moRedTroll) {
|
|
playSound(c, "die-troll");
|
|
if(doesFall(c)) fallingFloorAnimation(c, waRed1, m), pcount = 0;
|
|
else if(snakepile(c, m)) pcount = 0;
|
|
}
|
|
if(m == moBrownBug) {
|
|
if(doesFall(c)) ;
|
|
else if(snakepile(c, m)) pcount = 0;
|
|
}
|
|
if(m == moDarkTroll) {
|
|
playSound(c, "die-troll");
|
|
if(doesFall(c)) fallingFloorAnimation(c, waDeadwall, m), pcount = 0;
|
|
else if(c->wall == waRed1 || c->wall == waRed2 || c->wall == waRed3)
|
|
c->wall = waDeadwall, pcount = 0;
|
|
else if(snakepile(c, m))
|
|
pcount = 0;
|
|
}
|
|
if(isWitch(m) && (isFire(c) || passable(c, NULL, P_MONSTER)) && !c->item) {
|
|
if(m == moWitchFire) c->item = itOrbFire;
|
|
if(m == moWitchFlash) c->item = itOrbFlash;
|
|
if(m == moWitchGhost) c->item = itOrbAether;
|
|
if(m == moWitchWinter) c->item = itOrbWinter;
|
|
if(m == moWitchSpeed) c->item = itOrbSpeed;
|
|
if(isFire(c) && itemBurns(c->item))
|
|
c->item = itNone;
|
|
}
|
|
if(who == moPlayer || (isFriendly(who) && items[itOrbEmpathy])) {
|
|
eItem o = frog_power(m);
|
|
if(o && who != moPlayer) markOrb2(itOrbEmpathy);
|
|
if(o) items[o] += 5;
|
|
}
|
|
if(checkOrb(who, itOrbStone))
|
|
petrify(c, waPetrified, m), pcount = 0;
|
|
if(m == moFireFairy) {
|
|
drawFireParticles(c, 16); pcount = 0;
|
|
playSound(c, "die-fairy");
|
|
playSound(c, "fire");
|
|
makeflame(c, 50, false);
|
|
}
|
|
if(c->monst == moMetalBeast2 && !c->item && who == moLightningBolt && c->wall != waPetrified && c->wall != waChasm)
|
|
c->item = itFulgurite; // this is actually redundant in many cases
|
|
if(m == moPyroCultist && c->item == itNone && c->wall != waChasm && c->wall != waPetrified) {
|
|
// a reward for killing him before he shoots!
|
|
c->item = itOrbDragon;
|
|
}
|
|
if(m == moOutlaw && (c->item == itNone || c->item == itRevolver) && c->wall != waChasm)
|
|
c->item = itBounty;
|
|
// note: an Orb appears underwater!
|
|
if(m == moWaterElemental && c->item == itNone)
|
|
c->item = itOrbWater;
|
|
|
|
if(m == moPirate && isOnCIsland(c) && c->item == itNone && (
|
|
eubinary ||
|
|
(c->master->alt && celldistAlt(c) <= 2-getDistLimit()) ||
|
|
isHaunted(c->land)) && !cryst) {
|
|
bool toomany = false;
|
|
for(int i=0; i<c->type; i++) {
|
|
cell *c2 = c->move(i);
|
|
if(c2 && c2->item == itCompass) toomany = true;
|
|
if(c2 && BITRUNCATED) for(int j=0; j<c2->type; j++)
|
|
if(c2->move(j) && c2->move(j)->item == itCompass)
|
|
toomany = true;
|
|
}
|
|
if(!toomany) c->item = itCompass;
|
|
}
|
|
if(m == moSlime) {
|
|
pcount = 0;
|
|
drawParticles(c, winf[c->wall].color, 80, 200);
|
|
playSound(c, "splash" + pick12());
|
|
c->monst = moNone;
|
|
spill(c, c->wall, 2);
|
|
}
|
|
// if(c->monst == moShark) c->heat += 1;
|
|
// if(c->monst == moGreaterShark) c->heat += 10;
|
|
if(isIcyLand(c)) {
|
|
if(m == moCultist) HEAT(c) += 3;
|
|
if(m == moPyroCultist) HEAT(c) += 6;
|
|
if(m == moLesser) HEAT(c) += 10;
|
|
}
|
|
if(m == moLesser && !(kills[m] % 10))
|
|
degradeDemons();
|
|
if(m == moLesser) {
|
|
if(kills[m] % 10) {
|
|
if(vid.bubbles_special)
|
|
drawBubble(c, 0xFF0000, its(kills[m]%10), 1);
|
|
}
|
|
else {
|
|
if(vid.bubbles_special)
|
|
drawBubble(c, 0xFF8000, "+1 XP", .8);
|
|
degradeDemons();
|
|
}
|
|
}
|
|
if(isIvy(c)) {
|
|
pcount = 0;
|
|
eMonster m = c->monst;
|
|
bignum s = ivy_total() - 1;
|
|
/*if((m == moIvyBranch || m == moIvyHead) && c->move(c->mondir)->monst == moIvyRoot)
|
|
ivynext(c, moIvyNext); */
|
|
killIvy(c, who);
|
|
s = ivy_total() - s;
|
|
if(s > bignum(1) && vid.bubbles_special)
|
|
drawBubble(c, 0xFFFF00, s.get_str(100), .5);
|
|
if(m == moIvyBranch || m == moIvyHead || m == moIvyNext) {
|
|
int qty = 0;
|
|
cell *c2 = proper(c, c->mondir) ? c->move(c->mondir) : nullptr;
|
|
if(!c2) c2 = c; /* should not happen */
|
|
for(int i=0; i<c2->type; i++)
|
|
if(c2->move(i)->monst == moIvyWait && c2->move(i)->mondir == c2->c.spin(i))
|
|
qty++;
|
|
if(c2->monst == moIvyRoot || qty) {
|
|
c->monst = moIvyNext;
|
|
/* c->monst = moIvyHead;
|
|
ivynext(c);
|
|
if(c->monst == moIvyHead) c->monst = moIvyNext;
|
|
else c->monst = moNone; */
|
|
}
|
|
else {
|
|
changes.ccell(c2);
|
|
c2->monst = moIvyHead;
|
|
}
|
|
}
|
|
}
|
|
else if(c->monst == moTentacleGhost)
|
|
c->monst = moTentacletail;
|
|
else c->monst = moNone;
|
|
|
|
if(m == moPair && c->move(c->mondir)->monst == moPair) {
|
|
changes.ccell(c->move(c->mondir));
|
|
killMonster(c->move(c->mondir), who, deathflags);
|
|
}
|
|
|
|
if(isMagneticPole(m) && c->move(c->mondir)->monst == otherpole(m)) {
|
|
changes.ccell(c->move(c->mondir));
|
|
killMonster(c->move(c->mondir), who, deathflags);
|
|
}
|
|
|
|
if(m == moEarthElemental) earthWall(c);
|
|
if(m == moAlbatross && items[itOrbLuck])
|
|
useupOrb(itOrbLuck, items[itOrbLuck] / 2);
|
|
|
|
if(m == moAirElemental) {
|
|
changes.value_keep(airmap);
|
|
airmap.clear();
|
|
for(int i=0; i<isize(dcal); i++)
|
|
if(dcal[i]->monst == moAirElemental)
|
|
airmap.push_back(make_pair(dcal[i],0));
|
|
buildAirmap();
|
|
}
|
|
if(m == moMimic) {
|
|
for(auto& m: mirror::mirrors) if(c == m.second.at) {
|
|
drawParticles(c, mirrorcolor(m.second.mirrored), pcount);
|
|
if(c->wall == waMirrorWall)
|
|
drawParticles(c, mirrorcolor(!m.second.mirrored), pcount);
|
|
}
|
|
pcount = 0;
|
|
}
|
|
|
|
drawParticles(c, minf[m].color, pcount);
|
|
if(fallanim) {
|
|
fallingMonsterAnimation(c, m);
|
|
}
|
|
}
|
|
|
|
EX void fightmessage(eMonster victim, eMonster attacker, bool stun, flagtype flags) {
|
|
|
|
if(isBird(attacker)) {
|
|
playSound(NULL, "hit-axe"+pick123());
|
|
addMessage(XLAT("%The1 claws %the2!", attacker, victim));
|
|
}
|
|
|
|
else if(isGhost(attacker))
|
|
addMessage(XLAT("%The1 scares %the2!", attacker, victim));
|
|
|
|
else if(isSlimeMover(attacker) && !stun) {
|
|
playSound(NULL, "hit-crush"+pick123());
|
|
addMessage(XLAT("%The1 eats %the2!", attacker, victim));
|
|
}
|
|
|
|
else if(flags & AF_EAT) {
|
|
playSound(NULL, "hit-crush"+pick123());
|
|
addMessage(XLAT("%The1 eats %the2!", attacker, victim));
|
|
}
|
|
|
|
else if(attacker == moLancer) {
|
|
playSound(NULL, "hit-rose");
|
|
addMessage(XLAT("%The1 pierces %the2!", attacker, victim));
|
|
}
|
|
|
|
else if(attacker == moEarthElemental) {
|
|
playSound(NULL, "hit-crush"+pick123());
|
|
addMessage(XLAT("%The1 punches %the2!", attacker, victim));
|
|
}
|
|
|
|
else if(attacker == moPlayer) {
|
|
if(flags & (AF_SWORD | AF_SWORD_INTO)) {
|
|
playSound(NULL, "hit-axe"+pick123());
|
|
addMessage(XLAT("You slash %the1.", victim));
|
|
if(victim == moGoblin)
|
|
achievement_gain_once("GOBLINSWORD");
|
|
}
|
|
else if(victim == moKrakenT || victim == moDragonTail || victim == moDragonHead) {
|
|
playSound(NULL, "hit-sword"+pick123());
|
|
addMessage(XLAT("You hit %the1.", victim)); // normal
|
|
}
|
|
else if(stun && victim == moVizier) {
|
|
playSound(NULL, "hit-sword"+pick123());
|
|
addMessage(XLAT("You hit %the1.", victim)); // normal
|
|
}
|
|
else if(stun) {
|
|
playSound(NULL, "hit-sword"+pick123());
|
|
addMessage(XLAT("You stun %the1.", victim)); // normal
|
|
}
|
|
else if(isNonliving(victim)) {
|
|
playSound(NULL, "hit-sword"+pick123());
|
|
addMessage(XLAT("You destroy %the1.", victim)); // normal
|
|
}
|
|
else if(flags & AF_STAB) {
|
|
playSound(NULL, "hit-axe"+pick123());
|
|
addMessage(XLAT("You stab %the1.", victim)); // normal
|
|
}
|
|
else if(flags & AF_APPROACH) {
|
|
playSound(NULL, "hit-sword"+pick123());
|
|
if(victim == moLancer)
|
|
addMessage(XLAT("You trick %the1.", victim)); // normal
|
|
else
|
|
addMessage(XLAT("You pierce %the1.", victim)); // normal
|
|
}
|
|
else if(!peace::on) {
|
|
playSound(NULL, "hit-sword"+pick123());
|
|
addMessage(XLAT("You kill %the1.", victim)); // normal
|
|
}
|
|
}
|
|
|
|
else {
|
|
if(victim == moKrakenT || victim == moDragonTail || victim == moDragonHead) {
|
|
playSound(NULL, "hit-crush"+pick123());
|
|
addMessage(XLAT("%The1 hits %the2.", attacker, victim)); // normal
|
|
}
|
|
else if(stun && victim == moVizier) {
|
|
playSound(NULL, "hit-sword"+pick123());
|
|
addMessage(XLAT("%The1 hits %the2.", attacker, victim)); // normal
|
|
}
|
|
else if(stun) {
|
|
playSound(NULL, "hit-sword"+pick123());
|
|
addMessage(XLAT("%The1 attacks %the2!", attacker, victim)); // normal
|
|
}
|
|
else if(isNonliving(victim)) {
|
|
playSound(NULL, "hit-sword"+pick123());
|
|
addMessage(XLAT("%The1 destroys %the2!", attacker, victim)); // normal
|
|
}
|
|
else if(flags & AF_STAB) {
|
|
playSound(NULL, "hit-axe"+pick123());
|
|
addMessage(XLAT("%The1 stabs %the2.", attacker, victim));
|
|
}
|
|
else if(flags & AF_APPROACH) {
|
|
playSound(NULL, "hit-sword"+pick123());
|
|
addMessage(XLAT("%The1 tricks %the2.", attacker, victim));
|
|
}
|
|
else {
|
|
playSound(NULL, "hit-sword"+pick123());
|
|
addMessage(XLAT("%The1 kills %the2!", attacker, victim));
|
|
}
|
|
}
|
|
}
|
|
|
|
EX bool notthateasy(eMonster m) {
|
|
return
|
|
isMultitile(m) || isStunnable(m) || m == moDraugr;
|
|
}
|
|
|
|
EX bool attackMonster(cell *c, flagtype flags, eMonster killer) {
|
|
|
|
if((flags & AF_GETPLAYER) && isPlayerOn(c)) {
|
|
killThePlayerAt(killer, c, flags);
|
|
return true;
|
|
}
|
|
|
|
eMonster m = c->monst;
|
|
int tk = tkills();
|
|
|
|
int tkt = killtypes();
|
|
|
|
bool dostun = attackJustStuns(c, flags, killer);
|
|
|
|
if((flags & AF_BULL) && c->monst == moVizier && c->hitpoints > 1) {
|
|
dostun = true;
|
|
c->stuntime = 2;
|
|
}
|
|
|
|
bool eu = landUnlocked(laElementalWall);
|
|
bool tu = landUnlocked(laTrollheim);
|
|
|
|
if(flags & AF_MSG) fightmessage(m, killer, dostun, flags);
|
|
if(dostun)
|
|
stunMonster(c, killer, flags);
|
|
else
|
|
killMonster(c, killer, flags);
|
|
|
|
if(peace::on) return false;
|
|
|
|
int ntk = tkills();
|
|
int ntkt = killtypes();
|
|
|
|
if(tkt < R20 && ntkt >= R20 && in_full_game()) {
|
|
addMessage(XLAT("You hear a distant roar!"));
|
|
playSound(NULL, "message-roar");
|
|
}
|
|
|
|
if(tk == 0 && ntk > 0 && in_full_game() && !cheater) {
|
|
if(notthateasy(m))
|
|
addMessage(XLAT("Quite tough, for your first fight."));
|
|
else {
|
|
bool more = false;
|
|
forCellEx(c2, cwt.at) forCellEx(c3, c2)
|
|
if(c3->monst) more = true;
|
|
if(!more)
|
|
addMessage(XLAT("That was easy, but groups could be dangerous."));
|
|
}
|
|
}
|
|
|
|
if(tk < 10 && ntk >= 10 && in_full_game() && !big_unlock)
|
|
addMessage(XLAT("Good to know that your fighting skills serve you well in this strange world."));
|
|
|
|
if(tk < R100/2 && ntk >= R100/2 && in_full_game())
|
|
addMessage(XLAT("You wonder where all these monsters go, after their death..."));
|
|
|
|
if(tk < R100 && ntk >= R100 && in_full_game())
|
|
addMessage(XLAT("You feel that the souls of slain enemies pull you to the Graveyard..."));
|
|
|
|
if(!tu && landUnlocked(laTrollheim) && in_full_game()) {
|
|
playSound(c, "message-troll");
|
|
addMessage(XLAT("%The1 says, \"I die, but my clan in Trollheim will avenge me!\"", m));
|
|
}
|
|
|
|
if(!eu && landUnlocked(laElementalWall) && in_full_game())
|
|
addMessage(XLAT("After killing %the1, you feel able to reach the Elemental Planes!", m));
|
|
|
|
if(m == moVizier && c->monst != moVizier && kills[moVizier] == 1 && in_full_game()) {
|
|
addMessage(XLAT("Hmm, he has been training in the Emerald Mine. Interesting..."));
|
|
princess::forceMouse = true;
|
|
}
|
|
|
|
if(m == moIvyRoot && ntk>tk)
|
|
achievement_gain_once("IVYSLAYER");
|
|
|
|
return ntk > tk;
|
|
}
|
|
|
|
EX void pushMonster(const movei& mi) {
|
|
if(mi.s->monst == moPair || isMagneticPole(mi.s)) {
|
|
cell *other = mi.s->move(mi.s->mondir);
|
|
int id = neighborId(mi.t, other);
|
|
if(id == -1) {
|
|
killMonster(mi.s, moPlayer);
|
|
killMonster(other, moPlayer);
|
|
return;
|
|
}
|
|
else {
|
|
moveMonster(mi);
|
|
if(mi.t->monst) {
|
|
mi.t->mondir = id;
|
|
other->mondir = mi.t->c.spin(id);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
moveMonster(mi);
|
|
auto& cf = mi.s;
|
|
auto& ct = mi.t;
|
|
if(ct->monst == moBrownBug) {
|
|
int t = snakelevel(ct) - snakelevel(cf);
|
|
if(t > 0)
|
|
ct->stuntime = min(ct->stuntime + 2 * t, 7);
|
|
}
|
|
if(isBull(ct->monst)) ct->monst = moRagingBull;
|
|
}
|
|
|
|
EX void killFriendlyIvy() {
|
|
forCellEx(c2, cwt.at) if(c2->monst == moFriendlyIvy)
|
|
killMonster(c2, moPlayer, 0);
|
|
}
|
|
|
|
EX bool monsterPushable(cell *c2) {
|
|
if(markOrb(itCurseWeakness) && (c2->stuntime < 2 || attackJustStuns(c2, 0, moPlayer))) return false;
|
|
if(isMultitile(c2->monst)) return false;
|
|
return (c2->monst != moFatGuard && !(isMetalBeast(c2->monst) && c2->stuntime < 2) && c2->monst != moTortoise && c2->monst != moTerraWarrior && c2->monst != moVizier && c2->monst != moWorldTurtle);
|
|
}
|
|
|
|
EX bool should_switchplace(cell *c1, cell *c2) {
|
|
if(isPrincess(c2->monst) || among(c2->monst, moGolem, moIllusion, moMouse, moFriendlyGhost))
|
|
return true;
|
|
|
|
if(peace::on) return c2->monst;
|
|
return false;
|
|
}
|
|
|
|
EX bool switchplace_prevent(cell *c1, cell *c2, struct pcmove& m) {
|
|
if(!should_switchplace(c1, c2)) return false;
|
|
if(peace::on && (isMultitile(c2->monst) || saved_tortoise_on(c2) || isDie(c2->monst))) {
|
|
if(m.vmsg(miRESTRICTED)) addMessage(XLAT("Cannot switch places with %the1!", c2->monst));
|
|
return true;
|
|
}
|
|
if(c1->monst && c1->monst != moFriendlyIvy) {
|
|
if(m.vmsg(miRESTRICTED)) addMessage(XLAT("There is no room for %the1!", c2->monst));
|
|
return true;
|
|
}
|
|
if(passable(c1, c2, P_ISFRIEND | (c2->monst == moTameBomberbird ? P_FLYING : 0))) return false;
|
|
if(warningprotection_hit(c2->monst)) return true;
|
|
return false;
|
|
}
|
|
|
|
EX void handle_switchplaces(cell *c1, cell *c2, bool& switchplaces) {
|
|
if(should_switchplace(c1, c2)) {
|
|
bool pswitch = false;
|
|
if(c2->monst == moMouse)
|
|
princess::mouseSqueak(c2);
|
|
else if(isPrincess(c2->monst)) {
|
|
princess::line(c2);
|
|
princess::move(match(c2, c1));
|
|
}
|
|
else
|
|
pswitch = true;
|
|
c1->hitpoints = c2->hitpoints;
|
|
c1->stuntime = c2->stuntime;
|
|
placeGolem(c1, c2, c2->monst);
|
|
if(cwt.at->monst != moNone && pswitch)
|
|
addMessage(XLAT("You switch places with %the1.", c2->monst));
|
|
c2->monst = moNone;
|
|
switchplaces = true;
|
|
}
|
|
}
|
|
|
|
EX bool flashWouldKill(cell *c, flagtype extra) {
|
|
for(int t=0; t<c->type; t++) {
|
|
cell *c2 = c->move(t);
|
|
for(int u=0; u<c2->type; u++) {
|
|
cell *c3 = c2->move(u);
|
|
if(isWorm(c3)) continue; // immune to Flash
|
|
if(isFriendly(c3)) continue; // player's allies and mounts don't count
|
|
if(c3->monst == moEvilGolem) continue; // evil golems don't count
|
|
if(c3 != c && (c3->monst || isPlayerOn(c3))) {
|
|
bool b = canAttack(NULL, moWitchFlash, c3, c3->monst, AF_MAGIC | extra);
|
|
if(b) return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
EX vector<cell*> gun_targets(cell *c) {
|
|
manual_celllister cl;
|
|
vector<int> dists;
|
|
cl.add(c); dists.push_back(0);
|
|
for(int i=0; i<isize(dists); i++) {
|
|
cell *c1 = cl.lst[i];
|
|
if(dists[i] <= 2)
|
|
forCellEx(c2, c1)
|
|
if(passable(c2, c1, P_BULLET | P_FLYING | P_MONSTER))
|
|
if(cl.add(c2)) dists.push_back(dists[i] + 1);
|
|
}
|
|
return cl.lst;
|
|
}
|
|
|
|
EX void fallMonster(cell *c, flagtype flags IS(0)) {
|
|
attackMonster(c, flags, moNone);
|
|
}
|
|
|
|
EX void killHardcorePlayer(int id, flagtype flags) {
|
|
charstyle& cs = getcs(id);
|
|
cell *c = playerpos(id);
|
|
if(flags & AF_FALL)
|
|
fallingMonsterAnimation(c, moPlayer);
|
|
else for(int i=0; i<6; i++) {
|
|
drawParticle(c, cs.skincolor >> 8, 100);
|
|
drawParticle(c, cs.haircolor >> 8, 125);
|
|
if(cs.charid)
|
|
drawParticle(c, cs.dresscolor >> 8, 150);
|
|
else
|
|
drawParticle(c, cs.skincolor >> 8, 150);
|
|
if(cs.charid == 3)
|
|
drawParticle(c, cs.dresscolor2 >> 8, 175);
|
|
else
|
|
drawParticle(c, cs.skincolor >> 8, 150);
|
|
drawParticle(c, cs.swordcolor >> 8, 200);
|
|
}
|
|
|
|
if(multi::players > 1 && multi::activePlayers() > 1) {
|
|
multi::leaveGame(id);
|
|
}
|
|
else {
|
|
canmove = false;
|
|
achievement_final(true);
|
|
}
|
|
}
|
|
|
|
EX bool suicidal;
|
|
|
|
EX void killThePlayer(eMonster m, int id, flagtype flags) {
|
|
if(markOrb(itOrbShield)) return;
|
|
if(shmup::on) {
|
|
multi::cpid = id;
|
|
shmup::killThePlayer(m);
|
|
}
|
|
else if(items[itOrbDomination] && playerpos(id)->monst) {
|
|
addMessage(XLAT("%The1 tries to dismount you!", m));
|
|
attackMonster(playerpos(id), AF_NORMAL, m);
|
|
useupOrb(itOrbDomination, items[itOrbDomination]/2);
|
|
}
|
|
else if(items[itOrbShell] && !(flags & AF_EAT)) {
|
|
addMessage(XLAT("%The1 attacks your shell!", m));
|
|
useupOrb(itOrbShell, 10);
|
|
if(items[itOrbShell] < 1) items[itOrbShell] = 1, orbused[itOrbShell] = true;
|
|
}
|
|
else if(hardcore) {
|
|
addMessage(XLAT("You are killed by %the1!", m));
|
|
killHardcorePlayer(id, flags);
|
|
}
|
|
else if(m == moLightningBolt && lastmovetype == lmAttack && isAlchAny(playerpos(id))) {
|
|
addMessage(XLAT("You are killed by %the1!", m));
|
|
addMessage(XLAT("Don't play with slime and electricity next time, okay?"));
|
|
kills[moPlayer]++;
|
|
items[itOrbSafety] = 0;
|
|
}
|
|
else {
|
|
// printf("confused!\n");
|
|
addMessage(XLAT("%The1 is confused!", m));
|
|
changes.value_set(suicidal, true);
|
|
}
|
|
}
|
|
|
|
EX void killThePlayerAt(eMonster m, cell *c, flagtype flags) {
|
|
for(int i: player_indices())
|
|
if(playerpos(i) == c)
|
|
killThePlayer(m, i, flags);
|
|
}
|
|
|
|
#if HDR
|
|
template<class T> void do_swords(movei mi, eMonster who, const T& f) {
|
|
for(int bb=0; bb<2; bb++) if(who == moPlayer && sword::orbcount(bb)) {
|
|
cell *sf = sword::pos(mi.s, sword::dir[multi::cpid], bb);
|
|
cell *st = sword::pos(mi.t, sword::shift(mi, sword::dir[multi::cpid]), bb);
|
|
f(st, bb);
|
|
if(sf != st && !isNeighbor(sf,st)) {
|
|
// also attack the in-transit cell
|
|
if(S3 == 3) {
|
|
forCellEx(sb, sf) if(isNeighbor(sb, st) && sb != mi.s && sb != mi.t) f(sb, bb);
|
|
}
|
|
else {
|
|
forCellEx(sb, mi.s) if(isNeighbor(sb, st) && sb != mi.t) f(sb, bb);
|
|
forCellEx(sb, mi.t) if(isNeighbor(sb, sf) && sb != mi.s) f(sb, bb);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
int lastdouble = -3;
|
|
|
|
EX void stabbingAttack(movei mi, eMonster who, int bonuskill IS(0)) {
|
|
int numsh = 0, numflail = 0, numlance = 0, numslash = 0, numbb[2];
|
|
|
|
numbb[0] = numbb[1] = 0;
|
|
|
|
cell *mf = mi.s;
|
|
cell *mt = mi.t;
|
|
int backdir = mi.rev_dir_mirror();
|
|
|
|
do_swords(mi, who, [&] (cell *c, int bb) { if(swordAttack(mt, who, c, bb)) numbb[bb]++, numslash++; });
|
|
|
|
for(int bb=0; bb<2; bb++) achievement_count("SLASH", numbb[bb], 0);
|
|
|
|
if(peace::on) return;
|
|
|
|
for(int t=0; t<mf->type; t++) {
|
|
cell *c = mf->move(t);
|
|
if(!c) continue;
|
|
|
|
bool stabthere = false, away = true;
|
|
if(logical_adjacent(mt, who, c)) stabthere = true, away = false;
|
|
if(inmirror(c)) c = mirror::reflect(c).at;
|
|
|
|
if(stabthere && c->wall == waExplosiveBarrel && markOrb(itOrbThorns))
|
|
explodeBarrel(c);
|
|
|
|
if(stabthere && canAttack(mt,who,c,c->monst,AF_STAB)) {
|
|
changes.ccell(c);
|
|
if(c->monst != moHedge) {
|
|
markOrb(itOrbThorns); if(who != moPlayer) markOrb(itOrbEmpathy);
|
|
}
|
|
eMonster m = c->monst;
|
|
int k = tkills();
|
|
if(attackMonster(c, AF_STAB | AF_MSG, who)) {
|
|
spread_plague(mt, c, t, who);
|
|
produceGhost(c, m, who);
|
|
}
|
|
if(tkills() > k) numsh++;
|
|
}
|
|
|
|
if(away && c != mt && canAttack(mf,who,c,c->monst,AF_BACK)) {
|
|
changes.ccell(c);
|
|
if(c->monst == moVizier && c->hitpoints > 1) {
|
|
fightmessage(c->monst, who, true, AF_BACK);
|
|
c->hitpoints--;
|
|
// c->stuntime = 1;
|
|
}
|
|
else {
|
|
eMonster m = c->monst;
|
|
if(c->monst != moFlailer) {
|
|
playSound(NULL, "hit-sword"+pick123());
|
|
fightmessage(c->monst, who, false, AF_BACK);
|
|
}
|
|
else {
|
|
playSound(NULL, "hit-sword"+pick123());
|
|
if(who != moPlayer)
|
|
addMessage(XLAT("%The1 tricks %the2.", who, c->monst));
|
|
else
|
|
addMessage(XLAT("You trick %the1.", c->monst));
|
|
}
|
|
if(c->monst == moFlailer && isPrincess(who) && isUnarmed(who))
|
|
achievement_gain_once("PRINCESS_PACIFIST");
|
|
|
|
if(attackMonster(c, 0, who)) {
|
|
numflail++;
|
|
spread_plague(mf, c, t, who);
|
|
produceGhost(c, m, who);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if(!isUnarmed(who)) forCellIdEx(c, t, mt) {
|
|
if(!logical_adjacent(mt, who, c)) continue;
|
|
eMonster mm = c->monst;
|
|
int flag = AF_APPROACH;
|
|
if(proper(mt, backdir) && anglestraight(mt, backdir, t)) flag |= AF_HORNS;
|
|
if(canAttack(mt,who,c,c->monst, flag)) {
|
|
changes.ccell(c);
|
|
if(attackMonster(c, flag | AF_MSG, who)) numlance++;
|
|
spread_plague(mt, c, t, who);
|
|
produceGhost(c, mm, who);
|
|
}
|
|
}
|
|
|
|
if(who == moPlayer) {
|
|
if(numsh) achievement_count("STAB", numsh, 0);
|
|
|
|
if(numlance && numflail && numsh) achievement_gain_once("MELEE3");
|
|
|
|
if(numlance + numflail + numsh + numslash + bonuskill >= 5) achievement_gain_once("MELEE5");
|
|
|
|
if(numsh == 2) {
|
|
if(lastdouble == turncount-1) achievement_count("STAB", 4, 0);
|
|
changes.value_set(lastdouble, turncount);
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|