1
0
mirror of https://github.com/zenorogue/hyperrogue.git synced 2024-12-25 01:20:37 +00:00
hyperrogue/game.cpp

5612 lines
167 KiB
C++
Raw Normal View History

2015-08-08 13:57:52 +00:00
// Hyperbolic Rogue
// Copyright (C) 2011-2013 Zeno Rogue, see 'hyper.cpp' for details
#define DEB(x) // printf("%s\n", x); fflush(stdout);
#define SAGEMELT .1
#define TEMPLE_EACH 6
time_t timerstart, savetime;
bool timerstopped;
int savecount;
int turncount;
int lastexplore;
eLand lastland;
int sagephase = 0;
// number of Grails collected, to show you as a knight
int knighted = 0;
bool showoff = false;
bool safety = false;
int showid = 0;
bool lifebrought = false; // was Life brought to the Dead Caves?
bool invismove = false; // last move was invisible
int currentLocalTreasure;
bool landvisited[landtypes];
eLand showlist[10] = {
laHell, laRlyeh, laAlchemist, laGraveyard, laCaves, laDesert, laIce, laJungle, laMotion, laMirror
};
eLand firstland = laIce, euclidland = laIce;
extern void DEBT(const char *buf);
#define DEBT(x) // printf("%s\n", x);
bool eq(short a, short b) { return a==b; }
// game state
int items[ittypes], kills[motypes], explore[10], exploreland[10][landtypes], landcount[landtypes];
bool playerdead = false; // obsolete
bool playermoved = true; // center on the PC?
bool flipplayer = true; // flip the player image after move, do not flip after attack
int cheater = 0; // did the player cheat?
#define INF 9999
#define INFD 20
#define BARLEV (ISANDROID?9:10)
#define BUGLEV 15
// #define BARLEV 9
vector<cell*> dcal; // queue for cpdist
vector<cell*> pathq; // queue for pathdist
vector<cell*> pathqm; // list of monsters to move (pathq restriced to monsters)
vector<cell*> targets; // list of monster targets
// monsters of specific types to move
vector<cell*> worms, ivies, ghosts, golems, mirrors, mirrors2;
vector<cell*> temps; // temporary changes during bfs
vector<eMonster> tempval; // restore temps
// a bit nicer way of DFS
vector<int> reachedfrom;
// additional direction information for BFS algorithms
// it remembers from where we have got to this location
// the opposite cell will be added to the queue first,
// which helps the AI
vector<cell*> movesofgood[8];
int first7; // the position of the first monster at distance 7 in dcal
cellwalker cwt; // player character position
bool isIcyLand(cell *c) {
return c->land == laIce || c->land == laCocytus;
}
void initcell(cell *c) {
c->mpdist = INFD; // minimum distance from the player, ever
c->cpdist = INFD; // current distance from the player
c->pathdist = INFD; // current distance from the player, along paths (used by yetis)
c->heat = 0;
c->wall = waNone;
c->item = itNone;
c->monst = moNone;
c->bardir = NODIR;
c->land = laNone;
c->tmp = -1;
c->ligon = 0;
lastexplore = turncount;
}
// 0 = basic treasure, 1 = something else, 2 = power orb
#define IC_TREASURE 0
#define IC_OTHER 1
#define IC_ORB 2
int itemclass(eItem i) {
if(i == 0) return -1;
if(i < itKey || i == itFernFlower ||
i == itWine || i == itSilver || i == itEmerald || i == itRoyalJelly || i == itPower ||
i == itGrimoire)
return IC_TREASURE;
if(i == itKey || i == itOrbYendor || i == itGreenStone || i == itHolyGrail)
return IC_OTHER;
return IC_ORB;
}
int puregold() {
int i = items[itOrbYendor] * 50 + items[itHolyGrail] * 10;
for(int t=0; t<ittypes; t++)
if(itemclass(eItem(t)) == IC_TREASURE)
i += items[t];
return i;
}
eItem treasureType(eLand l) {
switch(l) {
case laIce: return itDiamond;
case laJungle: return itRuby;
case laCaves: return itGold;
case laDesert: return itSpice;
case laAlchemist: return itElixir;
case laMirror: return itShard;
case laMotion: return itFeather;
case laGraveyard: return itBone;
case laRlyeh: return itStatue;
case laDryForest: return itFernFlower;
case laHell: return itHell;
case laCocytus: return itSapphire;
case laCrossroads: return itHyperstone;
case laNone: return itNone;
case laBarrier: return itNone;
case laGameBoard: return itNone;
case laFjord: return itEmerald;
case laWineyard: return itWine;
case laHive: return itRoyalJelly;
case laDeadCaves: return itSilver;
case laPower: return itPower;
case laCamelot: return itHolyGrail;
case laTemple: return itGrimoire;
}
return itNone;
}
eItem localTreasureType() {
lastland = cwt.c->land;
return treasureType(lastland);
}
void countLocalTreasure() {
eItem i = localTreasureType();
currentLocalTreasure = i ? items[i] : 0;
}
bool hellUnlocked() {
int i = 0;
for(int t=0; t<ittypes; t++)
if(itemclass(eItem(t)) == IC_TREASURE && items[t] >= 10)
i++;
return i >= 9;
}
bool hyperstonesUnlocked() {
for(int t=1; t<ittypes; t++)
if(t != itHyperstone && itemclass(eItem(t)) == IC_TREASURE && items[t] < 10) {
return false;
}
return true;
}
int gold() {
return puregold();
}
int maxgold() {
int mg = 0;
for(int i=0; i<ittypes; i++)
if(itemclass(eItem(i)) == IC_TREASURE && items[i] > mg)
mg = items[i];
return mg;
}
int tkills() {
return
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];
}
bool passable(cell *w, cell *from, bool monster_passable, bool mirror_passable) {
if(w->wall == waFloorA && from && from->wall == waFloorB && !w->item && !from->item)
return false;
if(w->wall == waFloorB && from && from->wall == waFloorA && !w->item && !from->item)
return false;
if(w->wall == waMirror || w->wall == waCloud) return mirror_passable;
if((w->wall == waVineHalfA || w->wall == waVineHalfB) && from && from->wall == w->wall)
return false;
if(w->wall == waNone || w->wall == waFloorA || w->wall == waFloorB ||
w->wall == waCavefloor || w->wall == waFrozenLake || w->wall == waVineHalfA ||
w->wall == waVineHalfB || w->wall == waDeadfloor || w->wall == waDeadfloor2) {
if(w->monst) return monster_passable;
return true;
}
return false;
}
bool cellUnstable(cell *c) {
return c->land == laMotion && c->wall == waNone;
}
bool cellUnstableOrChasm(cell *c) {
return c->land == laMotion && (c->wall == waNone || c->wall == waChasm);
}
bool cellHalfvine(cell *c) {
return c->wall == waVineHalfA || c->wall == waVineHalfB;
}
bool thruVine(cell *c, cell *c2) {
return cellHalfvine(c) && c2->wall == c->wall;
}
bool itemBurns(eItem it) {
return it && it != itOrbDragon && it != itOrbFire;
}
bool attackThruVine(eMonster m) {
return m == moGhost || m == moVineSpirit;
}
// target, source
bool attackingForbidden(cell *c, cell *c2) {
return thruVine(c, c2) && !attackThruVine(c2->monst) && !attackThruVine(c->monst);
}
bool isFire(cell *w) {
return w->wall == waBonfire || w->wall == waPartialFire;
}
// eagles can go through lakes, chasms, and slime
// todo vines?
bool eaglepassable(cell *w) {
if(w->monst) return false;
return
w->wall == waNone || w->wall == waFloorA || w->wall == waFloorB ||
w->wall == waCavefloor || w->wall == waFrozenLake || w->wall == waLake ||
w->wall == waDeadfloor || w->wall == waDeadfloor2 || w->wall == waCamelotMoat ||
w->wall == waSulphur || w->wall == waSulphurC || w->wall == waChasm;
}
bool isActiv(cell *c) {
return c->wall == waThumper || c->wall == waBonfire || c->wall == waPartialFire;
}
bool isMimic(eMonster m) {
return m == moMirror || m == moMirage;
}
bool isMimic(cell *c) {
return isMimic(c->monst);
}
bool isGolemOrKnight(cell *c) {
return
c->monst == moGolem || c->monst == moGolemMoved ||
c->monst == moKnight ||c->monst == moKnightMoved;
}
bool isFriendly(cell *c) {
return isMimic(c->monst) || isGolemOrKnight(c) || c->monst == moIllusion;
}
bool isBug(eMonster m) {
return m >= moBug0 && m < moBug0+BUGCOLORS;
}
bool isBug(cell *c) {
return isBug(c->monst);
}
bool isFriendlyOrBug(cell *c) {
return isFriendly(c) || isBug(c);
}
bool isIvy(cell *c) {
return c->monst == moIvyRoot || c->monst == moIvyHead || c->monst == moIvyBranch || c->monst == moIvyWait ||
c->monst == moIvyNext || c->monst == moIvyDead;
}
bool isDemon(cell *c) {
return c->monst == moLesser || c->monst == moLesserM ||
c->monst == moGreater || c->monst == moGreaterM;
}
bool isWorm(cell *c) {
return c->monst == moWorm || c->monst == moWormtail || c->monst == moWormwait ||
c->monst == moTentacle || c->monst == moTentacletail || c->monst == moTentaclewait ||
c->monst == moTentacleEscaping;
}
void useup(cell *c) {
c->tmp--;
if(c->tmp == 0) c->wall = waNone;
}
bool isInactiveEnemy(cell *w) {
if(w->monst == moWormtail || w->monst == moWormwait || w->monst == moTentacletail || w->monst == moTentaclewait)
return true;
if(w->monst == moLesserM || w->monst == moGreaterM)
return true;
if(w->monst == moIvyRoot || w->monst == moIvyWait || w->monst == moIvyNext || w->monst == moIvyDead)
return true;
return false;
}
bool isActiveEnemy(cell *w, cell *killed) {
if(w->monst == moNone || w == killed) return false;
if(isFriendly(w)) return false;
if(isInactiveEnemy(w)) return false;
if(w->monst == moIvyHead || w->monst == moIvyBranch) {
while(w != killed && w->mondir != NODIR) w = w->mov[w->mondir];
return w != killed;
}
return true;
}
bool isArmedEnemy(cell *w, cell *killed) {
return w->monst != moCrystalSage && isActiveEnemy(w, killed);
}
bool player_passable(cell *w, cell *from, bool mon) {
if(w->monst && !isFriendly(w)) return false;
if(isFire(w) && items[itOrbWinter]) return true;
if(w->wall == waRoundTable && from->wall != waRoundTable)
return true;
if(items[itOrbGhost] > 1) return true;
return passable(w, from, mon, true);
}
bool isHive(eLand l) {
return l == laHive;
}
bool isKillable(cell *c) {
return c->monst != moShadow && !isWorm(c) && c->monst != moGreater && c->monst != moGreaterM
&& c->monst != moHedge && c->monst != moFlailer;
// && !isBug(c->monst);
}
bool isKillableSomehow(cell *c) {
return isKillable(c)
|| c->monst == moHedge || c->monst == moLancer || c->monst == moFlailer;
}
bool isNeighbor(cell *c1, cell *c2) {
for(int i=0; i<c1->type; i++) if(c1->mov[i] == c2) return true;
return false;
}
// how many monsters are near
eMonster which;
bool mirrorkill(cell *c) {
for(int t=0; t<c->type; t++)
if(c->mov[t] && isMimic(c->mov[t]) && c->mov[t]->mov[c->mov[t]->mondir] == c)
return true;
return false;
}
// friendly==false: would the flash kill enemy monsters (i.e., allied with the witch)?
// friendly==true: would the flash kill friendly monsters (or bugs)?
bool flashWouldKill(cell *c, bool friendly) {
for(int t=0; t<c->type; t++) {
cell *c2 = c->mov[t];
for(int u=0; u<c2->type; u++) {
cell *c3 = c2->mov[u];
if(isWorm(c3)) continue; // immune to Flash
if(c3->monst == moEvilGolem) continue; // evil golems don't count
if(c3 != c && c3->monst) {
bool b = isFriendly(c3) || isBug(c3);
if(friendly ? b: !b) return true;
}
}
}
return false;
}
int monstersnear(cell *c, cell *nocount = NULL, bool shielded = true) {
int res = 0;
bool fast = false;
if(shielded) {
if(items[itOrbShield] > 1) return 0;
fast = (items[itOrbSpeed] && !(items[itOrbSpeed] & 1));
}
for(int t=0; t<c->type; t++) {
cell *c2 = c->mov[t];
// consider monsters who attack from distance 2
if(c2)
if(!thruVine(c, c2)) for(int u=2; u<=c2->type-2; u++) {
cell *c3 = c2->mov[(c->spn[t]+u) % c2->type];
if(!c3) continue;
// only these monsters can attack from two spots...
if(c3->monst != moLancer && c3->monst != moWitchSpeed && c3->monst != moWitchFlash) continue;
// speedwitches can only attack not-fastened monsters,
// others can only attack if the move is not fastened
if(c3->monst == moWitchSpeed && items[itOrbSpeed]) continue;
if(c3->monst != moWitchSpeed && fast) continue;
// cannot attack if the immediate cell is impassable (except flashwitches)
if(c3->monst != moWitchFlash) {
if(!passable(c2, c3, !isArmedEnemy(c2, nocount), false)) continue;
if(c2 == cwt.c && items[itOrbFire]) continue;
}
// flashwitches cannot attack if it would kill another enemy
if(c3->monst == moWitchFlash && flashWouldKill(c3, false)) continue;
if(nocount && mirrorkill(c3)) continue;
res++, which = c3->monst;
}
// consider normal monsters
if(c2 && isArmedEnemy(c2, nocount) && c2->monst != moLancer) {
if(fast && c2->monst != moWitchSpeed) continue;
// they cannot attack through vines
if(attackingForbidden(c, c2))
continue;
// do not count if it would be killed by a mimic
if(nocount && mirrorkill(c2)) continue;
// do not include stabbed enemies
if(
(c2->monst == moHedge || (isKillable(c2) && items[itOrbThorns]))
&& c2->cpdist == 1 && c != cwt.c)
continue;
res++, which = c2->monst;
}
}
return res;
}
// reduce c->mpdist to d; also generate the landscape
bool checkBarriersBack(cellwalker& bb, int q=5);
bool checkBarriersFront(cellwalker& bb, int q=5) {
if(bb.c->mpdist < BARLEV) return false;
if(bb.c->mpdist == BUGLEV) return false;
if(bb.c->bardir != NODIR) return false;
if(bb.spin == 0) {q--; if(!q) return true; }
if(1) for(int i=0; i<7; i++) {
cellwalker bb2 = bb;
cwspin(bb2, i); cwstep(bb2);
if(bb2.c->bardir != NODIR) return false;
cwspin(bb2, 4); cwstep(bb2);
if(bb2.c->bardir != NODIR) return false;
}
cwstep(bb); cwspin(bb, 3); cwstep(bb); cwspin(bb, 3); cwstep(bb);
return checkBarriersBack(bb, q);
}
bool checkBarriersBack(cellwalker& bb, int q) {
// printf("back, %p, s%d\n", bb.c, bb.spin);
if(bb.c->mpdist < BARLEV) return false;
if(bb.c->mpdist == BUGLEV) return false;
if(bb.c->bardir != NODIR) return false;
// if(bb.spin == 0 && bb.c->mpdist == INFD) return true;
if(1) for(int i=0; i<7; i++) {
cellwalker bb2 = bb;
cwspin(bb2, i); cwstep(bb2);
if(bb2.c->bardir != NODIR) return false;
cwspin(bb2, 4); cwstep(bb2);
if(bb2.c->bardir != NODIR) return false;
}
cwspin(bb, 3); cwstep(bb); cwspin(bb, 4);
// bool create = cwstepcreates(bb);
cwstep(bb); cwspin(bb, 3);
// if(create && bb.spin == 0) return true;
return checkBarriersFront(bb, q);
}
void setbarrier(cell *c) {
c->wall = waBarrier;
c->land = laBarrier;
/*if(isHive(c->barleft) && isHive(c->barright))
c->wall = waWaxWall, c->land = c->barleft; */
}
void killIvy(cell *c) {
if(c->monst == moIvyDead) return;
for(int i=0; i<c->type; i++) if(c->mov[i])
if(isIvy(c->mov[i]) && c->mov[i]->mondir == c->spn[i])
killIvy(c->mov[i]);
c->monst = moIvyDead;
}
int buildIvy(cell *c, int children, int minleaf) {
c->mondir = NODIR;
c->monst = moIvyRoot;
cell *child = NULL;
int leaf = 0;
int leafchild = 0;
for(int i=0; i<c->type; i++) {
createMov(c, i);
if(passable(c->mov[i], c, false, false)) {
if(children && !child)
child = c->mov[i], leafchild = buildIvy(c->mov[i], children-1, 5);
else
c->mov[i]->monst = (leaf++) ? moIvyWait : moIvyHead,
c->mov[i]->mondir = c->spn[i];
}
}
leaf += leafchild;
if(leaf < minleaf) {
if(child) killIvy(child);
killIvy(c);
return 0;
}
else return leaf;
}
bool isIcyWall(cell *c) {
return c->wall == waNone || c->wall == waIcewall || c->wall == waFrozenLake || c->wall == waLake;
}
bool destroyHalfvine(cell *c, eWall newwall = waNone, int tval = 6);
void killMonster(cell *c);
void prespill(cell* c, eWall t, int rad) {
// these monsters block spilling
if(c->monst == moSeep || c->monst == moVineSpirit || c->monst == moShark ||
c->monst == moGreaterShark)
return;
// turn statues into Slimes!
if(c->wall == waBigStatue && t != waNone) {
c->wall = waNone;
c->monst = moSlimeNextTurn;
}
// slimedeath spill
if((c->monst == moSlime || c->monst == moSlimeNextTurn) && t == waNone) {
c->wall = waNone; killMonster(c);
}
// these walls block spilling completely
if(c->wall == waIcewall || c->wall == waBarrier || c->wall == waDeadTroll ||
c->wall == waDune || c->wall == waAncientGrave || c->wall == waThumper ||
c->wall == waFreshGrave || c->wall == waColumn || c->wall == waPartialFire ||
c->wall == waDeadwall || c->wall == waWaxWall || c->wall == waCamelot || c->wall == waRoundTable ||
c->wall == waBigStatue)
return;
// 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 == waDryTree || c->wall == waWetTree || c->wall == waTemporary ||
c->wall == waVinePlant || c->wall == waBonfire || c->wall == waVineHalfA || c->wall == waVineHalfB ||
c->wall == waCamelotMoat)
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->mov[i] && c->mov[i]->wall == waSulphurC)
c->mov[i]->wall = waSulphur;
}
destroyHalfvine(c);
c->wall = t;
// destroy items...
c->item = itNone;
// block spill
if(t == waTemporary) return;
// cwt.c->item = itNone;
if(rad) for(int i=0; i<c->type; i++) if(c->mov[i])
prespill(c->mov[i], t, rad-1);
}
void spillfix(cell* c, eWall t, int rad) {
if(c->wall == waTemporary) c->wall = t;
if(rad) for(int i=0; i<c->type; i++) if(c->mov[i])
spillfix(c->mov[i], t, rad-1);
}
void spill(cell* c, eWall t, int rad) {
prespill(c,t,rad); spillfix(c,t,rad);
}
void degradeDemons() {
addMessage(XLAT("You feel more experienced in demon fighting!"));
int dcs = size(dcal);
for(int i=0; i<dcs; i++) {
cell *c = dcal[i];
if(c->monst == moGreaterM || c->monst == moGreater)
achievement_gain("DEMONSLAYER");
if(c->monst == moGreaterM) c->monst = moLesserM;
if(c->monst == moGreater) c->monst = moLesser;
}
}
void ivynext(cell *c);
void earthFloor(cell *c) {
if(c->monst) return;
if(c->wall == waDeadwall) c->wall = waDeadfloor;
if(c->wall == waDune) c->wall = waNone;
if(c->wall == waAncientGrave || c->wall == waFreshGrave) c->wall = waNone;
}
void earthWall(cell *c) {
if(c->wall == waDeadfloor || c->wall == waDeadfloor2 || c->wall == waEarthD) {
c->item = itNone;
c->wall = waDeadwall;
}
if(c->wall == waNone && c->land == laDesert) {
c->item = itNone;
c->wall = waDune;
}
}
bool isWitch(eMonster m) {
// evil golems don't count
return m >= moWitch && m < moWitch+NUMWITCH-1;
}
void killMonster(cell *c) {
DEB("killmonster");
eMonster m = c->monst;
if(!m) return;
if(isWorm(c)) return;
if(m == moShadow) return;
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;
kills[m]++;
if(m == moTroll) {
destroyHalfvine(c);
c->wall = cellUnstableOrChasm(c) ? waChasm : waDeadTroll;
c->item = itNone;
for(int i=0; i<c->type; i++) if(c->mov[i]) {
c->mov[i]->item = itNone;
if(c->mov[i]->wall == waDeadwall || c->mov[i]->wall == waDeadfloor2) c->mov[i]->wall = waCavewall;
if(c->mov[i]->wall == waDeadfloor) c->mov[i]->wall = waCavefloor;
}
}
if(m == moMiner) {
destroyHalfvine(c);
c->wall = cellUnstableOrChasm(c) ? waChasm : waNone;
for(int i=0; i<c->type; i++) if(passable(c->mov[i], c, true, true)) {
destroyHalfvine(c->mov[i]);
c->mov[i]->wall = cellUnstableOrChasm(c) ? waChasm : waNone;
if(c->mov[i]->monst == moSlime || c->mov[i]->monst == moSlimeNextTurn)
killMonster(c->mov[i]);
}
}
if(m == moVineBeast) {
destroyHalfvine(c);
c->wall = cellUnstableOrChasm(c) ? waChasm : waVinePlant;
c->item = itNone;
}
if(m == moVineSpirit) {
destroyHalfvine(c);
c->wall = waNone;
}
if(isWitch(m) && (c->wall == waBonfire || passable(c, NULL, true, false)) && !c->item) {
if(m == moWitchFire) c->item = itOrbFire;
if(m == moWitchFlash) c->item = itOrbFlash;
if(m == moWitchGhost) c->item = itOrbGhost;
if(m == moWitchWinter) c->item = itOrbWinter;
if(m == moWitchSpeed) c->item = itOrbSpeed;
if(c->wall == waBonfire && itemBurns(c->item))
c->item = itNone;
}
if(m == moFireFairy) {
c->wall = cellUnstableOrChasm(c) ? waChasm : waBonfire;
c->item = itNone, c->tmp = 50;
}
if(m == moPyroCultist && c->item == itNone && c->wall != waChasm) {
// a reward for killing him before he shoots!
c->item = itOrbDragon;
}
if(m == moSlime) { 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) c->heat += 3;
if(m == moPyroCultist) c->heat += 6;
if(m == moLesser) c->heat += 10;
}
if(m == moLesser && !(kills[m] % 10))
degradeDemons();
if(isIvy(c)) {
eMonster m = c->monst;
/*if((m == moIvyBranch || m == moIvyHead) && c->mov[c->mondir]->monst == moIvyRoot)
ivynext(c, moIvyNext); */
killIvy(c);
if(m == moIvyBranch || m == moIvyHead || m == moIvyNext) {
int qty = 0;
cell *c2 = c->mov[c->mondir];
for(int i=0; i<c2->type; i++)
if(c2->mov[i]->monst == moIvyWait && c2->mov[i]->mondir == c2->spn[i])
qty++;
if(c->mov[c->mondir]->monst == moIvyRoot || qty) {
c->monst = moIvyNext;
/* c->monst = moIvyHead;
ivynext(c);
if(c->monst == moIvyHead) c->monst = moIvyNext;
else c->monst = moNone; */
}
else {
c->mov[c->mondir]->monst = moIvyHead;
}
}
}
else c->monst = moNone;
if(m == moEarthElemental) earthWall(c);
}
void burnMonstersAndItems(cell *c, int val, eWall firetype = waBonfire) {
if(itemBurns(c->item))
addMessage(XLAT("%The1 burns!", c->item)), c->item = itNone;
if(c->monst && c->monst != moGhost && !isWorm(c) && c->monst != moShadow) {
addMessage(XLAT("%The1 burns!", c->monst));
killMonster(c);
}
c->tmp = val;
c->wall = firetype;
}
void flameHalfvine(cell *c, int val) {
burnMonstersAndItems(c, val);
c->wall = waPartialFire;
}
bool destroyHalfvine(cell *c, eWall newwall, int tval) {
if(cellHalfvine(c)) {
for(int t=0; t<c->type; t++) if(c->mov[t]->wall == c->wall) {
if(newwall == waPartialFire) burnMonstersAndItems(c->mov[t], tval, newwall);
else c->mov[t]->wall = newwall;
}
if(newwall == waPartialFire) burnMonstersAndItems(c, tval, newwall);
else c->wall = newwall;
return true;
}
return false;
}
bool orbChance(cell *c, eLand usual, int chthere, int chcross) {
if(c->land == usual) return chthere && rand() % chthere == 0;
if(chcross && c->land == laCrossroads) {
chcross = (chcross / 50) * (50 + items[itHyperstone]);
return rand() % chcross == 0;
}
return false;
}
void buildBarrier(cell *c) {
// printf("build barrier at %p", c);
if(c->wall == waBarrier) {
// printf("-> ready\n");
return;
}
// if(c->wall == waWaxWall) return;
if(c->mpdist > BARLEV) {
// printf("-> too far\n");
return; // == INFD) return;
}
cellwalker bb(c, c->bardir); setbarrier(bb.c);
cwstep(bb);
bb.c->barleft = c->barright;
bb.c->barright = c->barleft;
setbarrier(bb.c);
cwspin(bb, 2); cwstep(bb); bb.c->land = c->barleft; cwstep(bb);
cwspin(bb, 2); cwstep(bb); bb.c->land = c->barright; cwstep(bb);
cwspin(bb, 2);
cwspin(bb, 3); cwstep(bb);
bb.c->barleft = c->barright;
bb.c->barright = c->barleft;
setbarrier(bb.c);
cwspin(bb, 3); cwstep(bb);
bb.c->bardir = bb.spin;
bb.c->barleft = c->barright;
bb.c->barright = c->barleft;
// printf("#1\n");
buildBarrier(bb.c);
for(int a=-3; a<=3; a++) if(a) {
bb.c = c; bb.spin = c->bardir; cwspin(bb, a); cwstep(bb);
bb.c->land = a > 0 ? c->barright : c->barleft;
}
bb.c = c; bb.spin = c->bardir;
cwspin(bb, 3); cwstep(bb); cwspin(bb, 4); bb.c->land = c->barright; cwstep(bb); cwspin(bb, 3);
bb.c->bardir = bb.spin;
bb.c->barleft = c->barright;
bb.c->barright = c->barleft;
// printf("#2\n");
buildBarrier(bb.c);
}
void chasmify(cell *c) {
c->wall = waChasm; c->item = itNone;
int q = 0;
cell *c2[10];
for(int i=0; i<c->type; i++) if(c->mov[i] && c->mov[i]->mpdist > c->mpdist && cellUnstable(c->mov[i]))
c2[q++] = c->mov[i];
if(q) {
cell *c3 = c2[rand() % q];
c3->wall = waChasmD;
}
}
void chasmifyEarth(cell *c) {
int q = 0;
int d2[10];
for(int i=2; i<=c->type-2; i++) {
int j = (i+c->mondir)%c->type;
cell *c2 = c->mov[j];
if(c2 && c2->mpdist > c->mpdist && (
c2->wall == waDeadfloor || c2->wall == waDeadwall ||
c2->wall == waDeadfloor2))
d2[q++] = j;
}
if(!q) printf("no further move!\n");
if(q) {
int d = d2[rand() % q];
cell *c3 = c->mov[d];
c3->wall = waEarthD;
for(int i=0; i<c3->type; i++) {
cell *c4 = createMov(c3, i);
earthFloor(c4);
}
c3->mondir = c->spn[d];
}
earthWall(c); c->item = itNone;
}
eLand getNewLand(eLand old) {
eLand tab[32];
int cnt = 0;
/* if(isHive(old) && rand() % 100 < 90) {
eLand n = old;
while(n == old) n = eLand(laHive0 + rand() % 3);
return n;
} */
// return (rand() % 2) ? laMotion : laJungle;
// the basic lands, always available
tab[cnt++] = laCrossroads;
tab[cnt++] = laIce;
tab[cnt++] = laDesert;
tab[cnt++] = laJungle;
if(old != laDeadCaves) tab[cnt++] = laCaves;
// the advanced lands
if(gold() >= 30) {
tab[cnt++] = laCrossroads;
tab[cnt++] = laAlchemist;
tab[cnt++] = laMirror;
tab[cnt++] = laMotion;
}
if(gold() >= 60) {
tab[cnt++] = laCrossroads;
tab[cnt++] = laRlyeh;
if(old != laDeadCaves && items[itGold] >= 5 && items[itFernFlower] >= 5) tab[cnt++] = laFjord;
if(old != laPower) tab[cnt++] = laDryForest;
if(old != laPower) tab[cnt++] = laWineyard;
if(old != laCaves && old != laFjord && items[itGold] >= 10) tab[cnt++] = laDeadCaves;
}
if(tkills() >= 100) {
tab[cnt++] = laGraveyard;
if(gold() >= 60) tab[cnt++] = laHive;
}
if(hellUnlocked()) {
tab[cnt++] = laCrossroads;
tab[cnt++] = laHell;
}
if(items[itHell] >= 10) {
tab[cnt++] = laCocytus;
if(old != laWineyard && old != laDryForest) tab[cnt++] = laPower;
}
eLand n = old;
while(n == old) n = tab[rand() % cnt];
return n;
}
bool notDippingFor(eItem i) {
int v = items[i] - currentLocalTreasure;
if(v <= 10) return true;
if(v >= 20) return false;
return v >= rand() % 10 + 10;
}
bool notDippingForExtra(eItem i, eItem x) {
int v = items[i] - min(items[x], currentLocalTreasure);
if(v <= 10) return true;
if(v >= 20) return false;
return v >= rand() % 10 + 10;
}
eLand euland[65536];
eLand switchable(eLand nearland, eLand farland, eucoord c) {
if(nearland == laCrossroads) {
if(rand() % 4 == 0 && (short(c)%3==0))
return laBarrier;
return laCrossroads;
}
else if(nearland == laBarrier) {
return getNewLand(farland);
}
else {
if(rand() % 20 == 0 && (short(c)%3==0))
return laBarrier;
return nearland;
}
}
eLand getEuclidLand(eucoord c) {
if(euland[c]) return euland[c];
if(c == 0 || c == eucoord(-1) || c == 1)
return euland[c] = laCrossroads;
if(euland[eucoord(c-2)] && ! euland[eucoord(c-1)]) getEuclidLand(c-1);
if(euland[eucoord(c+2)] && ! euland[eucoord(c+1)]) getEuclidLand(c+1);
if(euland[eucoord(c-1)]) return
euland[c] = switchable(euland[c-1], euland[eucoord(c-2)], c);
if(euland[eucoord(c+1)]) return
euland[c] = switchable(euland[c+1], euland[eucoord(c+2)], c);
return euland[c] = laCrossroads;
}
void createBugArmy(cell *c);
int newRoundTableRadius() {
return 28 + 2 * items[itHolyGrail];
}
int roundTableRadius(cell *c) {
if(euclid) return 28;
return c->master->alt->alt->fjordval & GRAIL_RADIUS_MASK;
}
bool grailWasFound(cell *c) {
if(euclid) return items[itHolyGrail];
return c->master->alt->alt->fjordval & GRAIL_FOUND;
}
int euclidAlt(short x, short y) {
if(euclidland == laTemple) {
return max(int(x), x+y);
}
else return eudist(x-20, y-10);
}
int celldistAltRelative(cell *c) {
return celldistAlt(c) - roundTableRadius(c);
}
heptagon *createAlternateMap(cell *c, int rad, hstate firststate);
void generateAlts(heptagon *h);
void buildCamelotWall(cell *c) {
c->wall = waCamelot;
for(int i=0; i<c->type; i++) {
cell *c2 = createMov(c, i);
if(c2->wall == waNone && celldistAlt(c2) > celldistAlt(c) && c2->monst == moNone)
c2->wall = waCamelotMoat;
}
}
// This function generates all lands. Warning: it's very long!
void setdist(cell *c, int d, cell *from) {
DEB("setdist");
if(signed(c->mpdist) <= d) return;
c->mpdist = d;
if(d >= BARLEV) {
if(!c->land) c->land = from->land;
if(c->land == laTemple) c->land = laRlyeh;
if(c->land == laCamelot) c->land = laCrossroads;
if(euclid) {
c->land = euclidland;
if(euclidland == laCrossroads) {
eucoord x, y;
decodeMaster(c->master, x, y);
c->land = getEuclidLand(y+2*x);
}
}
}
if(d == BARLEV && !euclid) {
if(c->type == 7 && rand() % 10000 < (
showoff ? (cwt.c->mpdist > 7 ? 0 : 10000) :
c->land == laCrossroads ? 5000 : 50) &&
c->land != laGameBoard) {
int bd = 2 + (rand() % 2) * 3;
cellwalker bb(c, bd);
cellwalker bb2 = bb;
if(checkBarriersFront(bb) && checkBarriersBack(bb2)) {
c->bardir = bd;
eLand oldland = c->land;
eLand newland = getNewLand(oldland);
if(showoff) newland = showlist[(showid++) % 10];
landcount[newland]++;
if(bd == 5) c->barleft = oldland, c->barright = newland;
else c->barleft = newland, c->barright = oldland;
}
}
if(c->land == laCrossroads && c->type == 7 && rand() % 2000 < 200 && items[itEmerald] >= 5) {
int rtr = newRoundTableRadius();
heptagon *alt = createAlternateMap(c, rtr+14, hsOrigin);
if(alt) {
alt->fjordval = rtr;
}
}
if(c->land == laRlyeh && c->type == 7 && rand() % 2000 < 100 && items[itStatue] >= 5)
createAlternateMap(c, 2, hsA);
if(c->bardir != NODIR && c->bardir != NOBARRIERS)
buildBarrier(c);
}
if(d < 10) {
explore[d]++;
exploreland[d][c->land]++;
if(d < BARLEV)
for(int i=0; i<c->type; i++) {
createMov(c, i);
setdist(c->mov[i], d+1, c);
}
if(d==8 && c->land == laFjord) {
if(euclid) {
eucoord x, y;
decodeMaster(c->master, x, y);
if(((y-2)&7) < 4) c->wall = waCavewall;
else c->wall = waCavefloor;
}
else {
int v = fjordval(c);
if((v&3) >= 2)
c->wall = waCavewall;
else c->wall = waCavefloor;
}
}
if(d==8 && c->land == laPower) {
int v;
if(euclid) {
eucoord x, y;
decodeMaster(c->master, x, y);
int y0 = ((short)y) % 6;
if(y0<0) y0+=6;
if(y0 == 3 || y0 == 4) v=24; else v=0;
}
else v = fjordval(c);
v &= ~3;
if((v == 24 || v == 32 || v == 56))
c->wall = waBonfire, c->tmp = 9;
else if(rand() % 100 < 10) {
c->wall = waGlass;
eItem protectedItems[17] = {
itPower, itPower, itPower, itPower, itPower, itPower,
itOrbLightning, itOrbLightning, itOrbThorns, itOrbThorns,
itOrbInvis, itOrbInvis,
itOrbShield, itOrbTeleport, itOrbPsi,
itOrbDragon, itOrbIllusion
};
c->item = protectedItems[rand() % 17];
}
}
if(d==8 && c->land == laWineyard) {
if(euclid) {
eucoord x, y;
decodeMaster(c->master, x, y);
int dy = ((short)y)%3; if(dy<0) dy += 3;
if(dy == 1) c->wall = waVinePlant;
}
else {
int v = fjordval(c);
int w = v / 4;
if(w == 9 || w == 10 || w == 7 || w == 8) {
c->wall = waVinePlant;
}
else if(v == 24 || v == 58 || v == 26 || v == 56)
c->wall = waVineHalfA;
else if(v == 25 || v == 59 || v == 27 || v == 57)
c->wall = waVineHalfB;
else c->wall = waNone;
}
}
if(d == 7 && cellHalfvine(c)) {
int i = -1;
for(int k=0; k<c->type; k++) if(c->mov[k] && c->mov[k]->wall == c->wall)
i = 0;
if(i == -1) c->wall = waNone;
}
// 24-58
// 26-56
if(d == 9) {
// if(c->land == laIce && ((celldist(c) % 10) + 10) % 10 == 5)
// c->wall = waColumn;
if(c->land == laIce) if(rand() % 100 < 5 && c->wall != waBarrier) {
c->wall = waIcewall;
for(int i=0; i<c->type; i++) if(rand() % 100 < 50) {
createMov(c, i);
setdist(c->mov[i], d+1, c);
cell *c2 = c->mov[i];
if(c2->wall == waBarrier || c2->land != laIce) continue;
c2->wall = waIcewall;
for(int j=0; j<c2->type; j++) if(rand() % 100 < 20) {
createMov(c2, j);
setdist(c->mov[i], d+2, c);
cell *c3 = c2->mov[j];
if(c3->wall == waBarrier || c3->land != laIce) continue;
c3->wall = waIcewall;
}
}
}
if(c->land == laIce || c->land == laCocytus) if(c->wall == waIcewall && items[itDiamond] >= 5 && rand() % 200 == 1)
c->wall = waBonfire, c->tmp = -1;;
if(c->land == laCaves)
c->wall = rand() % 100 < 55 ? waCavewall : waCavefloor;
if(c->land == laDeadCaves) {
int i = rand() % 100;
if(i<50) c->wall = waDeadwall;
else if(i<55) c->wall = waDeadfloor2;
else c->wall = waDeadfloor;
}
if(c->land == laAlchemist)
c->wall = rand() % 2 ? waFloorA : waFloorB;
if(c->land == laDryForest)
c->wall = rand() % 100 < 50 ? (rand() % 100 < 50 ? waDryTree : waWetTree) :
waNone;
if(c->land == laGraveyard && ishept(c))
c->wall = rand() % 5 ? waAncientGrave : waFreshGrave;
if(c->land == laRlyeh) {
if(rand() % 500 < 5) {
for(int i=0; i<c->type; i++) {
createMov(c, i);
setdist(c->mov[i], d+1, c);
if(c->mov[i] && c->mov[i]->land == laRlyeh)
c->mov[i]->wall = waColumn;
}
for(int j=0; j<2; j++) {
int i = rand() % c->type;
if(c->mov[i] && c->mov[i]->land == laRlyeh)
c->mov[i]->wall = waNone;
}
}
if(ishept(c) && rand() % 2) c->wall = waColumn;
}
if(c->land == laHell) {
if(rand() % 100 < 4) {
for(int i=0; i<c->type; i++) {
createMov(c, i);
setdist(c->mov[i], d+1, c);
if(c->mov[i] && c->mov[i]->land == laHell)
if(c->mov[i]->wall != waSulphurC)
c->mov[i]->wall = waSulphur;
}
c->wall = waSulphurC;
}
}
if(c->land == laCocytus) {
if(c->wall == waNone) c->wall = waFrozenLake;
if(rand() % 100 < 5) {
for(int i=0; i<c->type; i++) {
createMov(c, i);
setdist(c->mov[i], d+1, c);
if(c->mov[i] && c->mov[i]->land == laCocytus)
c->mov[i]->wall = waLake;
}
c->wall = waLake;
if(rand() % 500 < 100 + 2 * (items[itSapphire]))
c->monst = moShark;
}
}
if(isHive(c->land) && rand() % 2000 < 2)
createBugArmy(c);
if((c->land == laCrossroads && !euclid) || c->land == laCamelot)
if(euclid || c->master->alt) {
int d = celldistAltRelative(c);
{
eucoord x,y;
decodeMaster(c->master, x, y);
}
if(d <= 14) {
if(!euclid) generateAlts(c->master);
c->bardir = NOBARRIERS;
int d = celldistAltRelative(c);
if(d == 10) {
if(ishept(c)) buildCamelotWall(c);
else {
if(!euclid) for(int i=0; i<7; i++) generateAlts(c->master->move[i]);
int q = 0;
for(int t=0; t<6; t++) {
createMov(c, t);
if(celldistAltRelative(c->mov[t]) == 10 && !ishept(c->mov[t])) q++;
}
if(q == 1) buildCamelotWall(c);
// towers of Camelot
if(q == 0) {
c->monst = moKnight;
for(int i=0; i<6; i++)
buildCamelotWall(c->mov[i]);
for(int i=0; i<c->type; i++) if(celldistAltRelative(c->mov[i]) < d)
c->mondir = i;
}
}
}
if(d == 0) c->wall = waRoundTable;
if(celldistAlt(c) == 0) c->item = itHolyGrail;
if(d < 0 && rand() % 7000 <= 10 + items[itHolyGrail] * 5) {
eMonster m[3] = { moHedge, moLancer, moFlailer };
c->monst = m[rand() % 3];
}
if(d == 1) {
// roughly as many knights as table cells
if(rand() % 1720 < 1000)
c->monst = moKnight;
if(!euclid) for(int i=0; i<7; i++) generateAlts(c->master->move[i]);
for(int i=0; i<c->type; i++)
if(c->mov[i] && celldistAltRelative(c->mov[i]) < d)
c->mondir = (i+3) % 6;
}
if(d <= 10) c->land = laCamelot;
if(d > 10 && !euclid) c->land = laCrossroads;
}
}
if((c->land == laRlyeh && !euclid) || c->land == laTemple) {
if(euclid || (c->master->alt && c->master->alt->distance <= 2)) {
if(!euclid) generateAlts(c->master);
c->bardir = NOBARRIERS;
int d = celldistAlt(c);
if(d <= 0) {
c->land = laTemple, c->wall = waNone, c->monst = moNone, c->item = itNone;
}
if(d % TEMPLE_EACH==0) {
if(ishept(c))
c->wall = waColumn;
else {
if(!euclid) for(int i=0; i<7; i++) generateAlts(c->master->move[i]);
int q = 0;
for(int t=0; t<6; t++) {
createMov(c, t);
if(celldistAlt(c->mov[t]) % TEMPLE_EACH == 0 && !ishept(c->mov[t])) q++;
}
if(q == 2) c->wall = waColumn;
}
}
}
}
if(isHive(c->land) && rand() % 2000 < 100 && !c->wall && !c->item && !c->monst) {
int nww = 0;
for(int i=0; i<c->type; i++) if(c->mov[i] && c->mov[i]->wall == waWaxWall)
nww++;
if(nww == 0) {
c->wall = waWaxWall;
c->monst = moNone;
c->heat = rand() & 0xFFFFFF;
}
/* for(int i=0; i<c->type; i++) {
if(rand() % 6 < 5) {
createMov(c,i);
cell *c2 = c->mov[i];
c2->wall = waWaxWall;
c2->monst = moNone;
}
} */
}
if(c->land == laDesert) {
if(rand() % 100 < 5) {
for(int i=0; i<c->type; i++) {
createMov(c, i);
setdist(c->mov[i], d+1, c);
if(c->mov[i] && c->mov[i]->land == laDesert)
c->mov[i]->wall = waDune;
}
for(int j=0; j<2; j++) {
int i = rand() % c->type;
if(c->mov[i] && c->mov[i]->land == laDesert)
c->mov[i]->wall = waNone;
}
}
if(rand() % 300 == 1 && items[itSpice] >= 5)
c->wall = waThumper, c->tmp = -1;
}
}
if(d == 7 && c->land == laCaves && c->wall == waCavewall && rand() % 5000 < items[itGold])
c->monst = moSeep;
if(d == 7 && c->land == laFjord && c->wall == waCavewall && rand() % 5000 < items[itEmerald])
c->monst = moSeep;
if(d == 7 && c->land == laDeadCaves && c->wall == waDeadwall && rand() % 1000 < items[itSilver])
c->monst = moSeep;
if(d == 7 && c->wall == waVinePlant && rand() % 100 < 10)
c->monst = moVineSpirit;
// repair the buggy walls flowing in from another land, like ice walls flowing into the Caves
if(d == 7 && c->land == laCaves && c->wall != waCavewall && c->wall != waCavefloor)
c->wall = waCavefloor;
if(d == 7 && c->land == laDeadCaves && c->wall != waDeadwall &&
c->wall != waDeadfloor && c->wall != waDeadfloor2 && c->wall != waEarthD)
c->wall = waDeadfloor2;
if(d == 7 && c->land == laCocytus && c->wall != waFrozenLake && c->wall != waLake && c->wall != waIcewall)
c->wall = waFrozenLake;
if(d == 7 && c->land == laAlchemist && c->wall != waFloorA && c->wall != waFloorB)
c->wall = waFloorA;
if(d == 7 && c->wall == waIcewall && c->land != laIce && c->land != laCocytus)
c->wall = waNone;
if(d == 7 && c->wall == waChasmD) {
chasmify(c);
}
if(d == 7 && c->wall == waEarthD) {
chasmifyEarth(c);
}
// seal entrances to the Land of Power.
if(d == 7 && c->land == laPower && c->type == 7) {
bool onwall = false;
for(int i=0; i<7; i++) if(c->mov[i] && c->mov[i]->land != laPower)
onwall = true;
if(!onwall) for(int i=0; i<7; i++) {
cell *c2 = c->mov[i];
cell *c3 = c2->mov[(c->spn[i] + 3) % 6];
if(c3->land != laPower && c3->land != laBarrier)
if(c2->wall != waBonfire && c2->wall != waGlass) {
if(c->wall == waBonfire) c->monst = moWitchWinter;
else if(c->wall == waGlass) c->monst = moWitchGhost;
else c->monst = moEvilGolem;
}
}
}
if(d == 7 && passable(c, NULL, false, false)) {
if(c->land == laBarrier) c->wall = waBarrier;
}
if(d == 7 && passable(c, NULL, false, false) && !safety) {
int hard = items[itOrbYendor] * 5;
if(c->land == laIce) {
if(rand() % 5000 < 100 + 2 * (kills[moYeti] + kills[moWolf]) && notDippingFor(itDiamond))
c->item = itDiamond;
if(rand() % 8000 < 2 * (items[itDiamond] + hard))
c->monst = rand() % 2 ? moYeti : moWolf;
}
if(c->land == laCaves) {
if(rand() % 5000 < 100 + 2 * (kills[moTroll] + kills[moGoblin]) && notDippingFor(itGold))
c->item = itGold;
if(rand() % 8000 < 10 + 2 * (items[itGold] + hard))
c->monst = rand() % 2 ? moTroll : moGoblin;
}
if(c->land == laDeadCaves) {
if(rand() % 5000 < 100 + 2 * (kills[moDarkTroll] + kills[moEarthElemental]) && notDippingFor(itSilver))
c->item = itSilver;
if(rand() % 16000 < (items[itSilver] + hard)) {
c->monst = moEarthElemental;
for(int i=0; i<c->type; i++) {
cell *c2 = c->mov[i];
earthFloor(c2);
}
for(int i=0; i<c->type; i++) if(c->mov[i]->mpdist < c->mpdist) c->mondir = i;
chasmifyEarth(c); c->wall = waDeadfloor2;
}
else if(rand() % 8000 < 60 + 8 * (items[itSilver] + hard)) {
if(rand() % 100 < 25) {
}
else c->monst = rand() % 2 ? moDarkTroll : moGoblin;
}
}
if(c->land == laDesert) {
if(rand() % 5000 < 100 + 2 * (kills[moWorm] + kills[moDesertman]) && notDippingFor(itSpice))
c->item = itSpice;
if(rand() % 8000 < 10 + 2 * (items[itSpice] + hard))
c->monst = rand() % 2 ? moWorm : moDesertman,
c->mondir = NODIR;
}
if(c->land == laWineyard) {
if(rand() % 5000 < 100 + 2 * (kills[moVineBeast] + kills[moVineSpirit]) && notDippingFor(itWine))
c->item = itWine;
if(rand() % 8000 < 12 * (items[itWine] + hard))
c->monst = moVineBeast;
}
if(c->land == laFjord) {
if(rand() % 1000 < 100 + 2 * (kills[moMiner] + kills[moLancer] + kills[moFlailer]) && notDippingFor(itEmerald)) {
// do not destroy walls!
bool ok = true;
for(int i=0; i<c->type; i++) if(c->mov[i]->wall == waCavewall) ok = false;
if(ok) c->item = itEmerald;
}
if(rand() % 8000 < 50 + 10 * (items[itEmerald] + hard)) {
static eMonster fjordmonsters[4] = { moHedge, moLancer, moFlailer, moMiner };
c->monst = fjordmonsters[rand() % 4];
}
}
if(c->land == laJungle) {
if(rand() % 5000 < 25 + 2 * (kills[moIvyRoot] + kills[moMonkey]) && notDippingFor(itRuby))
c->item = itRuby;
if(rand() % 15000 < 5 + 1 * (items[itRuby] + hard))
c->monst = moMonkey;
else if(rand() % 80000 < 5 + items[itRuby] + hard)
c->monst = moEagle;
else if(ishept(c) && rand() % 4000 < 300 + items[itRuby]) {
bool hard = rand() % 100 < 25;
if(hard ? buildIvy(c, 1, 9) : buildIvy(c, 0, c->type))
c->item = itRuby;
}
}
if(c->land == laAlchemist) {
if(rand() % 5000 < 25 + min(kills[moSlime], 200) && notDippingFor(itElixir))
c->item = itElixir;
else if(rand() % 3500 < 10 + items[itElixir] + hard)
c->monst = moSlime;
}
if(c->land == laPower) {
if(rand() % (5000+50*items[itPower]) < 1200) {
eItem powerorbs[6] = {
itOrbFlash, itOrbSpeed, itOrbFire, itOrbWinter, itOrbGhost, itOrbLife};
c->item = powerorbs[rand() % 6];
}
else if(c->type == 6 && rand() % 5000 < 10)
c->wall = rand() % 2 ? waMirror : waCloud;
else if(rand() % 1000 < 10 + (items[itPower] ? 10:0) + (items[itPower] + hard))
c->monst = eMonster(moWitch + rand() % NUMWITCH);
}
if(c->land == laCrossroads) {
if(c->type == 6 && rand() % 8000 < 120 && items[itShard] >= 10)
c->wall = rand() % 2 ? waMirror : waCloud;
else if(hyperstonesUnlocked() && rand() % 5000 < tkills() && notDippingFor(itHyperstone))
c->item = itHyperstone;
else if(rand() % 4000 < items[itHyperstone] + 2 * items[itHolyGrail]) {
// only interesting monsters here!
static eMonster m[14] = {
moWorm, moTroll, moEagle,
moLesser, moGreater, moPyroCultist, moGhost,
moFireFairy, moIvyRoot, moTentacle, moHedge,
moLancer, moFlailer, moVineBeast
};
eMonster cm = m[rand() % 14];
if(cm == moIvyRoot) buildIvy(c, 0, c->type);
else c->monst = cm;
if(cm == moWorm || cm == moTentacle)
c->mondir = NODIR;
}
}
if(c->land == laMirror) {
if(c->type == 6 && rand() % 5000 < 120 && notDippingFor(itShard))
c->wall = rand() % 2 ? waMirror : waCloud;
if(rand() % 12000 < 8 + items[itShard] + hard)
c->monst = moRanger;
else if(rand() % 60000 < 8 + items[itShard] + hard)
c->monst = moEagle;
}
if(c->land == laGraveyard) {
if(rand() % 5000 < 30 + 2 * (kills[moZombie] + kills[moGhost] + kills[moNecromancer]) && notDippingFor(itBone))
c->item = itBone;
if(rand() % 20000 < 10 + items[itBone] + hard + (kills[moZombie] + kills[moGhost] + kills[moNecromancer])/60) {
eMonster grm[6] = { moZombie, moZombie, moZombie, moGhost, moGhost, moNecromancer};
c->monst = grm[rand() % 6];
}
}
if(c->land == laRlyeh) {
if(rand() % 5000 < 30 + 2 * (kills[moCultist] + kills[moTentacle] + kills[moPyroCultist]) && notDippingFor(itStatue))
c->item = itStatue;
if(rand() % 8000 < 5 + items[itStatue] + hard)
c->monst = moTentacle, c->item = itStatue, c->mondir = NODIR;
else if(rand() % 12000 < 5 + items[itStatue] + hard)
c->monst = rand() % 3 ? ((rand() % 40 < items[itStatue]-25) ? moCultistLeader : moCultist) : moPyroCultist;
else if(rand() % 8000 < 5 + items[itStatue] + hard && c->type == 6) {
for(int t=0; t<c->type; t++) {
if(c->mov[t] && c->mov[t]->monst == moNone && (c->wall == waNone || c->wall == waColumn))
c->mov[t]->wall = ishept(c->mov[t]) ? waColumn : waNone;
if(c->mov[t]->wall == waColumn)
c->mov[t]->item = itNone;
}
if(buildIvy(c, 0, 3)) c->item = itStatue;
}
}
if(c->land == laTemple) {
// depth!
int d = celldistAlt(c);
// remember: d is negative
if(d % TEMPLE_EACH == 0) {
if(rand() % 5000 < 20 - 2*d)
c->monst = moTentacle, c->mondir = NODIR;
}
else {
int d0 = d % TEMPLE_EACH;
if(d0<0) d0=-d0;
if(rand() % 100 < 30) // && d0 != 1 && d0 != TEMPLE_EACH-1)
c->wall = waBigStatue;
else if(rand() % 20000 < -d)
c->monst = rand() % 3 ? moCultist : moPyroCultist;
else if(rand() % 100000 < -d)
c->monst = moCultistLeader;
else if(rand() % 5000 < 250)
c->item = itGrimoire;
else if(rand() % 5000 < 10 && -d > TEMPLE_EACH * 10)
c->item = itOrbDragon;
}
}
if(c->land == laDryForest) {
if(rand() % 5000 < 100 + 2 * (kills[moFireFairy]*2 + kills[moHedge]) && notDippingFor(itFernFlower))
c->item = itFernFlower;
if(rand() % 4000 < 40 + items[itFernFlower] + hard)
c->monst = moHedge;
else if(rand() % 8000 < 2 * items[itFernFlower] + hard)
c->monst = moFireFairy;
}
if(c->land == laHell) {
if(rand() % 1500 < 30 + (kills[moCultist] + kills[moTentacle]) && notDippingFor(itHell))
c->item = itHell;
if(rand() % 8000 < 40 + items[itHell] + hard)
c->monst = moLesser;
else if(rand() % 24000 < 40 + items[itHell] + hard)
c->monst = moGreater;
}
if(c->land == laCocytus) {
if(rand() % 5000 < 100 + 2 * (kills[moShark] + kills[moGreaterShark] + kills[moCrystalSage]) && notDippingFor(itSapphire))
c->item = itSapphire;
if(rand() % 5000 < 2 * (items[itSapphire] + hard)) {
eMonster ms[3] = { moYeti, moGreaterShark, moCrystalSage };
c->monst = ms[rand() % 3];
if(c->monst == moGreaterShark) c->wall = waLake;
}
}
if(c->land == laMotion) {
if(rand() % 1500 < 30 + (kills[moRunDog]) && notDippingFor(itFeather))
c->item = itFeather;
if(rand() % 20000 < 25 + items[itFeather] + hard) {
c->monst = moRunDog;
// preset the movement direction
// this will make the dog go in the direction of the center,
// if the player is unreachable/invisible
for(int d=0; d<c->type; d++) if(c->mov[d] == from) {
c->mondir = (d+3) % c->type;
}
chasmify(c);
}
}
if(c->land == laHive) {
if(isHive(c->land) && rand() % 6000 < (items[itRoyalJelly] + hard-15))
c->monst = eMonster(moBug0 + rand() % BUGCOLORS);
/* if(rand() % 1500 < 30 + (kills[moBug0] + kills[moBug1] + kills[moBug2]) && notDippingFor(itRoyalJelly))
c->item = itRoyalJelly; */
/* if(rand() % 2000 < 2)
c->monst = eMonster(moBug0 + rand() % 3); */
}
if(!c->item && c->wall != waCloud && c->wall != waMirror) {
if(orbChance(c, laJungle, 1200, 1500) && items[itRuby] >= 10)
c->item = itOrbLightning;
if(orbChance(c, laIce, 2000, 1500) && items[itDiamond] >= 10)
c->item = itOrbFlash;
if(orbChance(c, laCaves, 1800, 2000) && items[itGold] >= 10)
c->item = itOrbLife;
if(orbChance(c, laAlchemist, 600, 800) && items[itElixir] >= 10)
c->item = itOrbSpeed;
if(orbChance(c, laGraveyard, 200, 200) && items[itBone] >= 10)
c->item = itGreenStone;
if(orbChance(c, laDesert, 2500, 600) && items[itSpice] >= 10)
c->item = itOrbShield;
if(orbChance(c, laHell, 2000, 1000) && items[itHell] >= 10)
c->item = itOrbYendor;
if(orbChance(c, laRlyeh, 1500, 1000) && items[itStatue] >= 10)
c->item = itOrbTeleport;
if(orbChance(c, laMotion, 2000, 700) && items[itFeather] >= 10) {
c->item = itOrbSafety;
}
if(orbChance(c, laIce, 1500, 0) && items[itDiamond] >= 10)
c->item = itOrbWinter;
if(orbChance(c, laDryForest, 2500, 0) && items[itFernFlower] >= 10)
c->item = itOrbWinter;
if(orbChance(c, laCocytus, 1500, 1500) && items[itSapphire] >= 10)
c->item = itOrbWinter;
if(orbChance(c, laCaves, 1200, 0) && items[itGold] >= 10)
c->item = itOrbDigging;
if(orbChance(c, laDryForest, 500, 2000) && items[itFernFlower] >= 10)
c->item = itOrbThorns;
if(orbChance(c, laDeadCaves, 1800, 0) && items[itSilver] >= 10)
c->item = itGreenStone;
if(orbChance(c, laDeadCaves, 1800, 1000) && items[itSilver] >= 10)
c->item = itOrbDigging;
if(orbChance(c, laFjord, 1500, 2500) && items[itEmerald] >= 10)
c->item = itOrbPsi;
if(orbChance(c, laWineyard, 900, 1200) && items[itWine] >= 10)
c->item = itOrbGhost;
if(orbChance(c, laHive, 800, 1200) && items[itRoyalJelly] >= 10)
c->item = itOrbInvis;
if(orbChance(c, laPower, 0, 1500) && items[itPower] >= 10)
c->item = itOrbFire;
if(orbChance(c, laTemple, 0, 2500) && items[itGrimoire] >= 10)
c->item = itOrbDragon;
if(orbChance(c, laCamelot, 1000, 1500) && items[itHolyGrail])
c->item = itOrbIllusion;
}
}
}
}
// find worms and ivies
void settemp(cell *c) {
temps.push_back(c); tempval.push_back(c->monst); c->monst = moNone;
}
void findWormIvy(cell *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 == moWormtail) {
bool bug = true;
for(int i=0; i<c->type; i++) {
cell* c2 = c->mov[i];
if(c2 && isWorm(c2) && c2->mov[c2->mondir] == c) {
settemp(c);
c = c2;
bug = false;
}
}
if(bug) break;
}
else if(c->monst == moIvyWait) {
cell* c2 = c->mov[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->mov[i];
if(c2 && (c2->monst == moIvyHead || c2->monst == moIvyBranch) && c2->mov[c2->mondir] == c) {
settemp(c);
c = c2;
bug = false;
}
}
if(bug) break;
}
else break;
}
}
bool isGhostMover(eMonster m) {
return m == moGhost || m == moGreaterShark ||
(cwt.c->land == laPower && (m == moWitchGhost || m == moWitchWinter));
}
bool havebugs, haveearth, haveeagles, haveleader;
bool bugsfighting;
// calculate cpdist and pathdist
void bfs() {
int dcs = size(dcal);
for(int i=0; i<dcs; i++) dcal[i]->cpdist = INFD;
worms.clear(); ivies.clear(); ghosts.clear(); golems.clear(); mirrors.clear();
temps.clear(); tempval.clear(); targets.clear(); havebugs = false;
haveearth = false; haveeagles = false; haveleader = false;
dcal.clear(); dcal.push_back(cwt.c);
reachedfrom.clear(); reachedfrom.push_back(rand() % cwt.c->type);
int pqs = size(pathq);
for(int i=0; i<pqs; i++) pathq[i]->pathdist = INFD;
pathq.clear(); if(!invismove) targets.push_back(cwt.c);
cwt.c->cpdist = 0;
int qb = 0;
while(true) {
int i, fd = reachedfrom[qb] + 3;
cell *c = dcal[qb++];
int d = c->cpdist;
if(d == 7) { first7 = qb; break; }
for(int j=0; j<c->type; j++) if(i = (fd+j) % c->type, c->mov[i]) {
// printf("i=%d cd=%d\n", i, c->mov[i]->cpdist);
cell *c2 = c->mov[i];
if(c2 && signed(c2->cpdist) > d+1) {
c2->cpdist = d+1;
// remove treasures
if(c2->item && c2->cpdist == 7 && itemclass(c2->item) == IC_TREASURE &&
items[c2->item] >= 20 + currentLocalTreasure)
c2->item = itNone;
c2->ligon = 0;
dcal.push_back(c2);
reachedfrom.push_back(c->spn[i]);
if(c2->monst) {
if(isWorm(c2) || isIvy(c2)) findWormIvy(c2);
else if(isGhostMover(c2->monst))
ghosts.push_back(c2);
else if(isBug(c2)) {
havebugs = true;
targets.push_back(c2);
}
else if(isFriendly(c2)) {
targets.push_back(c2);
if(c2->monst == moGolem) golems.push_back(c2);
if(c2->monst == moKnight) golems.push_back(c2);
if(c2->monst == moIllusion) {
if(items[itOrbIllusion]) items[itOrbIllusion]--;
else c2->monst = moNone;
}
if(isMimic(c2)) mirrors.push_back(c2);
}
else if(c2->monst == moEagle) haveeagles = true;
else if(c2->monst == moEarthElemental) haveearth = true;
else if(c2->monst == moCultistLeader) haveleader = true;
}
// pheromones!
if(c2->land == laHive && c2->heat >= 50 && c2->wall != waWaxWall)
havebugs = true;
if(c2->wall == waThumper && c2->tmp > 0) {
useup(c2);
targets.push_back(c2);
}
}
}
}
for(int i=0; i<size(targets); i++) {
targets[i]->pathdist = (targets[i] == cwt.c) ? 0 : 1;
pathq.push_back(targets[i]);
}
int qtemp = size(temps);
for(int i=0; i<qtemp; i++) temps[i]->monst = tempval[i];
pathqm.clear();
reachedfrom.clear(); reachedfrom.push_back(rand() % cwt.c->type);
qb = 0;
for(qb=0; qb < size(pathq); qb++) {
int fd = reachedfrom[qb] + 3;
cell *c = pathq[qb];
eucoord x, y;
decodeMaster(c->master, x, y);
if(c->monst && !isBug(c) && !isFriendly(c)) {
pathqm.push_back(c);
continue; // no paths going through monsters
}
if(c->cpdist > 7) continue;
int d = c->pathdist;
for(int j=0; j<c->type; j++) {
int i = (fd+j) % c->type;
// printf("i=%d cd=%d\n", i, c->mov[i]->cpdist);
if(c->mov[i] && c->mov[i]->pathdist == INFD && !thruVine(c, c->mov[i]) &&
(c->mov[i]->monst || passable(c->mov[i], (d==0)?NULL:c, true, false))) {
c->mov[i]->pathdist = d+1;
pathq.push_back(c->mov[i]); reachedfrom.push_back(c->spn[i]);
}
}
}
}
extern void cleargraphmemory();
// initialize the game
void initgame() {
cwt.c = origin.c7; cwt.spin = 0;
cwt.c->land = euclid ? euclidland : firstland;
createMov(cwt.c, 0);
for(int i=0; i<65536; i++) euland[i] = laNone;
// extern int sightrange; sightrange = 9;
// cwt.c->land = laHell; items[itHell] = 10;
for(int i=9; i>=0; i--) {
setdist(cwt.c, i, NULL);
verifycells(&origin);
}
if(cwt.c->land == laCocytus)
cwt.c->wall = waFrozenLake;
else if(cwt.c->land == laAlchemist || cwt.c->land == laGameBoard)
;
else if(cwt.c->land == laCaves || cwt.c->land == laFjord)
cwt.c->wall = waCavefloor;
else if(cwt.c->land == laDeadCaves)
cwt.c->wall = waDeadfloor2;
else
cwt.c->wall = waNone;
cwt.c->item = itNone;
cwt.c->monst = moNone;
cleargraphmemory();
if(!safety) {
timerstart = time(NULL); turncount = 0; sagephase = 0;
timerstopped = false;
savecount = 0; savetime = 0;
cheater = 0;
if(firstland != laIce) cheater++;
}
else safety = false;
// items[itGreenStone] = 100;
// items[itOrbTeleport] = 100;
/* items[itGold] = 10;
items[itDiamond] = 10;
items[itSpice] = 10;
items[itElixir] = 10;
items[itRuby] = 10;
items[itShard] = 10;
items[itSilver] = 10;
items[itWine] = 10;
items[itRoyalJelly] = 10;
items[itEmerald] = 10;
items[itFeather] = 10;
kills[moYeti] = 90; */
/*
items[itGold] = 20;
items[itDiamond] = 20;
items[itSpice] = 20;
items[itRuby] = 20;
items[itElixir] = 20;
*/
/*
items[itOrbShield] = 100;
items[itOrbSpeed] = 100;
items[itOrbWinter] = 100;
items[itOrbLightning] = 100;
*/
// items[itOrbLightning] = 100;
// items[itRuby] = 100;
// items[itOrbWinter] = 1000;
bfs();
}
void firetrail(cell *c) {
if(!passable(c, NULL, true, true)) return;
destroyHalfvine(c);
c->item = itNone;
if(c->wall == waFrozenLake)
c->wall = waLake;
if(cellUnstableOrChasm(c))
return;
c->wall = waBonfire, c->tmp = 10;
}
void moveNormal(cell *c) {
bool repeat = true;
eMonster m = c->monst;
again:
for(int j=0; j<c->type; j++)
if(c->mov[j] && isFriendlyOrBug(c->mov[j]) && repeat && !attackingForbidden(c->mov[j], c)) {
// XLATC enemy destroys a friend
addMessage(XLAT("%The1 destroys %the2!", m, c->mov[j]->monst));
c->mov[j]->monst = moNone;
return;
}
int posdir[10], nc = 0;
for(int j=0; j<c->type; j++) {
cell *c2 = c->mov[j];
if(!c2) continue;
if(c2->pathdist >= c->pathdist) continue;
if(!passable(c2, c, false, false)) continue;
// crystal sages can't stand out of Cocytus
if(m == moCrystalSage && (c2->land != laCocytus || c2->heat > SAGEMELT))
continue;
// lancers don't move next to other monsters
if(c->monst == moLancer) {
bool lancerok = true;
for(int u=2; u<=c2->type-2; u++) {
cell *c3 = c2->mov[(c->spn[j]+u)%c2->type];
if(c3->monst && !isFriendlyOrBug(c3) && isKillableSomehow(c3))
lancerok = false;
}
if(!lancerok) continue;
}
// if(m == moNecromancer ? c2->land == laGraveyard : true)
// it is more fun when demons step into the Land of Eternal Motion, IMO
// if((m == moLesser || m == moGreater) ? c2->land != laMotion : true)
if(c2->cpdist > 0) {
posdir[nc] = j;
nc++;
}
}
if(nc == 0 && !passable(c, NULL, true, true)) {
// running dogs run away!
// they prefer a straight direction
int sgn = rand() % 2 ? 1 : -1;
for(int b=3; b>=0; b--) for(int s=-1; s<=1; s+=2) if(!nc) {
int d = (c->mondir + b*s*sgn) % c->type;
d += c->type; d %= c->type;
cell *c2 = c->mov[d];
if(passable(c2, c, false, false))
posdir[nc++] = d;
}
}
/*
// Eagles can fly through chasms/slime if needed
if(m == moEagle && nc == 0) {
printf("no eagle no fly\n");
for(int j=0; j<c->type; j++) printf("%d from %d\n", c->mov[j]->cpdist, c->cpdist);
for(int j=0; j<c->type; j++)
if(c->mov[j] && c->mov[j]->cpdist < c->cpdist &&
!c->mov[j]->monst &&
(c->mov[j]->land == laMotion || c->mov[j]->land == laAlchemist) && c->wall != waDeadTroll)
if(c->mov[j]->cpdist > 0)
posdest[nc++] = c->mov[j];
printf("nc=%d\n", nc);
} */
if(!nc) return;
nc = rand() % nc;
cell *c2 = c->mov[posdir[nc]];
c2->monst = m, c->monst = moNone;
c2->mondir = c->spn[posdir[nc]];
if(m == moEagle && repeat && c->pathdist > 1) { repeat = false; c = c2; goto again; }
// lancers pierce our friends :(
if(m == moLancer) {
// printf("lancer stab?\n");
for(int u=2; u<=c2->type-2; u++) {
cell *c3 = c2->mov[(c->spn[posdir[nc]]+u)%c2->type];
if(c3->monst && isKillableSomehow(c3)) {
addMessage(XLAT("%The1 pierces %the2!", m, c3->monst));
killMonster(c3);
}
}
}
if(m == moWitchFire) firetrail(c);
if(isWitch(m) && c2->item == itOrbLife && passable(c, NULL, true, true)) {
// note that Fire Witches don't pick up Orbs of Life,
addMessage(XLAT("%The1 picks up %the2!", moWitch, c2->item));
c->monst = moEvilGolem; c2->item = itNone;
}
else if(m == moWitch) {
bool pickup = false;
if(c2->item == itOrbFlash)
pickup = true, m = moWitchFlash;
if(c2->item == itOrbWinter)
pickup = true, m = moWitchWinter;
if(c2->item == itOrbGhost)
pickup = true, m = moWitchGhost;
if(c2->item == itOrbFire)
pickup = true, m = moWitchFire;
// Orbs of Speed are a special case here, because we don't want
// the witch to move immediately
if(c2->item == itOrbLife)
pickup = true, c->monst = moEvilGolem;
if(pickup) {
addMessage(XLAT("%The1 picks up %the2!", moWitch, c2->item));
c2->monst = m; c2->item = itNone;
}
}
}
void explodeAround(cell *c) {
for(int j=0; j<c->type; j++) {
cell* c2 = c->mov[j];
if(c2) {
if(isIcyLand(c2)) c2->heat += 0.5;
if((c2->wall == waDune || c2->wall == waIcewall ||
c2->wall == waAncientGrave || c2->wall == waFreshGrave ||
c2->wall == waColumn || c2->wall == waThumper || c2->wall == waBonfire ||
c2->wall == waDryTree || c2->wall == waWetTree ||
c2->wall == waVinePlant || c2->wall == waVineHalfA || c2->wall == waVineHalfB)) {
destroyHalfvine(c2); c2->wall = waNone;
}
if(c2->wall == waCavewall || c2->wall == waDeadTroll) c2->wall = waCavefloor;
if(c2->wall == waDeadfloor2) c2->wall = waDeadfloor;
if(c2->wall == waDeadwall) c2->wall = waDeadfloor2;
if(c2->wall == waBigStatue) c2->wall = waNone;
if(c2->wall == waFloorA || c2->wall == waFloorB)
if(c->wall == waFloorA || c->wall == waFloorB)
c2->wall = c->wall;
}
}
}
void moveWorm(cell *c) {
if(c->monst == moWormwait) { c->monst = moWorm; return; }
else if(c->monst == moTentaclewait) { c->monst = moTentacle; return; }
else if(c->monst == moTentacleEscaping) {
// explodeAround(c);
c->monst = moNone;
if(c->mondir != NODIR) c->mov[c->mondir]->monst = moTentacleEscaping;
return;
}
else if(c->monst != moWorm && c->monst != moTentacle) return;
int ncg = 0, ncb = 0;
cell *gmov[7], *bmov[7];
int id = c->monst - moWorm;
for(int j=0; j<c->type; j++) {
if(c->mov[j] && isFriendlyOrBug(c->mov[j]) && !attackingForbidden(c->mov[j], c)) {
addMessage(XLAT("%The1 eats %the2!", c->monst, c->mov[j]->monst));
ncg = 1; gmov[0] = c->mov[j];
break;
}
if(c->mov[j] && passable(c->mov[j], c, false, false) && !cellUnstable(c->mov[j]) && c->mov[j] != cwt.c) {
if(c->mov[j]->pathdist < c->pathdist) gmov[ncg++] = c->mov[j]; else bmov[ncb++] = c->mov[j];
}
}
if(ncg == 0 && ncb == 0) {
int spices = 0;
if(id) {
addMessage(XLAT("Cthulhu withdraws his tentacle!"));
kills[moTentacle]++;
c->monst = moTentacleEscaping;
moveWorm(c);
}
else {
addMessage(XLAT("The sandworm explodes in a cloud of Spice!"));
kills[moWorm]++;
spices = 3;
}
eItem loc = treasureType(c->land);
while(c->monst == moWorm || c->monst == moWormtail || c->monst == moTentacle || c->monst == moTentacletail) {
// if(!id)
explodeAround(c);
if(spices > 0 && c->land == laDesert) {
if(notDippingForExtra(itSpice, loc))
c->item = itSpice;
spices--;
}
c->monst = moNone;
if(c->mondir != NODIR) c = c->mov[c->mondir];
}
return;
}
cell* goal;
if(ncg) goal = gmov[rand() % ncg];
else goal = bmov[rand() % ncb];
for(int j=0; j<c->type; j++) if(c->mov[j] == goal) {
goal->monst = eMonster(moWormwait + id);
c->monst = eMonster(moWormtail + id);
goal->mondir = c->spn[j];
if(id) break;
cell *c2 = c, *c3 = c2;
for(int a=0; a<15; a++)
if(c2->monst == moWormtail) {
if(c2->mondir == NODIR) return;
c3 = c2, c2 = c3->mov[c2->mondir];
}
if(c2->monst == moWormtail) c2->monst = moNone, c3->mondir = NODIR;
}
}
void ivynext(cell *c) {
cellwalker cw(c, c->mondir);
cw.c->monst = moIvyWait;
bool findleaf = false;
while(true) {
cwspin(cw, 1);
if(cw.spin == signed(cw.c->mondir)) {
if(findleaf) {
cw.c->monst = moIvyHead; break;
}
cw.c->monst = moIvyWait;
cwstep(cw);
continue;
}
cwstep(cw);
if(cw.c->monst == moIvyWait && signed(cw.c->mondir) == cw.spin) {
cw.c->monst = moIvyBranch;
findleaf = true; continue;
}
cwstep(cw);
}
}
// this removes Ivy, but also potentially causes Vines to grow
void removeIvy(cell *c) {
c->monst = moNone;
for(int i=0; i<c->type; i++)
// note that semi-vines don't count
if(c->mov[i]->wall == waVinePlant) {
destroyHalfvine(c);
c->wall = waVinePlant;
}
}
void moveivy() {
for(int i=0; i<size(ivies); i++) {
cell *c = ivies[i];
cell *co = c;
if(c->monst != moIvyHead) continue;
ivynext(c);
cell *mto = NULL;
int pd = c->pathdist;
int sp = 0;
while(c->monst != moIvyRoot) {
for(int j=0; j<c->type; j++) {
if(c->mov[j] && isFriendly(c->mov[j])) {
addMessage(XLAT("The ivy destroys %the1!", c->mov[j]->monst));
c->mov[j]->monst = moNone;
continue;
}
if(c->mov[j] && signed(c->mov[j]->pathdist) < pd && passable(c->mov[j], c, false, false))
mto = c->mov[j], pd = mto->pathdist, sp = c->spn[j];
}
c = c->mov[c->mondir];
}
if(mto && mto->cpdist) {
mto->monst = moIvyWait, mto->mondir = sp;
// if this is the only branch, we want to move the head immediately to mto instead
if(mto->mov[mto->mondir]->monst == moIvyHead) {
mto->monst = moIvyHead; co->monst = moIvyBranch;
}
}
else if(co->mov[co->mondir]->monst != moIvyRoot) {
// shrink useless branches, but do not remove them completely (at the root)
if(co->monst == moIvyHead) co->mov[co->mondir]->monst = moIvyHead;
removeIvy(co);
}
}
}
// move slimes, and also seeps
int sval = 1;
vector<cell*> slimedfs;
bool isSlimeMover(cell *c) {
return
c->monst == moSlime || c->monst == moSeep || c->monst == moShark ||
c->monst == moVineSpirit;
}
void slimevisit(cell *c, cell *from, int u) {
if(!c) return;
if(eq(c->tmp, sval)) return;
if(c->wall != waCavewall && c->wall != waLake && c->wall != waDeadwall &&
c->wall != waFloorA && c->wall != waFloorB && c->wall != waVinePlant &&
c->wall != waVineHalfB && c->wall != waVineHalfA
) return;
bool hv = false;
// cavewalls/deadwalls are the same for seeps
if(c->wall == waCavewall && from->wall == waDeadwall) hv++;
if(c->wall == waDeadwall && from->wall == waCavewall) hv++;
// only travel to halfvines correctly
if(cellHalfvine(c) && from != cwt.c) {
int i=0;
for(int t=0; t<c->type; t++) if(c->mov[t] && c->mov[t]->wall == c->wall) i=t;
int z = i-u; if(z<0) z=-z; z%=6;
if(z>1) return;
hv=true;
}
// only travel from halfvines correctly
if(cellHalfvine(from) && from != cwt.c) {
int i=0;
for(int t=0; t<from->type; t++) if(from->mov[t] && from->mov[t]->wall == from->wall) i=t;
int z = i-c->spn[u]; if(z<0) z=-z; z%=6;
if(z>1) return;
hv=true;
}
if(c->wall != from->wall && from != cwt.c && !hv) return;
if(c->item) return;
// if(c->wall == waThumper || c->wall == waBonfire) return;
c->tmp = sval;
if(size(slimedfs) < 1000) slimedfs.push_back(c), reachedfrom.push_back(u);
if(!isWorm(c) && !isIvy(c) && !isMimic(c))
for(int i=0; i<c->type; i++) if(c->mov[i] == from)
c->mondir = i;
if(isSlimeMover(c)) {
for(int j=0; j<c->type; j++)
if(c->mov[j] && isFriendlyOrBug(c->mov[j])) {
// XLATC slime/seep/shark
addMessage(XLAT("%The1 eats %the2!", c->monst, c->mov[j]->monst));
c->mov[j]->monst = moNone;
return;
}
if(from->cpdist == 0 || from->monst) return;
from->monst = c->monst, c->monst = moNone;
}
}
void moveslimes() {
sval++;
slimedfs.clear(); reachedfrom.clear();
for(int i=0; i<size(targets); i++) {
slimedfs.push_back(targets[i]);
reachedfrom.push_back(rand() % targets[i]->type);
}
for(int i=0; i<size(slimedfs); i++) {
cell *c = slimedfs[i];
int j = reachedfrom[i];
for(int t=0; t<c->type; t++) {
int u = (j+t) % c->type;
slimevisit(c->mov[u], c, c->spn[u]);
}
}
}
// move eagles
vector<cell*> eagledfs;
void eaglevisit(cell *c, cell *from, int id) {
if(!c) return;
if(eq(c->tmp, sval)) return;
if(c->monst == moEagle) {
if(id == 1) for(int j=0; j<c->type; j++)
if(c->mov[j] && isFriendlyOrBug(c->mov[j]) && !attackingForbidden(c->mov[j], c)) {
// XLATC eagle
addMessage(XLAT("%The1 claws %the2!", c->monst, c->mov[j]->monst));
c->mov[j]->monst = moNone;
return;
}
if(from->cpdist == 0 || from->monst) return;
from->monst = c->monst, c->monst = moNone;
}
if(c->wall == waThumper || isFire(c)) return;
c->tmp = sval;
if(!eaglepassable(c)) return;
if(size(eagledfs) < 1000) eagledfs.push_back(c);
}
void moveeagles(int id) {
if(invismove) return;
sval++;
eagledfs.clear();
for(int i=0; i<size(targets); i++)
eagledfs.push_back(targets[i]);
//eagledfs.push_back(cwt.c);
for(int i=0; i<size(eagledfs); i++) {
cell *c = eagledfs[i];
for(int t=0; t<c->type; t++)
eaglevisit(c->mov[t], c, id);
}
}
vector<cell*> earthdfs;
bool earthpassable(cell *c, cell *from) {
// cannot go through Living Caves...
if(c->wall == waCavefloor) return false;
// but can dig through...
if(c->wall == waDeadwall || c->wall == waDune)
return true;
return passable(c, from, true, false);
}
void earthMove(cell *from, int dir) {
cell *c2 = from->mov[dir];
int d = from->spn[dir];
earthWall(from);
if(c2) for(int u=2; u<=c2->type-2; u++) {
cell *c3 = c2->mov[(d + u)% c2->type];
earthFloor(c3);
}
}
void earthvisit(cell *c, cell *from, int d) {
if(!c) return;
if(eq(c->tmp, sval)) return;
if(!earthpassable(c, from)) return;
if(c->monst == moEarthElemental) {
// note: move from 'c' to 'from'!
for(int j=0; j<c->type; j++)
if(c->mov[j] && isFriendlyOrBug(c->mov[j]) && !attackingForbidden(c->mov[j], c)) {
// XLATC eagle
addMessage(XLAT("%The1 punches %the2!", c->monst, c->mov[j]->monst));
c->mov[j]->monst = moNone;
return;
}
if(!passable(from, c, false, false)) {
earthFloor(from);
return;
}
if(from->cpdist == 0 || from->monst) return;
earthMove(c, from->spn[d]);
from->monst = c->monst, c->monst = moNone;
}
if(c->wall == waThumper || isFire(c)) return;
c->tmp = sval;
if(size(earthdfs) < 1000) earthdfs.push_back(c);
}
void moveearth() {
if(invismove) return;
sval++;
earthdfs.clear();
for(int i=0; i<size(targets); i++)
earthdfs.push_back(targets[i]);
for(int i=0; i<size(earthdfs); i++) {
cell *c = earthdfs[i];
for(int t=0; t<c->type; t++)
earthvisit(c->mov[t], c, t);
}
}
vector<cell*> leaderdfs;
bool canPushStatueOn(cell *c) {
return passable(c, NULL, true, false);
}
// note: move from 'c' to 'from'!
void leadervisit(cell *c, cell *from, int d) {
if(!c) return;
if(eq(c->tmp, sval)) return;
if(c->monst == moCultistLeader) {
// he cannot push big statues into bonfires, just like the player
if(c->wall == waBonfire && from->wall == waBigStatue)
return;
// note: move from 'c' to 'from'!
for(int j=0; j<c->type; j++)
if(c->mov[j] && isFriendlyOrBug(c->mov[j]) && !attackingForbidden(c->mov[j], c)) {
// XLATC eagle
addMessage(XLAT("%The1 punches %the2!", c->monst, c->mov[j]->monst));
c->mov[j]->monst = moNone;
return;
}
if(from->wall != waBigStatue && !passable(from, c, false, false)) {
return;
}
if(from->cpdist == 0 || from->monst) return;
if(from->wall == waBigStatue) {
from->wall = c->wall;
c->wall = waBigStatue;
}
// earthMove(c, from->spn[d]);
from->monst = c->monst, c->monst = moNone;
}
else if(c->wall == waBigStatue ? !canPushStatueOn(from) : !passable(c, from, false, false))
return;
if(c->wall == waThumper || isFire(c)) return;
c->tmp = sval;
if(size(leaderdfs) < 1000) leaderdfs.push_back(c);
}
void moveleader() {
if(invismove) return;
sval++;
leaderdfs.clear();
for(int i=0; i<size(targets); i++)
leaderdfs.push_back(targets[i]);
//leaderdfs.push_back(cwt.c);
for(int i=0; i<size(leaderdfs); i++) {
cell *c = leaderdfs[i];
for(int t=0; t<c->type; t++)
leadervisit(c->mov[t], c, t);
}
}
#define SHSIZE 16
cell *shpos[SHSIZE];
int cshpos = 0;
void clearshadow() {
for(int i=0; i<SHSIZE; i++) shpos[i] = NULL;
}
void moveshadow() {
if(shpos[cshpos] && shpos[cshpos]->monst == moShadow)
shpos[cshpos]->monst = moNone;
shpos[cshpos] = cwt.c;
cshpos = (cshpos+1) % SHSIZE;
if(shpos[cshpos] && shpos[cshpos]->monst == moNone && shpos[cshpos]->cpdist && shpos[cshpos]->land == laGraveyard)
shpos[cshpos]->monst = moShadow;
}
// from-to
bool ghostmove(cell* c1, cell* c2) {
if(c1->monst == moGhost || c1->monst == moWitchGhost) return true;
if(c1->monst == moGreaterShark) return c2->wall == waLake;
if(c1->monst == moWitchWinter)
return c2->wall == waBonfire || passable(c2, c1, false, false);
return false;
}
void moveghosts() {
if(invismove) return;
for(int d=0; d<8; d++) movesofgood[d].clear();
for(int i=0; i<size(ghosts); i++) {
cell *c = ghosts[i];
if(isGhostMover(c->monst) && c->cpdist > 1) {
int goodmoves = 0;
for(int k=0; k<c->type; k++) if(c->mov[k] && !c->mov[k]->monst && c->mov[k]->cpdist < c->cpdist)
if(ghostmove(c, c->mov[k]))
goodmoves++;
movesofgood[goodmoves].push_back(c);
}
}
for(int d=0; d<8; d++) for(int i=0; i<size(movesofgood[d]); i++) {
cell *c = movesofgood[d][i];
if(isGhostMover(c->monst) && c->cpdist > 1) {
int mdir[7];
for(int j=0; j<c->type; j++)
if(c->mov[j] && isFriendlyOrBug(c->mov[j])) {
// XLATC ghost/greater shark
addMessage(XLAT("%The1 scares %the2!", c->monst, c->mov[j]->monst));
c->mov[j]->monst = moNone;
return;
}
int qmpos = 0;
for(int k=0; k<c->type; k++) if(c->mov[k] && !c->mov[k]->monst && c->mov[k]->cpdist < c->cpdist)
if(ghostmove(c, c->mov[k]))
mdir[qmpos++] = k;
if(!qmpos) continue;
int d = mdir[rand() % qmpos];
cell *c2 = c->mov[d];
c2->monst = c->monst; c->monst = moNone;
}
}
}
int lastdouble = -3;
void stabbingAttack(cell *mf, cell *mt, eMonster who = moNone) {
int numsh = 0, numflail = 0, numlance = 0;
for(int t=0; t<mf->type; t++) {
cell *c = mf->mov[t];
if(c->monst == moHedge || (!who && items[itOrbThorns] && c->monst && isKillable(c))) {
for(int u=0; u<c->type; u++) {
if(c->mov[u] == mt) {
if(who)
addMessage(XLAT("%The1 stabs %the2.", who, c->monst));
else
addMessage(XLAT("You stab %the1.", c->monst));
int k = tkills();
killMonster(c);
if(tkills() > k) numsh++;
}
}
}
if(c->monst == moFlailer) {
bool away = true;
for(int u=0; u<c->type; u++) if(c->mov[u] == mt) away = false;
if(away) {
if(who)
addMessage(XLAT("%The1 tricks %the2.", who, c->monst));
else
addMessage(XLAT("You trick %the1.", c->monst));
int k = tkills();
killMonster(c);
if(tkills() > k) numflail++;
}
}
}
for(int t=0; t<mt->type; t++) {
cell *c = mt->mov[t];
if(c->monst == moLancer) {
if(who)
addMessage(XLAT("%The1 tricks %the2.", who, c->monst));
else
addMessage(XLAT("You trick %the1.", c->monst));
int k = tkills();
killMonster(c);
if(tkills() > k) numlance++;
}
}
if(numsh) achievement_count("STAB", numsh, 0);
if(numlance && numflail && numsh) achievement_gain("MELEE3");
if(numlance + numflail + numsh >= 5) achievement_gain("MELEE5");
if(numsh == 2) {
if(lastdouble == turncount-1) achievement_count("STAB", 4, 0);
lastdouble = turncount;
}
}
void movegolems() {
int qg = 0;
for(int i=0; i<size(golems); i++) {
cell *c = golems[i];
eMonster m = c->monst;
if(m == moGolem || m == moKnight) {
if(m == moGolem) qg++;
int bestv = 100, bq = 0, bdirs[7];
for(int k=0; k<c->type; k++) if(c->mov[k]) {
int val;
if(c->mov[k] == cwt.c) val = 0;
else if(isActiveEnemy(c->mov[k], NULL) && isKillable(c->mov[k]) &&
!attackingForbidden(c->mov[k], c))
val = 12000;
else if(isInactiveEnemy(c->mov[k]) && isKillable(c->mov[k]) &&
!attackingForbidden(c->mov[k], c))
val = 10000;
else if(isIvy(c->mov[k]) && !attackingForbidden(c->mov[k], c)) val = 8000;
else if(monstersnear(c->mov[k], NULL, false)) val = 0;
else if(passable(c->mov[k], c, false, false)) val = 4000;
else val = 0;
if(c->monst == moGolem)
val -= c->mov[k]->cpdist;
if(c->monst == moKnight && c->mov[k]->master->alt)
val -= celldistAlt(c->mov[k]);
if(val > bestv) bestv = val, bq = 0;
if(val == bestv) bdirs[bq++] = k;
}
if(bestv <= 100) continue;
int dir = bdirs[rand() % bq];
cell *c2 = c->mov[dir];
if(c2->monst) {
addMessage(XLAT("%The1 destroys %the2!", c->monst, c2->monst));
killMonster(c2);
}
else {
stabbingAttack(c, c2, m);
c2->monst = m == moGolem ? moGolemMoved : moKnightMoved;
c2->mondir = c->spn[dir];
c->monst = moNone;
}
}
}
achievement_count("GOLEM", qg, 0);
}
bool wchance(int a, int of) {
of *= 10;
a += items[itOrbYendor] * 5 + items[itHolyGrail] + 1;
if(cwt.c->land == laCrossroads) a+= items[itHyperstone] * 10;
for(int i=0; i<ittypes; i++) if(itemclass(eItem(i)) == IC_TREASURE)
a = max(a, (items[i]-10) / 10);
return rand() % (a+of) < a;
}
void wandering() {
int t = turncount - lastexplore;
int seepcount = 0;
if(t > 40) seepcount = (t-40 + rand() % 20) / 20;
int ghostcount = 0;
if(t > 80) ghostcount = (t-80 + rand() % 20) / 20;
while(first7 < size(dcal)) {
int i = first7 + rand() % (size(dcal) - first7);
cell *c = dcal[i];
// wandering seeps & ghosts
if(seepcount && c->wall == waCavewall && !c->monst && eq(c->tmp, sval)) {
c->monst = moSeep;
seepcount--;
continue;
}
if(ghostcount && !c->monst && cwt.c->type != laCaves) {
c->monst = moGhost;
ghostcount--;
continue;
}
if((c->wall == waCavewall || c->wall == waDeadwall) && !c->monst && eq(c->tmp, sval) &&
wchance(items[treasureType(c->land)], 10)) {
c->monst = moSeep;
continue;
}
else if(c->monst || c->pathdist == INFD) break;
else if(c->land == laIce && wchance(items[itDiamond], 10))
c->monst = rand() % 2 ? moWolf : moYeti;
else if(c->land == laDesert && wchance(items[itSpice], 10))
c->monst = rand() % 10 ? moDesertman : moWorm;
else if(c->land == laCaves && wchance(items[itGold], 5))
c->monst = rand() % 3 ? moTroll : moGoblin;
else if(c->land == laDeadCaves && wchance(items[itSilver], 5))
c->monst = rand() % 20 ? (rand() % 3 ? moDarkTroll : moGoblin) : moEarthElemental;
else if(c->land == laJungle && wchance(items[itRuby], 40))
c->monst = rand() % 10 ? moMonkey : moEagle;
else if(c->land == laMirror && wchance(items[itShard], 15))
c->monst = rand() % 10 ? moRanger : moEagle;
else if(c->land == laHell && wchance(items[itHell], 20))
c->monst = rand() % 3 ? moLesser : moGreater;
else if(c->land == laRlyeh && wchance(items[itStatue], 15))
c->monst = rand() % 3 ? moPyroCultist :
(rand() % 40 < items[itStatue]-25) ? moCultistLeader : moCultist;
else if(c->land == laGraveyard && wchance(items[itBone], 15))
c->monst = rand() % 5 ? moGhost : moNecromancer;
else if(c->land == laDryForest && wchance(items[itFernFlower], 5))
c->monst = rand() % 5 ? moHedge : moFireFairy;
else if(c->land == laCocytus && wchance(items[itSapphire], 45))
c->monst = moCrystalSage;
else if(c->land == laAlchemist && wchance(items[itElixir], 3) && eq(c->tmp, sval) && c->item == itNone)
c->monst = moSlime;
else if(c->land == laFjord && wchance(items[itEmerald], 5)) {
static eMonster m[4] = {moHedge, moLancer, moMiner, moFlailer};
c->monst = m[rand() % 4];
}
else if(c->land == laWineyard && wchance(items[itWine], 10)) {
c->monst = moVineBeast;
}
else if(c->land == laPower && wchance(items[itPower], 10)) {
c->monst = eMonster(moWitch + rand() % NUMWITCH);
}
else if(c->land == laCamelot && rand() % 30 == 0 && celldistAltRelative(c) < 0) {
eMonster m[3] = { moHedge, moLancer, moFlailer };
c->monst = m[rand() % 3];
}
else if(c->land == laCrossroads && items[itHyperstone] && wchance(items[itHyperstone], 20)) {
// only interesting monsters here!
static eMonster m[12] = {
moWorm, moTroll, moEagle,
moLesser, moGreater, moPyroCultist, moGhost,
moFireFairy, moHedge,
moLancer, moFlailer, moVineBeast
};
c->monst = m[rand() % 9];
}
else break;
if(c->monst == moWorm) c->mondir = NODIR;
// laMotion -> no respawn!
}
}
void sageheat(cell *c, double v) {
c->heat += v;
if(c->wall == waFrozenLake && c->heat > .6) c->wall = waLake;
}
bool normalMover(eMonster m) {
return
m == moYeti || m == moRanger || m == moGoblin || m == moTroll || m == moDesertman ||
m == moMonkey || m == moZombie || m == moNecromancer || m == moCultist ||
m == moLesser || m == moGreater || m == moRunDog || m == moPyroCultist ||
m == moFireFairy || m == moCrystalSage || m == moHedge ||
m == moVineBeast || m == moLancer || m == moFlailer ||
m == moMiner || m == moDarkTroll ||
(cwt.c->land == laPower && (
(isWitch(m) && m != moWitchGhost && m != moWitchWinter) || m == moEvilGolem
));
}
struct buginfo_t {
cell *where;
short dist[BUGCOLORS];
};
vector<buginfo_t> buginfo;
vector<int> bugqueue[BUGCOLORS];
vector<int> bugqueue4[BUGCOLORS];
struct bugtomove_t {
int dist, moves, index;
bugtomove_t(int d, int m, int i) { dist=d; moves=m; index=i; }
};
bool operator < (const bugtomove_t& m1, const bugtomove_t& m2) {
if(m1.dist != m2.dist) return m1.dist < m2.dist;
if(m1.moves != m2.moves) return m1.moves < m2.moves;
return false;
}
vector<bugtomove_t> bugtomove;
vector<cell*> deadbug;
vector<cell*> bugcellq;
int bugcount[BUGCOLORS];
bool isBugEnemy(cell *c, int k) {
if(c == cwt.c && !invismove) return true;
if(!c->monst) return false;
if(c->monst == moBug0+k) return false;
if(isIvy(c)) return false;
return (isBug(c) || isKillableSomehow(c));
}
// list bugs and targets for each color
#define BUGINF 29999
void bugQueueInsert(int k, int i, int d) {
if(buginfo[i].dist[k] > d) {
if(buginfo[i].dist[k] != BUGINF) {
printf("%d -> %d\n", buginfo[i].dist[k], d);
}
buginfo[i].dist[k] = d;
bugqueue[k].push_back(i);
}
}
void bugcell(cell *c) {
if(isActiv(c) || !passable(c, NULL, true, false))
return;
short& i(c->tmp);
if(i >= 0 && i < size(buginfo) && buginfo[i].where == c)
return;
i = size(buginfo);
buginfo.resize(i+1);
buginfo_t& b(buginfo[i]);
b.where = c;
for(int k=0; k<BUGCOLORS; k++) {
b.dist[k] = BUGINF;
bool havebug = false, haveother = false;
for(int dir=0; dir<c->type; dir++) {
cell *c2 = c->mov[dir];
if(c2 && isBugEnemy(c2,k) && !attackingForbidden(c2, c)) {
if(isBug(c2)) havebug = true;
else haveother = true;
}
}
if(havebug) bugQueueInsert(k, i, 0);
else if(haveother) bugqueue4[k].push_back(i);
}
/*// bugs communicate if the distance is at most 2
// also all nearby cells are inserted to the buginfo structure
if(size(buginfo) < 30000) {
for(int dir=0; dir<c->type; dir++) {
cell *c2 = c->mov[dir];
if(c2) {
// if(isBug(c)) bugcellq.push_back(c2); => does not help...
for(int t=0; t<c2->type; t++)
if(c2->mov[t] && isBug(c2->mov[t]))
bugcellq.push_back(c2),
bugcellq.push_back(c2->mov[t]);
}
}
}*/
// use pheromones!
if(c->land == laHive && c->heat > 1) {
c->heat -= 1;
for(int dir=0; dir<c->type; dir++) {
cell *c2 = c->mov[dir];
if(c2) {
for(int t=0; t<c2->type; t++)
if(c2->mov[t])
bugcellq.push_back(c2),
bugcellq.push_back(c2->mov[t]);
}
}
}
}
int last_d = -1;
void handleBugQueue(int k, int t) {
int i = bugqueue[k][t];
buginfo_t& b(buginfo[i]);
cell *c = b.where;
int d = b.dist[k];
last_d = d;
int goodmoves = 0;
for(int dir=0; dir<c->type; dir++) {
cell *c2 = c->mov[dir];
if(!c2) continue;
if(c2->tmp < 0 || c2->tmp >= size(buginfo)) continue;
if(!passable(c, c2, true, false)) continue;
int j = c2->tmp;
if(buginfo[j].where != c2) continue;
if(buginfo[j].dist[k] < d) goodmoves++;
bugQueueInsert(k, j, d+1);
}
if(isBug(c) && c->monst == moBug0+k) {
bugcount[c->monst - moBug0]++;
bugtomove.push_back(bugtomove_t(d,goodmoves,i));
}
}
#include <set>
void movebugs() {
buginfo.clear();
for(int k=0; k<BUGCOLORS; k++) bugqueue[k].clear();
for(int k=0; k<BUGCOLORS; k++) bugqueue4[k].clear();
for(int k=0; k<BUGCOLORS; k++) bugcount[k] = 0;
bugtomove.clear();
deadbug.clear();
int xdcs = size(dcal); for(int i=0; i<xdcs; i++) bugcell(dcal[i]);
for(int i=0; i<size(bugcellq); i++) bugcell(bugcellq[i]);
bugcellq.clear();
// printf("buginfo = %d\n", size(buginfo));
for(int k=0; k<BUGCOLORS; k++) {
int t = 0;
last_d = -1;
int invadist = 4 - (items[itRoyalJelly]+10) / 20;
if(invadist<0) invadist = 0;
for(; t<size(bugqueue[k]) && last_d < invadist-1; t++) handleBugQueue(k, t);
for(int u=0; u<size(bugqueue4[k]); u++)
bugQueueInsert(k, bugqueue4[k][u], invadist);
bugqueue4[k].clear();
for(; t<size(bugqueue[k]); t++) handleBugQueue(k, t);
}
for(int k=0; k<BUGCOLORS; k++) {
set<int> check;
for(int t=0; t<size(bugqueue[k]); t++) {
if(check.count(bugqueue[k][t])) {
printf("REPETITION! [%d]\n", t);
}
check.insert(bugqueue[k][t]);
}
}
random_shuffle(bugtomove.begin(), bugtomove.end());
sort(bugtomove.begin(), bugtomove.end());
int battlecount = 0;
for(int t=0; t<size(bugtomove); t++) {
bugtomove_t& bm(bugtomove[t]);
int i = bm.index;
buginfo_t& b(buginfo[i]);
cell *c = b.where;
if(!isBug(c)) continue;
eMonster m = c->monst;
int k = (m - moBug0) % BUGCOLORS;
int gmoves[8], q=0, bqual = -1;
for(int dir=0; dir<c->type; dir++) {
cell *c2 = c->mov[dir];
int qual = -10;
if(!c2) continue;
else if(isBugEnemy(c2, k) && c2->monst != moDeadBug)
qual = c2 != cwt.c ? 2 : -5;
else {
if(c2->monst) continue;
if(!passable(c2, c, false, false)) continue;
if(c2->tmp < 0 || c2->tmp >= size(buginfo)) continue;
if(buginfo[c2->tmp].where != c2) continue;
if(buginfo[c2->tmp].dist[k] < b.dist[k])
qual = 1;
else if(buginfo[c2->tmp].dist[k] == b.dist[k])
qual = 0;
}
// printf("%d->#%d %d: %d\n", i, dir, c2->tmp, qual);
if(qual > bqual) bqual = qual, q=0;
if(qual == bqual) gmoves[q++] = dir;
}
if(!q) { c->heat += 3; continue; }
int d = gmoves[rand() % q];
cell *c2 = c->mov[d];
if(c2->monst) {
eMonster killed = c2->monst;
if(isBug(killed)) battlecount++;
else addMessage(XLAT("%The1 fights with %the2!", c->monst, c2->monst));
killMonster(c2);
// killMonster(c);
if(isBug(killed)) {
c2->monst = moDeadBug, deadbug.push_back(c2);
bugcount[killed - moBug0]--;
}
// c->monst = moDeadBug, deadbug.push_back(c);
}
else {
c2->monst = c->monst;
c2->mondir = c->spn[d];
c->monst = moNone;
// pheromones!
if(c->heat < 90) c->heat += 5;
if(c2->heat < 90) c2->heat += 5;
// if(isHive(c2->land)) c2->land = eLand(laHive0+k);
/* if(c2->item == itRoyalJelly && !isQueen(m)) {
// advance!
c2->monst = eMonster(m+BUGCOLORS);
c2->item = itNone;
} */
}
}
// cleanup
for(int i=0; i<size(deadbug); i++) deadbug[i]->monst = moNone;
if(battlecount)
addMessage(XLAT("The Hyperbugs are fighting!"));
int maxbug = 0;
for(int k=0; k<BUGCOLORS; k++) if(bugcount[k] > maxbug) maxbug = bugcount[k];
achievement_count("BUG", maxbug, 0);
}
void bugcitycell(cell *c, int d) {
if(isActiv(c) || !passable(c, NULL, true, false)) return;
short& i = c->tmp;
if(i >= 0 && i < size(buginfo) && buginfo[i].where == c)
return;
i = size(buginfo);
buginfo_t b;
b.where = c;
b.dist[0] = d;
buginfo.push_back(b);
}
void createBugArmy(cell *c) {
int k = rand() % BUGCOLORS;
int minbugs = 50, maxbugs = 50;
int var = 5 + items[itRoyalJelly];
if(var>25) var=25;
// minbugs += 100; maxbugs += 100;
minbugs -= var; maxbugs += var;
maxbugs += items[itRoyalJelly];
int numbugs = minbugs + rand() % (maxbugs - minbugs + 1);
/* int i = items[itRoyalJelly];
int chance = 20 + 25 * i + 9000;
// i=0: 16%
// i=10: 73%
// i=50: 1270 vs 6000
eMonster m = eMonster(moBug0 + rand() % BUGCOLORS);
if(c->wall) return;
for(int i=0; i<c->type; i++) {
cell *c2 = createMov(c,i);
if(rand() % (100+chance) < chance) {
if(!c2->wall) c2->monst = m;
for(int j=2; j<=c2->type-2; j++) {
int jj = (j+c->spn[i]) % c2->type;
cell *c3 = createMov(c2, jj);
if(rand() % (6000+chance) < chance && !c3->wall)
c3->monst = m;
}
}
}
c->monst = eMonster(m + BUGCOLORS); */
int gdir = -1;
for(int i=0; i<c->type; i++) {
if(c->mov[i] && c->mov[i]->mpdist < c->mpdist) gdir = i;
}
if(!gdir) return;
cellwalker bf(c, gdir);
for(int i=0; i<7; i++) {
if(bf.c->type == 6)
cwspin(bf, 3);
else
cwspin(bf, 3 + rand() % 2);
cwstep(bf);
}
cell *citycenter = bf.c;
buginfo.clear();
// mark the area with BFS
bugcitycell(citycenter, 0);
for(int i=0; i<size(buginfo); i++) {
buginfo_t& b(buginfo[i]);
cell *c = b.where;
int d = b.dist[0];
// ERRORS!
if(c->land != laHive && c->land != laNone) return;
if(c->bardir != NODIR) return;
if(c->heat >= 100) return;
// bfs
if(d < 9) for(int t=0; t<c->type; t++)
bugcitycell(createMov(c,t), d+1);
}
// place everything
for(int i=0; i<size(buginfo); i++) {
buginfo_t& b(buginfo[i]);
cell *c = b.where;
int d = b.dist[0];
if(d <= 1 && c->wall == waNone)
c->item = itRoyalJelly;
c->bardir = NOBARRIERS;
if(d == 9 || d == 6 || d == 3)
c->barleft = eLand(d/3),
c->barright = eLand(k);
else
c->barleft = laNone;
if(numbugs && c->wall == waNone)
c->monst = eMonster(moBug0 + k), numbugs--;
c->land = laHive;
// prevent barriers
if(c->mpdist == INFD) c->mpdist = BUGLEV;
}
}
void moveFastMonsters() {
for(int i=0; i<size(pathqm); i++) {
cell *c = pathqm[i];
if(c->monst == moWitchSpeed) {
if(c->pathdist == 1 && c->monst != moGhost) {
if(items[itOrbShield]) continue;
addMessage(XLAT("%The1 is confused!", c->monst));
break;
}
int goodmoves = 0;
for(int t=0; t<c->type; t++) {
cell *c2 = c->mov[t];
if(c2 && c2->pathdist < c->pathdist)
goodmoves++;
}
movesofgood[goodmoves].push_back(c);
}
}
for(int d=0; d<8; d++) for(int i=0; i<size(movesofgood[d]); i++) {
cell *c = movesofgood[d][i];
if(c->monst != moNone)
moveNormal(c);
}
}
void activateFlashFrom(cell *cf);
vector<cell*> nonmovers;
bool sagefresh = true;
void considerEnemyMove(cell *c) {
eMonster m = c->monst;
if(isActiveEnemy(c, NULL)) {
if(c->pathdist == 1 && c->monst != moGhost) {
// c->iswall = true; c->ismon = false;
if(items[itOrbShield] || c->monst == moCrystalSage) return;
addMessage(XLAT("%The1 is confused!", m));
// playerdead = true;
return;
}
if(c->monst == moWitch && c->item == itOrbSpeed) {
addMessage(XLAT("%The1 picks up %the2!", moWitch, c->item));
c->monst = moWitchSpeed; c->item = itNone;
}
if(c->monst == moNecromancer) {
int gravenum = 0, zombienum = 0;
cell *gtab[8], *ztab[8];
for(int j=0; j<c->type; j++) if(c->mov[j]) {
if(c->mov[j]->wall == waFreshGrave) gtab[gravenum++] = c->mov[j];
if(passable(c->mov[j], c, false, false) && c->mov[j]->pathdist < c->pathdist)
ztab[zombienum++] = c->mov[j];
}
if(gravenum && zombienum) {
cell *gr = gtab[rand() % gravenum];
gr->wall = waAncientGrave;
gr->monst = moGhost;
ztab[rand() % zombienum]->monst = moZombie;
addMessage(XLAT("%The1 raises some undead!", c->monst));
return;
}
}
if(c->monst == moWolf) {
int bhd = NODIR;
ld besth = c->heat;
for(int j=0; j<c->type; j++) if(c->mov[j]->heat > besth && passable(c->mov[j], c, false, false))
besth = c->mov[j]->heat, bhd = j;
if(bhd != NODIR) {
// printf("wolf moved from %Lf (%p) to %Lf (%p)\n", c->heat, c, besth, c->mov[bhd]);
c->mov[bhd]->monst = moWolfMoved, c->monst = moNone;
}
}
else if(c->monst == moPyroCultist && c->cpdist <= 4 && cwt.c->wall == waNone && !cellUnstable(cwt.c)) {
addMessage(XLAT("%The1 throws fire at you!", c->monst));
if(itemBurns(cwt.c->item))
addMessage(XLAT("%The1 burns!", cwt.c->item)), cwt.c->item = itNone;
cwt.c->wall = waBonfire;
cwt.c->tmp = 20;
c->monst = moCultist;
}
else if(c->monst == moWitchFlash && flashWouldKill(c, true) && !flashWouldKill(c, false)) {
addMessage(XLAT("%The1 activates her Flash spell!", c->monst));
c->monst = moWitch;
activateFlashFrom(c);
}
else if(c->monst == moCrystalSage && c->cpdist <= 4 && isIcyLand(cwt.c)) {
// only one sage attacks
if(sagefresh) {
sagefresh = false;
if(sagephase == 0) {
addMessage(XLAT("%The1 shows you two fingers.", c->monst));
addMessage(XLAT("You wonder what does it mean?"));
}
else if(sagephase == 1) {
addMessage(XLAT("%The1 shows you a finger.", c->monst));
addMessage(XLAT("You think about possible meanings."));
}
else {
addMessage(XLAT("%The1 moves his finger downwards.", c->monst));
addMessage(XLAT("Your brain is steaming."));
}
sagephase++;
sageheat(cwt.c, .0);
for(int i=0; i<cwt.c->type; i++)
sageheat(cwt.c->mov[i], .3);
}
}
else if(normalMover(m)) {
int goodmoves = 0;
for(int t=0; t<c->type; t++) {
cell *c2 = c->mov[t];
if(c2 && c2->pathdist < c->pathdist)
goodmoves++;
}
movesofgood[goodmoves].push_back(c);
}
}
}
void movemonsters() {
sagefresh = true;
turncount++;
DEBT("ghosts");
moveghosts();
DEBT("normal");
for(int d=0; d<8; d++) movesofgood[d].clear();
for(int i=0; i<size(pathqm); i++) {
cell *c = pathqm[i];
considerEnemyMove(c);
}
int dcs = size(dcal);
for(int i=0; i<dcs; i++) {
cell *c = dcal[i];
if(c->pathdist == INFD)
considerEnemyMove(c);
}
for(int d=0; d<8; d++) for(int i=0; i<size(movesofgood[d]); i++) {
cell *c = movesofgood[d][i];
if(normalMover(c->monst))
moveNormal(c);
}
if(sagefresh) sagephase = 0;
DEBT("worm");
int wrm = size(worms);
for(int i=0; i<wrm; i++) {
moveWorm(worms[i]);
}
DEBT("ivy");
moveivy();
DEBT("slimes");
moveslimes();
DEBT("eagles");
if(haveeagles) moveeagles(1);
if(haveeagles) moveeagles(2);
DEBT("earth");
if(haveearth) moveearth();
DEBT("leader");
if(haveleader) moveleader();
DEBT("bugs");
if(havebugs) movebugs();
DEBT("golems");
movegolems();
DEBT("fresh");
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);
if(c->monst == moGolemMoved) c->monst = moGolem;
if(c->monst == moKnightMoved) c->monst = moKnight;
if(c->monst == moSlimeNextTurn) c->monst = moSlime;
if(c->monst == moLesser) c->monst = moLesserM;
else if(c->monst == moLesserM) c->monst = moLesser;
if(c->monst == moGreater) c->monst = moGreaterM;
else if(c->monst == moGreaterM) c->monst = moGreater;
if(c->wall == waChasm) {
c->item = itNone;
if(c->monst && c->monst != moGhost && c->monst != moEagle) {
if(c->monst != moRunDog) achievement_gain("FALLDEATH1");
killMonster(c);
}
}
if(c->wall == waBonfire) {
if(c->monst && c->monst != moGhost && c->monst != moWitchWinter && c->monst != moWitchGhost) {
addMessage(XLAT("%The1 burns!", c->monst));
killMonster(c);
}
}
if(c->wall == waLake) {
c->item = itNone;
if(c->monst == moLesser || c->monst == moLesserM || c->monst == moGreater || c->monst == moGreaterM)
c->monst = moGreaterShark;
if(c->monst && c->monst != moShark && c->monst != moGreaterShark &&
c->monst != moGhost && c->monst != moEagle) killMonster(c);
}
if(c->monst && cellUnstable(c) && c->monst != moGhost && c->monst != moEagle) {
c->wall = waChasm;
}
}
DEBT("shadow");
moveshadow();
DEBT("wandering");
wandering();
}
// move heat
vector<cell*> vinefires;
void heat() {
double rate = items[itOrbSpeed] ? .5 : 1;
int oldmelt = kills[0];
/* if(cwt.c->heat > .5) cwt.c->heat += .3;
if(cwt.c->heat > 1.) cwt.c->heat += .3;
if(cwt.c->heat > 1.4) cwt.c->heat += .5; */
if(isIcyLand(cwt.c))
cwt.c->heat += (items[itOrbWinter] ? -1.2 : 1.2) * rate;
vinefires.clear();
int dcs = size(dcal);
for(int i=0; i<dcs; i++) {
cell *c = dcal[i];
if(c->cpdist > 8) break;
if(isFire(c) && c->tmp > 0) {
if(c->land != laPower) useup(c);
if(c->wall == waBonfire) for(int i=0; i<c->type; i++) {
cell *c2 = c->mov[i];
if(c2 && c2->wall == waVinePlant)
vinefires.push_back(c2);
// both halfvines have to be near fire at once
if(c2 && cellHalfvine(c2) && c->mov[(i+1)%c->type]->wall == c2->wall)
vinefires.push_back(c2);
}
// two semifires are required to spread
if(c->wall == waPartialFire) for(int i=0; i<c->type; i++) {
cell *c2 = c->mov[i];
if(c2 && (c2->wall == waVinePlant)) {
for(int j=0; j<c2->type; j++) if(c2->mov[j] && c2->mov[j]->wall == waPartialFire &&
c2->mov[j] != c)
vinefires.push_back(c2);
}
}
}
if(!isIcyLand(c)) continue;
if(c->monst == moRanger) c->heat += 3 * rate;
if(c->monst == moDesertman) c->heat += 4 * rate;
if(c->monst == moMonkey) c->heat += rate;
if(c->wall == waDeadTroll) c->heat -= 2 * rate;
if(c->wall == waBigStatue) c->heat -= 3 * rate;
if(c->monst == moLesser || c->monst == moLesserM || c->monst == moGreater || c->monst == moGreaterM)
c->heat += (c->land == laCocytus ? 1.5 : 10) * rate;
if(c->monst == moGreaterShark)
c->heat += 2 * rate;
if(c->monst == moCultist) c->heat += 3 * rate;
if(c->monst == moCultistLeader) c->heat += 4 * rate;
if(c->monst == moPyroCultist) c->heat += 6 * rate;
if(c->monst == moGhost) c->heat -= rate;
if(c->wall == waBonfire && c->tmp > 0) c->heat += 4 * rate;
ld hmod = 0;
for(int j=0; j<c->type; j++) if(c->mov[j]) {
if(!isIcyLand(c->mov[j])) {
// make sure that we can still enter Cocytus,
// it won't heat up right away even without Orb of Winter or Orb of Speed
if(c->mov[j] == cwt.c && (c->land == laIce || items[itOrbWinter]))
hmod += rate * (items[itOrbWinter] ? -1.2 : 1.2) / 4;
continue;
}
ld hdiff = c->mov[j]->heat - c->heat;
hdiff /= 10;
if(c->mov[j]->cpdist <= 8)
c->mov[j]->heat -= hdiff;
else
hdiff = -c->heat / 250;
hmod += hdiff;
}
c->heat += hmod * rate;
if(c->monst == moCrystalSage && c->heat >= SAGEMELT) {
addMessage(XLAT("%The1 melts away!", c->monst));
killMonster(c);
}
}
for(int i=0; i<dcs; i++) {
cell *c = dcal[i];
if(c->wall == waIcewall && c->heat > .4) c->wall = waNone, kills[0]++;
if(c->wall == waFrozenLake && c->heat > .6) c->wall = waLake, kills[0]++;
if(c->wall == waLake && c->heat < -.4 && c->monst != moGreaterShark) {
c->wall = waFrozenLake;
if(c->monst == moShark) {
addMessage(XLAT("%The1 is frozen!", c->monst));
killMonster(c);
}
}
}
for(int i=0; i<size(vinefires); i++) {
cell* c = vinefires[i];
if(c->wall == waVinePlant) {
if(c->monst == moVineBeast) killMonster(c);
c->wall = waBonfire, c->tmp = 6;
}
else if(cellHalfvine(c)) destroyHalfvine(c, waPartialFire);
}
if(kills[0] != oldmelt) bfs();
}
bool gardener = false;
void livecaves() {
int dcs = size(dcal);
vector<cell*> bringlife;
for(int i=0; i<dcs; i++) {
cell *c = dcal[i];
if(c->cpdist > 8) break;
if(c->wall != waCavefloor && c->wall != waCavewall) continue;
// if(c->wall == waThumper || c->wall == waBonfire) continue;
c->tmp = 0;
if(c->monst == moDarkTroll) c->monst = moTroll;
if(c->item || c->monst || c->cpdist == 0) continue;
for(int j=0; j<c->type; j++) if(c->mov[j]) {
if(c->mov[j]->wall == waDeadfloor) c->tmp++, bringlife.push_back(c->mov[j]);
else if(c->mov[j]->wall == waDeadwall || c->mov[j]->wall == waDeadfloor2) c->tmp--, bringlife.push_back(c->mov[j]);
else if(c->mov[j]->wall == waCavefloor) c->tmp++;
else if(c->mov[j]->wall == waCavewall) c->tmp--;
else if(c->mov[j]->wall == waDeadTroll) c->tmp -= 5;
else if(c->mov[j]->wall == waVinePlant) c->tmp--;
else if(c->mov[j]->wall != waBarrier) c->tmp += 5;
if(c->mov[j]->cpdist == 0 && items[itOrbDigging]) c->tmp+=100;
if(c->mov[j]->wall == waThumper && c->mov[j]->tmp > 0) c->tmp+=100;
if(c->mov[j]->wall == waBonfire) c->tmp+=100;
if(c->mov[j]->wall == waBigStatue) c->tmp-=100;
if(c->mov[j]->item) c->tmp+=2;
if(c->mov[j]->monst == moZombie) c->tmp += 10;
if(c->mov[j]->monst == moGhost) c->tmp += 10;
if(c->mov[j]->monst == moNecromancer) c->tmp += 10;
if(c->mov[j]->monst == moWormtail) c->tmp++;
if(c->mov[j]->monst == moTentacletail) c->tmp-=2;
if(isIvy(c->mov[j])) c->tmp--;
if(isDemon(c->mov[j])) c->tmp-=3;
// if(c->mov[j]->monst) c->tmp++;
// if(c->mov[j]->monst == moTroll) c->tmp -= 3;
}
}
for(int i=0; i<dcs; i++) {
cell *c = dcal[i];
if(c->cpdist > 8) break;
if(c->wall != waCavefloor && c->wall != waCavewall) continue;
// if(c->land != laCaves) continue;
// if(c->wall == waThumper || c->wall == waBonfire) continue;
if(c->tmp > 0) c->wall = waCavefloor;
if(c->tmp < 0) {
c->wall = waCavewall;
if(c->land != laCaves && c->land != laDeadCaves && c->land != laFjord && !gardener) {
gardener = true;
achievement_gain("GARDENER");
}
}
}
for(int i=0; i<size(bringlife); i++) {
cell *c = bringlife[i];
if(!lifebrought) { lifebrought = true;
achievement_gain("LIFEBRINGER");
}
if(c->wall == waDeadfloor) c->wall = waCavefloor;
if(c->wall == waDeadfloor2) c->wall = waCavewall;
if(c->wall == waDeadwall) c->wall = waCavewall;
if(c->wall == waCavewall && c->item) c->wall = waCavefloor;
if(c->land == laDeadCaves) c->land = laCaves;
if(c->item == itSilver) c->item = itGold;
if(c->item == itGreenStone) c->item = itOrbLife;
if(c->monst == moEarthElemental) {
addMessage(XLAT("%The1 is destroyed by the forces of Life!", c->monst));
killMonster(c);
c->item = itOrbDigging;
}
}
}
void dryforest() {
int dcs = size(dcal);
for(int i=0; i<dcs; i++) {
cell *c = dcal[i];
if(c->cpdist > 8) break;
if(c->land != laDryForest) continue;
if(c->wall == waThumper) continue;
if(c->wall == waBonfire)
c->heat = 0;
for(int j=0; j<c->type; j++) if(c->mov[j]) {
if(c->mov[j]->wall == waBonfire) c->heat++;
}
}
for(int i=0; i<dcs; i++) {
cell *c = dcal[i];
if(c->cpdist > 8) break;
if(c->land != laDryForest) continue;
if(c->wall == waNone && c->heat >= 10)
burnMonstersAndItems(c, 50);
if((c->wall == waDryTree || c->wall == waWetTree || c->wall == waBonfire) && c->heat >= 1)
c->wall = waBonfire, c->tmp = 50;
}
/*
for(int i=0; i<dcs; i++) {
cell *c = dcal[i];
c->tmp = 0;
c->heat = 0;
if(c->cpdist > 8) break;
if(c->land != laDryForest) continue;
for(int j=0; j<c->type; j++) if(c->mov[j]) {
if(c->mov[j]->wall == waWetTree)
c->tmp++;
if(c->mov[j]->wall == waDryTree)
c->heat++;
}
}
for(int i=0; i<dcs; i++) {
cell *c = dcal[i];
int a = c->type - c->tmp - int(c->heat);
if(c->tmp > a && c->tmp > c->heat)
c->wall = waWetTree;
else if(c->heat > a && c->heat > c->tmp)
c->wall = waDryTree;
else if(a > c->heat && a > c->tmp)
c->wall = waNone;
} */
}
// mirror management
bool cellMirrorable(cell *c) {
return
c->wall == waNone || c->wall == waCavefloor || c->wall == waFloorA || c->wall == waFloorB ||
c->wall == waFrozenLake || c->wall == waDeadfloor || c->wall == waDeadfloor2;
}
void castLightningBolt(cellwalker lig);
void createMM(cellwalker& cw, eMonster type) {
if(type == moLightningBolt)
castLightningBolt(cw);
else if(cw.c->monst == moNone && cellMirrorable(cw.c) && cw.c != cwt.c) {
cw.c->monst = type;
cw.c->mondir = cw.spin;
}
}
void createMirrors(cell *c, int dir, eMonster type) {
cellwalker C(c, dir);
if(type == moMirror) type = moMirage;
else if(type == moMirage) type = moMirror;
for(int i=0; i<6; i++) {
cwstep(C);
if(C.c->type == 6) {
cwspin(C, i);
createMM(C, type);
cwspin(C, -i);
}
cwstep(C);
cwspin(C, 1);
}
}
void createMirages(cell *c, int dir, eMonster type) {
cellwalker C(c, dir);
for(int i=0; i<6; i++) {
cwstep(C);
if(C.c->type == 6) {
cwspin(C, 2);
cwstep(C);
cwspin(C, 4-i);
createMM(C, type);
cwspin(C, 6-4+i);
cwstep(C);
cwspin(C, 2);
cwstep(C);
cwspin(C, 2-i);
createMM(C, type);
cwspin(C, 6-2+i);
cwstep(C);
cwspin(C, 2);
}
cwstep(C);
cwspin(C, 1);
}
}
void spinmirrors(int d) {
for(int i=0; i<size(mirrors); i++) {
cell *c = mirrors[i];
if(c->monst == moMirror)
mirrors[i]->mondir = (mirrors[i]->mondir - d + 42) % mirrors[i]->type;
if(c->monst == moMirage)
mirrors[i]->mondir = (mirrors[i]->mondir + d + 42) % mirrors[i]->type;
}
}
void destroyMirrors() {
for(int i=0; i<size(mirrors); i++) {
cell *c = mirrors[i];
eMonster m = c->monst;
if(isMimic(m)) c->monst = moNone;
}
mirrors.clear();
}
void destroyStrayMirrors() {
for(int i=0; i<size(mirrors2); i++) {
cell *c = mirrors2[i];
if(c->cpdist > 7 && isMimic(c)) {
c->monst = moNone;
}
}
}
void gomirrors(bool go) {
int tk = tkills();
int nummirage = 0;
mirrors2.clear();
for(int i=0; i<size(mirrors); i++) {
cell *c = mirrors[i];
eMonster m = c->monst;
if(isMimic(m)) {
if(m == moMirage) nummirage++;
cell *c2 = c->mov[c->mondir];
if(c2 && c2->monst != moNone && !isMimic(c2) && isKillable(c2)) {
addMessage(XLAT("%The1 destroys %the2!", m, c2->monst));
killMonster(c2);
}
if(!go) continue;
c->monst = moNone;
if(!c2) continue;
stabbingAttack(c, c2, m);
if(!passable(c2, c, true, true)) continue;
if(isWorm(c2)) continue;
if(c2->monst == moGreater) {
c2->monst = moLesser; continue;
}
if(c2->monst == moGreaterM) {
c2->monst = moLesserM; continue;
}
if(c2 == cwt.c) {
addMessage(XLAT("You join %the1.", m));
continue;
}
if(isMimic(c2)) {
addMessage(XLAT("Two of your images crash and disappear!"));
c2->monst = moNone;
continue;
}
if(isIvy(c2)) {
// killIvy(c2);
continue;
}
c2->monst = m;
c2->mondir = c->spn[c->mondir];
mirrors2.push_back(c2);
}
}
for(int i=0; i<size(mirrors2); i++) {
cell *c = mirrors2[i];
eMonster m = c->monst;
if(c->wall == waMirror) {
addMessage(XLAT("%The1 breaks the mirror!", m));
createMirrors(c, c->mondir, m);
c->wall = waNone;
}
if(c->wall == waCloud) {
addMessage(XLAT("%The1 disperses the cloud!", m));
createMirages(c, c->mondir, m);
c->wall = waNone;
}
}
achievement_count("MIRRORKILL", tkills(), tk);
achievement_count("MIRAGE", nummirage, 0);
}
void reduceOrbPowers() {
if(items[itOrbLightning]) items[itOrbLightning]--;
if(items[itOrbSpeed]) items[itOrbSpeed]--;
if(items[itOrbFlash]) items[itOrbFlash]--;
if(items[itOrbShield]) items[itOrbShield]--;
if(items[itOrbWinter]) items[itOrbWinter]--;
if(items[itOrbFire]) items[itOrbFire]--;
if(items[itOrbIllusion]) items[itOrbIllusion]--;
if(items[itOrbDragon]) items[itOrbDragon]--;
if(items[itOrbPsi]) items[itOrbPsi]--;
if(items[itOrbInvis]) items[itOrbInvis]--;
if(items[itOrbGhost]) items[itOrbGhost]--;
if(items[itOrbDigging]) items[itOrbDigging]--;
if(items[itOrbTeleport]) items[itOrbTeleport]--;
if(items[itOrbSafety]) items[itOrbSafety]--;
if(items[itOrbThorns]) items[itOrbThorns]--;
}
void flashAlchemist(cell *c) {
if(c->wall == waFloorA || c->wall == waFloorB) {
if(cwt.c->wall == waFloorA || cwt.c->wall == waFloorB)
c->wall = cwt.c->wall;
else
c->wall = eWall(c->wall ^ waFloorB ^ waFloorA);
}
}
void flashCell(cell *c, bool msg) {
flashAlchemist(c);
if(msg && c->monst && !isWorm(c) && c->monst != moShadow)
addMessage(XLAT("%The1 is destroyed by the Flash.", c->monst));
killMonster(c);
if(isIcyLand(c))
c->heat += 2;
if(c->land == laDryForest)
c->heat += 2;
if(c->wall == waCavewall) c->wall = waCavefloor;
if(c->wall == waDeadTroll) c->wall = waCavefloor;
if(c->wall == waDeadfloor2) c->wall = waDeadfloor;
if(c->wall == waDeadwall) c->wall = waDeadfloor2;
if(c->wall == waMirror) c->wall = waNone;
if(c->wall == waCloud) c->wall = waNone;
if(c->wall == waDune) c->wall = waNone;
if(c->wall == waAncientGrave) c->wall = waNone;
if(c->wall == waFreshGrave) c->wall = waNone;
if(c->wall == waColumn) c->wall = waNone;
if(c->wall == waGlass) c->wall = waNone;
if(c->wall == waDryTree || c->wall == waWetTree) c->wall = waNone;
if(c->wall == waBigStatue) c->wall = waNone;
if(isActiv(c)) c->tmp = 77;
}
extern void drawFlash(cell* c);
void activateFlashFrom(cell *cf) {
drawFlash(cf);
for(int i=0; i<size(dcal); i++) {
cell *c = dcal[i];
if(c == cf) continue;
for(int t=0; t<c->type; t++)
for(int u=0; u<cf->type; u++)
if(c->mov[t] == cf->mov[u] && c->mov[t] != NULL) {
flashCell(c, true);
}
}
}
void activateFlash() {
int tk = tkills();
drawFlash(cwt.c);
addMessage(XLAT("You activate the Flash spell!"));
items[itOrbFlash] = 0;
for(int i=0; i<size(dcal); i++) {
cell *c = dcal[i];
if(c->cpdist > 2) break;
flashCell(c, false);
}
achievement_count("FLASH", tkills(), tk);
}
bool barrierAt(cellwalker& c, int d) {
if(d >= 7) return true;
if(d <= -7) return true;
d = c.spin + d + 42;
d%=c.c->type;
if(!c.c->mov[d]) return true;
if(c.c->mov[d]->wall == waBarrier) return true;
return false;
}
void castLightningBolt(cellwalker lig) {
int bnc = 0;
while(true) {
// printf("at: %p i=%d d=%d\n", lig.c, i, lig.spin);
if(lig.c->mov[lig.spin] == 0) break;
cwstep(lig);
cell *c = lig.c;
flashAlchemist(c);
killMonster(c);
if(isIcyLand(c) || c->land == laDryForest) c->heat += 2;
c->ligon = 1;
bool brk = false, spin = false;
if(c->wall == waCavewall) c->wall = waCavefloor, brk = true;
if(c->wall == waDeadTroll) c->wall = waCavefloor, brk = true;
if(c->wall == waDeadfloor2)c->wall = waDeadfloor;
if(c->wall == waDeadwall) c->wall = waDeadfloor2, brk = true;
if(c->wall == waGlass) c->wall = waNone, spin = true;
if(c->wall == waDune) c->wall = waNone, brk = true;
if(c->wall == waIcewall) c->wall = waNone, brk = true;
if(c->wall == waAncientGrave) c->wall = waNone, spin = true;
if(c->wall == waFreshGrave) c->wall = waNone, spin = true;
if(c->wall == waBigStatue) c->wall = waNone, spin = true;
if(c->wall == waColumn) c->wall = waNone, spin = true;
if(isActiv(c)) c->tmp = 77;
if(c->wall == waDryTree || c->wall == waWetTree || c->wall == waVinePlant) {
burnMonstersAndItems(c, 4);
brk = true;
}
if(cellHalfvine(c) && c->mov[lig.spin] && c->wall == c->mov[lig.spin]->wall) {
destroyHalfvine(c, waPartialFire, 4);
brk = true;
}
if(c == cwt.c) {bnc++; if(bnc > 10) break; }
if(spin) cwspin(lig, rand() % lig.c->type);
if(brk) break;
if(c->wall == waBarrier || c->wall == waCamelot) {
int left = -1;
int right = 1;
while(barrierAt(lig, left)) left--;
while(barrierAt(lig, right)) right++;
cwspin(lig, -(right + left));
bnc++; if(bnc > 10) break;
}
else {
cwspin(lig, 3);
if(c->type == 7) cwspin(lig, rand() % 2);
}
if(c->wall == waCloud) {
c->wall = waNone;
createMirages(c, lig.spin, moLightningBolt);
}
if(c->wall == waMirror) {
c->wall = waNone;
createMirrors(c, lig.spin, moLightningBolt);
break;
}
}
}
void activateLightning() {
int tk = tkills();
extern void drawLightning();
drawLightning();
addMessage(XLAT("You activate the Lightning spell!"));
items[itOrbLightning] = 0;
for(int i=0; i<cwt.c->type; i++)
castLightningBolt(cellwalker(cwt.c, i));
achievement_count("LIGHTNING", tkills(), tk);
}
// move the PC in direction d (or stay in place for d == -1)
bool canmove = true;
bool checkNeedMove(bool checkonly) {
if(items[itOrbGhost] > 1) return false;
if(cwt.c->wall == waRoundTable) {
if(checkonly) return true;
addMessage(XLAT("It would be impolite to land on the table!"));
}
else if(cwt.c->wall == waLake) {
if(checkonly) return true;
addMessage(XLAT("Ice below you is melting! RUN!"));
}
else if(isFire(cwt.c) && items[itOrbShield] < 2 && !items[itOrbWinter]) {
if(checkonly) return true;
addMessage(XLAT("This spot will be burning soon! RUN!"));
}
else if(items[itOrbGhost] == 1 && !player_passable(cwt.c, NULL, false)) {
if(checkonly) return true;
addMessage(XLAT("Your Aether power has expired! RUN!"));
}
else if(cwt.c->wall == waChasm) {
if(checkonly) return true;
addMessage(XLAT("The floor has collapsed! RUN!"));
}
else return false;
return true;
}
#define YDIST 101
struct yendorinfo {
cell *path[YDIST];
bool found;
};
vector<yendorinfo> yi;
int yii = 0;
bool checkYendor(cell *yendor, bool checkonly) {
int byi = size(yi);
for(int i=0; i<size(yi); i++) if(yi[i].path[0] == yendor) byi = i;
if(byi < size(yi) && yi[byi].found) return true;
if(checkonly) return false;
if(byi == size(yi)) {
yendorinfo nyi;
nyi.path[0] = yendor;
cellwalker lig(yendor, rand() % yendor->type);
cell *prev = yendor;
for(int i=0; i<YDIST-1; i++) {
nyi.path[i] = lig.c;
prev = lig.c;
cwstep(lig);
cwspin(lig, 3);
if(lig.c->type == 7) cwspin(lig, rand() % 2);
setdist(lig.c, 10, prev);
setdist(lig.c, 9, prev);
}
nyi.path[YDIST-1] = lig.c;
nyi.found = false;
cell *key = lig.c;
for(int b=10; b>=7; b--) setdist(key, b, prev);
for(int i=-1; i<key->type; i++) {
cell *c2 = i >= 0 ? key->mov[i] : key;
c2->monst = moNone; c2->item = itNone;
if(!passable(c2, NULL, true, true)) {
if(c2->wall == waCavewall) c2->wall = waCavefloor;
else if(c2->wall == waDeadwall) c2->wall = waDeadfloor2;
else if(c2->wall == waLake) c2->wall = waFrozenLake;
else c2->wall = waNone;
}
}
key->item = itKey;
yi.push_back(nyi);
}
yii = byi;
addMessage(XLAT("You need to find the right Key to unlock this Orb of Yendor!"));
achievement_gain("YENDOR1");
return false;
}
int countMyGolems() {
int g=0, dcs = size(dcal);
for(int i=0; i<dcs; i++) {
cell *c = dcal[i];
if(c->monst == moGolem) g++;
}
return g;
}
void restoreGolems(int qty) {
int dcs = size(dcal);
for(int i=1; qty && i<dcs; i++) {
cell *c = dcal[i];
if(passable(c, NULL, false, false))
c->monst = moGolem, qty--;
}
}
void activateSafety(eLand l) {
extern void drawSafety();
int g = countMyGolems();
drawSafety();
addMessage(XLAT("You fall into a wormhole!"));
eLand f = firstland;
if(l == laTemple) l = laRlyeh;
if(l == laCamelot) l = laCrossroads;
firstland = l;
for(int i=0; i<65536; i++) euland[i] = laNone;
euland[0] = euland[1] = firstland;
safety = true;
clearMemory();
initcells();
initgame();
firstland = f;
safety = false;
restoreGolems(g);
extern void restartGraph();
restartGraph();
}
bool hasSafeOrb(cell *c) {
return
c->item == itOrbSafety ||
c->item == itOrbShield ||
c->item == itOrbYendor;
}
bool movepcto(int d, bool checkonly = false);
void checkmove() {
canmove = false;
if(movepcto(-1, true)) canmove = true;
for(int i=0; i<cwt.c->type; i++)
if(movepcto(1, true)) canmove = true;
if(!canmove)
achievement_final(true);
if(canmove && timerstopped) {
timerstart = time(NULL);
timerstopped = false;
}
}
// move the PC. Warning: a very long function! todo: refactor
void placeGolem(cell *on, cell *moveto, eMonster m) {
if(passable(on, moveto, false, false))
cwt.c->monst = m;
else if(on->wall == waBonfire)
addMessage(XLAT("%The1 burns!", m));
}
void movecost(cell* from, cell *to) {
if(from->land == laPower && to->land != laPower) {
int n=0;
for(int i=0; i<ittypes; i++)
if(itemclass(eItem(i)) == IC_ORB && items[i] >= 2 && i != itOrbFire)
items[i] = 2, n++;
if(n)
addMessage(XLAT("As you leave, your powers are drained!"));
}
}
enum orbAction { roMouse, roKeyboard, roCheck, roMouseForce };
// roCheck: return orb type if successful, 0 otherwise
// roMouse/roKeyboard:
// return orb type if successful, eItem(-1) if do nothing, 0 otherwise
eItem targetRangedOrb(cell *c, orbAction a);
bool haveRangedOrb() {
return
items[itOrbPsi] || items[itOrbDragon] || items[itOrbTeleport] ||
items[itOrbIllusion];
}
bool isRangedOrb(eItem i) {
return i == itOrbPsi || i == itOrbDragon || i == itOrbTeleport || i == itOrbIllusion;
}
bool haveRangedTarget() {
if(!haveRangedOrb())
return false;
for(int i=0; i<size(dcal); i++) {
cell *c = dcal[i];
if(targetRangedOrb(c, roCheck)) return true;
}
return false;
}
bool movepcto(int d, bool checkonly) {
if(checkonly && haveRangedTarget()) return true;
if(!checkonly) flipplayer = false;
if(!checkonly) DEB("movepc");
if(d >= 0) {
cwspin(cwt, d);
spinmirrors(d);
d = cwt.spin;
}
if(d != -1 && !checkonly) playermoved = true;
if(!checkonly) invismove = false;
if(d >= 0) {
cell *c2 = cwt.c->mov[d];
if(!player_passable(c2, cwt.c, false) && items[itOrbFlash]) {
if(checkonly) return true;
activateFlash();
checkmove();
return true;
}
if(!player_passable(c2, cwt.c, false) && items[itOrbLightning]) {
if(checkonly) return true;
activateLightning();
checkmove();
return true;
}
if(isActiv(c2) && c2->tmp == -1) {
if(checkonly) return true;
addMessage(XLAT("You activate %the1.", c2->wall));
c2->tmp = 100;
checkmove();
return true;
}
if((c2->wall == waThumper/* || (c2->wall == waBigStatue && c2->type == 6)*/) && !monstersnear(c2) && !c2->monst) {
eWall w = c2->wall;
cellwalker push = cwt;
cwstep(push);
cwspin(push, 3);
cwstep(push);
/* if(w == waBigStatue && push.c->type == 7) {
if(checkonly) return false;
addMessage(XLAT("%The1 is too heavy to put it back on the pedestal.", c2->wall));
return false;
} */
if((!passable(push.c, c2, false, true) || !passable(push.c, cwt.c, false, true) || push.c->item) && c2->type == 7) {
cwstep(push);
cwspin(push, 1);
cwstep(push);
}
if(!passable(push.c, c2, false, true) || !passable(push.c, cwt.c, false, true) || push.c->item) {
if(checkonly) return false;
addMessage(XLAT("No room to push %the1.", c2->wall));
return false;
}
if(checkonly) return true;
addMessage(XLAT("You push %the1.", c2->wall));
push.c->tmp = c2->tmp;
if(c2->land == laAlchemist)
c2->wall = (cwt.c->wall == waFloorB || cwt.c->wall == waFloorA) ? cwt.c->wall : push.c->wall;
else c2->wall = waNone;
push.c->wall = w;
}
/* if((c2->wall == waBigStatue) && c2->type == 7 && !monstersnear(c2)) {
int q = 0;
for(int i=3; i<=4; i++) {
cellwalker push = cwt;
cwstep(push);
cwspin(push, i);
cwstep(push);
if(passable(push.c, c2, false, true)) q++;
}
if(!q) {
if(checkonly) return false;
addMessage(XLAT("No room to push %the1.", c2->wall));
return false;
}
if(checkonly) return true;
addMessage(XLAT("You push %the1.", c2->wall));
c2->wall = waNone;
for(int i=3; i<=4; i++) {
cellwalker push = cwt;
cwstep(push);
cwspin(push, i);
cwstep(push);
if(passable(push.c, c2, false, true))
push.c->wall = waBigStatue;
}
} */
if(c2->wall == waBigStatue && !monstersnear(c2) && !c2->monst) {
if(!canPushStatueOn(cwt.c)) {
if(checkonly) return false;
if(cwt.c->wall == waBonfire)
addMessage(XLAT("You have to escape first!"));
else
addMessage(XLAT("There is not enough space!"));
return false;
}
if(checkonly) return true;
addMessage(XLAT("You push %the1 behind you!", c2->wall));
c2->wall = cwt.c->wall;
if(cellUnstable(cwt.c))
cwt.c->wall = waChasm;
else
cwt.c->wall = waBigStatue;
}
if(c2->wall == waDryTree && !monstersnear(cwt.c)) {
if(checkonly) return true;
addMessage(XLAT("You start cutting down the tree."));
c2->wall = waWetTree;
}
else if(c2->wall == waWetTree && !monstersnear(cwt.c)) {
if(checkonly) return true;
addMessage(XLAT("You cut down the tree."));
c2->wall = waNone;
}
else if(c2->monst == moKnight) {
if(checkonly) return false;
bool tooeasy = (roundTableRadius(c2) < newRoundTableRadius());
if(grailWasFound(cwt.c) && rand() % 5 == 0) {
addMessage(XLAT("\"I would like to congratulate you again!\""));
}
else if(rand() % 5 != 0 && !tooeasy) {
static int i;
i++;
if(i%2)
addMessage(XLAT("\"Find the Holy Grail to become one of us!\""));
else
addMessage(XLAT("\"The Holy Grail is in the center of the Round Table.\""));
}
else {
int i = rand() % 3;
if(i == 0)
addMessage(XLAT("\"I enjoy watching the hyperbug battles.\""));
if(i == 1)
addMessage(XLAT("\"Have you visited a temple in R'Lyeh?\""));
if(i == 2)
addMessage(XLAT("\"Nice castle, eh?\""));
}
return false;
}
else if(c2->monst && !isFriendly(c2)) {
if(c2->monst == moWorm || c2->monst == moWormtail || c2->monst == moWormwait) {
if(checkonly) return false;
addMessage(XLAT("You cannot attack Sandworms directly!"));
return false;
}
if(attackingForbidden(c2, cwt.c)) {
if(checkonly) return false;
addMessage(XLAT("You cannot attack through the Vine!"));
return false;
}
if(c2->monst == moTentacle || c2->monst == moTentacletail || c2->monst == moTentaclewait) {
if(checkonly) return false;
addMessage(XLAT("You cannot attack Tentacles directly!"));
return false;
}
/* if(isBug(c2)) {
if(checkonly) return false;
addMessage(XLAT("You cannot win with %the1!", c2->monst));
return false;
}
*/
if(c2->monst == moHedge && !items[itOrbThorns]) {
if(checkonly) return false;
addMessage(XLAT("You cannot attack %the1 directly!", c2->monst));
addMessage(XLAT("Stab them by walking around them."));
return false;
}
if(c2->monst == moFlailer) {
if(checkonly) return false;
addMessage(XLAT("You cannot attack %the1 directly!", c2->monst));
addMessage(XLAT("Make him hit himself by walking away from him."));
return false;
}
if(c2->monst == moShadow) {
if(checkonly) return false;
addMessage(XLAT("You cannot defeat the Shadow!"));
return false;
}
if(c2->monst == moGreater || c2->monst == moGreaterM) {
if(checkonly) return false;
addMessage(XLAT("You cannot defeat the Greater Demon yet!"));
return false;
}
if(monstersnear(cwt.c, c2)) {
if(checkonly) return false;
addMessage(XLAT("You would be killed by %the1!", which));
return false;
}
if(checkNeedMove(checkonly))
return false;
if(checkonly) return true;
addMessage(XLAT("You kill %the1.", c2->monst));
int mt = c2->monst;
int tk = tkills();
killMonster(c2);
int ntk = tkills();
if(tk == 0 && ntk > 0)
addMessage(XLAT("That was easy, but groups could be dangerous."));
if(tk < 10 && ntk >= 10)
addMessage(XLAT("Good to know that your fighting skills serve you well in this strange world."));
if(tk < 50 && ntk >= 50)
addMessage(XLAT("You wonder where all these monsters go, after their death..."));
if(tk < 100 && ntk >= 100)
addMessage(XLAT("You feel that the souls of slain enemies pull you to the Graveyard..."));
if(mt == moIvyRoot && ntk>tk)
achievement_gain("IVYSLAYER");
gomirrors(0);
}
else if(!player_passable(c2, cwt.c, true)) {
if(checkonly) return false;
if(c2->wall == waFloorA || c2->wall == waFloorB)
addMessage(XLAT("Wrong color!"));
else if(c2->wall == waRoundTable)
addMessage(XLAT("It would be impolite to land on the table!"));
else
addMessage(XLAT("You cannot move through %the1!", c2->wall));
return false;
}
else if(c2->land == laGameBoard) {
// do not pick up!
if(checkonly) return true;
flipplayer = true;
cwstep(cwt);
setdist(cwt.c, 0, NULL);
bfs();
checkmove();
return true;
}
else {
if(c2->item == itOrbYendor && !checkYendor(c2, checkonly)) {
return false;
}
if(c2->item == itHolyGrail) {
if(roundTableRadius(c2) < newRoundTableRadius()) {
if(checkonly) return false;
addMessage(XLAT("That was not a challenge. Find a larger castle!"));
return false;
}
}
if(!hasSafeOrb(c2) && monstersnear(c2)) {
if(checkonly) return false;
if(items[itOrbFlash]) {
if(checkonly) return true;
activateFlash();
checkmove();
return true;
}
if(items[itOrbLightning]) {
if(checkonly) return true;
activateLightning();
checkmove();
return true;
}
addMessage(XLAT("%The1 would kill you there!", which));
return false;
}
if(checkonly) return true;
flipplayer = true;
if(c2->item && c2->land == laAlchemist) c2->wall = cwt.c->wall;
if(c2->wall == waRoundTable) {
addMessage(XLAT("You jump over the table!"));
}
if(cwt.c->wall == waRoundTable) {
int dd = celldistAltRelative(c2) - celldistAltRelative(cwt.c);
bool tooeasy = (roundTableRadius(c2) < newRoundTableRadius());
if(dd>0) {
if(grailWasFound(cwt.c)) {
addMessage(XLAT("The Knights congratulate you on your success!"));
knighted = roundTableRadius(cwt.c);
}
else if(!tooeasy)
addMessage(XLAT("The Knights laugh at your failure!"));
}
else {
if(grailWasFound(cwt.c))
addMessage(XLAT("The Knights stare at you!"));
else if(tooeasy)
addMessage(XLAT("Come on, this is too easy... find a bigger castle!"));
else
addMessage(XLAT("The Knights wish you luck!"));
}
}
int pg = gold();
bool dopickup = true;
invismove = items[itOrbInvis] > 0;
if(items[itOrbFire]) {
invismove = false;
firetrail(cwt.c);
}
if(items[itOrbDigging]) {
invismove = false;
earthMove(cwt.c, d);
}
if(c2->item) {
invismove = false;
string s0 = "";
if(0) ;
if(gold() == 0)
addMessage(XLAT("Wow! %1! This trip should be worth it!", c2->item));
else if(gold() == 1)
addMessage(XLAT("For now, collect as much treasure as possible..."));
else if(gold() == 2)
addMessage(XLAT("Prove yourself here, then find new lands, with new quests..."));
else if(!items[c2->item] && itemclass(c2->item) == IC_TREASURE)
addMessage(XLAT("You collect your first %1!", c2->item));
else if(c2->item == itKey)
addMessage(XLAT("You have found the Key! Now unlock this Orb of Yendor!"));
else if(c2->item == itGreenStone && !items[itGreenStone])
addMessage(XLAT("This orb is dead..."));
else if(c2->item == itGreenStone)
addMessage(XLAT("Another Dead Orb."));
else if(itemclass(c2->item) != IC_TREASURE)
addMessage(XLAT("You have found %the1!", c2->item));
else if(items[c2->item] == 4 && maxgold() == 4) {
addMessage(XLAT("You feel that %the2 become%s2 more dangerous.", c2->item, c2->land));
addMessage(XLAT("With each %1 you collect...", c2->item, c2->land));
}
else if(items[c2->item] == 9 && maxgold() == 9)
addMessage(XLAT("Are there any magical orbs in %the1?...", c2->land));
else if(items[c2->item] == 10 && maxgold() == 10) {
addMessage(XLAT("You feel that %the1 slowly become%s1 dangerous...", c2->land));
addMessage(XLAT("Better find some other place."));
}
else if(c2->item == itSpice && items[itSpice] == 7)
addMessage(XLAT("You have a vision of the future, fighting demons in Hell..."));
else if(c2->item == itElixir && items[itElixir] == 4)
addMessage(XLAT("With this Elixir, your life should be long and prosperous..."));
else if(c2->item == itBone && items[itBone] == 6)
addMessage(XLAT("The Necromancer's Totem contains hellish incantations..."));
else if(c2->item == itStatue && items[itStatue] == 6)
addMessage(XLAT("The inscriptions on the Statue of Cthulhu point you toward your destiny..."));
else if(c2->item == itStatue && items[itStatue] == 4)
addMessage(XLAT("There must be some temples of Cthulhu in R'Lyeh..."));
else if(c2->item == itDiamond && items[itDiamond] == 8)
addMessage(XLAT("Still, even greater treasures lie ahead..."));
else if(c2->item == itFernFlower && items[itFernFlower] == 4)
addMessage(XLAT("You overheard Hedgehog Warriors talking about emeralds..."));
else if(c2->item == itEmerald && items[itEmerald] == 4)
addMessage(XLAT("You overhear miners talking about a castle..."));
else if(c2->item == itEmerald && items[itEmerald] == 5)
addMessage(XLAT("A castle in the Crossroads..."));
else {
string t = XLAT("You collect %the1.", c2->item);
addMessage(t);
}
}
if(c2->item == itOrbSpeed) {
items[c2->item] += 31;
if(items[c2->item] > 67) items[c2->item] = 67;
}
else if(c2->item == itOrbLife) {
placeGolem(cwt.c, c2, moGolem);
}
else if(c2->item == itOrbSafety) {
items[c2->item] += 7;
activateSafety(c2->land);
return true;
}
else if(c2->item == itOrbLightning) {
items[c2->item] += 78;
if(items[c2->item] > 777) items[c2->item] = 777;
}
else if(c2->item == itOrbThorns) {
items[c2->item] += 78;
if(items[c2->item] > 151) items[c2->item] = 151;
}
else if(c2->item == itOrbFlash) {
items[c2->item] += 78;
if(items[c2->item] > 777) items[c2->item] = 777;
}
else if(c2->item == itOrbShield) {
items[c2->item] += 16;
if(items[c2->item] > 77) items[c2->item] = 77;
}
else if(c2->item == itOrbWinter) {
items[c2->item] += 31;
if(items[c2->item] > 77) items[c2->item] = 77;
}
else if(c2->item == itOrbFire) {
items[c2->item] += 31;
if(items[c2->item] > 77) items[c2->item] = 77;
}
else if(c2->item == itOrbDragon) {
items[c2->item] += 78;
if(items[c2->item] > 111) items[c2->item] = 111;
}
else if(c2->item == itOrbIllusion) {
items[c2->item] += 78;
if(items[c2->item] > 111) items[c2->item] = 111;
}
else if(c2->item == itOrbPsi) {
items[c2->item] += 78;
if(items[c2->item] > 111) items[c2->item] = 111;
}
else if(c2->item == itOrbInvis) {
items[c2->item] += 31;
if(items[c2->item] > 77) items[c2->item] = 77;
}
else if(c2->item == itOrbGhost) {
items[c2->item] += 31;
if(items[c2->item] > 77) items[c2->item] = 77;
}
else if(c2->item == itOrbDigging) {
items[c2->item] += 78;
if(items[c2->item] > 101) items[c2->item] = 101;
}
else if(c2->item == itOrbTeleport) {
items[c2->item] += 78;
if(items[c2->item] > 201) items[c2->item] = 201;
}
else if(c2->item == itOrbYendor) {
for(int i=0; i<4; i++) switch(rand() % 12) {
case 0: items[itOrbSpeed] += 31; break;
case 1: items[itOrbLightning] += 78; break;
case 2: items[itOrbFlash] += 78; break;
case 3: items[itOrbShield] += 31; break;
case 4: items[itOrbWinter] += 151; break;
case 5: items[itOrbDigging] += 151; break;
case 6: items[itOrbTeleport] += 151; break;
case 7: items[itOrbThorns] += 151; break;
case 8: items[itOrbInvis] += 151; break;
case 9: items[itOrbPsi] += 151; break;
case 10: items[itOrbGhost] += 151; break;
case 11: items[itOrbFire] += 151; break;
}
items[itOrbYendor]++;
items[itKey]--;
addMessage(XLAT("CONGRATULATIONS!"));
achievement_collection(itOrbYendor, pg, gold());
achievement_victory(false);
}
else if(c2->item == itHolyGrail) {
int v = newRoundTableRadius() + 12;
items[itOrbTeleport] += v;
items[itOrbSpeed] += v;
items[itHolyGrail]++;
addMessage(XLAT("Congratulations! You have found the Holy Grail!"));
if(!euclid) c2->master->alt->fjordval |= GRAIL_FOUND;
achievement_collection(c2->item, pg, gold());
}
else if(c2->item == itKey) {
for(int i=0; i<size(yi); i++) if(yi[i].path[YDIST-1] == c2)
yi[i].found = true;
items[itKey]++;
}
else if(c2->item == itGrimoire && items[itGrimoire] > celldistAlt(c2)/-TEMPLE_EACH) {
addMessage(XLAT("You already have this Grimoire! Seek new tomes in the inner circles."));
dopickup = false;
}
else {
bool lhu = hellUnlocked();
if(c2->item) items[c2->item]++;
int g2 = gold();
if(c2->item == itHyperstone && items[itHyperstone] == 10)
achievement_victory(true);
achievement_collection(c2->item, pg, g2);
if(pg < 15 && g2 >= 15)
addMessage(XLAT("Collect treasure to access more different lands..."));
if(pg < 30 && g2 >= 30)
addMessage(XLAT("You feel that you have enough treasure to access new lands!"));
if(pg < 45 && g2 >= 45)
addMessage(XLAT("Collect more treasures, there are still more lands waiting..."));
if(pg < 60 && g2 >= 60)
addMessage(XLAT("You feel that the stars are right, and you can access R'Lyeh!"));
if(pg < 75 && g2 >= 75)
addMessage(XLAT("Kill monsters and collect treasures, and you may get access to Hell..."));
if(pg < 90 && g2 >= 90)
addMessage(XLAT("To access Hell, collect 10 treasures each of 9 kinds..."));
if(hellUnlocked() && !lhu) {
addMessage(XLAT("Abandon all hope, the gates of Hell are opened!"));
addMessage(XLAT("And the Orbs of Yendor await!"));
}
}
if(dopickup) c2->item = itNone;
// if(c2->land == laHive)
// c2->heat = 1;
int numOrb = 0;
for(int i=0; i<ittypes; i++)
if(itemclass(eItem(i)) == IC_ORB && items[i])
numOrb++;
if(numOrb) achievement_count("ORB", numOrb, 0);
if(items[itOrbWinter] && isIcyLand(cwt.c)) {
invismove = false;
if(cwt.c->wall == waNone)
cwt.c->wall = waIcewall;
}
movecost(cwt.c, c2);
if(c2->monst == moGolem || c2->monst == moIllusion) {
addMessage(XLAT("You switch places with %the1.", c2->monst));
placeGolem(cwt.c, c2, c2->monst);
c2->monst = moNone;
}
else if(c2->monst) {
addMessage(XLAT("You rejoin %the1.", c2->monst));
killMonster(c2);
}
stabbingAttack(cwt.c, c2);
cwstep(cwt);
gomirrors(1);
if(c2->wall == waMirror) {
invismove = false;
addMessage(XLAT("The mirror shatters!"));
if(c2->land == laMirror) {
int g = gold();
items[itShard]++;
achievement_collection(itShard, g+1, g);
}
c2->wall = waNone;
createMirrors(cwt.c, cwt.spin, moMirage);
}
if(c2->wall == waGlass && items[itOrbGhost] > 2) {
addMessage(XLAT("Your Aether powers are drained by %the1!", c2->wall));
items[itOrbGhost] = 2;
}
if(c2->wall == waCloud) {
invismove = false;
addMessage(XLAT("The cloud turns into a bunch of images!"));
if(c2->land == laMirror) {
int g = gold();
items[itShard]++;
achievement_collection(itShard, g+1, g);
}
c2->wall = waNone;
createMirages(cwt.c, cwt.spin, moMirage);
}
if(cellUnstable(c2) && !items[itOrbGhost])
c2->wall = waChasm;
countLocalTreasure();
landvisited[cwt.c->land] = true;
setdist(cwt.c, 0, NULL);
}
}
else {
if(checkNeedMove(checkonly))
return false;
if(monstersnear(cwt.c)) {
if(checkonly) return false;
addMessage(XLAT("%The1 would get you!", which));
return false;
}
if(checkonly) return true;
if(d == -2 && items[itGreenStone] && cwt.c->item == itNone) {
items[itGreenStone]--;
if(false) {
cwt.c->item = itNone;
spill(cwt.c, eWall(cwt.c->wall ^ waFloorA ^ waFloorB), 3);
addMessage(XLAT("The slime reacts with %the1!", itGreenStone));
}
else {
cwt.c->item = itGreenStone;
addMessage(XLAT("You drop %the1.", itGreenStone));
}
}
else if(d == -2) {
if(gold() >= 300)
addMessage(XLAT("You feel great, like a true treasure hunter."));
else if(gold() >= 200)
addMessage(XLAT("Your eyes shine like gems."));
else if(gold() >= 100)
addMessage(XLAT("Your eyes shine as you glance at your precious treasures."));
else if(gold() >= 50)
addMessage(XLAT("You glance at your great treasures."));
else if(gold() >= 10)
addMessage(XLAT("You glance at your precious treasures."));
else if(gold() > 0)
addMessage(XLAT("You glance at your precious treasure."));
else
addMessage(XLAT("Your inventory is empty."));
}
}
DEBT("bfs");
bfs();
destroyStrayMirrors();
DEBT("heat");
heat();
DEBT("rop");
int phase1 = (1 & items[itOrbSpeed]);
reduceOrbPowers();
DEBT("mmo");
int phase2 = (1 & items[itOrbSpeed]);
if(!phase2) movemonsters();
if(cwt.c->land == laPower && !phase1) { bfs(); moveFastMonsters(); }
DEBT("lc");
if(!phase1) livecaves();
if(!phase1) dryforest();
DEBT("check");
checkmove();
DEBT("done");
return true;
}
/* bool isPsiTarget(cell *dst) {
return
dst->cpdist > 1 &&
dst->monst &&
!(isWorm(dst) || dst->monst == moShadow);
} */
void teleportTo(cell *dest) {
cwt.c->monst = dest->monst;
dest->monst = moNone;
movecost(cwt.c, dest);
cwt.c = dest; cwt.spin = rand() % dest->type; flipplayer = !!(rand() % 2);
items[itOrbTeleport] = 0;
addMessage(XLAT("You teleport to a new location!"));
destroyMirrors();
for(int i=9; i>=0; i--)
setdist(cwt.c, i, NULL);
bfs();
checkmove();
}
void psi_attack(cell *dest) {
addMessage(XLAT("You kill %the1 with a mental blast!", dest->monst));
killMonster(dest);
items[itOrbPsi] -= 30;
if(items[itOrbPsi]<0) items[itOrbPsi] = 0;
checkmove();
}
bool flammable(cell *c) {
return
c->wall == waNone || c->wall == waFloorA || c->wall == waFloorB ||
c->wall == waCavefloor || c->wall == waDeadfloor ||
c->wall == waDryTree || c->wall == waWetTree ||
c->wall == waVinePlant || c->wall == waVineHalfA || c->wall == waVineHalfB ||
c->wall == waIcewall;
}
void placeDragonfire(cell *c) {
if(cellUnstable(c))
c->wall = waChasm;
else if(c->wall == waNone && c->land == laCocytus)
c->wall = waLake, c->heat += 20;
else if(cellHalfvine(c))
flameHalfvine(c, 20);
else {
c->wall = waBonfire;
c->tmp = 20;
}
if(itemBurns(c->item))
addMessage(XLAT("%The1 burns!", c->item)), c->item = itNone;
addMessage(XLAT("You throw fire!"));
items[itOrbDragon] -= 5;
if(items[itOrbDragon]<0) items[itOrbDragon] = 0;
checkmove();
}
void placeIllusion(cell *c) {
c->monst = moIllusion;
items[itOrbIllusion] -= 5;
if(items[itOrbIllusion]<0) items[itOrbIllusion] = 0;
addMessage(XLAT("You create an Illusion!"));
checkmove();
}
eItem targetRangedOrb(cell *c, orbAction a) {
if(!haveRangedOrb()) return itNone;
if(c == cwt.c || isNeighbor(cwt.c, c)) {
if(a == roKeyboard || a == roMouseForce )
addMessage(XLAT("You cannot target that close!"));
return itNone;
}
if(c->cpdist > 7) {
if(a != roCheck)
addMessage(XLAT("You cannot target that far away!"));
return itNone;
}
// (1) switch with an illusion
if(items[itOrbTeleport] && c->monst == moIllusion) {
if(a != roCheck) teleportTo(c);
return itOrbTeleport;
}
// (2) place illusion
if(items[itOrbIllusion] && c->monst == moNone && c->item == itNone && passable(c, NULL, false, true)) {
if(a != roCheck) placeIllusion(c);
return itOrbIllusion;
}
// (3) teleport
if(items[itOrbTeleport] && c->monst == moNone && c->item == itNone && passable(c, NULL, false, true)) {
if(a != roCheck) teleportTo(c);
return itOrbTeleport;
}
// (4) remove an illusion
if(items[itOrbIllusion] && c->monst == moIllusion) {
if(a != roCheck) {
addMessage(XLAT("You take the Illusion away."));
items[itOrbIllusion] += 4;
c->monst = moNone;
}
return itOrbIllusion;
}
// (5) psi blast
if(items[itOrbPsi] && c->monst && !isWorm(c) && c->monst != moShadow) {
if(a != roCheck) psi_attack(c);
return itOrbPsi;
}
// (6) place fire
if(items[itOrbDragon] && flammable(c)) {
if(a != roCheck) placeDragonfire(c);
return itOrbDragon;
}
if(a == roCheck) return itNone;
if(items[itOrbPsi] && c->monst) {
addMessage(XLAT("%The1 is immune to mental blasts!", c->monst));
}
else if(items[itOrbTeleport] && c->monst) {
addMessage(XLAT("Cannot teleport on a monster!"));
}
else if(items[itOrbIllusion] && c->item)
addMessage(XLAT("Cannot cast illusion on an item!"));
else if(items[itOrbIllusion] && c->monst)
addMessage(XLAT("Cannot cast illusion on a monster!"));
else if(items[itOrbIllusion] && !passable(c, NULL, false, true))
addMessage(XLAT("Cannot cast illusion here!"));
else if(items[itOrbTeleport] && c->item) {
addMessage(XLAT("Cannot teleport on an item!"));
}
else if(items[itOrbTeleport] && !passable(c, NULL, false, true)) {
addMessage(XLAT("Cannot teleport here!"));
}
else if(items[itOrbDragon] && !flammable(c)) {
addMessage(XLAT("Cannot throw fire there!"));
}
else return eItem(0);
return eItem(-1);
}
#define MAXBOX 120
#define POSSCORE 107 // update this when new boxes are added!
struct score {
string ver;
int box[MAXBOX];
};
int savebox[MAXBOX], boxid;
bool saving;
string boxname[MAXBOX];
bool fakebox[MAXBOX];
void applyBox(int& t) {
if(saving) savebox[boxid++] = t;
else t = savebox[boxid++];
}
void applyBoxNum(int& i, string name = "") {
fakebox[boxid] = (name == "");
boxname[boxid] = name;
applyBox(i);
}
// just skips the value when loading
void applyBoxSave(int i, string name = "") {
fakebox[boxid] = (name == "");
boxname[boxid] = name;
applyBox(i);
}
int applyBoxLoad(string name = "") {
fakebox[boxid] = (name == "");
boxname[boxid] = name;
int i=0; applyBox(i);
return i;
}
void applyBoxI(eItem it, bool f = false) {
boxname[boxid] = iinf[it].name;
fakebox[boxid] = f;
applyBox(items[it]);
}
void applyBoxM(eMonster m, bool f = false) {
fakebox[boxid] = f;
boxname[boxid] = minf[m].name;
applyBox(kills[m]);
}
void killbox(eMonster m, int& val) {
if(saving) kills[m] = val;
else { val = kills[m]; kills[m] = 0; }
}
void applyBoxes() {
applyBoxSave(timerstart, "time elapsed");
time_t timer = time(NULL);
applyBoxSave(timer, "date");
applyBoxSave(gold(), "treasure collected");
applyBoxSave(tkills(), "total kills");
applyBoxNum(turncount, "turn count");
applyBoxNum(cellcount, "cells generated");
if(!saving) timerstart = time(NULL);
for(int i=0; i<itOrbLightning; i++)
if(i == 0) items[i] = 0, applyBoxI(itFernFlower);
else applyBoxI(eItem(i));
for(int i=0; i<43; i++) {
kills[i] = 0;
bool fake =
i == moLesserM || i == moNone || i == moWolfMoved || i == moTentacletail;
if(i == moWormtail) applyBoxM(moCrystalSage);
else if(i == moWormwait) applyBoxM(moFireFairy);
else if(i == moTentacleEscaping) applyBoxM(moMiner);
else if(i == moGolemMoved) applyBoxM(moIllusion);
else if(i == moTentaclewait) applyBoxI(itOrbThorns, true);
else if(i == moGreater) applyBoxI(itOrbDragon, true);
else if(i == moGreaterM) applyBoxI(itOrbIllusion, true);
else applyBoxM(eMonster(i), fake);
}
if(saving) {
applyBoxSave(savetime + timer - timerstart);
}
else savetime = applyBoxLoad();
savecount++; applyBoxNum(savecount, "number of saves"); savecount--;
applyBoxNum(cheater);
if(saving) applyBoxSave(cwt.c->land);
else firstland = eLand(applyBoxLoad());
for(int i=itOrbLightning; i<25; i++) applyBoxI(eItem(i), true);
applyBoxI(itRoyalJelly);
applyBoxI(itWine);
applyBoxI(itSilver);
applyBoxI(itEmerald);
applyBoxI(itPower);
applyBoxI(itOrbFire, true);
applyBoxI(itOrbInvis, true);
applyBoxI(itOrbGhost, true);
applyBoxI(itOrbPsi, true);
applyBoxM(moBug0);
applyBoxM(moBug1);
applyBoxM(moBug2);
applyBoxM(moVineBeast);
applyBoxM(moVineSpirit);
applyBoxM(moLancer);
applyBoxM(moFlailer);
applyBoxM(moEarthElemental);
applyBoxM(moDarkTroll);
applyBoxM(moWitch);
applyBoxM(moWitchFire);
applyBoxM(moWitchFlash);
applyBoxM(moWitchGhost);
applyBoxM(moWitchSpeed);
applyBoxM(moEvilGolem);
applyBoxM(moWitchWinter);
applyBoxI(itHolyGrail);
applyBoxI(itGrimoire);
applyBoxM(moKnight);
applyBoxM(moCultistLeader);
}
void saveBox() {
boxid = 0; saving = true; applyBoxes();
}
void loadBox() {
// have boxid
boxid = 0; saving = false; applyBoxes();
}
// certify that saves and achievements were received
// in an official version of HyperRogue
#ifdef CERTIFY
#include "certify.cpp"
#else
bool tampered;
void saveCertificate(FILE *f) {}
bool loadCertificate(FILE *f, score& sc) {return true; }
int achievement_certify(const char *s, int a, int b, int c) { return 0; }
#endif
void saveStats() {
if(euclid) return;
#ifndef ANDROID
FILE *f = fopen(scorefile, "at");
if(!f) {
printf("Could not open the score file '%s'!\n", scorefile);
addMessage(XLAT("Could not open the score file: ", scorefile));
return;
}
if(showoff) return;
time_t timer;
timer = time(NULL);
char sbuf[128]; strftime(sbuf, 128, "%c", localtime(&timerstart));
char buf[128]; strftime(buf, 128, "%c", localtime(&timer));
fprintf(f, "HyperRogue: game statistics (version "VER")\n");
if(cheater)
fprintf(f, "CHEATER! (cheated %d times)\n", cheater);
if(true) {
fprintf(f, VER);
saveBox();
for(int i=0; i<boxid; i++) fprintf(f, " %d", savebox[i]);
saveCertificate(f);
fprintf(f, "\n");
}
fprintf(f, "Played on: %s - %s (%d turns)\n", sbuf, buf, turncount);
fprintf(f, "Total wealth: %d\n", gold());
fprintf(f, "Total enemies killed: %d\n", tkills());
fprintf(f, "cells generated: %d\n", cellcount);
fprintf(f, "Number of cells explored, by distance from the player:\n");
for(int i=0; i<10; i++) fprintf(f, " %d", explore[i]); fprintf(f, "\n");
/*for(int j=0; j<landtypes; j++) {
bool haveland = false;
for(int i=0; i<10; i++)
if(exploreland[i][j])
haveland = true;
if(haveland)
for(int i=0; i<10; i++)
fprintf(f, " %d", exploreland[i][j]);
fprintf(f, " %s\n", linf[j].name);
} */
if(kills[0]) fprintf(f, "walls melted: %d\n", kills[0]);
fprintf(f, "cells travelled: %d\n", celldist(cwt.c));
fprintf(f, "\n");
for(int i=0; i<ittypes; i++) if(items[i])
fprintf(f, "%4dx %s\n", items[i], iinf[i].name);
fprintf(f, "\n");
for(int i=1; i<motypes; i++) if(kills[i])
fprintf(f, "%4dx %s <%d>\n", kills[i], minf[i].name, i);
fprintf(f, "\n\n\n");
printf("Game statistics saved to %s\n", scorefile);
addMessage(XLAT("Game statistics saved to %1", scorefile));
fclose(f);
#endif
}
bool havesave = true;
#ifndef ANDROID
// load the save
void loadsave() {
printf("Trying to load a save.\n");
FILE *f = fopen(scorefile, "rt");
havesave = f;
if(!f) return;
score sc;
bool ok = false;
bool tamper = false;
while(!feof(f)) {
char buf[120];
if(fgets(buf, 120, f) == NULL) break;
if(buf[0] == 'H' && buf[1] == 'y') {
if(fscanf(f, "%s", buf) <= 0) break; sc.ver = buf;
if(sc.ver < "4.4" || sc.ver == "CHEATER!") continue;
ok = true;
for(int i=0; i<MAXBOX; i++) {
if(fscanf(f, "%d", &sc.box[i]) <= 0) {
boxid = i;
tamper = loadCertificate(f, sc);
break;
}
}
}
}
fclose(f);
if(ok && sc.box[65 + 4 + itOrbSafety - itOrbLightning]) {
tampered = tamper;
// printf("box = %d (%d)\n", sc.box[65 + 4 + itOrbSafety - itOrbLightning], boxid);
for(int i=0; i<boxid; i++) savebox[i] = sc.box[i];
for(int i=boxid; i<MAXBOX; i++) savebox[i] = 0;
loadBox();
if(items[itHolyGrail]) {
items[itHolyGrail]--;
knighted = newRoundTableRadius();
items[itHolyGrail]++;
}
else knighted = 0;
safety = true;
addMessage(XLAT("Game loaded."));
}
}
#endif
void restartGame() {
DEB("savestats");
achievement_final(true);
saveStats();
DEB("clear");
for(int i=0; i<ittypes; i++) items[i] = 0;
for(int i=0; i<motypes; i++) kills[i] = 0;
for(int i=0; i<10; i++) explore[i] = 0;
tampered = false; achievementsReceived.clear();
knighted = 0;
// items[itGreenStone] = 100;
cellcount = 0;
DEB("clearmem");
clearMemory();
DEB("initc");
initcells();
DEB("initg");
initgame();
canmove = true;
DEB("restg");
extern void restartGraph();
restartGraph();
extern void resetmusic();
resetmusic();
}
void restartGameSwitchEuclid() {
DEB("savestats");
achievement_final(true);
saveStats();
DEB("clear");
for(int i=0; i<ittypes; i++) items[i] = 0;
for(int i=0; i<motypes; i++) kills[i] = 0;
for(int i=0; i<10; i++) explore[i] = 0;
// items[itGreenStone] = 100;
cellcount = 0;
DEB("clearmem");
clearMemory();
euclid = !euclid;
DEB("initc");
initcells();
DEB("initg");
initgame();
canmove = true;
DEB("restg");
extern void restartGraph();
restartGraph();
extern void resetmusic();
resetmusic();
}
void clearGameMemory() {
pathq.clear();
dcal.clear();
yii = 0; yi.clear();
clearshadow();
}
bool fjordwalled[64];
#ifndef ANDROID
void applyGameBoard(char u, int sym, cell *c, char boardmode) {
if(!c) c = cwt.c;
if(sym == SDLK_RETURN) {
items[c->item]++;
c->item = itNone;
}
if(u == ' ')
c->item = itNone;
extern void movepckeydir(int);
if(sym == 'd' || sym == SDLK_KP6) movepckeydir(0);
if( sym == SDLK_KP3) movepckeydir(1);
if(sym == 'x' || sym == SDLK_KP2) movepckeydir(2);
if( sym == SDLK_KP1) movepckeydir(3);
if(sym == 'a' || sym == SDLK_KP4) movepckeydir(4);
if( sym == SDLK_KP7) movepckeydir(5);
if(sym == 'w' || sym == SDLK_KP8) movepckeydir(6);
if( sym == SDLK_KP9) movepckeydir(7);
if(u == 'g')
c->item = itGreenStone;
if(u == 'r')
c->item = itOrbSpeed;
if(u == 't')
c->item = itOrbFlash;
if(u == 'o')
c->item = itOrbShield;
if(u == 'i')
c->item = itOrbTeleport;
if(u == 'p')
c->item = itOrbLightning;
if(u == 'h')
c->item = itDiamond;
if(u == 'j')
c->item = itHell;
if(u == 'k')
c->item = itFernFlower;
if(u == 'l')
c->item = itSapphire;
if(boardmode == 'f') {
int fv = fjordval(c);
if(u == '0' || u == '1' || u == '2' || u == '3' || u == '4') fjordwalled[fv] = !fjordwalled[fv];
if(u == '1' || u == '4') fjordwalled[fv^1] = !fjordwalled[fv^1];
if(u == '2' || u == '4') fjordwalled[fv^2] = !fjordwalled[fv^2];
if(u == '3' || u == '4') fjordwalled[fv^3] = !fjordwalled[fv^3];
return;
}
if(u == '0')
c->wall = waNone;
if(u == '1')
c->wall = waFloorA;
if(u == '2')
c->wall = waFloorB;
if(u == '3')
c->wall = waFrozenLake;
if(u == '4')
c->wall = waCavefloor;
if(u == '5')
c->wall = waLake;
if(u == '6')
c->wall = waCavewall;
if(u == '7')
c->wall = waIcewall;
if(u == '8')
c->wall = waDryTree;
if(u == '9')
c->wall = waColumn;
}
#endif
static int orbid = 0;
eItem nextOrb() {
orbid++;
eItem i = eItem(orbid % ittypes);
if(itemclass(i) == IC_ORB) return i;
else return nextOrb();
}
eItem randomTreasure() {
eItem i = eItem(rand() % ittypes);
if(itemclass(i) == IC_TREASURE) return i;
else return randomTreasure();
}
eItem randomTreasure2(int cv) {
int bq = 60000, cq = 0;
eItem best = itDiamond;
eItem lt = localTreasureType();
for(int a=1; a<ittypes; a++) {
eItem i = eItem(a);
if(itemclass(i) != IC_TREASURE) continue;
int q = 2*items[i];
if(a == lt) q -= (2*cv-1);
if(a == itEmerald && cwt.c->land == laCrossroads) q -= 5;
if(q < bq) bq = q, cq = 0;
if(q == bq) { cq++; if(rand() % cq == 0) best = i; }
}
return best;
}
extern int webdisplay;
void applyCheat(char u, cell *c = NULL) {
if(u == 'M' && cwt.c->type == 6) {
addMessage(XLAT("You summon some Mirages!"));
cheater++;
createMirrors(cwt.c, cwt.spin, moMirage),
createMirages(cwt.c, cwt.spin, moMirage);
}
if(u == 'G') {
addMessage(XLAT("You summon a golem!"));
cheater++;
int i = cwt.spin;
if(passable(cwt.c->mov[i], NULL, false, false))
cwt.c->mov[i]->monst = moGolem;
}
if(u == 'L') {
do {
firstland = eLand(firstland+1);
if(firstland == landtypes) firstland = eLand(2);
}
while(firstland == laGameBoard || firstland == laCamelot || firstland == laTemple);
euclidland = firstland;
cheater++; addMessage(XLAT("You will now start your games in %1", firstland));
}
if(u == 'C') {
cheater++;
activateSafety(laCrossroads);
addMessage(XLAT("Activated the Hyperstone Quest!"));
for(int i=0; i<itHyperstone; i++) items[i] = 10;
items[itFernFlower] = 10;
items[itHyperstone] = 0;
items[itOrbShield] = 10;
kills[moYeti] = 20;
kills[moDesertman] = 20;
kills[moRunDog] = 20;
kills[moZombie] = 20;
kills[moMonkey] = 20;
kills[moCultist] = 20;
kills[moTroll] = 20;
}
if(u == 'P') {
for(int i=0; i<ittypes; i++)
if(itemclass(eItem(i)) == IC_ORB)
items[i] = 0;
cheater++; addMessage(XLAT("Orb power depleted!"));
}
if(u == 'O') {
cheater++; addMessage(XLAT("Orbs summoned!"));
for(int i=0; i<cwt.c->type; i++)
if(passable(cwt.c->mov[i], NULL, false, false)) {
eItem it = nextOrb();
cwt.c->mov[i]->item = it;
}
}
if(u == 'F') {
items[itOrbFlash] += 1;
items[itOrbTeleport] += 1;
items[itOrbLightning] += 1;
items[itOrbSpeed] += 1;
items[itOrbShield] += 1;
cheater++; addMessage(XLAT("Orb power gained!"));
}
if(u == 'D') {
items[itGreenStone] += 10;
cheater++; addMessage(XLAT("Dead orbs gained!"));
}
if(u == 'Y') {
items[itOrbYendor] ++;
cheater++; addMessage(XLAT("Orb of Yendor gained!"));
}
if(u == 'T') {
items[randomTreasure2(10)] += 10;
cheater++; addMessage(XLAT("Treasure gained!"));
}
if(u == 'T'-64) {
items[randomTreasure2(100)] += 100;
cheater++; addMessage(XLAT("Lots of treasure gained!"));
}
if(u == 'W') {
addMessage(XLAT("You summon a sandworm!"));
cheater++;
int i = cwt.spin;
if(passable(cwt.c->mov[i], NULL, false, false))
cwt.c->mov[i]->monst = moWorm,
cwt.c->mov[i]->mondir = NODIR;
}
if(u == 'I') {
addMessage(XLAT("You summon an Ivy!"));
cheater++;
int i = cwt.spin;
int j = cwt.c->spn[i];
cell* c = cwt.c->mov[i]->mov[(j+3)%cwt.c->mov[i]->type];
if(passable(c, NULL, false, false)) buildIvy(c, 0, 1);
}
if(u == 'E') {
addMessage(XLAT("You summon a monster!"));
cheater++;
int i = cwt.spin;
if(cwt.c->mov[i]->wall == waChasm)
cwt.c->mov[i]->wall = waNone;
if(passable(cwt.c->mov[i], NULL, true, false)) {
eMonster mo[7] = { moEagle, moPyroCultist, moGhost, moTroll, moKnight, moMiner, moVineBeast };
cwt.c->mov[i]->monst = mo[rand() % 7];
}
}
if(u == 'H') {
addMessage(XLAT("You summon some Thumpers!"));
cheater++;
for(int i=0; i<cwt.c->type; i++)
if(passable(cwt.c->mov[i], NULL, false, false))
cwt.c->mov[i]->wall = rand() % 2 ? waThumper : waBigStatue, cwt.c->mov[i]->tmp = -1;
}
if(u == 'B') {
addMessage(XLAT("You summon a bonfire!"));
cheater++;
int i = cwt.spin;
if(passable(cwt.c->mov[i], NULL, false, false))
cwt.c->mov[i]->wall = waBonfire, cwt.c->mov[i]->tmp = -1;
}
if(u == 'Z') {
cwt.spin++; flipplayer = false;
cwt.spin %= cwt.c->type;
}
if(u == 'J') {
if(items[localTreasureType()] > 0)
items[localTreasureType()] = 0;
else for(int i=1; i<ittypes; i++)
if(itemclass(eItem(i)) == IC_TREASURE)
items[i] = 0;
cheater++; addMessage(XLAT("Treasure lost!"));
}
if(u == 'K') {
for(int i=0; i<motypes; i++) kills[i] += 10;
cheater++; addMessage(XLAT("Kills gained!"));
}
if(u == 'S') {
activateSafety(cwt.c->land);
items[itOrbSafety] += 3;
cheater++; addMessage(XLAT("Activated Orb of Safety!"));
}
if(u == 'U') {
activateSafety(firstland);
cheater++; addMessage(XLAT("Teleported to %1!", firstland));
}
if(u == 'W'-64) {
webdisplay++;
cheater++; addMessage(XLAT("Cheat-changed the display.", firstland));
}
}
void generateAlts(heptagon *h) {
if(!h->alt) return;
h->c7->bardir = NOBARRIERS;
for(int i=0; i<7; i++) if(h->c7->mov[i])
h->c7->mov[i]->bardir = NOBARRIERS;
for(int i=0; i<7; i++)
createStep(h->alt, i)->alt = h->alt->alt;
int relspin = -4; // for horocycles it must go the other way
for(int i=0; i<7; i++) for(int j=0; j<7; j++) {
createStep(h, i);
if(h->move[i]->alt == h->alt->move[j])
relspin = (i-j+7) % 7;
}
if(relspin == -4) {
if(h->alt != h->alt->alt) {
printf("relspin {%p:%p}\n", h->alt, h->alt->alt);
for(int i=0; i<7; i++) printf("%p ", h->alt->move[i]); printf(" ALT\n");
for(int i=0; i<7; i++) printf("%p ", h->move[i]); printf(" REAL\n");
for(int i=0; i<7; i++) printf("%p ", h->move[i]->alt); printf(" REAL ALT\n");
}
relspin = 3;
}
// h[relspin] matches alt[0]
//printf("{%d~%d}\n", h->distance, h->alt->distance);
for(int i=0; i<7; i++) {
int ir = (7+i-relspin)%7;
heptagon *hm = h->alt->move[ir];
heptagon *ho = createStep(h, i);
// printf("[%p:%d ~ %p:%d] %p ~ %p\n",
// h, i, h->alt, ir,
// ho, hm);
if(ho->alt && ho->alt != hm) {
if(ho->alt->alt == hm->alt) {
printf("ERROR: alt cross! [%d -> %d]\n", ho->alt->distance, hm->distance);
// exit(1);
}
continue;
}
ho->alt = hm;
}
}
heptagon *createAlternateMap(cell *c, int rad, hstate firststate) {
// check for direction
int gdir = -1;
for(int i=0; i<c->type; i++) {
if(c->mov[i] && c->mov[i]->mpdist < c->mpdist) gdir = i;
}
if(!gdir) return NULL;
// check for non-crossing
int bd = 2;
cellwalker bb(c, bd);
cellwalker bb2 = bb;
if(!(checkBarriersFront(bb) && checkBarriersBack(bb2))) {
return NULL;
}
// okay, let's go then!
cellwalker bf(c, gdir);
cell *cx[rad+1];
for(int i=0; i<rad; i++) {
cx[i] = bf.c;
if(bf.c->type == 6)
cwspin(bf, 3);
else
cwspin(bf, 3 + rand() % 2);
cwstep(bf);
}
cx[rad] = bf.c;
heptagon *h = bf.c->master;
heptagon *alt = new heptagon;
allAlts.push_back(alt);
//printf("new alt {%p}\n", alt);
alt->s = firststate;
alt->fjordval = 0;
for(int i=0; i<7; i++) alt->move[i] = NULL;
alt->distance = 0;
alt->c7 = NULL;
alt->alt = alt;
h->alt = alt;
for(int d=rad; d>=0; d--) {
generateAlts(cx[d]->master);
cx[d]->bardir = NOBARRIERS;
}
return alt;
//for(int d=rad; d>=0; d--) printf("%3d. %p {%d}\n", d, cx[d]->master, cx[d]->master->alt->distance);
}