int res = 0;

for(int i=0; killtable[i]; i++) res += killtable[i][0];

return res;

int res = 0;

for(int i=0; killtable[i]; i++) if(killtable[i][0]) res++;

return res;

// 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;

else flags |= AF_IGNORE_UNARMED;

}

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 | AF_HORNS)) {

if(m2 == moLancer && (flags & AF_APPROACH)) ;

else if((flags & AF_HORNS) && checkOrb(m1, itOrbHorns)) { flags |= AF_IGNORE_UNARMED; }

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 | AF_BOW)))

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

cell *cp = (flags & AF_BOW) ? cwt.at : c1;

if(cp && c2 && isWorm(cp->monst) && isWorm(c2->monst) && wormhead(cp) == 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;

destroyHalfvine(c);

destroyTrapsOn(c);

playSound(c, "die-troll");

if(walltype == waIcewall && !isIcyLand(c->land))

return false;

if(c->land == laWestWall) return false;

if(do_not_touch_this_wall(c)) return false;

if(isWateryOrBoat(c) && c->land == laWhirlpool) {

c->wall = waSea;

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;

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]++;

eWall orig;

int spill_a, spill_b;

spillinfo() { spill_a = spill_b = 0; }

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++;

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);

}

if(flip && t == waFloorA) return waFloorB;

if(flip && t == waFloorB) return waFloorA;

return t;

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);

}

chainspill(c);

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;

chainspill(c);

}

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();

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);

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;

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);

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);

return kills[moMutant] + kills[moFriendlyIvy] +

kills[moIvyRoot] + kills[moIvyHead] + kills[moIvyBranch] + kills[moIvyWait] + kills[moIvyDead]

+ clearing::imputed;

eMonster m = c->monst;

DEBBI(debug_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 CAP_COMPLEX2

if(m == moHunterGuard) ambush::guard_attack();

#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(true); });

}

}

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 == moAsteroid && !shmup::on && c->item == itNone && c->wall != waChasm && c->land == laAsteroids) {

c->item = itAsteroid;

changes.value_add(splitrocks, 2);

}

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) || ls::hv_structure()) && 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)

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;

}

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);

}

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(items[itOrbSlaying]) {

playSound(NULL, "hit-crush"+pick123());

addMessage(XLAT("You crush %the1!", victim)); // normal

}

else if(stun && items[itCurseWeakness]) {

playSound(NULL, "click");

addMessage(XLAT("You punch %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));

}

}