void checklock();

~pathdata();

pathdata(eMonster m, bool include_allies IS(true));

pathdata(int i);

if(!pathlock) {

println(hlog, "onpath(", cw, ", ", d, ") without pathlock");

}

cw.at->pathdist = d;

pathq.push_back(cw);

for(auto c: pathq) c.at->pathdist = PINFD;

pathq.clear();

pathqm.clear();

if(pathlock) { printf("path error: compute_graphical_distance\n"); }

cell *c1 = centerover ? centerover : pd_from ? pd_from : cwt.at;

int sr = get_sightrange_ambush();

if(pd_from == c1 && pd_range == sr) return;

clear_pathdata();

pathlock++;

pd_from = c1;

pd_range = sr;

onpath(c1, 0);

for(int qb=0; qb<isize(pathq); qb++) {

cell *c = pathq[qb].at;

if(c->pathdist == pd_range) break;

if(qb == 0) forCellCM(c1, c) ;

forCellEx(c1, c)

if(c1->pathdist == PINFD)

onpath(c1, c->pathdist + 1);

}

pathlock--;

set<cell*> visited;

queue<cell*> q;

void visit(cell *c) {

if(visited.count(c)) return;

visited.insert(c);

q.push(c);

}

array<visit_set, max_radius+1> info;

void visit_gate(cell *g) { info[0].visit(g); }

void run();

int radius = toggle_radius(waOpenPlate);

if(pathq.empty()) return;

int d = pathq.back().at->pathdist;

if(d == PINFD - 1) return;

d++;

if(d < 5) d = 5; /* the Princess AI avoids plates when too close to the player */

hassert(radius <= max_radius);

for(int k=0; k<=radius; k++) while(!info[k].q.empty()) {

cell *c = info[k].q.front();

info[k].q.pop();

if(k < radius) forCellEx(c1, c) {

info[k+1].visit(c1);

if(k == 0 && c1->wall == waClosedGate)

info[0].visit(c1);

}

if(k == radius && c->wall == waOpenPlate && c->pathdist == PINFD)

onpath_random_dir(c, d);

}

for(cell *c: targets)

if(include_allies || isPlayerOn(c))

onpath_random_dir(c, isPlayerOn(c) ? 0 : 1);

int qtarg = isize(targets);

int limit = gamerange();

int qb = 0;

bool princess = isPrincess(param);

princess_ai gd;

princess_retry:

for(; qb < isize(pathq); qb++) {

cellwalker cw = pathq[qb];

/* The opposite cell will be added to the queue first, which helps the AI. */

cw += cw.at->type/2;

cell*& c = cw.at;

if(c->monst && !isBug(c) && !(isFriendly(c) && !c->stuntime)) {

pathqm.push_back(c);

continue; // no paths going through monsters

}

if(isMounted(c) && !isPlayerOn(c)) {

// don't treat the Worm you are riding as passable

pathqm.push_back(c);

continue;

}

if(c->cpdist > limit && !(c->land == laTrollheim && turncount < c->landparam) && c->wall != waThumperOn) continue;

int d = c->pathdist;

if(d == PINFD - 1) continue;

for(int j=0; j<c->type; j++) {

cellwalker cw1 = cw + j;

// printf("i=%d cd=%d\n", i, c->move(i)->cpdist);

cell *c2 = cw1.peek();

if(!in_line_of_sight(c2)) continue;

flagtype f = P_MONSTER;

if(param == moIvyRoot) f |= P_IVY;

if(param == moTameBomberbird) f |= P_FLYING | P_ISFRIEND;

if(isPrincess(param)) f |= P_ISFRIEND | P_USEBOAT | P_CHAIN;

if(param == moGolem) f |= P_ISFRIEND;

bool pass = c2 && c2->pathdist == PINFD;

if(pass && qb < qtarg && !nonAdjacent(c, c2) && !thruVine(c,c2)) pass = passable(c2, NULL, f);

else pass = pass && passable(c, c2, f);

if(pass) {

if(qb >= qtarg) {

if(param == moTortoise && nogoSlow(c, c2)) continue;

if(param == moIvyRoot && !ivy_passable(c, c2)) continue;

if(param == moWorm && (cellUnstable(c) || cellEdgeUnstable(c) || prairie::no_worms(c))) continue;

if(!isFriendly(param) && items[itOrbLava] && c2->cpdist <= 5 && pseudohept(c) && makeflame(c2, 1, true))

continue;

}

onpath_with_dir(cw1 + wstep, d+1);

}

else if(c2 && c2->wall == waClosedGate && princess)

gd.visit_gate(c2);

}

}

if(princess) {

gd.run();

if(qb < isize(pathq)) goto princess_retry;

}

if(pd_from) pd_from = NULL, clear_pathdata();

if(pathlock) printf("path error\n");

pathlock++;

checklock();

if(isize(pathq))

println(hlog, "! we got tiles on pathq: ", isize(pathq));

computePathdist(m, include_allies);

yendor::onpath();

int dcs = isize(dcal);

for(int i=0; i<dcs; i++) dcal[i]->cpdist = INFD;

worms.clear(); ivies.clear(); ghosts.clear(); golems.clear();

tempmonsters.clear(); targets.clear();

statuecount = 0;

wetslime = 0;

hexsnakes.clear();

hadwhat = havewhat;

havewhat = 0; jiangshi_on_screen = 0;

snaketypes.clear();

if(!(hadwhat & HF_WARP)) { avengers = 0; }

if(!(hadwhat & HF_MIRROR)) { mirrorspirits = 0; }

elec::havecharge = false;

elec::afterOrb = false;

elec::haveelec = false;

airmap.clear();

if(!(hadwhat & HF_ROSE)) rosemap.clear();

dcal.clear(); bfs_reachedfrom.clear();

for(cell *c: player_positions()) {

if(c->cpdist == 0) continue;

c->cpdist = 0;

dcal.push_back(c);

bfs_reachedfrom.push_back(hrand(c->type));

if(!invismove) targets.push_back(c);

}

int distlimit = gamerange();

for(cell *c: player_positions()) {

if(items[itOrbDomination])

if(c->monst == moTentacle || c->monst == moTentaclewait || c->monst == moTentacleEscaping)

worms.push_back(c);

}

int qb = 0;

first7 = 0;

while(true) {

if(qb == isize(dcal)) break;

int i, fd = bfs_reachedfrom[qb] + dcal[qb]->type/2;

cell *c = dcal[qb++];

int d = c->cpdist;

if(WDIM == 2 && d == distlimit) { first7 = qb; break; }

for(int j=0; j<c->type; j++) if(i = (fd+j) % c->type, c->move(i)) {

// printf("i=%d cd=%d\n", i, c->move(i)->cpdist);

cell *c2 = c->move(i);

if(!c2) continue;

if(isWarpedType(c2->land)) havewhat |= HF_WARP;

if(c2->land == laMirror) havewhat |= HF_MIRROR;

if((c->wall == waBoat || c->wall == waSea) &&

(c2->wall == waSulphur || c2->wall == waSulphurC))

c2->wall = waSea;

if(c2 && signed(c2->cpdist) > d+1) {

if(WDIM == 3 && (d > 2 && !gmatrix.count(c2))) {

if(!first7) first7 = qb;

continue;

}

c2->cpdist = d+1;

// remove treasures

if(!peace::on && c2->item && c2->cpdist == distlimit && itemclass(c2->item) == IC_TREASURE &&

!among(c2->item, itBrownian, itBabyTortoise) && WDIM != 3 &&

(items[c2->item] >= (ls::any_chaos()?10:20) + currentLocalTreasure || getGhostcount() >= 2)) {

c2->item = itNone;

if(c2->land == laMinefield) { c2->landparam &= ~3; }

}

if(c2->item == itBombEgg && c2->cpdist == distlimit && items[itBombEgg] >= c2->landparam) {

c2->item = itNone;

c2->landparam |= 2;

c2->landparam &= ~1;

if(!c2->monst) c2->monst = moBomberbird, c2->stuntime = 0;

}

if(c2->item == itBarrow && c2->cpdist == distlimit && c2->wall != waBarrowDig) {

c2->item = itNone;

}

if(c2->item == itLotus && c2->cpdist == distlimit && items[itLotus] >= getHauntedDepth(c2)) {

c2->item = itNone;

}

if(c2->item == itMutant2 && timerghost) {

bool rotten = true;

for(int i=0; i<c2->type; i++)

if(c2->move(i) && c2->move(i)->monst == moMutant)

rotten = false;

if(rotten) c2->item = itNone;

}

if(c2->item == itDragon && (shmup::on ? shmup::curtime-c2->landparam>300000 :

turncount-c2->landparam > 500))

c2->item = itNone;

if(c2->item == itTrollEgg && c2->cpdist == distlimit && !shmup::on && c2->landparam && turncount-c2->landparam > 650)

c2->item = itNone;

if(c2->item == itWest && c2->cpdist == distlimit && items[itWest] >= c2->landparam + 4)

c2->item = itNone;

if(c2->item == itMutant && c2->cpdist == distlimit && items[itMutant] >= c2->landparam) {

c2->item = itNone;

}

if(c2->item == itIvory && c2->cpdist == distlimit && items[itIvory] >= c2->landparam) {

c2->item = itNone;

}

if(c2->item == itAmethyst && c2->cpdist == distlimit && items[itAmethyst] >= -celldistAlt(c2)/5) {

c2->item = itNone;

}

if(!keepLightning) c2->ligon = 0;

dcal.push_back(c2);

bfs_reachedfrom.push_back(c->c.spin(i));

if(c2->wall == waBigStatue && c2->land != laTemple)

statuecount++;

if(isAlch(c2->wall) && c2->land == laWet)

wetslime++;

if(cellHalfvine(c2) && isWarped(c2)) {

addMessage(XLAT("%The1 is destroyed!", c2->wall));

destroyHalfvine(c2);

}

if(c2->wall == waCharged) elec::havecharge = true;

if(isElectricLand(c2)) elec::haveelec = true;

if(c2->land == laWhirlpool) havewhat |= HF_WHIRLPOOL;

if(c2->land == laWhirlwind) havewhat |= HF_WHIRLWIND;

if(c2->land == laWestWall) havewhat |= HF_WESTWALL;

if(c2->land == laPrairie) havewhat |= HF_RIVER;

if(c2->land == laClearing) havewhat |= HF_MUTANT;

if(c2->wall == waRose) havewhat |= HF_ROSE;

if((hadwhat & HF_ROSE) && (rosemap[c2] & 3)) havewhat |= HF_ROSE;

if(c2->monst) {

if(isHaunted(c2->land) &&

c2->monst != moGhost && c2->monst != moZombie && c2->monst != moNecromancer)

fail_survivalist();

if(c2->monst == moHexSnake || c2->monst == moHexSnakeTail) {

havewhat |= HF_HEX;

if(c2->mondir != NODIR)

snaketypes.insert(snake_pair(c2));

if(c2->monst == moHexSnake) hexsnakes.push_back(c2);

else findWormIvy(c2);

}

else if(c2->monst == moKrakenT || c2->monst == moKrakenH) {

havewhat |= HF_KRAKEN;

}

else if(c2->monst == moDragonHead || c2->monst == moDragonTail) {

havewhat |= HF_DRAGON;

}

else if(c2->monst == moWitchSpeed)

havewhat |= HF_FAST;

else if(c2->monst == moMutant)

havewhat |= HF_MUTANT;

else if(c2->monst == moJiangshi)

jiangshi_on_screen++;

else if(c2->monst == moOutlaw)

havewhat |= HF_OUTLAW;

else if(isGhostMover(c2->monst))

ghosts.push_back(c2);

else if(isWorm(c2) || isIvy(c2)) findWormIvy(c2);

else if(isBug(c2)) {

havewhat |= HF_BUG;

targets.push_back(c2);

}

else if(isFriendly(c2)) {

if(c2->monst != moMouse && !markEmpathy(itOrbInvis) && !(isWatery(c2) && markEmpathy(itOrbFish)) &&

!c2->stuntime) targets.push_back(c2);

if(c2->monst == moGolem) golems.push_back(c2);

if(c2->monst == moFriendlyGhost) golems.push_back(c2);

if(c2->monst == moKnight) golems.push_back(c2);

if(c2->monst == moTameBomberbird) golems.push_back(c2);

if(c2->monst == moMouse) { golems.push_back(c2); havewhat |= HF_MOUSE; }

if(c2->monst == moPrincess || c2->monst == moPrincessArmed) golems.push_back(c2);

if(c2->monst == moIllusion) {

if(items[itOrbIllusion]) items[itOrbIllusion]--;

else c2->monst = moNone;

}

}

else if(c2->monst == moButterfly) {

addButterfly(c2);

}

else if(isAngryBird(c2->monst)) {

havewhat |= HF_BIRD;

if(c2->monst == moBat) havewhat |= HF_BATS | HF_EAGLES;

if(c2->monst == moEagle) havewhat |= HF_EAGLES;

}

else if(among(c2->monst, moFrog, moVaulter, moPhaser))

havewhat |= HF_JUMP;

else if(c2->monst == moReptile) havewhat |= HF_REPTILE;

else if(isLeader(c2->monst)) havewhat |= HF_LEADER;

else if(c2->monst == moEarthElemental) havewhat |= HF_EARTH;

else if(c2->monst == moWaterElemental) havewhat |= HF_WATER;

else if(c2->monst == moVoidBeast) havewhat |= HF_VOID;

else if(c2->monst == moHunterDog) havewhat |= HF_HUNTER;

else if(isMagneticPole(c2->monst)) havewhat |= HF_MAGNET;

else if(c2->monst == moAltDemon) havewhat |= HF_ALT;

else if(c2->monst == moHexDemon) havewhat |= HF_HEXD;

else if(among(c2->monst, moAnimatedDie, moAngryDie)) havewhat |= HF_DICE;

else if(c2->monst == moMonk) havewhat |= HF_MONK;

else if(c2->monst == moShark || c2->monst == moCShark || among(c2->monst, moRusalka, moPike)) havewhat |= HF_SHARK;

else if(c2->monst == moAirElemental)

havewhat |= HF_AIR, airmap.push_back(make_pair(c2,0));

}

// pheromones!

if(c2->land == laHive && c2->landparam >= 50 && c2->wall != waWaxWall)

havewhat |= HF_BUG;

if(c2->wall == waThumperOn)

targets.push_back(c2);

}

}

}

for(int i=first7; i<isize(dcal); i++)

forCellEx(c2, dcal[i])

if(c2->wall == waThumperOn) {

targets.push_back(c2);

}

for(auto& t: tempmonsters) t.first->monst = t.second;

buildAirmap();

create_los();

int dcs = isize(dcal);

for(int i=0; i<dcs; i++) {

cell *c = dcal[i];

if(c->monst == moWolfMoved) c->monst = moWolf;

if(c->monst == moIvyNext) {

c->monst = moIvyHead; ivynext(c);

}

if(c->monst == moIvyDead)

removeIvy(c);

refreshFriend(c);

if(c->monst == moSlimeNextTurn) c->monst = moSlime;

if(c->monst == moLesser && !cellEdgeUnstable(c)) c->monst = moLesserM;

else if(c->monst == moLesserM) c->monst = moLesser;

if(c->monst == moGreater && !cellEdgeUnstable(c)) c->monst = moGreaterM;

else if(c->monst == moGreaterM) c->monst = moGreater;

if(c->monst == moPair && !c->stuntime) {

cell *c2 = c->move(c->mondir);

if(c2->monst != moPair) continue;

if(true) for(int i: {-1, 1}) {

cell *c3 = c->modmove(c->mondir + i);

if(among(c3->wall, waRuinWall, waColumn, waStone, waVinePlant, waPalace)) {

drawParticles(c3, winf[c3->wall].color, 30);

c3->wall = waNone;

}

}

}

if(c->stuntime && !isMutantIvy(c)) {

if(turn) c->stuntime--;

int breathrange = sphere ? 2 : 3;

if(c->stuntime == 0 && c->monst == moDragonHead) {

// if moDragonHead is renamed to "Dragon Head", we might need to change this

eMonster subject = c->monst;

if(!c->hitpoints) c->hitpoints = 1;

else if(shmup::on && dragon::totalhp(c) > 2 && shmup::dragonbreath(c)) {

c->hitpoints = 0;

}

else if(dragon::totalhp(c) <= 2) ;

else if(isMounted(c)) {

if(dragon::target && celldistance(c, dragon::target) <= breathrange && makeflame(dragon::target, 5, true)) {

addMessage(XLAT("%The1 breathes fire!", subject));

makeflame(dragon::target, 5, false);

playSound(dragon::target, "fire");

c->hitpoints = 0;

}

}

else {

for(int i=0; i<isize(targets); i++) {

cell *t = targets[i];

if(celldistance(c, t) <= breathrange && makeflame(t, 5, true)) {

if(isPlayerOn(t)) addMessage(XLAT("%The1 breathes fire at you!", subject));

else if(t->monst)

addMessage(XLAT("%The1 breathes fire at %the2!", subject, t->monst));

else

addMessage(XLAT("%The1 breathes fire!", subject));

makeflame(t, 5, false);

playSound(t, "fire");

c->hitpoints = 0;

}

}

}

}

}

// tortoises who have found their children no longer move

if(saved_tortoise_on(c))

c->stuntime = 2;

if(c->monst == moReptile) {

if(c->wall == waChasm || cellUnstable(c)) {

c->monst = moNone;

c->wall = waReptile;

c->wparam = reptilemax();

playSound(c, "click");

}

else if(isChasmy(c) || isWatery(c)) {

if(c->wall == waMercury) {

fallMonster(c, AF_FALL);

c->wall = waNone;

}

else {

c->wall = waReptileBridge;

c->wparam = reptilemax();

c->monst = moNone;

}

c->item = itNone;

playSound(c, "click");

}

}

if(c->wall == waChasm) {

if(c->land != laWhirlwind) c->item = itNone;

if(c->monst && !survivesChasm(c->monst) && c->monst != moReptile && normal_gravity_at(c)) {

if(c->monst != moRunDog && c->land == laMotion)

achievement_gain_once("FALLDEATH1");

addMessage(XLAT("%The1 falls!", c->monst));

fallMonster(c, AF_FALL);

}

}

else if(isReptile(c->wall) && turn) {

if(c->monst || isPlayerOn(c)) c->wparam = -1;

else if(c->cpdist <= 7) {

c->wparam--;

if(c->wparam == 0) {

if(c->wall == waReptile) c->wall = waChasm;

else placeWater(c, NULL);

c->monst = moReptile;

c->hitpoints = 3;

c->stuntime = 0;

vector<int> gooddirs;

// in the peace mode, a reptile will

// prefer to walk on the ground, rather than the chasm

for(int i=0; i<c->type; i++) {

int i0 = (i+3) % c->type;

int i1 = (i+c->type-3) % c->type;

if(c->move(i0) && passable(c->move(i0), c, 0))

if(c->move(i1) && passable(c->move(i1), c, 0))

gooddirs.push_back(i);

}

c->mondir = hrand_elt(gooddirs, c->mondir);

playSound(c, "click");

}

}

}

else if(isFire(c)) {

if(c->monst == moSalamander) c->stuntime = max<int>(c->stuntime, 1);

else if(c->monst == moVaulter && c->mondir == JUMP)

c->mondir = NODIR;

else if(c->monst && !survivesFire(c->monst) && !isWorm(c->monst)) {

addMessage(XLAT("%The1 burns!", c->monst));

if(isBull(c->monst)) {

addMessage(XLAT("Fire is extinguished!"));

c->wall = waNone;

}

fallMonster(c, AF_CRUSH);

}

if(c->item && itemBurns(c->item)) {

addMessage(XLAT("%The1 burns!", c->item));

c->item = itNone;

}

}

else if(isWatery(c)) {

if(c->monst == moLesser || c->monst == moLesserM || c->monst == moGreater || c->monst == moGreaterM)

c->monst = moGreaterShark;

if(c->monst && !survivesWater(c->monst) && normal_gravity_at(c)) {

playSound(c, "splash"+pick12());

if(isNonliving(c->monst))

addMessage(XLAT("%The1 sinks!", c->monst));

else

addMessage(XLAT("%The1 drowns!", c->monst));

if(isBull(c->monst)) {

addMessage(XLAT("%The1 is filled!", c->wall));

c->wall = waShallow;

}

fallMonster(c, AF_FALL);

}

}

else if(c->wall == waSulphur || c->wall == waSulphurC || c->wall == waMercury) {

if(c->monst && !survivesPoison(c->monst, c->wall) && normal_gravity_at(c)) {

playSound(c, "splash"+pick12());

if(isNonliving(c->monst))

addMessage(XLAT("%The1 sinks!", c->monst));

else

addMessage(XLAT("%The1 drowns!", c->monst));

if(isBull(c->monst)) {

addMessage(XLAT("%The1 is filled!", c->wall));

c->wall = waNone;

}

fallMonster(c, AF_FALL);

}

}

else if(c->wall == waMagma) {

if(c->monst == moSalamander) c->stuntime = max<int>(c->stuntime, 1);

else if(c->monst && !survivesPoison(c->monst, c->wall) && normal_gravity_at(c)) {

if(isNonliving(c->monst))

addMessage(XLAT("%The1 is destroyed by lava!", c->monst));

else

addMessage(XLAT("%The1 is killed by lava!", c->monst));

playSound(c, "steamhiss", 70);

fallMonster(c, AF_FALL);

}

}

else if(!isWateryOrBoat(c) && c->wall != waShallow) {

if(c->monst == moGreaterShark)

c->monst = moGreaterM;

else if(c->monst == moShark || c->monst == moCShark) {

addMessage(XLAT("%The1 suffocates!", c->monst));

fallMonster(c, AF_CRUSH);

}

else if(c->monst == moKrakenH) {

addMessage(XLAT("%The1 suffocates!", c->monst));

kraken::kill(c, moNone);

}

}

if(c->monst == moVineSpirit && !cellHalfvine(c) && c->wall != waVinePlant) {

addMessage(XLAT("%The1 is destroyed!", c->monst));

fallMonster(c, AF_CRUSH);

}

if(c->monst) mayExplodeMine(c, c->monst);

if(c->monst && c->wall == waClosedGate && !survivesWall(c->monst)) {

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

addMessage(XLAT("%The1 is crushed!", c->monst));

fallMonster(c, AF_CRUSH);

}

if(c->monst && cellUnstable(c) && !ignoresPlates(c->monst) && !shmup::on)

doesFallSound(c);

}

while(true) {

if(c->monst == moWorm || c->monst == moTentacle || c->monst == moWormwait || c->monst == moTentaclewait ||

c->monst == moTentacleEscaping) {

worms.push_back(c); settemp(c);

break;

}

else if(c->monst == moHexSnake) {

hexsnakes.push_back(c); settemp(c);

}

else if(c->monst == moWormtail || c->monst == moHexSnakeTail) {

bool bug = true;

for(int i=0; i<c->type; i++) {

cell* c2 = c->move(i);

if(c2 && isWorm(c2) && c2->mondir != NODIR && c2->move(c2->mondir) == c) {

settemp(c);

c = c2;

bug = false;

}

}

if(bug) break;

}

else if(c->monst == moIvyWait) {

cell* c2 = c->move(c->mondir);

settemp(c); c=c2;

}

else if(c->monst == moIvyHead) {

ivies.push_back(c); settemp(c);

break;

}

else if(c->monst == moIvyBranch || c->monst == moIvyRoot) {

bool bug = true;

for(int i=0; i<c->type; i++) {

cell* c2 = c->move(i);

if(c2 && (c2->monst == moIvyHead || c2->monst == moIvyBranch) && c2->move(c2->mondir) == c) {

settemp(c);

c = c2;

bug = false;

}

}

if(bug) break;

}

else break;

}

calcTidalPhase();

recalcTide = true;

while(recalcTide) {

recalcTide = false;

for(int i=0; i<isize(dcal); i++) checkTide(dcal[i]);

}

reset_spill();

checkSwitch();

mirror::breakAll();

DEBB(debug_turn, ("bfs"));

bfs();

DEBB(debug_turn, ("charge"));

if(elec::havecharge) elec::act();

DEBB(debug_turn, ("mmo"));

int phase2 = (1 & items[itOrbSpeed]);

if(!phase2) movemonsters();

for(cell *pc: player_positions()) if(pc->item == itOrbSafety) {

collectItem(pc, pc, true);

return;

}

if(playerInPower() && (phase2 || !items[itOrbSpeed]) && (havewhat & HF_FAST))

moveNormals(moWitchSpeed);

if(phase2 && markOrb(itOrbEmpathy)) {

bfs();

movegolems(AF_FAST);

for(int i=0; i<isize(dcal); i++) {

if(dcal[i]->monst == moFriendlyGhost && dcal[i]->stuntime)

dcal[i]->stuntime--;

refreshFriend(dcal[i]);

}

}

DEBB(debug_turn, ("rop"));

if(!dual::state) reduceOrbPowers();

int phase1 = (1 & items[itOrbSpeed]);

if(dual::state && items[itOrbSpeed]) phase1 = !phase1;

DEBB(debug_turn, ("lc"));

if(!phase1) livecaves();

if(!phase1) ca::simulate();

if(!phase1) heat::processfires();

// this depends on turncount, so we do it always

advance_tides();

for(cell *c: crush_now) {

changes.ccell(c);

playSound(NULL, "closegate");

if(canAttack(c, moCrusher, c, c->monst, AF_GETPLAYER | AF_CRUSH)) {

attackMonster(c, AF_MSG | AF_GETPLAYER | AF_CRUSH, moCrusher);

}

moveEffect(movei(c, FALL), moDeadBird);

destroyBoats(c, NULL, true);

explodeBarrel(c);

}

changes.value_keep(crush_now);

changes.value_keep(crush_next);

crush_now = std::move(crush_next);

crush_next.clear();

DEBB(debug_turn, ("heat"));

heat::processheat();

// if(elec::havecharge) elec::drawcharges();

orbbull::check();

#if CAP_COMPLEX2

if(!phase1) terracotta::check();

#endif

if(items[itOrbFreedom])

for(cell *pc: player_positions())

checkFreedom(pc);

DEBB(debug_turn, ("check"));

checkmove(false);

if(canmove) elec::checklightningfast();

#if CAP_HISTORY

for(cell *pc: player_positions())

history::movehistory.push_back(pc);

#endif

if(recompute_los) create_los();

if(isize(whirlline) == 1)

return false;

if(whirlline.back() == whirlline.front()) {

whirlline.pop_back();

return true;

}

int pos = isize(whirlline)/2;

if(isize(whirlline) > 2 && whirlline.back() == whirlline[pos]) {

while(pos && whirlline.back() == whirlline[pos])

whirlline.pop_back();

/* something weird must have happened... */

static bool once = true;

if(once) addMessage("warning: a looped line");

once = false;

return true;

}

return false;

if(inmirror(c)) {

cellwalker cw(c, neighborId(c, last));

auto cw2 = mirror::reflect(cw);

return blocks_sight(cw2.at, cw2.cpeek());

}

if(invisfish && !isWateryOrBoat(c)) return true;

if(c->monst == passive_switch) return true;

if(among(c->wall, waBigStatue, waMirror, waCloud, waThumperOff, waThumperOn, waExplosiveBarrel)) return c->cpdist > 1;

if(snakelevel(c) == 3 && !(c->cpdist == 1 && snakelevel(cwt.at) >= 2)) return true;

if(c->wall == waTrunk && last && last->wall != waTrunk && c->cpdist > 1) return true;

if(c->land == laMountain && last->land == laMountain) {

int d = celldistAlt(last);

if(celldistAlt(c) > d && (cwt.at->land != laMountain || celldistAlt(cwt.at) > d)) return true;

}

return (isWall(c) && !among(c->wall, waFreshGrave, waAncientGrave, waClosedGate, waMirrorWall, waSmallTree, waShrub, waRoundTable)) || thruVine(c, last);

if(in_line_of_sight(c)) return true;

if(cheater && lineofsight_cheat) return true;

int range = 0;

if(items[itOrbAether]) range = 2;

if(items[itOrbDash] || items[itOrbFrog] || items[itOrbPhasing]) range = 3;

if(items[itOrbInvis]) range = 999999;

return c->cpdist <= range;

current_fov.clear();

if(lineofsight == los::geodesic) {

for(auto c: dcal) {

if(c->cpdist == 0) current_fov[c] |= 3;

forCellEx(c1, c) if(c1->cpdist < c->cpdist && (current_fov[c1] & 2))

current_fov[c] |= blocks_sight(c, c1) ? 1 : 3;

}

}

if(lineofsight == los::geometric) for(int p=0; p<numplayers(); p++) if(multi::playerActive(p)) {

auto cp = playerpos(p);

current_fov[cp] = 3;