5612 lines
167 KiB
C++
5612 lines
167 KiB
C++
// 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);
|
|
}
|