mirror of
https://github.com/zenorogue/hyperrogue.git
synced 2024-11-04 21:26:17 +00:00
1553 lines
48 KiB
C++
1553 lines
48 KiB
C++
// Hyperbolic Rogue - PC movement
|
|
// Copyright (C) 2011-2019 Zeno Rogue, see 'hyper.cpp' for details
|
|
|
|
/** \file pcmove.cpp
|
|
* \brief PC movements
|
|
*/
|
|
|
|
#include "hyper.h"
|
|
|
|
namespace hr {
|
|
|
|
EX bool keepLightning = false;
|
|
|
|
EX bool seenSevenMines = false;
|
|
|
|
/** have we been warned about the Haunted Woods? */
|
|
EX bool hauntedWarning;
|
|
|
|
/** is the Survivalist achievement still valid? have we received it? */
|
|
EX bool survivalist;
|
|
|
|
EX void fail_survivalist() {
|
|
changes.value_set(survivalist, false);
|
|
}
|
|
|
|
/** last move was invisible */
|
|
EX bool invismove = false;
|
|
/** last move was invisible due to Orb of Fish (thus Fish still see you)*/
|
|
EX bool invisfish = false;
|
|
|
|
/** if false, make the PC look in direction cwt.spin (after attack); otherwise, make them look the other direction (after move) */
|
|
EX bool flipplayer = true;
|
|
|
|
/** Cellwalker describing the single player. Also used temporarily in shmup and multiplayer modes. */
|
|
EX cellwalker cwt;
|
|
|
|
EX cell*& singlepos() { return cwt.at; }
|
|
EX inline bool singleused() { return !(shmup::on || multi::players > 1); }
|
|
|
|
/** should we center the screen on the PC? */
|
|
EX bool playermoved = true;
|
|
|
|
/** did the player cheat? how many times? */
|
|
EX int cheater = 0;
|
|
|
|
/** lands visited -- unblock some modes */
|
|
EX bool landvisited[landtypes];
|
|
|
|
EX int noiseuntil; // noise until the given turn
|
|
|
|
EX void createNoise(int t) {
|
|
noiseuntil = max(noiseuntil, turncount+t);
|
|
invismove = false;
|
|
if(shmup::on) shmup::visibleFor(100 * t);
|
|
}
|
|
|
|
#if HDR
|
|
enum eLastmovetype { lmSkip, lmMove, lmAttack, lmPush, lmTree, lmInstant };
|
|
extern eLastmovetype lastmovetype, nextmovetype;
|
|
|
|
enum eForcemovetype { fmSkip, fmMove, fmAttack, fmInstant, fmActivate };
|
|
extern eForcemovetype forcedmovetype;
|
|
#endif
|
|
|
|
EX namespace orbbull {
|
|
cell *prev[MAXPLAYER];
|
|
eLastmovetype prevtype[MAXPLAYER];
|
|
int count;
|
|
|
|
bool is(cell *c1, cell *c2, cell *c3) {
|
|
int lp = neighborId(c2, c1);
|
|
int ln = neighborId(c2, c3);
|
|
return lp >= 0 && ln >= 0 && anglestraight(c2, lp, ln);
|
|
}
|
|
|
|
EX void gainBullPowers() {
|
|
items[itOrbShield]++; orbused[itOrbShield] = true;
|
|
items[itOrbThorns]++; orbused[itOrbThorns] = true;
|
|
items[itOrbHorns]++; orbused[itOrbHorns] = true;
|
|
}
|
|
|
|
EX void check() {
|
|
int cp = multi::cpid;
|
|
if(cp < 0 || cp >= MAXPLAYER) cp = 0;
|
|
|
|
if(!items[itOrbBull]) {
|
|
prev[cp] = NULL;
|
|
return;
|
|
}
|
|
|
|
bool seq = false;
|
|
|
|
if(prev[cp] && prevtype[cp] == lmMove && lastmovetype == lmMove)
|
|
seq = is(prev[cp], lastmove, cwt.at);
|
|
|
|
if(prev[cp] && prevtype[cp] == lmMove && lastmovetype == lmAttack)
|
|
seq = is(prev[cp], cwt.at, lastmove);
|
|
|
|
if(prev[cp] && prevtype[cp] == lmAttack && lastmovetype == lmAttack && count)
|
|
seq = lastmove == prev[cp];
|
|
|
|
if(prev[cp] && prevtype[cp] == lmAttack && lastmovetype == lmMove && count)
|
|
seq = cwt.at == prev[cp];
|
|
|
|
prev[cp] = lastmove; prevtype[cp] = lastmovetype;
|
|
|
|
if(seq) {
|
|
if(lastmovetype == lmMove) count++;
|
|
gainBullPowers();
|
|
}
|
|
else count = 0;
|
|
}
|
|
EX }
|
|
|
|
EX bool checkNeedMove(bool checkonly, bool attacking) {
|
|
if(items[itOrbDomination] > ORBBASE && cwt.at->monst)
|
|
return false;
|
|
int flags = 0;
|
|
if(cwt.at->monst) {
|
|
if(isMountable(cwt.at->monst))
|
|
addMessage(XLAT("You need to dismount %the1!", cwt.at->monst));
|
|
else
|
|
addMessage(XLAT("You need to move to give space to %the1!", cwt.at->monst));
|
|
}
|
|
else if(cwt.at->wall == waRoundTable) {
|
|
if(markOrb2(itOrbAether)) return false;
|
|
if(checkonly) return true;
|
|
addMessage(XLAT("It would be impolite to land on the table!"));
|
|
}
|
|
else if(cwt.at->wall == waLake) {
|
|
if(markOrb2(itOrbAether)) return false;
|
|
if(markOrb2(itOrbFish)) return false;
|
|
if(in_gravity_zone(cwt.at) && passable(cwt.at, NULL, P_ISPLAYER)) return false;
|
|
flags |= AF_FALL;
|
|
addMessage(XLAT("Ice below you is melting! RUN!"));
|
|
}
|
|
else if(!attacking && cellEdgeUnstable(cwt.at)) {
|
|
if(markOrb2(itOrbAether)) return false;
|
|
if(in_gravity_zone(cwt.at) && passable(cwt.at, NULL, P_ISPLAYER)) return false;
|
|
addMessage(XLAT("Nothing to stand on here!"));
|
|
}
|
|
else if(among(cwt.at->wall, waSea, waCamelotMoat, waLake, waDeepWater)) {
|
|
if(markOrb(itOrbFish)) return false;
|
|
if(markOrb2(itOrbAether)) return false;
|
|
if(in_gravity_zone(cwt.at) && passable(cwt.at, NULL, P_ISPLAYER)) return false;
|
|
addMessage(XLAT("You have to run away from the water!"));
|
|
}
|
|
else if(cwt.at->wall == waClosedGate) {
|
|
if(markOrb2(itOrbAether)) return false;
|
|
addMessage(XLAT("The gate is closing right on you! RUN!"));
|
|
}
|
|
else if(isFire(cwt.at) && !markOrb(itOrbWinter) && !markOrb2(itOrbShield)) {
|
|
if(markOrb2(itOrbAether)) return false;
|
|
addMessage(XLAT("This spot will be burning soon! RUN!"));
|
|
}
|
|
else if(cwt.at->wall == waMagma && !markOrb(itOrbWinter) && !markOrb2(itOrbShield)) {
|
|
if(markOrb2(itOrbAether)) return false;
|
|
if(in_gravity_zone(cwt.at) && passable(cwt.at, cwt.at, P_ISPLAYER)) return false;
|
|
addMessage(XLAT("Run away from the magma!"));
|
|
}
|
|
else if(cwt.at->wall == waChasm) {
|
|
if(markOrb2(itOrbAether)) return false;
|
|
if(in_gravity_zone(cwt.at) && passable(cwt.at, cwt.at, P_ISPLAYER)) return false;
|
|
flags |= AF_FALL;
|
|
addMessage(XLAT("The floor has collapsed! RUN!"));
|
|
}
|
|
else if(items[itOrbAether] > ORBBASE && !passable(cwt.at, NULL, P_ISPLAYER | P_NOAETHER)) {
|
|
if(markOrb2(itOrbAether)) return false;
|
|
return true;
|
|
}
|
|
else if(!passable(cwt.at, NULL, P_ISPLAYER)) {
|
|
if(isFire(cwt.at)) return false; // already checked: have Shield
|
|
if(markOrb2(itOrbAether)) return false;
|
|
addMessage(XLAT("Your Aether power has expired! RUN!"));
|
|
}
|
|
else return false;
|
|
if(hardcore && !checkonly)
|
|
killHardcorePlayer(multi::cpid, flags);
|
|
return true;
|
|
}
|
|
|
|
EX cell *lastmove;
|
|
eLastmovetype lastmovetype, nextmovetype;
|
|
eForcemovetype forcedmovetype;
|
|
|
|
#if HDR
|
|
struct pcmove {
|
|
bool switchplaces;
|
|
bool checkonly;
|
|
bool errormsgs;
|
|
int origd;
|
|
bool fmsMove, fmsAttack, fmsActivate;
|
|
int d;
|
|
int subdir;
|
|
bool boatmove;
|
|
bool good_tortoise;
|
|
flagtype attackflags;
|
|
|
|
bool movepcto();
|
|
bool actual_move();
|
|
bool stay();
|
|
bool after_instant(bool kl);
|
|
|
|
bool perform_actual_move();
|
|
bool after_move();
|
|
bool perform_move_or_jump();
|
|
bool swing();
|
|
bool boat_move();
|
|
bool after_escape();
|
|
bool move_if_okay();
|
|
bool attack();
|
|
|
|
void tell_why_cannot_attack();
|
|
void tell_why_impassable();
|
|
void handle_friendly_ivy();
|
|
|
|
movei mi, mip;
|
|
pcmove() : mi(nullptr, nullptr, 0), mip(nullptr, nullptr, 0) {}
|
|
|
|
bool vmsg();
|
|
};
|
|
#endif
|
|
|
|
EX cell *global_pushto;
|
|
|
|
bool pcmove::vmsg() { changes.rollback(); return errormsgs && !checkonly; }
|
|
|
|
EX bool movepcto(int d, int subdir IS(1), bool checkonly IS(false)) {
|
|
pcmove pcm;
|
|
pcm.checkonly = checkonly;
|
|
pcm.d = d; pcm.subdir = subdir;
|
|
auto b = pcm.movepcto();
|
|
global_pushto = pcm.mip.t;
|
|
return b;
|
|
}
|
|
|
|
bool pcmove::movepcto() {
|
|
if(dual::state == 1) return dual::movepc(d, subdir, checkonly);
|
|
if(d >= 0 && !checkonly && subdir != 1 && subdir != -1) printf("subdir = %d\n", subdir);
|
|
mip.t = NULL;
|
|
switchplaces = false;
|
|
|
|
if(d == MD_USE_ORB)
|
|
return targetRangedOrb(multi::whereto[multi::cpid].tgt, roMultiGo);
|
|
|
|
errormsgs = multi::players == 1 || multi::cpid == multi::players-1;
|
|
if(hardcore && !canmove) return false;
|
|
if(!checkonly && d >= 0) {
|
|
flipplayer = false;
|
|
if(multi::players > 1) multi::flipped[multi::cpid] = false;
|
|
}
|
|
DEBBI(checkonly ? 0 : DF_TURN, ("movepc"));
|
|
if(!checkonly) invismove = false;
|
|
boatmove = false;
|
|
|
|
if(multi::players > 1)
|
|
lastmountpos[multi::cpid] = cwt.at;
|
|
else
|
|
lastmountpos[0] = cwt.at;
|
|
|
|
if(againstRose(cwt.at, NULL) && d<0 && !scentResistant()) {
|
|
if(vmsg())
|
|
addMessage("You just cannot stand in place, those roses smell too nicely.");
|
|
return false;
|
|
}
|
|
|
|
gravity_state = gsNormal;
|
|
|
|
fmsMove = forcedmovetype == fmSkip || forcedmovetype == fmMove;
|
|
fmsAttack = forcedmovetype == fmSkip || forcedmovetype == fmAttack;
|
|
fmsActivate = forcedmovetype == fmSkip || forcedmovetype == fmActivate;
|
|
|
|
changes.init(checkonly);
|
|
bool b = (d >= 0) ? actual_move() : stay();
|
|
if(checkonly || !b) {
|
|
changes.rollback();
|
|
if(!checkonly) flipplayer = false;
|
|
}
|
|
else if(changes.on) {
|
|
println(hlog, "error: not commited!");
|
|
changes.commit();
|
|
}
|
|
|
|
if(!b) {
|
|
// bool try_instant = (forcedmovetype == fmInstant) || (forcedmovetype == fmSkip && !passable(c2, cwt.at, P_ISPLAYER | P_MIRROR | P_USEBOAT | P_FRIENDSWAP));
|
|
|
|
if(items[itOrbFlash]) {
|
|
if(checkonly) { nextmovetype = lmInstant; return true; }
|
|
if(orbProtection(itOrbFlash)) return true;
|
|
activateFlash();
|
|
checkmove();
|
|
return true;
|
|
}
|
|
|
|
if(items[itOrbLightning]) {
|
|
if(checkonly) { nextmovetype = lmInstant; return true; }
|
|
if(orbProtection(itOrbLightning)) return true;
|
|
activateLightning();
|
|
checkmove();
|
|
return true;
|
|
}
|
|
|
|
if(who_kills_me == moOutlaw && items[itRevolver] && !checkonly) {
|
|
cell *c2 = cwt.cpeek();
|
|
forCellEx(c3, c2) forCellEx(c4, c3) if(c4->monst == moOutlaw) {
|
|
eItem i = targetRangedOrb(c4, roCheck);
|
|
if(i == itRevolver) {
|
|
targetRangedOrb(c4, roKeyboard);
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return b;
|
|
}
|
|
|
|
bool pcmove::after_move() {
|
|
if(checkonly) return true;
|
|
|
|
invisfish = false;
|
|
if(items[itOrbFish]) {
|
|
invisfish = true;
|
|
for(int i=0; i<numplayers(); i++)
|
|
if(multi::playerActive(i) && !isWatery(playerpos(i)))
|
|
invisfish = false;
|
|
if(d < 0) invisfish = false; // no invisibility if staying still
|
|
if(invisfish) invismove = true, markOrb(itOrbFish);
|
|
}
|
|
|
|
last_gravity_state = gravity_state;
|
|
if(multi::players == 1) monstersTurn();
|
|
|
|
save_memory();
|
|
|
|
check_total_victory();
|
|
|
|
if(items[itWhirlpool] && cwt.at->land != laWhirlpool)
|
|
achievement_gain_once("WHIRL1");
|
|
|
|
if(items[itLotus] >= 25 && !isHaunted(cwt.at->land) && survivalist)
|
|
achievement_gain_once("SURVIVAL");
|
|
|
|
if(seenSevenMines && cwt.at->land != laMinefield) {
|
|
changes.value_set(seenSevenMines, false);
|
|
achievement_gain("SEVENMINE");
|
|
}
|
|
|
|
DEBB(DF_TURN, ("done"));
|
|
return true;
|
|
}
|
|
|
|
bool pcmove::swing() {
|
|
sideAttack(cwt.at, d, moPlayer, 0);
|
|
|
|
mirror::act(origd, mirror::SPINMULTI | mirror::ATTACK);
|
|
|
|
if(monstersnear(cwt.at, moPlayer, nullptr, cwt.at)) {
|
|
if(vmsg())
|
|
wouldkill("You would be killed by %the1!");
|
|
return false;
|
|
}
|
|
if(checkonly) return true;
|
|
if(changes.on) changes.commit();
|
|
|
|
animateAttack(mi, LAYER_SMALL);
|
|
if(survivalist && isHaunted(mi.t->land))
|
|
survivalist = false;
|
|
lastmovetype = lmTree; lastmove = mi.t;
|
|
swordAttackStatic();
|
|
|
|
return after_move();
|
|
}
|
|
|
|
bool pcmove::after_instant(bool kl) {
|
|
changes.commit();
|
|
keepLightning = kl;
|
|
bfs();
|
|
keepLightning = false;
|
|
if(multi::players > 1) { multi::whereto[multi::cpid].d = MD_UNDECIDED; return false; }
|
|
checkmove();
|
|
return true;
|
|
}
|
|
|
|
EX void copy_metadata(cell *x, const gcell *y) {
|
|
x->wall = y->wall;
|
|
x->monst = y->monst;
|
|
x->item = y->item;
|
|
x->mondir = y->mondir;
|
|
x->stuntime = y->stuntime;
|
|
x->hitpoints = y->hitpoints;
|
|
x->monmirror = y->monmirror;
|
|
x->LHU = y->LHU;
|
|
if(isIcyLand(x)) {
|
|
x->landparam = y->landparam;
|
|
}
|
|
x->wparam = y->wparam;
|
|
}
|
|
|
|
#if HDR
|
|
|
|
extern void playSound(cell *c, const string& fname, int vol);
|
|
|
|
/** A structure to keep track of changes made during the player movement.
|
|
* This is a singleton object, \link hr::changes \endlink.
|
|
*/
|
|
|
|
struct changes_t {
|
|
vector<reaction_t> rollbacks;
|
|
vector<reaction_t> commits;
|
|
bool on;
|
|
bool checking;
|
|
|
|
/**
|
|
* Start keeping track of changes, perform changes.
|
|
* init(false) if you intend to commit the changes (if successful), or
|
|
* init(true) if you just want to check whether the move would be successful,
|
|
* without performing it if it is.
|
|
*/
|
|
|
|
void init(bool ch) {
|
|
on = true;
|
|
ccell(cwt.at);
|
|
forCellEx(c1, cwt.at) ccell(c1);
|
|
value_keep(kills);
|
|
value_keep(items);
|
|
value_keep(hrngen);
|
|
checking = ch;
|
|
}
|
|
|
|
/**
|
|
* Commit the changes. Should only be called after init(false).
|
|
*/
|
|
|
|
void commit() {
|
|
on = false;
|
|
for(auto& p: commits) p();
|
|
rollbacks.clear();
|
|
commits.clear();
|
|
}
|
|
|
|
/**
|
|
* Rollback the changes. Should only be called after init(true).
|
|
*/
|
|
|
|
void rollback(int pos = 0) {
|
|
on = false;
|
|
while(!rollbacks.empty()) {
|
|
rollbacks.back()();
|
|
rollbacks.pop_back();
|
|
}
|
|
rollbacks.clear();
|
|
commits.clear();
|
|
}
|
|
|
|
/**
|
|
* The changes to cell c will be rolled back when rollback() is called.
|
|
*/
|
|
void ccell(cell *c) {
|
|
if(!on) return;
|
|
gcell a = *c;
|
|
rollbacks.push_back([c, a] { copy_metadata(c, &a); });
|
|
}
|
|
|
|
/**
|
|
* Set the value of what to value. This change will be rolled back if necessary.
|
|
*/
|
|
template<class T> void value_set(T& what, T value) {
|
|
if(!on) { what = value; return; }
|
|
if(what == value) return;
|
|
T old = what;
|
|
rollbacks.push_back([&what, old] { what = old; });
|
|
what = value;
|
|
}
|
|
|
|
/**
|
|
* Add step to the value of what. This change will be rolled back if necessary.
|
|
*/
|
|
|
|
template<class T> void value_add(T& what, T step) {
|
|
value_keep(what); what += step;
|
|
}
|
|
|
|
template<class T> void value_inc(T& what) { value_add(what, 1); }
|
|
|
|
/**
|
|
* Any change to the value of what will be rolled back if necessary.
|
|
*/
|
|
|
|
template<class T> void value_keep(T& what) {
|
|
if(!on) return;
|
|
T old = what;
|
|
rollbacks.push_back([&what, old] { what = old; });
|
|
}
|
|
|
|
/**
|
|
* Like value_keep but for maps.
|
|
*/
|
|
|
|
template<class T, class U, class V> void map_value(map<T, U>& vmap, V& key) {
|
|
if(vmap.count(key)) {
|
|
auto val = vmap[key];
|
|
at_rollback([&vmap, key, val] { vmap[key] = val; });
|
|
}
|
|
else {
|
|
at_rollback([&vmap, key] { vmap.erase(key); });
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Perform the given action on commit. @see LATE
|
|
*/
|
|
|
|
void at_commit(reaction_t act) {
|
|
if(!on) act();
|
|
else commits.emplace_back(act);
|
|
}
|
|
|
|
/**
|
|
* Perform the given action on rollback.
|
|
*/
|
|
|
|
void at_rollback(reaction_t act) {
|
|
if(on) rollbacks.emplace_back(act);
|
|
}
|
|
};
|
|
#endif
|
|
|
|
/**
|
|
* The only instance of hr::changes_t
|
|
*/
|
|
EX changes_t changes;
|
|
|
|
/**
|
|
* Auxiliary function for hr::apply_chaos(). Returns whether the cell attribute LHU
|
|
* should be switched.
|
|
*/
|
|
bool switch_lhu_in(eLand l) {
|
|
return among(l, laBrownian, laMinefield, laTerracotta, laHive);
|
|
}
|
|
|
|
/**
|
|
* Apply the Orb of Chaos. We assume that the player moves from cwt.peek, in
|
|
* in the direction given by cwt.spin.
|
|
*/
|
|
void apply_chaos() {
|
|
cell *ca = (cwt+1).cpeek();
|
|
cell *cb = (cwt-1).cpeek();
|
|
if(!items[itOrbChaos] || chaos_forbidden(ca) || chaos_forbidden(cb)) return;
|
|
if(ca && is_paired(ca->monst)) killMonster(ca, moPlayer);
|
|
if(cb && is_paired(cb->monst)) killMonster(cb, moPlayer);
|
|
changes.ccell(ca);
|
|
changes.ccell(cb);
|
|
gcell coa = *ca;
|
|
gcell cob = *cb;
|
|
if(ca->monst != cb->monst)
|
|
markOrb(itOrbChaos);
|
|
if(ca->wall != cb->wall)
|
|
markOrb(itOrbChaos);
|
|
if(ca->item != cb->item)
|
|
markOrb(itOrbChaos);
|
|
copy_metadata(ca, &cob);
|
|
copy_metadata(cb, &coa);
|
|
if(!switch_lhu_in(ca->land)) ca->LHU = coa.LHU;
|
|
if(!switch_lhu_in(cb->land)) cb->LHU = cob.LHU;
|
|
int sa = ca->mondir - ((cwt+1)+wstep).spin;
|
|
int sb = cb->mondir - ((cwt-1)+wstep).spin;
|
|
if(ca->monst && !(isFriendly(ca) && markOrb(itOrbEmpathy)))
|
|
ca->stuntime = min(ca->stuntime + 3, 15), markOrb(itOrbChaos);
|
|
if(cb->monst && !(isFriendly(cb) && markOrb(itOrbEmpathy)))
|
|
cb->stuntime = min(cb->stuntime + 3, 15), markOrb(itOrbChaos);
|
|
ca->monmirror = !ca->monmirror;
|
|
cb->monmirror = !cb->monmirror;
|
|
if(ca->mondir < ca->type)
|
|
ca->mondir = ((cwt+1)+wstep-sb).spin;
|
|
if(cb->mondir < cb->type)
|
|
cb->mondir = ((cwt+1)+wstep-sa).spin;
|
|
if(isPrincess(ca) && !isPrincess(cb))
|
|
princess::move(movei{cb, ca, JUMP});
|
|
if(isPrincess(cb) && !isPrincess(ca))
|
|
princess::move(movei{ca, cb, JUMP});
|
|
if(ca->monst == moTortoise || cb->monst == moTortoise) {
|
|
tortoise::move_adult(ca, cb);
|
|
}
|
|
if(ca->item == itBabyTortoise || cb->item == itBabyTortoise) {
|
|
tortoise::move_baby(ca, cb);
|
|
}
|
|
}
|
|
|
|
bool pcmove::actual_move() {
|
|
|
|
origd = d;
|
|
if(d >= 0) {
|
|
cwt += d;
|
|
dynamicval<bool> b(changes.on, false);
|
|
mirror::act(d, mirror::SPINSINGLE);
|
|
d = cwt.spin;
|
|
}
|
|
if(d != -1 && !checkonly) playermoved = true;
|
|
|
|
mi = movei(cwt.at, d);
|
|
cell *& c2 = mi.t;
|
|
good_tortoise = c2->monst == moTortoise && tortoise::seek() && !tortoise::diff(tortoise::getb(c2)) && !c2->item;
|
|
|
|
if(items[itOrbGravity]) {
|
|
if(c2->monst && !should_switchplace(cwt.at, c2))
|
|
gravity_state = get_static_gravity(cwt.at);
|
|
else
|
|
gravity_state = get_move_gravity(cwt.at, c2);
|
|
if(gravity_state) markOrb(itOrbGravity);
|
|
}
|
|
|
|
if(againstRose(cwt.at, c2) && !scentResistant()) {
|
|
if(vmsg()) addMessage("Those roses smell too nicely. You have to come towards them.");
|
|
return false;
|
|
}
|
|
|
|
if(items[itOrbDomination] > ORBBASE && isMountable(c2->monst) && !monstersnear2() && fmsMove) {
|
|
if(checkonly) { nextmovetype = lmMove; return true; }
|
|
if(!isMountable(cwt.at->monst)) dragon::target = NULL;
|
|
movecost(cwt.at, c2, 3);
|
|
|
|
flipplayer = true; if(multi::players > 1) multi::flipped[multi::cpid] = true;
|
|
invismove = (turncount >= noiseuntil) && items[itOrbInvis] > 0;
|
|
killFriendlyIvy();
|
|
return perform_move_or_jump();
|
|
}
|
|
|
|
if(isActivable(c2) && fmsActivate) {
|
|
if(checkonly) { nextmovetype = lmInstant; return true; }
|
|
activateActiv(c2, true);
|
|
return after_instant(false);
|
|
}
|
|
|
|
if(isPushable(c2->wall) && !c2->monst && !nonAdjacentPlayer(c2, cwt.at) && fmsMove) {
|
|
mip = determinePush(cwt, subdir, [c2] (cell *c) { return canPushThumperOn(c, c2, cwt.at); });
|
|
if(mip.t) changes.ccell(mip.t);
|
|
if(mip.d == NO_SPACE) {
|
|
if(vmsg()) addMessage(XLAT("No room to push %the1.", c2->wall));
|
|
return false;
|
|
}
|
|
nextmovetype = lmMove;
|
|
addMessage(XLAT("You push %the1.", c2->wall));
|
|
lastmovetype = lmPush; lastmove = cwt.at;
|
|
pushThumper(mip);
|
|
return perform_actual_move();
|
|
}
|
|
|
|
if(c2->item == itHolyGrail && roundTableRadius(c2) < newRoundTableRadius()) {
|
|
if(vmsg()) addMessage(XLAT("That was not a challenge. Find a larger castle!"));
|
|
return false;
|
|
}
|
|
|
|
if(c2->item == itOrbYendor && !checkonly && !peace::on && !itemHiddenFromSight(c2) && yendor::check(c2)) {
|
|
return false;
|
|
}
|
|
|
|
if(isWatery(c2) && !nonAdjacentPlayer(cwt.at,c2) && !c2->monst && cwt.at->wall == waBoat && fmsMove)
|
|
return boat_move();
|
|
|
|
if(!c2->monst && cwt.at->wall == waBoat && cwt.at->item != itOrbYendor && boatGoesThrough(c2) && markOrb(itOrbWater) && !nonAdjacentPlayer(c2, cwt.at) && fmsMove) {
|
|
|
|
if(havePushConflict(cwt.at, checkonly)) return false;
|
|
|
|
if(c2->item && !cwt.at->item) moveItem(c2, cwt.at, false), boatmove = true;
|
|
placeWater(c2, cwt.at);
|
|
moveBoat(mi);
|
|
changes.ccell(c2);
|
|
c2->mondir = revhint(cwt.at, d);
|
|
if(c2->item) boatmove = !boatmove;
|
|
return perform_actual_move();
|
|
}
|
|
|
|
return after_escape();
|
|
}
|
|
|
|
bool pcmove::boat_move() {
|
|
|
|
cell *& c2 = mi.t;
|
|
if(havePushConflict(cwt.at, checkonly)) return false;
|
|
|
|
if(againstWind(c2, cwt.at)) {
|
|
if(vmsg()) addMessage(XLAT(airdist(c2) < 3 ? "The Air Elemental blows you away!" : "You cannot go against the wind!"));
|
|
return false;
|
|
}
|
|
|
|
if(againstCurrent(c2, cwt.at) && !markOrb(itOrbWater)) {
|
|
if(markOrb(itOrbFish) || markOrb(itOrbAether) || gravity_state)
|
|
return after_escape();
|
|
if(vmsg()) addMessage(XLAT("You cannot go against the current!"));
|
|
return false;
|
|
}
|
|
|
|
if(cwt.at->item == itOrbYendor) {
|
|
if(markOrb(itOrbFish) || markOrb(itOrbAether) || gravity_state)
|
|
return after_escape();
|
|
if(vmsg()) addMessage(XLAT("The Orb of Yendor is locked in with powerful magic."));
|
|
return false;
|
|
}
|
|
|
|
nextmovetype = lmMove;
|
|
moveBoat(mi);
|
|
boatmove = true;
|
|
return perform_actual_move();
|
|
}
|
|
|
|
void pcmove::tell_why_cannot_attack() {
|
|
cell *& c2 = mi.t;
|
|
if(c2->monst == moWorm || c2->monst == moWormtail || c2->monst == moWormwait)
|
|
addMessage(XLAT("You cannot attack Sandworms directly!"));
|
|
else if(c2->monst == moHexSnake || c2->monst == moHexSnakeTail)
|
|
addMessage(XLAT("You cannot attack Rock Snakes directly!"));
|
|
else if(nonAdjacent(c2, cwt.at))
|
|
addMessage(XLAT("You cannot attack diagonally!"));
|
|
else if(thruVine(c2, cwt.at))
|
|
addMessage(XLAT("You cannot attack through the Vine!"));
|
|
else if(c2->monst == moTentacle || c2->monst == moTentacletail || c2->monst == moTentaclewait || c2->monst == moTentacleEscaping)
|
|
addMessage(XLAT("You cannot attack Tentacles directly!"));
|
|
else if(c2->monst == moHedge && !markOrb(itOrbThorns)) {
|
|
addMessage(XLAT("You cannot attack %the1 directly!", c2->monst));
|
|
addMessage(XLAT("Stab them by walking around them."));
|
|
}
|
|
else if(c2->monst == moRoseBeauty || isBull(c2->monst) || c2->monst == moButterfly)
|
|
addMessage(XLAT("You cannot attack %the1!", c2->monst));
|
|
else if(c2->monst == moFlailer && !c2->stuntime) {
|
|
addMessage(XLAT("You cannot attack %the1 directly!", c2->monst));
|
|
addMessage(XLAT("Make him hit himself by walking away from him."));
|
|
}
|
|
else if(c2->monst == moVizier && c2->hitpoints > 1 && !(attackflags & AF_FAST)) {
|
|
addMessage(XLAT("You cannot attack %the1 directly!", c2->monst));
|
|
addMessage(XLAT("Hit him by walking away from him."));
|
|
}
|
|
else if(c2->monst == moShadow)
|
|
addMessage(XLAT("You cannot defeat the Shadow!"));
|
|
else if(c2->monst == moGreater || c2->monst == moGreaterM)
|
|
addMessage(XLAT("You cannot defeat the Greater Demon yet!"));
|
|
else if(c2->monst == moDraugr)
|
|
addMessage(XLAT("Your mundane weapon cannot hurt %the1!", c2->monst));
|
|
else if(isRaider(c2->monst))
|
|
addMessage(XLAT("You cannot attack Raiders directly!"));
|
|
else if(isSwitch(c2->monst))
|
|
addMessage(XLAT("You cannot attack Jellies in their wall form!"));
|
|
else
|
|
addMessage(XLAT("For some reason... cannot attack!"));
|
|
}
|
|
|
|
bool pcmove::after_escape() {
|
|
cell*& c2 = mi.t;
|
|
|
|
if(c2->wall == waBigStatue && !c2->monst && !nonAdjacentPlayer(c2, cwt.at) && fmsMove) {
|
|
if(!canPushStatueOn(cwt.at)) {
|
|
if(vmsg()) {
|
|
if(isFire(cwt.at))
|
|
addMessage(XLAT("You have to escape first!"));
|
|
else
|
|
addMessage(XLAT("There is not enough space!"));
|
|
}
|
|
return false;
|
|
}
|
|
|
|
if(havePushConflict(cwt.at, checkonly)) return false;
|
|
|
|
changes.ccell(c2);
|
|
changes.ccell(cwt.at);
|
|
|
|
c2->wall = cwt.at->wall;
|
|
if(doesnotFall(cwt.at))
|
|
cwt.at->wall = waBigStatue;
|
|
|
|
nextmovetype = lmMove;
|
|
addMessage(XLAT("You push %the1 behind you!", waBigStatue));
|
|
animateMovement(mi.rev(), LAYER_BOAT);
|
|
return perform_actual_move();
|
|
}
|
|
|
|
bool attackable;
|
|
attackable =
|
|
c2->wall == waBigTree ||
|
|
c2->wall == waSmallTree ||
|
|
(c2->wall == waShrub && items[itOrbSlaying]) ||
|
|
c2->wall == waMirrorWall;
|
|
if(attackable && markOrb(itOrbAether) && c2->wall != waMirrorWall)
|
|
attackable = false;
|
|
bool nm; nm = attackable;
|
|
if(forcedmovetype == fmAttack) attackable = true;
|
|
attackable = attackable && (!c2->monst || isFriendly(c2));
|
|
attackable = attackable && !nonAdjacentPlayer(cwt.at,c2);
|
|
|
|
bool dont_attack = items[itOrbFlash] || items[itOrbLightning];
|
|
|
|
if(attackable && fmsAttack && !dont_attack) {
|
|
if(checkNeedMove(checkonly, true)) return false;
|
|
nextmovetype = nm ? lmAttack : lmSkip;
|
|
if(c2->wall == waSmallTree) {
|
|
drawParticles(c2, winf[c2->wall].color, 4);
|
|
addMessage(XLAT("You chop down the tree."));
|
|
playSound(c2, "hit-axe" + pick123());
|
|
changes.ccell(c2);
|
|
c2->wall = waNone;
|
|
spread_plague(cwt.at, c2, mi.d, moPlayer);
|
|
return swing();
|
|
}
|
|
else if(c2->wall == waShrub && markOrb(itOrbSlaying)) {
|
|
drawParticles(c2, winf[c2->wall].color, 4);
|
|
addMessage(XLAT("You chop down the shrub."));
|
|
playSound(c2, "hit-axe" + pick123());
|
|
changes.ccell(c2);
|
|
c2->wall = waNone;
|
|
spread_plague(cwt.at, c2, mi.d, moPlayer);
|
|
return swing();
|
|
}
|
|
else if(c2->wall == waBigTree) {
|
|
drawParticles(c2, winf[c2->wall].color, 8);
|
|
addMessage(XLAT("You start chopping down the tree."));
|
|
playSound(c2, "hit-axe" + pick123());
|
|
changes.ccell(c2);
|
|
c2->wall = waSmallTree;
|
|
return swing();
|
|
}
|
|
if(!peace::on) {
|
|
if(c2->wall == waMirrorWall)
|
|
addMessage(XLAT("You swing your sword at the mirror."));
|
|
else if(c2->wall)
|
|
addMessage(XLAT("You swing your sword at %the1.", c2->wall));
|
|
else
|
|
addMessage(XLAT("You swing your sword."));
|
|
return swing();
|
|
}
|
|
return false;
|
|
}
|
|
else if(c2->monst == moKnight) {
|
|
if(vmsg()) camelot::knightFlavorMessage(c2);
|
|
return false;
|
|
}
|
|
else if(c2->monst && (!isFriendly(c2) || c2->monst == moTameBomberbird || isMountable(c2->monst))
|
|
&& !(peace::on && !isMultitile(c2->monst) && !good_tortoise))
|
|
return attack();
|
|
else if(!passable(c2, cwt.at, P_USEBOAT | P_ISPLAYER | P_MIRROR | P_MONSTER)) {
|
|
if(vmsg()) tell_why_impassable();
|
|
return false;
|
|
}
|
|
else if(fmsMove)
|
|
return move_if_okay();
|
|
|
|
else return false;
|
|
}
|
|
|
|
bool pcmove::move_if_okay() {
|
|
cell*& c2 = mi.t;
|
|
if(mine::marked_mine(c2) && !mine::safe() && !checkonly && warningprotection(XLAT("Are you sure you want to step there?")))
|
|
return false;
|
|
|
|
if(snakelevel(c2) <= snakelevel(cwt.at)-2) {
|
|
bool can_leave = false;
|
|
forCellEx(c3, c2) if(passable(c3, c2, P_ISPLAYER | P_MONSTER)) can_leave = true;
|
|
if(!can_leave && !checkonly && warningprotection(XLAT("Are you sure you want to step there?")))
|
|
return false;
|
|
}
|
|
|
|
if(switchplace_prevent(cwt.at, c2, checkonly))
|
|
return false;
|
|
if(!checkonly && warningprotection_hit(do_we_stab_a_friend(cwt.at, c2, moPlayer)))
|
|
return false;
|
|
|
|
nextmovetype = lmMove;
|
|
return perform_actual_move();
|
|
}
|
|
|
|
void pcmove::tell_why_impassable() {
|
|
cell*& c2 = mi.t;
|
|
if(nonAdjacent(cwt.at,c2))
|
|
addMessage(XLAT(
|
|
geosupport_football() < 2 ?
|
|
"You cannot move between the cells without dots here!" :
|
|
"You cannot move between the triangular cells here!"
|
|
));
|
|
else if(againstWind(c2, cwt.at))
|
|
addMessage(XLAT(airdist(c2) < 3 ? "The Air Elemental blows you away!" : "You cannot go against the wind!"));
|
|
else if(isAlch(c2))
|
|
addMessage(XLAT("Wrong color!"));
|
|
else if(c2->wall == waRoundTable)
|
|
addMessage(XLAT("It would be impolite to land on the table!"));
|
|
else if(snakelevel(cwt.at) >= 3 && snakelevel(c2) == 0)
|
|
addMessage(XLAT("You would get hurt!", c2->wall));
|
|
else if(cellEdgeUnstable(cwt.at) && cellEdgeUnstable(c2)) {
|
|
addMessage(XLAT("Gravity does not allow this!"));
|
|
}
|
|
else if(c2->wall == waChasm && c2->land == laDual)
|
|
addMessage(XLAT("You cannot move there!"));
|
|
else if(!c2->wall)
|
|
addMessage(XLAT("You cannot move there!"));
|
|
else {
|
|
addMessage(XLAT("You cannot move through %the1!", c2->wall));
|
|
}
|
|
}
|
|
|
|
bool pcmove::attack() {
|
|
auto& c2 = mi.t;
|
|
if(!fmsAttack) return false;
|
|
|
|
if(items[itOrbFlash] || items[itOrbLightning])
|
|
return false;
|
|
|
|
attackflags = AF_NORMAL;
|
|
if(items[itOrbSpeed]&1) attackflags |= AF_FAST;
|
|
if(items[itOrbSlaying]) attackflags |= AF_CRUSH;
|
|
|
|
bool ca =canAttack(cwt.at, moPlayer, c2, c2->monst, attackflags);
|
|
|
|
if(!ca) {
|
|
if(forcedmovetype == fmAttack) {
|
|
if(monstersnear(cwt.at,moPlayer,NULL,cwt.at)) {
|
|
if(vmsg()) wouldkill("%The1 would get you!");
|
|
return false;
|
|
}
|
|
nextmovetype = lmSkip;
|
|
addMessage(XLAT("You swing your sword at %the1.", c2->monst));
|
|
return swing();
|
|
}
|
|
if(vmsg()) tell_why_cannot_attack();
|
|
return false;
|
|
}
|
|
|
|
// mip.t=c2 means that the monster is not destroyed and thus
|
|
// still counts for lightning in monstersnear
|
|
|
|
mip = movei(c2, nullptr, NO_SPACE);
|
|
|
|
if(isStunnable(c2->monst) && c2->hitpoints > 1) {
|
|
if(monsterPushable(c2))
|
|
mip = determinePush(cwt, subdir, [c2] (cell *c) { return passable(c, c2, P_BLOW); });
|
|
else
|
|
mip.t = c2;
|
|
if(mip.t) changes.ccell(mip.t);
|
|
}
|
|
|
|
if(havePushConflict(mip.t, checkonly)) return false;
|
|
|
|
if(!(isWatery(cwt.at) && c2->monst == moWaterElemental) && checkNeedMove(checkonly, true))
|
|
return false;
|
|
|
|
if(c2->monst == moTameBomberbird && warningprotection_hit(moTameBomberbird)) return false;
|
|
|
|
nextmovetype = lmAttack;
|
|
|
|
mirror::act(origd, mirror::SPINMULTI | mirror::ATTACK);
|
|
|
|
int tk = tkills();
|
|
plague_kills = 0;
|
|
|
|
if(good_tortoise) {
|
|
changes.at_commit([c2] {
|
|
items[itBabyTortoise] += 4;
|
|
updateHi(itBabyTortoise, items[itBabyTortoise]);
|
|
c2->item = itBabyTortoise;
|
|
tortoise::babymap[c2] = tortoise::seekbits;
|
|
playSound(c2, playergender() ? "heal-princess" : "heal-prince");
|
|
addMessage(XLAT(playergender() == GEN_F ? "You are now a tortoise heroine!" : "You are now a tortoise hero!"));
|
|
c2->stuntime = 2;
|
|
achievement_collection(itBabyTortoise);
|
|
});
|
|
}
|
|
else {
|
|
eMonster m = c2->monst;
|
|
if(m) {
|
|
if((attackflags & AF_CRUSH) && !canAttack(cwt.at, moPlayer, c2, c2->monst, attackflags ^ AF_CRUSH ^ AF_MUSTKILL))
|
|
markOrb(itOrbSlaying);
|
|
if(c2->monst == moTerraWarrior && hrand(100) > 2 * items[itTerra]) {
|
|
if(hrand(2 + jiangshi_on_screen) < 2)
|
|
changes.value_add(wandering_jiangshi, 1);
|
|
}
|
|
attackMonster(c2, attackflags | AF_MSG, moPlayer);
|
|
if(m == moRusalka) {
|
|
changes.ccell(cwt.at);
|
|
if(cwt.at->wall == waNone) cwt.at->wall = waShallow;
|
|
else if(cwt.at->wall == waShallow || isAlch(cwt.at->wall)) cwt.at->wall = waDeepWater;
|
|
}
|
|
changes.ccell(c2);
|
|
// salamanders are stunned for longer time when pushed into a wall
|
|
if(c2->monst == moSalamander && (mip.t == c2 || !mip.t)) c2->stuntime = 10;
|
|
if(!c2->monst || isAnyIvy(m)) {
|
|
spread_plague(cwt.at, c2, mi.d, moPlayer);
|
|
produceGhost(c2, m, moPlayer);
|
|
}
|
|
if(mip.proper()) pushMonster(mip);
|
|
animateAttack(mi, LAYER_SMALL);
|
|
}
|
|
}
|
|
|
|
sideAttack(cwt.at, d, moPlayer, tkills() - tk - plague_kills);
|
|
lastmovetype = lmAttack; lastmove = c2;
|
|
swordAttackStatic();
|
|
|
|
if(monstersnear(cwt.at, moPlayer, nullptr, cwt.at)) {
|
|
if(vmsg()) wouldkill("You would be killed by %the1!");
|
|
return false;
|
|
}
|
|
if(checkonly) return true;
|
|
if(changes.on) changes.commit();
|
|
|
|
return after_move();
|
|
}
|
|
|
|
EX bool chaos_forbidden(cell *c) {
|
|
return do_not_touch_this_wall(c) || isMultitile(c->monst);
|
|
}
|
|
|
|
bool pcmove::perform_actual_move() {
|
|
cell*& c2 = mi.t;
|
|
changes.at_commit([&] {
|
|
flipplayer = true; if(multi::players > 1) multi::flipped[multi::cpid] = true;
|
|
});
|
|
if(c2->item && isAlch(c2)) {
|
|
if(cwt.at->wall == waBoat)
|
|
c2->wall = waNone;
|
|
else
|
|
c2->wall = cwt.at->wall;
|
|
}
|
|
if(c2->wall == waRoundTable) {
|
|
addMessage(XLAT("You jump over the table!"));
|
|
}
|
|
|
|
if(cwt.at->wall == waRoundTable)
|
|
camelot::roundTableMessage(c2);
|
|
|
|
invismove = (turncount >= noiseuntil) && items[itOrbInvis] > 0;
|
|
|
|
if(items[itOrbFire]) {
|
|
invismove = false;
|
|
if(makeflame(cwt.at, 10, false)) markOrb(itOrbFire);
|
|
}
|
|
|
|
handle_friendly_ivy();
|
|
|
|
if(items[itOrbDigging]) {
|
|
invismove = false;
|
|
if(earthMove(mi)) markOrb(itOrbDigging);
|
|
}
|
|
|
|
movecost(cwt.at, c2, 1);
|
|
|
|
if(!boatmove && collectItem(c2)) return true;
|
|
if(doPickupItemsWithMagnetism(c2)) return true;
|
|
|
|
if(isIcyLand(cwt.at) && cwt.at->wall == waNone && markOrb(itOrbWinter)) {
|
|
invismove = false;
|
|
cwt.at->wall = waIcewall;
|
|
}
|
|
|
|
if(items[itOrbWinter])
|
|
forCellEx(c3, c2) if(c3->wall == waIcewall && c3->item) {
|
|
changes.ccell(c3);
|
|
markOrb(itOrbWinter);
|
|
if(collectItem(c3)) return true;
|
|
}
|
|
|
|
movecost(cwt.at, c2, 2);
|
|
|
|
handle_switchplaces(cwt.at, c2, switchplaces);
|
|
|
|
return perform_move_or_jump();
|
|
}
|
|
|
|
void pcmove::handle_friendly_ivy() {
|
|
cell*& c2 = mi.t;
|
|
bool haveIvy = false;
|
|
forCellEx(c3, cwt.at) if(c3->monst == moFriendlyIvy) haveIvy = true;
|
|
|
|
bool killIvy = haveIvy;
|
|
|
|
if(items[itOrbNature]) {
|
|
if(c2->monst != moFriendlyIvy && strictlyAgainstGravity(c2, cwt.at, false, MF_IVY)) {
|
|
invismove = false;
|
|
}
|
|
else if(cwt.at->monst) invismove = false;
|
|
else if(haveIvy || !cellEdgeUnstable(cwt.at, MF_IVY)) {
|
|
cwt.at->monst = moFriendlyIvy;
|
|
cwt.at->mondir = neighborId(cwt.at, c2);
|
|
invismove = false;
|
|
markOrb(itOrbNature);
|
|
killIvy = false;
|
|
}
|
|
}
|
|
|
|
if(killIvy) killFriendlyIvy();
|
|
}
|
|
|
|
bool pcmove::perform_move_or_jump() {
|
|
lastmovetype = lmMove; lastmove = cwt.at;
|
|
apply_chaos();
|
|
|
|
stabbingAttack(cwt.at, mi.t, moPlayer);
|
|
cell *c1 = cwt.at;
|
|
changes.value_keep(cwt);
|
|
cwt += wstep;
|
|
|
|
mirror::act(origd, mirror::SPINMULTI | mirror::ATTACK | mirror::GO);
|
|
|
|
playerMoveEffects(c1, mi.t);
|
|
|
|
if(mi.t->monst == moFriendlyIvy) changes.ccell(mi.t), mi.t->monst = moNone;
|
|
|
|
if(monstersnear(cwt.at, moPlayer, nullptr, c1)) {
|
|
if(vmsg()) wouldkill("%The1 would kill you there!");
|
|
return false;
|
|
}
|
|
|
|
if(checkonly) return true;
|
|
if(changes.on) changes.commit();
|
|
|
|
if(switchplaces) {
|
|
indAnimateMovement(mi, LAYER_SMALL);
|
|
indAnimateMovement(mi.rev(), LAYER_SMALL);
|
|
commitAnimations(LAYER_SMALL);
|
|
}
|
|
else
|
|
animateMovement(mi, LAYER_SMALL);
|
|
current_display->which_copy = current_display->which_copy * adj(mi);
|
|
|
|
countLocalTreasure();
|
|
landvisited[cwt.at->land] = true;
|
|
afterplayermoved();
|
|
|
|
return after_move();
|
|
}
|
|
|
|
bool pcmove::stay() {
|
|
if(items[itOrbGravity]) {
|
|
gravity_state = get_static_gravity(cwt.at);
|
|
if(gravity_state) markOrb(itOrbGravity);
|
|
}
|
|
lastmovetype = lmSkip; lastmove = NULL;
|
|
if(checkNeedMove(checkonly, false))
|
|
return false;
|
|
swordAttackStatic();
|
|
nextmovetype = lmSkip;
|
|
if(monstersnear(cwt.at, moPlayer, nullptr, cwt.at)) {
|
|
if(vmsg()) wouldkill("%The1 would get you!");
|
|
return false;
|
|
}
|
|
if(checkonly) return true;
|
|
if(changes.on) changes.commit();
|
|
if(d == -2)
|
|
dropGreenStone(cwt.at);
|
|
if(cellUnstable(cwt.at) && !markOrb(itOrbAether))
|
|
doesFallSound(cwt.at);
|
|
|
|
if(last_gravity_state && !gravity_state)
|
|
playerMoveEffects(cwt.at, cwt.at);
|
|
|
|
return after_move();
|
|
}
|
|
|
|
#if HDR
|
|
inline bool movepcto(const movedir& md) { return movepcto(md.d, md.subdir); }
|
|
#endif
|
|
|
|
|
|
EX bool warningprotection(const string& s) {
|
|
if(hardcore) return false;
|
|
if(multi::activePlayers() > 1) return false;
|
|
if(items[itWarning]) return false;
|
|
pushScreen([s] () {
|
|
gamescreen(1);
|
|
dialog::addBreak(250);
|
|
dialog::init(XLAT("WARNING"), 0xFF0000, 150, 100);
|
|
dialog::addBreak(500);
|
|
dialog::addInfo(s);
|
|
dialog::addBreak(500);
|
|
dialog::addItem(XLAT("YES"), 'y');
|
|
dialog::lastItem().scale = 200;
|
|
auto yes = [] () { items[itWarning] = 1; popScreen(); };
|
|
dialog::add_action(yes);
|
|
dialog::add_key_action(SDLK_RETURN, yes);
|
|
dialog::addItem(XLAT("NO"), 'n');
|
|
dialog::lastItem().scale = 200;
|
|
dialog::add_action([] () { items[itWarning] = 0; popScreen(); });
|
|
dialog::display();
|
|
});
|
|
return true;
|
|
}
|
|
|
|
EX bool warningprotection_hit(eMonster m) {
|
|
if(m && warningprotection(XLAT("Are you sure you want to hit %the1?", m)))
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
EX bool playerInWater() {
|
|
for(int i=0; i<numplayers(); i++)
|
|
if(multi::playerActive(i) && isWatery(playerpos(i)) && !playerInBoat(i))
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
EX int numplayers() {
|
|
return multi::players;
|
|
}
|
|
|
|
EX cell *playerpos(int i) {
|
|
if(shmup::on) return shmup::playerpos(i);
|
|
if(multi::players > 1) return multi::player[i].at;
|
|
return singlepos();
|
|
}
|
|
|
|
EX bool allPlayersInBoats() {
|
|
for(int i=0; i<numplayers(); i++)
|
|
if(multi::playerActive(i) && playerpos(i)->wall != waBoat) return true;
|
|
return false;
|
|
}
|
|
|
|
EX int whichPlayerOn(cell *c) {
|
|
if(singleused()) return c == singlepos() ? 0 : -1;
|
|
for(int i=0; i<numplayers(); i++)
|
|
if(playerpos(i) == c) return i;
|
|
return -1;
|
|
}
|
|
|
|
EX bool isPlayerOn(cell *c) {
|
|
return whichPlayerOn(c) >= 0;
|
|
}
|
|
|
|
EX bool isPlayerInBoatOn(cell *c, int i) {
|
|
return
|
|
(playerpos(i) == c && (
|
|
c->wall == waBoat || c->wall == waStrandedBoat || (shmup::on && shmup::playerInBoat(i))
|
|
));
|
|
}
|
|
|
|
EX bool playerInBoat(int i) {
|
|
return isPlayerInBoatOn(playerpos(i), i);
|
|
}
|
|
|
|
EX bool isPlayerInBoatOn(cell *c) {
|
|
for(int i=0; i<numplayers(); i++) if(isPlayerInBoatOn(c, i)) return true;
|
|
return false;
|
|
}
|
|
|
|
EX bool playerInPower() {
|
|
if(singleused())
|
|
return singlepos()->land == laPower || singlepos()->land == laHalloween;
|
|
for(int i=0; i<numplayers(); i++)
|
|
if(multi::playerActive(i) && (playerpos(i)->land == laPower || playerpos(i)->land == laHalloween))
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
EX void playerMoveEffects(cell *c1, cell *c2) {
|
|
|
|
if(peace::on) items[itOrbSword] = c2->land == laBurial ? 100 : 0;
|
|
|
|
changes.value_keep(sword::dir[multi::cpid]);
|
|
sword::dir[multi::cpid] = sword::shift(c1, c2, sword::dir[multi::cpid]);
|
|
|
|
destroyWeakBranch(c1, c2, moPlayer);
|
|
|
|
mine::uncover_full(c2);
|
|
|
|
if((c2->wall == waClosePlate || c2->wall == waOpenPlate) && normal_gravity_at(c2) && !markOrb(itOrbAether))
|
|
toggleGates(c2, c2->wall);
|
|
|
|
if(c2->wall == waArrowTrap && c2->wparam == 0 && normal_gravity_at(c2) && !markOrb(itOrbAether))
|
|
activateArrowTrap(c2);
|
|
|
|
if(c2->wall == waFireTrap && c2->wparam == 0 && normal_gravity_at(c2) &&!markOrb(itOrbAether)) {
|
|
playSound(c2, "click");
|
|
changes.ccell(c2);
|
|
c2->wparam = 1;
|
|
}
|
|
|
|
princess::playernear(c2);
|
|
|
|
if(c2->wall == waGlass && items[itOrbAether] > ORBBASE+1) {
|
|
addMessage(XLAT("Your Aether powers are drained by %the1!", c2->wall));
|
|
drainOrb(itOrbAether, 2);
|
|
}
|
|
|
|
if(cellUnstable(c2) && !markOrb(itOrbAether)) doesFallSound(c2);
|
|
|
|
if(c2->wall == waStrandedBoat && markOrb(itOrbWater))
|
|
c2->wall = waBoat;
|
|
|
|
if(c2->land == laOcean && c2->wall == waBoat && c2->landparam < 30 && markOrb(itOrbWater))
|
|
c2->landparam = 40;
|
|
|
|
if((c2->land == laHauntedWall || c2->land == laHaunted) && !hauntedWarning) {
|
|
changes.value_set(hauntedWarning, true);
|
|
addMessage(XLAT("You become a bit nervous..."));
|
|
addMessage(XLAT("Better not to let your greed make you stray from your path."));
|
|
playSound(c2, "nervous");
|
|
}
|
|
}
|
|
|
|
EX void afterplayermoved() {
|
|
pregen();
|
|
if(!racing::on)
|
|
setdist(cwt.at, 7 - getDistLimit() - genrange_bonus, NULL);
|
|
prairie::treasures();
|
|
if(generatingEquidistant) {
|
|
printf("Warning: generatingEquidistant set to true\n");
|
|
generatingEquidistant = false;
|
|
}
|
|
}
|
|
|
|
EX void produceGhost(cell *c, eMonster victim, eMonster who) {
|
|
if(who != moPlayer && !items[itOrbEmpathy]) return;
|
|
if(markOrb(itOrbUndeath) && !c->monst && isGhostable(victim)) {
|
|
changes.ccell(c);
|
|
c->monst = moFriendlyGhost, c->stuntime = 0;
|
|
if(who != moPlayer) markOrb(itOrbEmpathy);
|
|
}
|
|
}
|
|
|
|
EX bool swordAttack(cell *mt, eMonster who, cell *c, int bb) {
|
|
eMonster m = c->monst;
|
|
if(c->wall == waCavewall) markOrb(bb ? itOrbSword2: itOrbSword);
|
|
if(c->wall == waSmallTree || c->wall == waBigTree || c->wall == waRose || c->wall == waCTree || c->wall == waVinePlant ||
|
|
thruVine(mt, c) || c->wall == waBigBush || c->wall == waSmallBush || c->wall == waSolidBranch || c->wall == waWeakBranch) {
|
|
changes.ccell(c);
|
|
playSound(NULL, "hit-axe"+pick123());
|
|
markOrb(bb ? itOrbSword2: itOrbSword);
|
|
drawParticles(c, winf[c->wall].color, 16);
|
|
addMessage(XLAT("You chop down %the1.", c->wall));
|
|
destroyHalfvine(c);
|
|
c->wall = waNone;
|
|
}
|
|
if(c->wall == waBarrowDig) {
|
|
changes.ccell(c);
|
|
playSound(NULL, "hit-axe"+pick123());
|
|
markOrb(bb ? itOrbSword2: itOrbSword);
|
|
drawParticles(c, winf[c->wall].color, 16);
|
|
c->wall = waNone;
|
|
}
|
|
if(c->wall == waBarrowWall && items[itBarrow] >= 25) {
|
|
changes.ccell(c);
|
|
playSound(NULL, "hit-axe"+pick123());
|
|
markOrb(bb ? itOrbSword2: itOrbSword);
|
|
drawParticles(c, winf[c->wall].color, 16);
|
|
c->wall = waNone;
|
|
}
|
|
if(c->wall == waExplosiveBarrel)
|
|
explodeBarrel(c);
|
|
if(!peace::on && canAttack(mt, who, c, m, AF_SWORD)) {
|
|
changes.ccell(c);
|
|
markOrb(bb ? itOrbSword2: itOrbSword);
|
|
int k = tkills();
|
|
attackMonster(c, AF_NORMAL | AF_MSG | AF_SWORD, who);
|
|
if(c->monst == moShadow) c->monst = moNone;
|
|
produceGhost(c, m, who);
|
|
if(tkills() > k) return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
EX void swordAttackStatic(int bb) {
|
|
swordAttack(cwt.at, moPlayer, sword::pos(multi::cpid, bb), bb);
|
|
}
|
|
|
|
EX void swordAttackStatic() {
|
|
for(int bb = 0; bb < 2; bb++)
|
|
if(sword::orbcount(bb))
|
|
swordAttackStatic(bb);
|
|
}
|
|
|
|
EX int plague_kills;
|
|
|
|
EX void spread_plague(cell *mf, cell *mt, int dir, eMonster who) {
|
|
if(!(who == moPlayer ? markOrb(itOrbPlague) : !markEmpathy(itOrbPlague))) return;
|
|
forCellEx(mx, mt) if(celldistance(mx, mf) > celldistance(mx, mf->modmove(dir)) && celldistance(mx, mf) <= 4) {
|
|
sideAttackAt(mf, dir, mx, who, itOrbPlague, mt);
|
|
}
|
|
}
|
|
|
|
EX void sideAttackAt(cell *mf, int dir, cell *mt, eMonster who, eItem orb, cell *pf) {
|
|
eMonster m = mt->monst;
|
|
flagtype f = AF_SIDE;
|
|
if(orb == itOrbPlague) f |= AF_PLAGUE;
|
|
if(items[itOrbSlaying]) f|= AF_CRUSH;
|
|
if(!items[orb]) return;
|
|
auto plague_particles = [&] {
|
|
if(orb == itOrbPlague) {
|
|
for(int i=0; i<16; i++)
|
|
drawDirectionalParticle(pf, neighborId(pf, mt), (i&1) ? orb_auxiliary_color(orb) : iinf[orb].color);
|
|
}
|
|
};
|
|
if(canAttack(mf, who, mt, m, f)) {
|
|
if((f & AF_CRUSH) && !canAttack(mf, who, mt, m, AF_SIDE | AF_MUSTKILL))
|
|
markOrb(itOrbSlaying);
|
|
markOrb(orb);
|
|
changes.ccell(mt);
|
|
plague_particles();
|
|
if(who != moPlayer) markOrb(itOrbEmpathy);
|
|
int kk = 0;
|
|
if(orb == itOrbPlague) kk = tkills();
|
|
if(attackMonster(mt, AF_NORMAL | AF_SIDE | AF_MSG, who) || isAnyIvy(m)) {
|
|
if(orb == itOrbPlague && kk < tkills())
|
|
plague_kills++;
|
|
if(mt->monst != m) spread_plague(mf, mt, dir, who);
|
|
produceGhost(mt, m, who);
|
|
}
|
|
}
|
|
else if(mt->wall == waSmallTree) {
|
|
changes.ccell(mt);
|
|
plague_particles();
|
|
markOrb(orb);
|
|
mt->wall = waNone;
|
|
spread_plague(mf, mt, dir, who);
|
|
}
|
|
else if(mt->wall == waShrub && markEmpathy(itOrbSlaying)) {
|
|
changes.ccell(mt);
|
|
plague_particles();
|
|
markOrb(orb);
|
|
mt->wall = waNone;
|
|
spread_plague(mf, mt, dir, who);
|
|
}
|
|
else if(mt->wall == waBigTree) {
|
|
changes.ccell(mt);
|
|
plague_particles();
|
|
markOrb(orb);
|
|
mt->wall = waSmallTree;
|
|
}
|
|
else if(mt->wall == waExplosiveBarrel && orb != itOrbPlague) {
|
|
changes.ccell(mt);
|
|
explodeBarrel(mt);
|
|
}
|
|
}
|
|
|
|
EX void sideAttack(cell *mf, int dir, eMonster who, int bonus, eItem orb) {
|
|
if(!items[orb]) return;
|
|
if(who != moPlayer && !items[itOrbEmpathy]) return;
|
|
for(int k: {-1, 1}) {
|
|
int dir1 = dir + k*bonus;
|
|
dir1 = mf->c.fix(dir1);
|
|
cell *mt = mf->move(dir1);
|
|
sideAttackAt(mf, dir1, mt, who, orb, mf);
|
|
}
|
|
}
|
|
|
|
EX void sideAttack(cell *mf, int dir, eMonster who, int bonuskill) {
|
|
|
|
int k = tkills();
|
|
plague_kills = 0;
|
|
sideAttack(mf, dir, who, 1, itOrbSide1);
|
|
sideAttack(mf, dir, who, 2, itOrbSide2);
|
|
sideAttack(mf, dir, who, 3, itOrbSide3);
|
|
k += plague_kills;
|
|
|
|
if(who == moPlayer) {
|
|
int kills = tkills() - k + bonuskill;
|
|
if(kills >= 5) achievement_gain("MELEE5");
|
|
}
|
|
}
|
|
|
|
EX eMonster do_we_stab_a_friend(cell *mf, cell *mt, eMonster who) {
|
|
eMonster m = moNone;
|
|
do_swords(mf, mt, who, [&] (cell *c, int bb) {
|
|
if(!peace::on && canAttack(mt, who, c, c->monst, AF_SWORD) && c->monst && isFriendly(c)) m = c->monst;
|
|
});
|
|
|
|
for(int t=0; t<mf->type; t++) {
|
|
cell *c = mf->move(t);
|
|
if(!c) continue;
|
|
|
|
bool stabthere = false;
|
|
if(logical_adjacent(mt, who, c)) stabthere = true;
|
|
|
|
if(stabthere && canAttack(mt,who,c,c->monst,AF_STAB) && isFriendly(c))
|
|
return c->monst;
|
|
}
|
|
|
|
return m;
|
|
}
|
|
|
|
EX void wouldkill(const char *msg) {
|
|
if(who_kills_me == moWarning)
|
|
addMessage(XLAT("This move appears dangerous -- are you sure?"));
|
|
else if(who_kills_me == moFireball)
|
|
addMessage(XLAT("Cannot move into the current location of another player!"));
|
|
else if(who_kills_me == moAirball)
|
|
addMessage(XLAT("Players cannot get that far away!"));
|
|
else
|
|
addMessage(XLAT(msg, who_kills_me));
|
|
}
|
|
|
|
EX bool havePushConflict(cell *pushto, bool checkonly) {
|
|
if(pushto && multi::activePlayers() > 1) {
|
|
for(int i=0; i<multi::players; i++) if(i != multi::cpid && multi::playerActive(i))
|
|
if(multi::origpos[i] == pushto || multi::origtarget[i] == pushto) {
|
|
addMessage(XLAT("Cannot push into another player!"));
|
|
return true;
|
|
}
|
|
for(int i=0; i<isize(stalemate::moves); i++) {
|
|
if(pushto == stalemate::moves[i].pushto) {
|
|
addMessage(XLAT("Cannot push into the same location!"));
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool got_crossroads;
|
|
|
|
EX void movecost(cell* from, cell *to, int phase) {
|
|
if(from->land == laPower && to->land != laPower && (phase & 1)) {
|
|
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!"));
|
|
}
|
|
|
|
#if CAP_TOUR
|
|
if(from->land != to->land && tour::on && (phase & 2)) {
|
|
changes.at_commit([to] { tour::checkGoodLand(to->land); });
|
|
}
|
|
#endif
|
|
|
|
if(to->land ==laCrossroads4 && !got_crossroads && !geometry && (phase & 2) && !cheater) {
|
|
achievement_gain("CR4");
|
|
got_crossroads = true;
|
|
chaosUnlocked = true;
|
|
}
|
|
|
|
if(isHaunted(from->land) && !isHaunted(to->land) && (phase & 2)) {
|
|
updateHi(itLotus, truelotus = items[itLotus]);
|
|
if(items[itLotus] >= 1) achievement_gain("LOTUS1");
|
|
if(items[itLotus] >= (big_unlock ? 25 : 10)) achievement_gain("LOTUS2");
|
|
if(items[itLotus] >= (big_unlock ? 50 : 25)) achievement_gain("LOTUS3");
|
|
if(items[itLotus] >= 50 && !big_unlock) achievement_gain("LOTUS4");
|
|
achievement_final(false);
|
|
}
|
|
|
|
if(geometry == gNormal && celldist(to) == 0 && !usedSafety && gold() >= 100 && (phase & 2))
|
|
achievement_gain("COMEBACK");
|
|
|
|
bool tortoiseOK =
|
|
to->land == from->land || to->land == laTortoise ||
|
|
(to->land == laDragon && from->land != laTortoise) ||
|
|
chaosmode;
|
|
|
|
if(tortoise::seek() && !from->item && !tortoiseOK && passable(from, NULL, 0) && (phase & 2)) {
|
|
changes.ccell(from);
|
|
changes.map_value(tortoise::babymap, from);
|
|
from->item = itBabyTortoise;
|
|
tortoise::babymap[from] = tortoise::seekbits;
|
|
addMessage(XLAT("You leave %the1.", itBabyTortoise));
|
|
items[itBabyTortoise]--;
|
|
}
|
|
}
|
|
|
|
} |