/* * CGameHandler.cpp, part of VCMI engine * * Authors: listed in file AUTHORS in main folder * * License: GNU General Public License v2.0 or later * Full text of license available in license.txt file, in main folder * */ #include "StdInc.h" #include "../lib/filesystem/Filesystem.h" #include "../lib/filesystem/FileInfo.h" #include "../lib/int3.h" #include "../lib/mapping/CCampaignHandler.h" #include "../lib/StartInfo.h" #include "../lib/CModHandler.h" #include "../lib/CArtHandler.h" #include "../lib/CBuildingHandler.h" #include "../lib/CHeroHandler.h" #include "../lib/spells/CSpellHandler.h" #include "../lib/spells/ISpellMechanics.h" #include "../lib/CGeneralTextHandler.h" #include "../lib/CTownHandler.h" #include "../lib/CCreatureHandler.h" #include "../lib/CGameState.h" #include "../lib/CStack.h" #include "../lib/battle/BattleInfo.h" #include "../lib/CondSh.h" #include "../lib/NetPacks.h" #include "../lib/VCMI_Lib.h" #include "../lib/mapping/CMap.h" #include "../lib/rmg/CMapGenOptions.h" #include "../lib/VCMIDirs.h" #include "../lib/ScopeGuard.h" #include "../lib/CSoundBase.h" #include "CGameHandler.h" #include "CVCMIServer.h" #include "../lib/CCreatureSet.h" #include "../lib/CThreadHelper.h" #include "../lib/GameConstants.h" #include "../lib/registerTypes/RegisterTypes.h" #include "../lib/serializer/CTypeList.h" #include "../lib/serializer/Connection.h" #ifndef _MSC_VER #include #endif extern std::atomic serverShuttingDown; #ifdef min #undef min #endif #ifdef max #undef max #endif #define COMPLAIN_RET_IF(cond, txt) do {if (cond){complain(txt); return;}} while(0) #define COMPLAIN_RET_FALSE_IF(cond, txt) do {if (cond){complain(txt); return false;}} while(0) #define COMPLAIN_RET(txt) {complain(txt); return false;} #define COMPLAIN_RETF(txt, FORMAT) {complain(boost::str(boost::format(txt) % FORMAT)); return false;} class ServerSpellCastEnvironment: public SpellCastEnvironment { public: ServerSpellCastEnvironment(CGameHandler * gh); ~ServerSpellCastEnvironment(){}; void sendAndApply(CPackForClient * info) const override; CRandomGenerator & getRandomGenerator() const override; void complain(const std::string & problem) const override; const CMap * getMap() const override; const CGameInfoCallback * getCb() const override; bool moveHero(ObjectInstanceID hid, int3 dst, bool teleporting) const override; void genericQuery(Query * request, PlayerColor color, std::function callback) const override; private: mutable CGameHandler * gh; }; CondSh battleMadeAction(false); CondSh battleResult(nullptr); template class CApplyOnGH; class CBaseForGHApply { public: virtual bool applyOnGH(CGameHandler *gh, CConnection *c, void *pack, PlayerColor player) const =0; virtual ~CBaseForGHApply(){} template static CBaseForGHApply *getApplier(const U * t=nullptr) { return new CApplyOnGH(); } }; template class CApplyOnGH : public CBaseForGHApply { public: bool applyOnGH(CGameHandler *gh, CConnection *c, void *pack, PlayerColor player) const override { T *ptr = static_cast(pack); ptr->c = c; ptr->player = player; return ptr->applyGh(gh); } }; template <> class CApplyOnGH : public CBaseForGHApply { public: bool applyOnGH(CGameHandler *gh, CConnection *c, void *pack, PlayerColor player) const override { logGlobal->error("Cannot apply on GH plain CPack!"); assert(0); return false; } }; static CApplier *applier = nullptr; CMP_stack cmpst ; static inline double distance(int3 a, int3 b) { return std::sqrt((double)(a.x-b.x)*(a.x-b.x) + (a.y-b.y)*(a.y-b.y)); } static void giveExp(BattleResult &r) { if (r.winner > 1) { // draw return; } r.exp[0] = 0; r.exp[1] = 0; for (auto i = r.casualties[!r.winner].begin(); i!=r.casualties[!r.winner].end(); i++) { r.exp[r.winner] += VLC->creh->creatures.at(i->first)->valOfBonuses(Bonus::STACK_HEALTH) * i->second; } } static void summonGuardiansHelper(std::vector & output, const BattleHex & targetPosition, ui8 side, bool targetIsTwoHex) //return hexes for summoning two hex monsters in output, target = unit to guard { int x = targetPosition.getX(); int y = targetPosition.getY(); const bool targetIsAttacker = side == BattleSide::ATTACKER; if (targetIsAttacker) //handle front guardians, TODO: should we handle situation when units start battle near opposite side of the battlefield? Cannot happen in normal H3... BattleHex::checkAndPush(targetPosition.cloneInDirection(BattleHex::EDir::RIGHT, false).cloneInDirection(BattleHex::EDir::RIGHT, false), output); else BattleHex::checkAndPush(targetPosition.cloneInDirection(BattleHex::EDir::LEFT, false).cloneInDirection(BattleHex::EDir::LEFT, false), output); //guardian spawn locations for four default position cases for attacker and defender, non-default starting location for att and def is handled in first two if's if (targetIsAttacker && ((y % 2 == 0) || (x > 1))) { if (targetIsTwoHex && (y % 2 == 1) && (x == 2)) //handle exceptional case { BattleHex::checkAndPush(targetPosition.cloneInDirection(BattleHex::EDir::TOP_RIGHT, false), output); BattleHex::checkAndPush(targetPosition.cloneInDirection(BattleHex::EDir::BOTTOM_RIGHT, false), output); } else { //add back-side guardians for two-hex target, side guardians for one-hex BattleHex::checkAndPush(targetPosition.cloneInDirection(targetIsTwoHex ? BattleHex::EDir::TOP_LEFT : BattleHex::EDir::TOP_RIGHT, false), output); BattleHex::checkAndPush(targetPosition.cloneInDirection(targetIsTwoHex ? BattleHex::EDir::BOTTOM_LEFT : BattleHex::EDir::BOTTOM_RIGHT, false), output); if (!targetIsTwoHex && x > 2) //back guard for one-hex BattleHex::checkAndPush(targetPosition.cloneInDirection(BattleHex::EDir::LEFT, false), output); else if (targetIsTwoHex)//front-side guardians for two-hex target { BattleHex::checkAndPush(targetPosition.cloneInDirection(BattleHex::EDir::RIGHT, false).cloneInDirection(BattleHex::EDir::TOP_RIGHT, false), output); BattleHex::checkAndPush(targetPosition.cloneInDirection(BattleHex::EDir::RIGHT, false).cloneInDirection(BattleHex::EDir::BOTTOM_RIGHT, false), output); if (x > 3) //back guard for two-hex BattleHex::checkAndPush(targetPosition.cloneInDirection(BattleHex::EDir::LEFT, false).cloneInDirection(BattleHex::EDir::LEFT, false), output); } } } else if (!targetIsAttacker && ((y % 2 == 1) || (x < GameConstants::BFIELD_WIDTH - 2))) { if (targetIsTwoHex && (y % 2 == 0) && (x == GameConstants::BFIELD_WIDTH - 3)) //handle exceptional case... equivalent for above for defender side { BattleHex::checkAndPush(targetPosition.cloneInDirection(BattleHex::EDir::TOP_LEFT, false), output); BattleHex::checkAndPush(targetPosition.cloneInDirection(BattleHex::EDir::BOTTOM_LEFT, false), output); } else { BattleHex::checkAndPush(targetPosition.cloneInDirection(targetIsTwoHex ? BattleHex::EDir::TOP_RIGHT : BattleHex::EDir::TOP_LEFT, false), output); BattleHex::checkAndPush(targetPosition.cloneInDirection(targetIsTwoHex ? BattleHex::EDir::BOTTOM_RIGHT : BattleHex::EDir::BOTTOM_LEFT, false), output); if (!targetIsTwoHex && x < GameConstants::BFIELD_WIDTH - 3) BattleHex::checkAndPush(targetPosition.cloneInDirection(BattleHex::EDir::RIGHT, false), output); else if (targetIsTwoHex) { BattleHex::checkAndPush(targetPosition.cloneInDirection(BattleHex::EDir::LEFT, false).cloneInDirection(BattleHex::EDir::TOP_LEFT, false), output); BattleHex::checkAndPush(targetPosition.cloneInDirection(BattleHex::EDir::LEFT, false).cloneInDirection(BattleHex::EDir::BOTTOM_LEFT, false), output); if (x < GameConstants::BFIELD_WIDTH - 4) BattleHex::checkAndPush(targetPosition.cloneInDirection(BattleHex::EDir::RIGHT, false).cloneInDirection(BattleHex::EDir::RIGHT, false), output); } } } else if (!targetIsAttacker && y % 2 == 0) { BattleHex::checkAndPush(targetPosition.cloneInDirection(BattleHex::EDir::LEFT, false).cloneInDirection(BattleHex::EDir::TOP_LEFT, false), output); BattleHex::checkAndPush(targetPosition.cloneInDirection(BattleHex::EDir::LEFT, false).cloneInDirection(BattleHex::EDir::BOTTOM_LEFT, false), output); } else if (targetIsAttacker && y % 2 == 1) { BattleHex::checkAndPush(targetPosition.cloneInDirection(BattleHex::EDir::RIGHT, false).cloneInDirection(BattleHex::EDir::TOP_RIGHT, false), output); BattleHex::checkAndPush(targetPosition.cloneInDirection(BattleHex::EDir::RIGHT, false).cloneInDirection(BattleHex::EDir::BOTTOM_RIGHT, false), output); } } PlayerStatus PlayerStatuses::operator[](PlayerColor player) { boost::unique_lock l(mx); if (players.find(player) != players.end()) { return players.at(player); } else { throw std::runtime_error("No such player!"); } } void PlayerStatuses::addPlayer(PlayerColor player) { boost::unique_lock l(mx); players[player]; } bool PlayerStatuses::checkFlag(PlayerColor player, bool PlayerStatus::*flag) { boost::unique_lock l(mx); if (players.find(player) != players.end()) { return players[player].*flag; } else { throw std::runtime_error("No such player!"); } } void PlayerStatuses::setFlag(PlayerColor player, bool PlayerStatus::*flag, bool val) { boost::unique_lock l(mx); if (players.find(player) != players.end()) { players[player].*flag = val; } else { throw std::runtime_error("No such player!"); } cv.notify_all(); } template void callWith(std::vector args, std::function fun, ui32 which) { fun(args[which]); } void CGameHandler::levelUpHero(const CGHeroInstance * hero, SecondarySkill skill) { changeSecSkill(hero, skill, 1, 0); expGiven(hero); } void CGameHandler::levelUpHero(const CGHeroInstance * hero) { // required exp for at least 1 lvl-up hasn't been reached if (!hero->gainsLevel()) { return; } // give primary skill logGlobal->trace("%s got level %d", hero->name, hero->level); auto primarySkill = hero->nextPrimarySkill(getRandomGenerator()); SetPrimSkill sps; sps.id = hero->id; sps.which = primarySkill; sps.abs = false; sps.val = 1; sendAndApply(&sps); PrepareHeroLevelUp pre; pre.hero = hero; sendAndApply(&pre); HeroLevelUp hlu; hlu.hero = hero; hlu.primskill = primarySkill; hlu.skills = pre.skills; if (hlu.skills.size() == 0) { sendAndApply(&hlu); levelUpHero(hero); } else if (hlu.skills.size() == 1) { sendAndApply(&hlu); levelUpHero(hero, pre.skills.front()); } else if (hlu.skills.size() > 1) { auto levelUpQuery = std::make_shared(this, hlu); hlu.queryID = levelUpQuery->queryID; queries.addQuery(levelUpQuery); sendAndApply(&hlu); //level up will be called on query reply } } void CGameHandler::levelUpCommander (const CCommanderInstance * c, int skill) { SetCommanderProperty scp; auto hero = dynamic_cast(c->armyObj); if (hero) scp.heroid = hero->id; else { complain ("Commander is not led by hero!"); return; } scp.accumulatedBonus.subtype = 0; scp.accumulatedBonus.additionalInfo = 0; scp.accumulatedBonus.duration = Bonus::PERMANENT; scp.accumulatedBonus.turnsRemain = 0; scp.accumulatedBonus.source = Bonus::COMMANDER; scp.accumulatedBonus.valType = Bonus::BASE_NUMBER; if (skill <= ECommander::SPELL_POWER) { scp.which = SetCommanderProperty::BONUS; auto difference = [](std::vector< std::vector > skillLevels, std::vector secondarySkills, int skill)->int { int s = std::min (skill, (int)ECommander::SPELL_POWER); //spell power level controls also casts and resistance return skillLevels.at(skill).at(secondarySkills.at(s)) - (secondarySkills.at(s) ? skillLevels.at(skill).at(secondarySkills.at(s)-1) : 0); }; switch (skill) { case ECommander::ATTACK: scp.accumulatedBonus.type = Bonus::PRIMARY_SKILL; scp.accumulatedBonus.subtype = PrimarySkill::ATTACK; break; case ECommander::DEFENSE: scp.accumulatedBonus.type = Bonus::PRIMARY_SKILL; scp.accumulatedBonus.subtype = PrimarySkill::DEFENSE; break; case ECommander::HEALTH: scp.accumulatedBonus.type = Bonus::STACK_HEALTH; scp.accumulatedBonus.valType = Bonus::PERCENT_TO_BASE; break; case ECommander::DAMAGE: scp.accumulatedBonus.type = Bonus::CREATURE_DAMAGE; scp.accumulatedBonus.subtype = 0; scp.accumulatedBonus.valType = Bonus::PERCENT_TO_BASE; break; case ECommander::SPEED: scp.accumulatedBonus.type = Bonus::STACKS_SPEED; break; case ECommander::SPELL_POWER: scp.accumulatedBonus.type = Bonus::MAGIC_RESISTANCE; scp.accumulatedBonus.val = difference (VLC->creh->skillLevels, c->secondarySkills, ECommander::RESISTANCE); sendAndApply (&scp); //additional pack scp.accumulatedBonus.type = Bonus::CREATURE_SPELL_POWER; scp.accumulatedBonus.val = difference (VLC->creh->skillLevels, c->secondarySkills, ECommander::SPELL_POWER) * 100; //like hero with spellpower = ability level sendAndApply (&scp); //additional pack scp.accumulatedBonus.type = Bonus::CASTS; scp.accumulatedBonus.val = difference (VLC->creh->skillLevels, c->secondarySkills, ECommander::CASTS); sendAndApply (&scp); //additional pack scp.accumulatedBonus.type = Bonus::CREATURE_ENCHANT_POWER; //send normally break; } scp.accumulatedBonus.val = difference (VLC->creh->skillLevels, c->secondarySkills, skill); sendAndApply (&scp); scp.which = SetCommanderProperty::SECONDARY_SKILL; scp.additionalInfo = skill; scp.amount = c->secondarySkills.at(skill) + 1; sendAndApply (&scp); } else if (skill >= 100) { scp.which = SetCommanderProperty::SPECIAL_SKILL; scp.accumulatedBonus = *VLC->creh->skillRequirements.at(skill-100).first; scp.additionalInfo = skill; //unnormalized sendAndApply (&scp); } expGiven(hero); } void CGameHandler::levelUpCommander(const CCommanderInstance * c) { if (!c->gainsLevel()) { return; } CommanderLevelUp clu; auto hero = dynamic_cast(c->armyObj); if (hero) clu.hero = hero; else { complain ("Commander is not led by hero!"); return; } //picking sec. skills for choice for (int i = 0; i <= ECommander::SPELL_POWER; ++i) { if (c->secondarySkills.at(i) < ECommander::MAX_SKILL_LEVEL) clu.skills.push_back(i); } int i = 100; for (auto specialSkill : VLC->creh->skillRequirements) { if (c->secondarySkills.at(specialSkill.second.first) == ECommander::MAX_SKILL_LEVEL && c->secondarySkills.at(specialSkill.second.second) == ECommander::MAX_SKILL_LEVEL && !vstd::contains (c->specialSKills, i)) clu.skills.push_back (i); ++i; } int skillAmount = clu.skills.size(); if (!skillAmount) { sendAndApply(&clu); levelUpCommander(c); } else if (skillAmount == 1 || hero->tempOwner == PlayerColor::NEUTRAL) //choose skill automatically { sendAndApply(&clu); levelUpCommander(c, *RandomGeneratorUtil::nextItem(clu.skills, getRandomGenerator())); } else if (skillAmount > 1) //apply and ask for secondary skill { auto commanderLevelUp = std::make_shared(this, clu); clu.queryID = commanderLevelUp->queryID; queries.addQuery(commanderLevelUp); sendAndApply(&clu); } } void CGameHandler::expGiven(const CGHeroInstance *hero) { if (hero->gainsLevel()) levelUpHero(hero); else if (hero->commander && hero->commander->gainsLevel()) levelUpCommander(hero->commander); //if (hero->commander && hero->level > hero->commander->level && hero->commander->gainsLevel()) // levelUpCommander(hero->commander); // else // levelUpHero(hero); } void CGameHandler::changePrimSkill(const CGHeroInstance * hero, PrimarySkill::PrimarySkill which, si64 val, bool abs) { if (which == PrimarySkill::EXPERIENCE) // Check if scenario limit reached { if (gs->map->levelLimit != 0) { TExpType expLimit = VLC->heroh->reqExp(gs->map->levelLimit); TExpType resultingExp = abs ? val : hero->exp + val; if (resultingExp > expLimit) { // set given experience to max possible, but don't decrease if hero already over top abs = true; val = std::max(expLimit, hero->exp); InfoWindow iw; iw.player = hero->tempOwner; iw.text.addTxt(MetaString::GENERAL_TXT, 1); //can gain no more XP iw.text.addReplacement(hero->name); sendAndApply(&iw); } } } SetPrimSkill sps; sps.id = hero->id; sps.which = which; sps.abs = abs; sps.val = val; sendAndApply(&sps); //only for exp - hero may level up if (which == PrimarySkill::EXPERIENCE) { if (hero->commander && hero->commander->alive) { //FIXME: trim experience according to map limit? SetCommanderProperty scp; scp.heroid = hero->id; scp.which = SetCommanderProperty::EXPERIENCE; scp.amount = val; sendAndApply (&scp); CBonusSystemNode::treeHasChanged(); } expGiven(hero); } } void CGameHandler::changeSecSkill(const CGHeroInstance * hero, SecondarySkill which, int val, bool abs) { if(!hero) { logGlobal->error("changeSecSkill provided no hero"); return; } SetSecSkill sss; sss.id = hero->id; sss.which = which; sss.val = val; sss.abs = abs; sendAndApply(&sss); if (which == SecondarySkill::WISDOM) { if (hero->visitedTown) giveSpells(hero->visitedTown, hero); } } void CGameHandler::endBattle(int3 tile, const CGHeroInstance *hero1, const CGHeroInstance *hero2) { LOG_TRACE(logGlobal); //Fill BattleResult structure with exp info giveExp(*battleResult.data); if (battleResult.get()->result == BattleResult::NORMAL) // give 500 exp for defeating hero, unless he escaped { if (hero1) battleResult.data->exp[1] += 500; if (hero2) battleResult.data->exp[0] += 500; } if (hero1) battleResult.data->exp[0] = hero1->calculateXp(battleResult.data->exp[0]);//scholar skill if (hero2) battleResult.data->exp[1] = hero2->calculateXp(battleResult.data->exp[1]); const CArmedInstance *bEndArmy1 = gs->curB->sides.at(0).armyObject; const CArmedInstance *bEndArmy2 = gs->curB->sides.at(1).armyObject; const BattleResult::EResult result = battleResult.get()->result; auto findBattleQuery = [this]() -> std::shared_ptr { for (auto &q : queries.allQueries()) { if (auto bq = std::dynamic_pointer_cast(q)) if (bq->bi == gs->curB) return bq; } return std::shared_ptr(); }; auto battleQuery = findBattleQuery(); if (!battleQuery) { logGlobal->error("Cannot find battle query!"); } if (battleQuery != queries.topQuery(gs->curB->sides[0].color)) complain("Player " + boost::lexical_cast(gs->curB->sides[0].color) + " although in battle has no battle query at the top!"); battleQuery->result = boost::make_optional(*battleResult.data); //Check how many battle queries were created (number of players blocked by battle) const int queriedPlayers = battleQuery ? boost::count(queries.allQueries(), battleQuery) : 0; finishingBattle = make_unique(battleQuery, queriedPlayers); CasualtiesAfterBattle cab1(bEndArmy1, gs->curB), cab2(bEndArmy2, gs->curB); //calculate casualties before deleting battle ChangeSpells cs; //for Eagle Eye if (finishingBattle->winnerHero) { if (int eagleEyeLevel = finishingBattle->winnerHero->valOfBonuses(Bonus::SECONDARY_SKILL_VAL2, SecondarySkill::EAGLE_EYE)) { double eagleEyeChance = finishingBattle->winnerHero->valOfBonuses(Bonus::SECONDARY_SKILL_PREMY, SecondarySkill::EAGLE_EYE); for (const CSpell *sp : gs->curB->sides.at(!battleResult.data->winner).usedSpellsHistory) if (sp->level <= eagleEyeLevel && !vstd::contains(finishingBattle->winnerHero->spells, sp->id) && getRandomGenerator().nextInt(99) < eagleEyeChance) cs.spells.insert(sp->id); } } std::vector arts; //display them in window if (result == BattleResult::NORMAL && finishingBattle->winnerHero) { auto sendMoveArtifact = [&](const CArtifactInstance *art, MoveArtifact *ma) { arts.push_back(art); ma->dst = ArtifactLocation(finishingBattle->winnerHero, art->firstAvailableSlot(finishingBattle->winnerHero)); sendAndApply(ma); }; if (finishingBattle->loserHero) { //TODO: wrap it into a function, somehow (boost::variant -_-) auto artifactsWorn = finishingBattle->loserHero->artifactsWorn; for (auto artSlot : artifactsWorn) { MoveArtifact ma; ma.src = ArtifactLocation(finishingBattle->loserHero, artSlot.first); const CArtifactInstance * art = ma.src.getArt(); if (art && !art->artType->isBig() && art->artType->id != ArtifactID::SPELLBOOK) // don't move war machines or locked arts (spellbook) { sendMoveArtifact(art, &ma); } } while(!finishingBattle->loserHero->artifactsInBackpack.empty()) { //we assume that no big artifacts can be found MoveArtifact ma; ma.src = ArtifactLocation(finishingBattle->loserHero, ArtifactPosition(GameConstants::BACKPACK_START)); //backpack automatically shifts arts to beginning const CArtifactInstance * art = ma.src.getArt(); if (art->artType->id != ArtifactID::GRAIL) //grail may not be won { sendMoveArtifact(art, &ma); } } if (finishingBattle->loserHero->commander) //TODO: what if commanders belong to no hero? { artifactsWorn = finishingBattle->loserHero->commander->artifactsWorn; for (auto artSlot : artifactsWorn) { MoveArtifact ma; ma.src = ArtifactLocation(finishingBattle->loserHero->commander.get(), artSlot.first); const CArtifactInstance * art = ma.src.getArt(); if (art && !art->artType->isBig()) { sendMoveArtifact(art, &ma); } } } } for (auto armySlot : gs->curB->battleGetArmyObject(!battleResult.data->winner)->stacks) { auto artifactsWorn = armySlot.second->artifactsWorn; for (auto artSlot : artifactsWorn) { MoveArtifact ma; ma.src = ArtifactLocation(armySlot.second, artSlot.first); const CArtifactInstance * art = ma.src.getArt(); if (art && !art->artType->isBig()) { sendMoveArtifact(art, &ma); } } } } sendAndApply(battleResult.data); //after this point casualties objects are destroyed if (arts.size()) //display loot { InfoWindow iw; iw.player = finishingBattle->winnerHero->tempOwner; iw.text.addTxt (MetaString::GENERAL_TXT, 30); //You have captured enemy artifact for (auto art : arts) //TODO; separate function to display loot for various ojects? { iw.components.push_back(Component( Component::ARTIFACT, art->artType->id, art->artType->id == ArtifactID::SPELL_SCROLL? art->getGivenSpellID() : 0, 0)); if (iw.components.size() >= 14) { sendAndApply(&iw); iw.components.clear(); } } if (iw.components.size()) { sendAndApply(&iw); } } //Eagle Eye secondary skill handling if (!cs.spells.empty()) { cs.learn = 1; cs.hid = finishingBattle->winnerHero->id; InfoWindow iw; iw.player = finishingBattle->winnerHero->tempOwner; iw.text.addTxt(MetaString::GENERAL_TXT, 221); //Through eagle-eyed observation, %s is able to learn %s iw.text.addReplacement(finishingBattle->winnerHero->name); std::ostringstream names; for (int i = 0; i < cs.spells.size(); i++) { names << "%s"; if (i < cs.spells.size() - 2) names << ", "; else if (i < cs.spells.size() - 1) names << "%s"; } names << "."; iw.text.addReplacement(names.str()); auto it = cs.spells.begin(); for (int i = 0; i < cs.spells.size(); i++, it++) { iw.text.addReplacement(MetaString::SPELL_NAME, it->toEnum()); if (i == cs.spells.size() - 2) //we just added pre-last name iw.text.addReplacement(MetaString::GENERAL_TXT, 141); // " and " iw.components.push_back(Component(Component::SPELL, *it, 0, 0)); } sendAndApply(&iw); sendAndApply(&cs); } cab1.updateArmy(this); cab2.updateArmy(this); //take casualties after battle is deleted //if one hero has lost we will erase him if (battleResult.data->winner!=0 && hero1) { RemoveObject ro(hero1->id); sendAndApply(&ro); } if (battleResult.data->winner!=1 && hero2) { auto town = hero2->visitedTown; RemoveObject ro(hero2->id); sendAndApply(&ro); if (town && !town->garrisonHero) // TODO: that must be called from CGHeroInstance or CGTownInstance town->battleFinished(hero1, *battleResult.get()); } //give exp if (battleResult.data->exp[0] && hero1 && battleResult.get()->winner == 0) changePrimSkill(hero1, PrimarySkill::EXPERIENCE, battleResult.data->exp[0]); else if (battleResult.data->exp[1] && hero2 && battleResult.get()->winner == 1) changePrimSkill(hero2, PrimarySkill::EXPERIENCE, battleResult.data->exp[1]); queries.popIfTop(battleQuery); //--> continuation (battleAfterLevelUp) occurs after level-up queries are handled or on removing query (above) } void CGameHandler::battleAfterLevelUp(const BattleResult &result) { LOG_TRACE(logGlobal); finishingBattle->remainingBattleQueriesCount--; logGlobal->trace("Decremented queries count to %d", finishingBattle->remainingBattleQueriesCount); if (finishingBattle->remainingBattleQueriesCount > 0) //Battle results will be handled when all battle queries are closed return; //TODO consider if we really want it to work like above. ATM each player as unblocked as soon as possible // but the battle consequences are applied after final player is unblocked. Hard to abuse... // Still, it looks like a hole. // Necromancy if applicable. const CStackBasicDescriptor raisedStack = finishingBattle->winnerHero ? finishingBattle->winnerHero->calculateNecromancy(*battleResult.data) : CStackBasicDescriptor(); // Give raised units to winner and show dialog, if any were raised, // units will be given after casualties are taken const SlotID necroSlot = raisedStack.type ? finishingBattle->winnerHero->getSlotFor(raisedStack.type) : SlotID(); if (necroSlot != SlotID()) { finishingBattle->winnerHero->showNecromancyDialog(raisedStack, getRandomGenerator()); addToSlot(StackLocation(finishingBattle->winnerHero, necroSlot), raisedStack.type, raisedStack.count); } BattleResultsApplied resultsApplied; resultsApplied.player1 = finishingBattle->victor; resultsApplied.player2 = finishingBattle->loser; sendAndApply(&resultsApplied); setBattle(nullptr); if (visitObjectAfterVictory && result.winner==0 && !finishingBattle->winnerHero->stacks.empty()) { logGlobal->trace("post-victory visit"); visitObjectOnTile(*getTile(finishingBattle->winnerHero->getPosition()), finishingBattle->winnerHero); } visitObjectAfterVictory = false; //handle victory/loss of engaged players std::set playerColors = {finishingBattle->loser, finishingBattle->victor}; checkVictoryLossConditions(playerColors); if (result.result == BattleResult::SURRENDER || result.result == BattleResult::ESCAPE) //loser has escaped or surrendered { SetAvailableHeroes sah; sah.player = finishingBattle->loser; sah.hid[0] = finishingBattle->loserHero->subID; if (result.result == BattleResult::ESCAPE) //retreat { sah.army[0].clear(); sah.army[0].setCreature(SlotID(0), finishingBattle->loserHero->type->initialArmy.at(0).creature, 1); } if (const CGHeroInstance *another = getPlayer(finishingBattle->loser)->availableHeroes.at(0)) sah.hid[1] = another->subID; else sah.hid[1] = -1; sendAndApply(&sah); } if (result.winner != 2 && finishingBattle->winnerHero && finishingBattle->winnerHero->stacks.empty()) { RemoveObject ro(finishingBattle->winnerHero->id); sendAndApply(&ro); if (VLC->modh->settings.WINNING_HERO_WITH_NO_TROOPS_RETREATS) { SetAvailableHeroes sah; sah.player = finishingBattle->victor; sah.hid[0] = finishingBattle->winnerHero->subID; sah.army[0].clear(); sah.army[0].setCreature(SlotID(0), finishingBattle->winnerHero->type->initialArmy.at(0).creature, 1); if (const CGHeroInstance *another = getPlayer(finishingBattle->victor)->availableHeroes.at(0)) sah.hid[1] = another->subID; else sah.hid[1] = -1; sendAndApply(&sah); } } } void CGameHandler::prepareAttack(BattleAttack &bat, const CStack *att, const CStack *def, int distance, int targetHex) { bat.bsa.clear(); bat.stackAttacking = att->ID; const int attackerLuck = att->LuckVal(); auto sideHeroBlocksLuck = [](const SideInBattle &side){ return NBonus::hasOfType(side.hero, Bonus::BLOCK_LUCK); }; if (!vstd::contains_if (gs->curB->sides, sideHeroBlocksLuck)) { if (attackerLuck > 0 && getRandomGenerator().nextInt(23) < attackerLuck) { bat.flags |= BattleAttack::LUCKY; } if (VLC->modh->settings.data["hardcodedFeatures"]["NEGATIVE_LUCK"].Bool()) // negative luck enabled { if (attackerLuck < 0 && getRandomGenerator().nextInt(23) < abs(attackerLuck)) { bat.flags |= BattleAttack::UNLUCKY; } } } if (getRandomGenerator().nextInt(99) < att->valOfBonuses(Bonus::DOUBLE_DAMAGE_CHANCE)) { bat.flags |= BattleAttack::DEATH_BLOW; } if (att->getCreature()->idNumber == CreatureID::BALLISTA) { const CGHeroInstance * owner = gs->curB->getHero(att->owner); int chance = owner->valOfBonuses(Bonus::SECONDARY_SKILL_PREMY, SecondarySkill::ARTILLERY); if (chance > getRandomGenerator().nextInt(99)) { bat.flags |= BattleAttack::BALLISTA_DOUBLE_DMG; } } // only primary target applyBattleEffects(bat, att, def, distance, false); if (!bat.shot()) //multiple-hex attack - only in meele { std::set attackedCreatures = gs->curB->getAttackedCreatures(att, targetHex); //creatures other than primary target for (const CStack * stack : attackedCreatures) { if (stack != def) //do not hit same stack twice { applyBattleEffects(bat, att, stack, distance, true); } } } const std::shared_ptr bonus = att->getBonusLocalFirst(Selector::type(Bonus::SPELL_LIKE_ATTACK)); if (bonus && (bat.shot())) //TODO: make it work in melee? { //this is need for displaying hit animation bat.flags |= BattleAttack::SPELL_LIKE; bat.spellID = SpellID(bonus->subtype); //TODO: should spell override creature`s projectile? auto attackedCreatures = SpellID(bonus->subtype).toSpell()->getAffectedStacks(gs->curB, ECastingMode::SPELL_LIKE_ATTACK, att, bonus->val, targetHex); //TODO: get exact attacked hex for defender for (const CStack * stack : attackedCreatures) { if (stack != def) //do not hit same stack twice { applyBattleEffects(bat, att, stack, distance, true); } } //now add effect info for all attacked stacks for (BattleStackAttacked & bsa : bat.bsa) { if (bsa.attackerID == att->ID) //this is our attack and not f.e. fire shield { //this is need for displaying affect animation bsa.flags |= BattleStackAttacked::SPELL_EFFECT; bsa.spellID = SpellID(bonus->subtype); } } } } void CGameHandler::applyBattleEffects(BattleAttack &bat, const CStack *att, const CStack *def, int distance, bool secondary) //helper function for prepareAttack { BattleStackAttacked bsa; if (secondary) bsa.flags |= BattleStackAttacked::SECONDARY; //all other targets do not suffer from spells & spell-like abilities bsa.attackerID = att->ID; bsa.stackAttacked = def->ID; bsa.damageAmount = gs->curB->calculateDmg(att, def, bat.shot(), distance, bat.lucky(), bat.unlucky(), bat.deathBlow(), bat.ballistaDoubleDmg(), getRandomGenerator()); def->prepareAttacked(bsa, getRandomGenerator()); //calculate casualties //life drain handling if(att->hasBonusOfType(Bonus::LIFE_DRAIN) && def->isLiving()) { StacksHealedOrResurrected shi; shi.lifeDrain = true; shi.tentHealing = false; shi.cure = false; shi.drainedFrom = def->ID; int32_t toHeal = bsa.damageAmount * att->valOfBonuses(Bonus::LIFE_DRAIN) / 100; CHealth health = att->healthAfterHealed(toHeal, EHealLevel::RESURRECT, EHealPower::PERMANENT); CHealthInfo hi; health.toInfo(hi); hi.stackId = att->ID; hi.delta = toHeal; shi.healedStacks.push_back(hi); if(hi.delta > 0) bsa.healedStacks.push_back(shi); } //soul steal handling if(att->hasBonusOfType(Bonus::SOUL_STEAL) && def->isLiving()) { StacksHealedOrResurrected shi; shi.lifeDrain = true; shi.tentHealing = false; shi.cure = false; shi.drainedFrom = def->ID; for(int i = 0; i < 2; i++) //we can have two bonuses - one with subtype 0 and another with subtype 1 { if(att->hasBonusOfType(Bonus::SOUL_STEAL, i)) { int32_t toHeal = bsa.killedAmount * att->valOfBonuses(Bonus::SOUL_STEAL, i) * att->MaxHealth(); CHealth health = att->healthAfterHealed(toHeal, EHealLevel::OVERHEAL, ((i == 0) ? EHealPower::ONE_BATTLE : EHealPower::PERMANENT)); CHealthInfo hi; health.toInfo(hi); hi.stackId = att->ID; hi.delta = toHeal; if(hi.delta > 0) shi.healedStacks.push_back(hi); } } if(!shi.healedStacks.empty()) bsa.healedStacks.push_back(shi); } bat.bsa.push_back(bsa); //add this stack to the list of victims after drain life has been calculated //fire shield handling if(!bat.shot() && !def->isClone() && def->hasBonusOfType(Bonus::FIRE_SHIELD) && !att->hasBonusOfType(Bonus::FIRE_IMMUNITY)) { // TODO: Fire shield damage should be calculated separately after BattleAttack applied. // Currently it looks like attacking stack damage itself with defenders fire shield. // So no separate message on spell damage in log and experience calculation is likely wrong too. BattleStackAttacked bsa2; bsa2.stackAttacked = att->ID; //invert bsa2.attackerID = def->ID; bsa2.flags |= BattleStackAttacked::EFFECT; //FIXME: play animation upon efreet and not attacker bsa2.effect = 11; bsa2.damageAmount = (std::min(def->health.available(), bsa.damageAmount) * def->valOfBonuses(Bonus::FIRE_SHIELD)) / 100; //TODO: scale with attack/defense att->prepareAttacked(bsa2, getRandomGenerator()); bat.bsa.push_back(bsa2); } } void CGameHandler::handleConnection(std::set players, CConnection &c) { setThreadName("CGameHandler::handleConnection"); auto handleDisconnection = [&](const std::exception & e) { boost::unique_lock lock(*c.wmx); assert(!c.connected); //make sure that connection has been marked as broken logGlobal->error(e.what()); conns -= &c; for(auto playerConn : connections) { if(!serverShuttingDown && playerConn.second == &c) { PlayerCheated pc; pc.player = playerConn.first; pc.losingCheatCode = true; sendAndApply(&pc); checkVictoryLossConditionsForPlayer(playerConn.first); } } }; try { while(1)//server should never shut connection first //was: while(!end2) { CPack *pack = nullptr; PlayerColor player = PlayerColor::NEUTRAL; si32 requestID = -999; int packType = 0; { boost::unique_lock lock(*c.rmx); if(!c.connected) throw clientDisconnectedException(); c >> player >> requestID >> pack; //get the package if (!pack) { logGlobal->error("Received a null package marked as request %d from player %d", requestID, player); } else { packType = typeList.getTypeID(pack); //get the id of type logGlobal->trace("Received client message (request %d by player %d (%s)) of type with ID=%d (%s).\n", requestID, player, player.getStr(), packType, typeid(*pack).name()); } } //prepare struct informing that action was applied auto sendPackageResponse = [&](bool succesfullyApplied) { //dont reply to disconnected client //TODO: this must be implemented as option of CPackForServer if(dynamic_cast(pack) || dynamic_cast(pack)) return; PackageApplied applied; applied.player = player; applied.result = succesfullyApplied; applied.packType = packType; applied.requestID = requestID; boost::unique_lock lock(*c.wmx); c << &applied; }; CBaseForGHApply *apply = applier->getApplier(packType); //and appropriate applier object if(isBlockedByQueries(pack, player)) { sendPackageResponse(false); } else if (apply) { const bool result = apply->applyOnGH(this, &c, pack, player); if (result) logGlobal->trace("Message %s successfully applied!", typeid(*pack).name()); else complain((boost::format("Got false in applying %s... that request must have been fishy!") % typeid(*pack).name()).str()); sendPackageResponse(true); } else { logGlobal->error("Message cannot be applied, cannot find applier (unregistered type)!"); sendPackageResponse(false); } vstd::clear_pointer(pack); } } catch(boost::system::system_error &e) //for boost errors just log, not crash - probably client shut down connection { handleDisconnection(e); } catch(clientDisconnectedException & e) { handleDisconnection(e); } catch(...) { serverShuttingDown = true; handleException(); throw; } logGlobal->error("Ended handling connection"); } int CGameHandler::moveStack(int stack, BattleHex dest) { int ret = 0; const CStack *curStack = gs->curB->battleGetStackByID(stack), *stackAtEnd = gs->curB->battleGetStackByPos(dest); assert(curStack); assert(dest < GameConstants::BFIELD_SIZE); if (gs->curB->tacticDistance) { assert(gs->curB->isInTacticRange(dest)); } auto start = curStack->position; if (start == dest) return 0; //initing necessary tables auto accessibility = getAccesibility(curStack); //shifting destination (if we have double wide stack and we can occupy dest but not be exactly there) if(!stackAtEnd && curStack->doubleWide() && !accessibility.accessible(dest, curStack)) { BattleHex shifted = dest.cloneInDirection(curStack->destShiftDir(), false); if(accessibility.accessible(shifted, curStack)) dest = shifted; } if((stackAtEnd && stackAtEnd!=curStack && stackAtEnd->alive()) || !accessibility.accessible(dest, curStack)) { complain("Given destination is not accessible!"); return 0; } bool canUseGate = false; auto dbState = gs->curB->si.gateState; if(battleGetSiegeLevel() > 0 && curStack->side == BattleSide::DEFENDER && dbState != EGateState::DESTROYED && dbState != EGateState::BLOCKED) { canUseGate = true; } std::pair< std::vector, int > path = gs->curB->getPath(start, dest, curStack); ret = path.second; int creSpeed = gs->curB->tacticDistance ? GameConstants::BFIELD_SIZE : curStack->Speed(); auto isGateDrawbridgeHex = [&](BattleHex hex) -> bool { if (gs->curB->town->subID == ETownType::FORTRESS && hex == ESiegeHex::GATE_BRIDGE) return true; if (hex == ESiegeHex::GATE_OUTER) return true; if (hex == ESiegeHex::GATE_INNER) return true; return false; }; auto occupyGateDrawbridgeHex = [&](BattleHex hex) -> bool { if (isGateDrawbridgeHex(hex)) return true; if (curStack->doubleWide()) { BattleHex otherHex = curStack->occupiedHex(hex); if (otherHex.isValid() && isGateDrawbridgeHex(otherHex)) return true; } return false; }; if (curStack->hasBonusOfType(Bonus::FLYING)) { if (path.second <= creSpeed && path.first.size() > 0) { if (canUseGate && dbState != EGateState::OPENED && occupyGateDrawbridgeHex(dest)) { BattleUpdateGateState db; db.state = EGateState::OPENED; sendAndApply(&db); } //inform clients about move BattleStackMoved sm; sm.stack = curStack->ID; std::vector tiles; tiles.push_back(path.first[0]); sm.tilesToMove = tiles; sm.distance = path.second; sm.teleporting = false; sendAndApply(&sm); } } else //for non-flying creatures { std::vector tiles; const int tilesToMove = std::max((int)(path.first.size() - creSpeed), 0); int v = path.first.size()-1; path.first.push_back(start); // check if gate need to be open or closed at some point BattleHex openGateAtHex, gateMayCloseAtHex; if (canUseGate) { for (int i = path.first.size()-1; i >= 0; i--) { auto needOpenGates = [&](BattleHex hex) -> bool { if (gs->curB->town->subID == ETownType::FORTRESS && hex == ESiegeHex::GATE_BRIDGE) return true; if (hex == ESiegeHex::GATE_BRIDGE && i-1 >= 0 && path.first[i-1] == ESiegeHex::GATE_OUTER) return true; else if (hex == ESiegeHex::GATE_OUTER || hex == ESiegeHex::GATE_INNER) return true; return false; }; auto hex = path.first[i]; if (!openGateAtHex.isValid() && dbState != EGateState::OPENED) { if (needOpenGates(hex)) openGateAtHex = path.first[i+1]; //TODO we need find batter way to handle double-wide stacks //currently if only second occupied stack part is standing on gate / bridge hex then stack will start to wait for bridge to lower before it's needed. Though this is just a visual bug. if (curStack->doubleWide()) { BattleHex otherHex = curStack->occupiedHex(hex); if (otherHex.isValid() && needOpenGates(otherHex)) openGateAtHex = path.first[i+2]; } //gate may be opened and then closed during stack movement, but not other way around if (openGateAtHex.isValid()) dbState = EGateState::OPENED; } if (!gateMayCloseAtHex.isValid() && dbState != EGateState::CLOSED) { if (hex == ESiegeHex::GATE_INNER && i-1 >= 0 && path.first[i-1] != ESiegeHex::GATE_OUTER) { gateMayCloseAtHex = path.first[i-1]; } if (gs->curB->town->subID == ETownType::FORTRESS) { if (hex == ESiegeHex::GATE_BRIDGE && i-1 >= 0 && path.first[i-1] != ESiegeHex::GATE_OUTER) { gateMayCloseAtHex = path.first[i-1]; } else if (hex == ESiegeHex::GATE_OUTER && i-1 >= 0 && path.first[i-1] != ESiegeHex::GATE_INNER && path.first[i-1] != ESiegeHex::GATE_BRIDGE) { gateMayCloseAtHex = path.first[i-1]; } } else if (hex == ESiegeHex::GATE_OUTER && i-1 >= 0 && path.first[i-1] != ESiegeHex::GATE_INNER) { gateMayCloseAtHex = path.first[i-1]; } } } } bool stackIsMoving = true; while(stackIsMoving) { if (verror("Movement terminated abnormally"); break; } bool gateStateChanging = false; //special handling for opening gate on from starting hex if (openGateAtHex.isValid() && openGateAtHex == start) gateStateChanging = true; else { for (bool obstacleHit = false; (!obstacleHit) && (!gateStateChanging) && (v >= tilesToMove); --v) { BattleHex hex = path.first[v]; tiles.push_back(hex); if ((openGateAtHex.isValid() && openGateAtHex == hex) || (gateMayCloseAtHex.isValid() && gateMayCloseAtHex == hex)) { gateStateChanging = true; } //if we walked onto something, finalize this portion of stack movement check into obstacle if(!battleGetAllObstaclesOnPos(hex, false).empty()) obstacleHit = true; if (curStack->doubleWide()) { BattleHex otherHex = curStack->occupiedHex(hex); //two hex creature hit obstacle by backside auto obstacle2 = battleGetAllObstaclesOnPos(otherHex, false); if(otherHex.isValid() && !obstacle2.empty()) obstacleHit = true; } } } if (tiles.size() > 0) { //commit movement BattleStackMoved sm; sm.stack = curStack->ID; sm.distance = path.second; sm.teleporting = false; sm.tilesToMove = tiles; sendAndApply(&sm); tiles.clear(); } //we don't handle obstacle at the destination tile -> it's handled separately in the if at the end if (curStack->position != dest) { if(stackIsMoving && start != curStack->position) stackIsMoving = handleDamageFromObstacle(curStack, stackIsMoving); if (gateStateChanging) { if (curStack->position == openGateAtHex) { openGateAtHex = BattleHex(); //only open gate if stack is still alive if (curStack->alive()) { BattleUpdateGateState db; db.state = EGateState::OPENED; sendAndApply(&db); } } else if (curStack->position == gateMayCloseAtHex) { gateMayCloseAtHex = BattleHex(); updateGateState(); } } } else //movement finished normally: we reached destination stackIsMoving = false; } } //handling obstacle on the final field (separate, because it affects both flying and walking stacks) handleDamageFromObstacle(curStack); return ret; } CGameHandler::CGameHandler(void) { QID = 1; //gs = nullptr; IObjectInterface::cb = this; applier = new CApplier(); registerTypesServerPacks(*applier); visitObjectAfterVictory = false; spellEnv = new ServerSpellCastEnvironment(this); } CGameHandler::~CGameHandler(void) { delete spellEnv; delete applier; applier = nullptr; delete gs; } void CGameHandler::init(StartInfo *si) { if (si->seedToBeUsed == 0) { si->seedToBeUsed = std::time(nullptr); } gs = new CGameState(); logGlobal->info("Gamestate created!"); gs->init(si); logGlobal->info("Gamestate initialized!"); // reset seed, so that clients can't predict any following random values getRandomGenerator().resetSeed(); for (auto & elem : gs->players) { states.addPlayer(elem.first); } } static bool evntCmp(const CMapEvent &a, const CMapEvent &b) { return a.earlierThan(b); } void CGameHandler::setPortalDwelling(const CGTownInstance * town, bool forced=false, bool clear = false) {// bool forced = true - if creature should be replaced, if false - only if no creature was set const PlayerState * p = getPlayer(town->tempOwner); if (!p) { logGlobal->warn("There is no player owner of town %s at %s", town->name, town->pos.toString()); return; } if (forced || town->creatures.at(GameConstants::CREATURES_PER_TOWN).second.empty())//we need to change creature { SetAvailableCreatures ssi; ssi.tid = town->id; ssi.creatures = town->creatures; ssi.creatures[GameConstants::CREATURES_PER_TOWN].second.clear();//remove old one const std::vector > &dwellings = p->dwellings; if (dwellings.empty())//no dwellings - just remove { sendAndApply(&ssi); return; } auto dwelling = *RandomGeneratorUtil::nextItem(dwellings, getRandomGenerator()); // for multi-creature dwellings like Golem Factory auto creatureId = RandomGeneratorUtil::nextItem(dwelling->creatures, getRandomGenerator())->second[0]; if (clear) { ssi.creatures[GameConstants::CREATURES_PER_TOWN].first = std::max((ui32)1, (VLC->creh->creatures.at(creatureId)->growth)/2); } else { ssi.creatures[GameConstants::CREATURES_PER_TOWN].first = VLC->creh->creatures.at(creatureId)->growth; } ssi.creatures[GameConstants::CREATURES_PER_TOWN].second.push_back(creatureId); sendAndApply(&ssi); } } void CGameHandler::newTurn() { logGlobal->trace("Turn %d", gs->day+1); NewTurn n; n.specialWeek = NewTurn::NO_ACTION; n.creatureid = CreatureID::NONE; n.day = gs->day + 1; bool firstTurn = !getDate(Date::DAY); bool newWeek = getDate(Date::DAY_OF_WEEK) == 7; //day numbers are confusing, as day was not yet switched bool newMonth = getDate(Date::DAY_OF_MONTH) == 28; std::map hadGold;//starting gold - for buildings like dwarven treasury if (firstTurn) { for (auto obj : gs->map->objects) { if (obj && obj->ID == Obj::PRISON) //give imprisoned hero 0 exp to level him up. easiest to do at this point { changePrimSkill (getHero(obj->id), PrimarySkill::EXPERIENCE, 0); } } } if (newWeek && !firstTurn) { n.specialWeek = NewTurn::NORMAL; bool deityOfFireBuilt = false; for (const CGTownInstance *t : gs->map->towns) { if (t->hasBuilt(BuildingID::GRAIL, ETownType::INFERNO)) { deityOfFireBuilt = true; break; } } if (deityOfFireBuilt) { n.specialWeek = NewTurn::DEITYOFFIRE; n.creatureid = CreatureID::IMP; } else { int monthType = getRandomGenerator().nextInt(99); if (newMonth) //new month { if (monthType < 40) //double growth { n.specialWeek = NewTurn::DOUBLE_GROWTH; if (VLC->modh->settings.ALL_CREATURES_GET_DOUBLE_MONTHS) { std::pair newMonster(54, VLC->creh->pickRandomMonster(getRandomGenerator())); n.creatureid = newMonster.second; } else if (VLC->creh->doubledCreatures.size()) { const std::vector doubledCreatures (VLC->creh->doubledCreatures.begin(), VLC->creh->doubledCreatures.end()); n.creatureid = *RandomGeneratorUtil::nextItem(doubledCreatures, getRandomGenerator()); } else { complain("Cannot find creature that can be spawned!"); n.specialWeek = NewTurn::NORMAL; } } else if (monthType < 50) n.specialWeek = NewTurn::PLAGUE; } else //it's a week, but not full month { if (monthType < 25) { n.specialWeek = NewTurn::BONUS_GROWTH; //+5 std::pair newMonster(54, VLC->creh->pickRandomMonster(getRandomGenerator())); //TODO do not pick neutrals n.creatureid = newMonster.second; } } } } std::map > pool = gs->hpool.heroesPool; for (auto& hp : pool) { auto hero = hp.second; if (hero->isInitialized() && hero->stacks.size()) { // reset retreated or surrendered heroes auto maxmove = hero->maxMovePoints(true); // if movement is greater than maxmove, we should decrease it if (hero->movement != maxmove || hero->mana < hero->manaLimit()) { NewTurn::Hero hth; hth.id = hero->id; hth.move = maxmove; hth.mana = hero->getManaNewTurn(); n.heroes.insert(hth); } } } for (auto & elem : gs->players) { if (elem.first == PlayerColor::NEUTRAL) continue; else if (elem.first >= PlayerColor::PLAYER_LIMIT) assert(0); //illegal player number! std::pair playerGold(elem.first, elem.second.resources.at(Res::GOLD)); hadGold.insert(playerGold); if (newWeek) //new heroes in tavern { SetAvailableHeroes sah; sah.player = elem.first; //pick heroes and their armies CHeroClass *banned = nullptr; for (int j = 0; j < GameConstants::AVAILABLE_HEROES_PER_PLAYER; j++) { //first hero - native if possible, second hero -> any other class if (CGHeroInstance *h = gs->hpool.pickHeroFor(j == 0, elem.first, getNativeTown(elem.first), pool, getRandomGenerator(), banned)) { sah.hid[j] = h->subID; h->initArmy(getRandomGenerator(), &sah.army[j]); banned = h->type->heroClass; } else { sah.hid[j] = -1; } } sendAndApply(&sah); } n.res[elem.first] = elem.second.resources; for (CGHeroInstance *h : (elem).second.heroes) { if (h->visitedTown) giveSpells(h->visitedTown, h); NewTurn::Hero hth; hth.id = h->id; auto ti = make_unique(h, 1); // TODO: this code executed when bonuses of previous day not yet updated (this happen in NewTurn::applyGs). See issue 2356 hth.move = h->maxMovePoints(gs->map->getTile(h->getPosition(false)).terType != ETerrainType::WATER, ti.get()); hth.mana = h->getManaNewTurn(); n.heroes.insert(hth); if (!firstTurn) //not first day { n.res[elem.first][Res::GOLD] += h->valOfBonuses(Selector::typeSubtype(Bonus::SECONDARY_SKILL_PREMY, SecondarySkill::ESTATES)); //estates for (int k = 0; k < GameConstants::RESOURCE_QUANTITY; k++) { n.res[elem.first][k] += h->valOfBonuses(Bonus::GENERATE_RESOURCE, k); } } } } for (CGTownInstance *t : gs->map->towns) { PlayerColor player = t->tempOwner; handleTownEvents(t, n); if (newWeek) //first day of week { if (t->hasBuilt(BuildingID::PORTAL_OF_SUMMON, ETownType::DUNGEON)) setPortalDwelling(t, true, (n.specialWeek == NewTurn::PLAGUE ? true : false)); //set creatures for Portal of Summoning if (!firstTurn) if (t->hasBuilt(BuildingID::TREASURY, ETownType::RAMPART) && player < PlayerColor::PLAYER_LIMIT) n.res[player][Res::GOLD] += hadGold.at(player)/10; //give 10% of starting gold if (!vstd::contains(n.cres, t->id)) { n.cres[t->id].tid = t->id; n.cres[t->id].creatures = t->creatures; } auto & sac = n.cres.at(t->id); for (int k=0; k < GameConstants::CREATURES_PER_TOWN; k++) //creature growths { if (!t->creatures.at(k).second.empty()) // there are creatures at this level { ui32 &availableCount = sac.creatures.at(k).first; const CCreature *cre = VLC->creh->creatures.at(t->creatures.at(k).second.back()); if (n.specialWeek == NewTurn::PLAGUE) availableCount = t->creatures.at(k).first / 2; //halve their number, no growth else { if (firstTurn) //first day of game: use only basic growths availableCount = cre->growth; else availableCount += t->creatureGrowth(k); //Deity of fire week - upgrade both imps and upgrades if (n.specialWeek == NewTurn::DEITYOFFIRE && vstd::contains(t->creatures.at(k).second, n.creatureid)) availableCount += 15; if (cre->idNumber == n.creatureid) //bonus week, effect applies only to identical creatures { if (n.specialWeek == NewTurn::DOUBLE_GROWTH) availableCount *= 2; else if (n.specialWeek == NewTurn::BONUS_GROWTH) availableCount += 5; } } } } } if (!firstTurn && player < PlayerColor::PLAYER_LIMIT)//not the first day and town not neutral { n.res[player] = n.res[player] + t->dailyIncome(); } if (t->hasBuilt(BuildingID::GRAIL, ETownType::TOWER)) { // Skyship, probably easier to handle same as Veil of darkness //do it every new day after veils apply if (player != PlayerColor::NEUTRAL) //do not reveal fow for neutral player { FoWChange fw; fw.mode = 1; fw.player = player; // find all hidden tiles const auto & fow = getPlayerTeam(player)->fogOfWarMap; for (size_t i=0; ihasBonusOfType (Bonus::DARKNESS)) { for (auto & player : gs->players) { if (getPlayerStatus(player.first) == EPlayerStatus::INGAME && getPlayerRelations(player.first, t->tempOwner) == PlayerRelations::ENEMIES) changeFogOfWar(t->visitablePos(), t->getBonusLocalFirst(Selector::type(Bonus::DARKNESS))->val, player.first, true); } } } if (newMonth) { SetAvailableArtifacts saa; saa.id = -1; pickAllowedArtsSet(saa.arts, getRandomGenerator()); sendAndApply(&saa); } sendAndApply(&n); if (newWeek) { //spawn wandering monsters if (newMonth && (n.specialWeek == NewTurn::DOUBLE_GROWTH || n.specialWeek == NewTurn::DEITYOFFIRE)) { spawnWanderingMonsters(n.creatureid); } //new week info popup if (!firstTurn) { InfoWindow iw; switch (n.specialWeek) { case NewTurn::DOUBLE_GROWTH: iw.text.addTxt(MetaString::ARRAY_TXT, 131); iw.text.addReplacement(MetaString::CRE_SING_NAMES, n.creatureid); iw.text.addReplacement(MetaString::CRE_SING_NAMES, n.creatureid); break; case NewTurn::PLAGUE: iw.text.addTxt(MetaString::ARRAY_TXT, 132); break; case NewTurn::BONUS_GROWTH: iw.text.addTxt(MetaString::ARRAY_TXT, 134); iw.text.addReplacement(MetaString::CRE_SING_NAMES, n.creatureid); iw.text.addReplacement(MetaString::CRE_SING_NAMES, n.creatureid); break; case NewTurn::DEITYOFFIRE: iw.text.addTxt(MetaString::ARRAY_TXT, 135); iw.text.addReplacement(MetaString::CRE_SING_NAMES, 42); //%s imp iw.text.addReplacement(MetaString::CRE_SING_NAMES, 42); //%s imp iw.text.addReplacement2(15); //%+d 15 iw.text.addReplacement(MetaString::CRE_SING_NAMES, 43); //%s familiar iw.text.addReplacement2(15); //%+d 15 break; default: if (newMonth) { iw.text.addTxt(MetaString::ARRAY_TXT, (130)); iw.text.addReplacement(MetaString::ARRAY_TXT, getRandomGenerator().nextInt(32, 41)); } else { iw.text.addTxt(MetaString::ARRAY_TXT, (133)); iw.text.addReplacement(MetaString::ARRAY_TXT, getRandomGenerator().nextInt(43, 57)); } } for (auto & elem : gs->players) { iw.player = elem.first; sendAndApply(&iw); } } } logGlobal->trace("Info about turn %d has been sent!", n.day); handleTimeEvents(); //call objects for (auto & elem : gs->map->objects) { if (elem) elem->newTurn(getRandomGenerator()); } synchronizeArtifactHandlerLists(); //new day events may have changed them. TODO better of managing that } void CGameHandler::run(bool resume) { LOG_TRACE_PARAMS(logGlobal, "resume=%d", resume); using namespace boost::posix_time; for (CConnection *cc : conns) { if (!resume) { (*cc) << gs->initialOpts; // gs->scenarioOps } std::set players; (*cc) >> players; //how many players will be handled at that client std::stringstream sbuffer; sbuffer << "Connection " << cc->connectionID << " will handle " << players.size() << " player: "; for (PlayerColor color : players) { sbuffer << color << " "; { boost::unique_lock lock(gsm); if(!color.isSpectator()) // there can be more than one spectator connections[color] = cc; } } logGlobal->info(sbuffer.str()); cc->addStdVecItems(gs); cc->enableStackSendingByID(); cc->disableSmartPointerSerialization(); } for (auto & elem : conns) { std::set pom; for (auto j = connections.cbegin(); j!=connections.cend();j++) if (j->second == elem) pom.insert(j->first); boost::thread(std::bind(&CGameHandler::handleConnection,this,pom,std::ref(*elem))); } auto playerTurnOrder = generatePlayerTurnOrder(); while(!serverShuttingDown) { if (!resume) newTurn(); std::list::iterator it; if (resume) { it = std::find(playerTurnOrder.begin(), playerTurnOrder.end(), gs->currentPlayer); } else { it = playerTurnOrder.begin(); } resume = false; for (; it != playerTurnOrder.end(); it++) { auto playerColor = *it; PlayerState * playerState = &gs->players[playerColor]; //can't copy CBonusSystemNode by value if (playerState->status == EPlayerStatus::INGAME) { //if player runs out of time, he shouldn't get the turn (especially AI) checkVictoryLossConditionsForAll(); if (gs->players[playerColor].status != EPlayerStatus::INGAME) { //player lost at the beginning of his turn continue; } else //give normal turn { states.setFlag(playerColor, &PlayerStatus::makingTurn, true); YourTurn yt; yt.player = playerColor; //Change local daysWithoutCastle counter for local interface message //TODO: needed? yt.daysWithoutCastle = playerState->daysWithoutCastle; applyAndSend(&yt); //wait till turn is done boost::unique_lock lock(states.mx); while(states.players.at(playerColor).makingTurn && !serverShuttingDown) { static time_duration p = milliseconds(100); states.cv.timed_wait(lock, p); } } } } //additional check that game is not finished bool activePlayer = false; for (auto player : playerTurnOrder) { if (gs->players[player].status == EPlayerStatus::INGAME) activePlayer = true; } if (!activePlayer) serverShuttingDown = true; } while(conns.size() && (*conns.begin())->isOpen()) boost::this_thread::sleep(boost::posix_time::milliseconds(5)); //give time client to close socket } std::list CGameHandler::generatePlayerTurnOrder() const { // Generate player turn order std::list playerTurnOrder; for (const auto & player : gs->players) // add human players first { if (player.second.human) playerTurnOrder.push_back(player.first); } for (const auto & player : gs->players) // then add non-human players { if (!player.second.human) playerTurnOrder.push_back(player.first); } return playerTurnOrder; } void CGameHandler::setupBattle(int3 tile, const CArmedInstance *armies[2], const CGHeroInstance *heroes[2], bool creatureBank, const CGTownInstance *town) { battleResult.set(nullptr); const auto t = getTile(tile); ETerrainType terrain = t->terType; if (gs->map->isCoastalTile(tile)) //coastal tile is always ground terrain = ETerrainType::SAND; BFieldType terType = gs->battleGetBattlefieldType(tile, getRandomGenerator()); if (heroes[0] && heroes[0]->boat && heroes[1] && heroes[1]->boat) terType = BFieldType::SHIP_TO_SHIP; //send info about battles BattleStart bs; bs.info = BattleInfo::setupBattle(tile, terrain, terType, armies, heroes, creatureBank, town); sendAndApply(&bs); } void CGameHandler::checkBattleStateChanges() { //check if drawbridge state need to be changes if (battleGetSiegeLevel() > 0) updateGateState(); //check if battle ended if (auto result = battleIsFinished()) { setBattleResult(BattleResult::NORMAL, *result); } } void CGameHandler::giveSpells(const CGTownInstance *t, const CGHeroInstance *h) { if (!h->hasSpellbook()) return; //hero hasn't spellbook ChangeSpells cs; cs.hid = h->id; cs.learn = true; if (t->hasBuilt(BuildingID::GRAIL, ETownType::CONFLUX) && t->hasBuilt(BuildingID::MAGES_GUILD_1)) { // Aurora Borealis give spells of all levels even if only level 1 mages guild built for (int i = 0; i < h->maxSpellLevel(); i++) { std::vector spells; getAllowedSpells(spells, i+1); for (auto & spell : spells) cs.spells.insert(spell); } } else { for (int i = 0; i < std::min(t->mageGuildLevel(), h->maxSpellLevel()); i++) { for (int j = 0; j < t->spellsAtLevel(i+1, true) && j < t->spells.at(i).size(); j++) { if (!vstd::contains(h->spells, t->spells.at(i).at(j))) cs.spells.insert(t->spells.at(i).at(j)); } } } if (!cs.spells.empty()) sendAndApply(&cs); } void CGameHandler::setBlockVis(ObjectInstanceID objid, bool bv) { SetObjectProperty sop(objid, ObjProperty::BLOCKVIS, bv); sendAndApply(&sop); } bool CGameHandler::removeObject(const CGObjectInstance * obj) { if (!obj || !getObj(obj->id)) { logGlobal->error("Something wrong, that object already has been removed or hasn't existed!"); return false; } RemoveObject ro; ro.id = obj->id; sendAndApply(&ro); checkVictoryLossConditionsForAll(); //eg if monster escaped (removing objs after battle is done dircetly by endBattle, not this function) return true; } void CGameHandler::setAmount(ObjectInstanceID objid, ui32 val) { SetObjectProperty sop(objid, ObjProperty::PRIMARY_STACK_COUNT, val); sendAndApply(&sop); } bool CGameHandler::moveHero(ObjectInstanceID hid, int3 dst, ui8 teleporting, bool transit, PlayerColor asker) { const CGHeroInstance *h = getHero(hid); // not turn of that hero or player can't simply teleport hero (at least not with this function) if (!h || (asker != PlayerColor::NEUTRAL && (teleporting || h->getOwner() != gs->currentPlayer))) { logGlobal->error("Illegal call to move hero!"); return false; } logGlobal->trace("Player %d (%s) wants to move hero %d from %s to %s", asker, asker.getStr(), hid.getNum(), h->pos.toString(), dst.toString()); const int3 hmpos = CGHeroInstance::convertPosition(dst, false); if (!gs->map->isInTheMap(hmpos)) { logGlobal->error("Destination tile is outside the map!"); return false; } const TerrainTile t = *getTile(hmpos); const int3 guardPos = gs->guardingCreaturePosition(hmpos); const bool embarking = !h->boat && !t.visitableObjects.empty() && t.visitableObjects.back()->ID == Obj::BOAT; const bool disembarking = h->boat && t.terType != ETerrainType::WATER && !t.blocked; //result structure for start - movement failed, no move points used TryMoveHero tmh; tmh.id = hid; tmh.start = h->pos; tmh.end = dst; tmh.result = TryMoveHero::FAILED; tmh.movePoints = h->movement; //check if destination tile is available auto ti = make_unique(h); const bool canFly = ti->hasBonusOfType(Bonus::FLYING_MOVEMENT); const bool canWalkOnSea = ti->hasBonusOfType(Bonus::WATER_WALKING); const int cost = CPathfinderHelper::getMovementCost(h, h->getPosition(), hmpos, nullptr, nullptr, h->movement, ti.get()); //it's a rock or blocked and not visitable tile //OR hero is on land and dest is water and (there is not present only one object - boat) if (((t.terType == ETerrainType::ROCK || (t.blocked && !t.visitable && !canFly)) && complain("Cannot move hero, destination tile is blocked!")) || ((!h->boat && !canWalkOnSea && !canFly && t.terType == ETerrainType::WATER && (t.visitableObjects.size() < 1 || (t.visitableObjects.back()->ID != Obj::BOAT && t.visitableObjects.back()->ID != Obj::HERO))) //hero is not on boat/water walking and dst water tile doesn't contain boat/hero (objs visitable from land) -> we test back cause boat may be on top of another object (#276) && complain("Cannot move hero, destination tile is on water!")) || ((h->boat && t.terType != ETerrainType::WATER && t.blocked) && complain("Cannot disembark hero, tile is blocked!")) || ((distance(h->pos, dst) >= 1.5 && !teleporting) && complain("Tiles are not neighboring!")) || ((h->inTownGarrison) && complain("Can not move garrisoned hero!")) || ((h->movement < cost && dst != h->pos && !teleporting) && complain("Hero doesn't have any movement points left!")) || ((transit && !canFly && !CGTeleport::isTeleport(t.topVisitableObj())) && complain("Hero cannot transit over this tile!")) /*|| (states.checkFlag(h->tempOwner, &PlayerStatus::engagedIntoBattle) && complain("Cannot move hero during the battle"))*/) { //send info about movement failure sendAndApply(&tmh); return false; } //several generic blocks of code // should be called if hero changes tile but before applying TryMoveHero package auto leaveTile = [&]() { for (CGObjectInstance *obj : gs->map->getTile(int3(h->pos.x-1, h->pos.y, h->pos.z)).visitableObjects) { obj->onHeroLeave(h); } this->getTilesInRange(tmh.fowRevealed, h->getSightCenter()+(tmh.end-tmh.start), h->getSightRadius(), h->tempOwner, 1); }; auto doMove = [&](TryMoveHero::EResult result, EGuardLook lookForGuards, EVisitDest visitDest, ELEaveTile leavingTile) -> bool { LOG_TRACE_PARAMS(logGlobal, "Hero %s starts movement from %s to %s", h->name % tmh.start.toString() % tmh.end.toString()); auto moveQuery = std::make_shared(this, tmh, h); queries.addQuery(moveQuery); if (leavingTile == LEAVING_TILE) leaveTile(); tmh.result = result; sendAndApply(&tmh); if (visitDest == VISIT_DEST && t.topVisitableObj() && t.topVisitableObj()->id == h->id) { // Hero should be always able to visit any object he staying on even if there guards around visitObjectOnTile(t, h); } else if (lookForGuards == CHECK_FOR_GUARDS && this->isInTheMap(guardPos)) { tmh.attackedFrom = boost::make_optional(guardPos); const TerrainTile &guardTile = *gs->getTile(guardPos); objectVisited(guardTile.visitableObjects.back(), h); moveQuery->visitDestAfterVictory = visitDest==VISIT_DEST; } else if (visitDest == VISIT_DEST) { visitObjectOnTile(t, h); } queries.popIfTop(moveQuery); logGlobal->trace("Hero %s ends movement", h->name); return result != TryMoveHero::FAILED; }; //interaction with blocking object (like resources) auto blockingVisit = [&]() -> bool { for (CGObjectInstance *obj : t.visitableObjects) { if (obj != h && obj->blockVisit && !obj->passableFor(h->tempOwner)) { return doMove(TryMoveHero::BLOCKING_VISIT, this->IGNORE_GUARDS, VISIT_DEST, REMAINING_ON_TILE); //this-> is needed for MVS2010 to recognize scope (?) } } return false; }; if (!transit && embarking) { tmh.movePoints = h->movementPointsAfterEmbark(h->movement, cost, false, ti.get()); return doMove(TryMoveHero::EMBARK, IGNORE_GUARDS, DONT_VISIT_DEST, LEAVING_TILE); // In H3 embark ignore guards } if (disembarking) { tmh.movePoints = h->movementPointsAfterEmbark(h->movement, cost, true, ti.get()); return doMove(TryMoveHero::DISEMBARK, CHECK_FOR_GUARDS, VISIT_DEST, LEAVING_TILE); } if (teleporting) { if (blockingVisit()) // e.g. hero on the other side of teleporter return true; doMove(TryMoveHero::TELEPORTATION, IGNORE_GUARDS, DONT_VISIT_DEST, LEAVING_TILE); // visit town for town portal \ castle gates // do not use generic visitObjectOnTile to avoid double-teleporting // if this moveHero call was triggered by teleporter if (!t.visitableObjects.empty()) { if (CGTownInstance * town = dynamic_cast(t.visitableObjects.back())) town->onHeroVisit(h); } return true; } //still here? it is standard movement! { tmh.movePoints = h->movement >= cost ? h->movement - cost : 0; EGuardLook lookForGuards = CHECK_FOR_GUARDS; EVisitDest visitDest = VISIT_DEST; if (transit) { if (CGTeleport::isTeleport(t.topVisitableObj())) visitDest = DONT_VISIT_DEST; if (canFly) { lookForGuards = IGNORE_GUARDS; visitDest = DONT_VISIT_DEST; } } else if (blockingVisit()) return true; doMove(TryMoveHero::SUCCESS, lookForGuards, visitDest, LEAVING_TILE); return true; } } bool CGameHandler::teleportHero(ObjectInstanceID hid, ObjectInstanceID dstid, ui8 source, PlayerColor asker) { const CGHeroInstance *h = getHero(hid); const CGTownInstance *t = getTown(dstid); if (!h || !t || h->getOwner() != gs->currentPlayer) COMPLAIN_RET("Invalid call to teleportHero!"); const CGTownInstance *from = h->visitedTown; if (((h->getOwner() != t->getOwner()) && complain("Cannot teleport hero to another player")) || ((!from || !from->hasBuilt(BuildingID::CASTLE_GATE, ETownType::INFERNO)) && complain("Hero must be in town with Castle gate for teleporting")) || (!t->hasBuilt(BuildingID::CASTLE_GATE, ETownType::INFERNO) && complain("Cannot teleport hero to town without Castle gate in it"))) return false; int3 pos = t->visitablePos(); pos += h->getVisitableOffset(); moveHero(hid,pos,1); return true; } void CGameHandler::setOwner(const CGObjectInstance * obj, PlayerColor owner) { PlayerColor oldOwner = getOwner(obj->id); SetObjectProperty sop(obj->id, ObjProperty::OWNER, owner.getNum()); sendAndApply(&sop); std::set playerColors = {owner, oldOwner}; checkVictoryLossConditions(playerColors); const CGTownInstance * town = dynamic_cast(obj); if (town) //town captured { if (owner < PlayerColor::PLAYER_LIMIT) //new owner is real player { if (town->hasBuilt(BuildingID::PORTAL_OF_SUMMON, ETownType::DUNGEON)) setPortalDwelling(town, true, false); } if (oldOwner < PlayerColor::PLAYER_LIMIT) //old owner is real player { if (getPlayer(oldOwner)->towns.empty()) //previous player lost last last town { InfoWindow iw; iw.player = oldOwner; iw.text.addTxt(MetaString::GENERAL_TXT, 6); //%s, you have lost your last town. If you do not conquer another town in the next week, you will be eliminated. iw.text.addReplacement(MetaString::COLOR, oldOwner.getNum()); sendAndApply(&iw); } } } const PlayerState * p = getPlayer(owner); if ((obj->ID == Obj::CREATURE_GENERATOR1 || obj->ID == Obj::CREATURE_GENERATOR4) && p && p->dwellings.size()==1)//first dwelling captured { for (const CGTownInstance * t : getPlayer(owner)->towns) { if (t->hasBuilt(BuildingID::PORTAL_OF_SUMMON, ETownType::DUNGEON)) setPortalDwelling(t);//set initial creatures for all portals of summoning } } } void CGameHandler::showBlockingDialog(BlockingDialog *iw) { auto dialogQuery = std::make_shared(this, *iw); queries.addQuery(dialogQuery); iw->queryID = dialogQuery->queryID; sendToAllClients(iw); } void CGameHandler::showTeleportDialog(TeleportDialog *iw) { auto dialogQuery = std::make_shared(this, *iw); queries.addQuery(dialogQuery); iw->queryID = dialogQuery->queryID; sendToAllClients(iw); } void CGameHandler::giveResource(PlayerColor player, Res::ERes which, int val) //TODO: cap according to Bersy's suggestion { if (!val) return; //don't waste time on empty call TResources resources; resources.at(which) = val; giveResources(player, resources); } void CGameHandler::giveResources(PlayerColor player, TResources resources) { SetResources sr; sr.abs = false; sr.player = player; sr.res = resources; sendAndApply(&sr); } void CGameHandler::giveCreatures(const CArmedInstance *obj, const CGHeroInstance * h, const CCreatureSet &creatures, bool remove) { COMPLAIN_RET_IF(!creatures.stacksCount(), "Strange, giveCreatures called without args!"); COMPLAIN_RET_IF(obj->stacksCount(), "Cannot give creatures from not-cleared object!"); COMPLAIN_RET_IF(creatures.stacksCount() > GameConstants::ARMY_SIZE, "Too many stacks to give!"); //first we move creatures to give to make them army of object-source for (auto & elem : creatures.Slots()) { addToSlot(StackLocation(obj, obj->getSlotFor(elem.second->type)), elem.second->type, elem.second->count); } tryJoiningArmy(obj, h, remove, true); } void CGameHandler::takeCreatures(ObjectInstanceID objid, const std::vector &creatures) { std::vector cres = creatures; if (cres.size() <= 0) return; const CArmedInstance* obj = static_cast(getObj(objid)); for (CStackBasicDescriptor &sbd : cres) { TQuantity collected = 0; while(collected < sbd.count) { bool foundSth = false; for (auto i = obj->Slots().begin(); i != obj->Slots().end(); i++) { if (i->second->type == sbd.type) { TQuantity take = std::min(sbd.count - collected, i->second->count); //collect as much cres as we can changeStackCount(StackLocation(obj, i->first), -take, false); collected += take; foundSth = true; break; } } if (!foundSth) //we went through the whole loop and haven't found appropriate cres { complain("Unexpected failure during taking creatures!"); return; } } } } void CGameHandler::showCompInfo(ShowInInfobox * comp) { sendToAllClients(comp); } void CGameHandler::heroVisitCastle(const CGTownInstance * obj, const CGHeroInstance * hero) { HeroVisitCastle vc; vc.hid = hero->id; vc.tid = obj->id; vc.flags |= 1; sendAndApply(&vc); vistiCastleObjects (obj, hero); giveSpells (obj, hero); checkVictoryLossConditionsForPlayer(hero->tempOwner); //transported artifact? } void CGameHandler::vistiCastleObjects (const CGTownInstance *t, const CGHeroInstance *h) { std::vector::const_iterator i; for (i = t->bonusingBuildings.begin(); i != t->bonusingBuildings.end(); i++) (*i)->onHeroVisit (h); } void CGameHandler::stopHeroVisitCastle(const CGTownInstance * obj, const CGHeroInstance * hero) { HeroVisitCastle vc; vc.hid = hero->id; vc.tid = obj->id; sendAndApply(&vc); } void CGameHandler::removeArtifact(const ArtifactLocation &al) { EraseArtifact ea; ea.al = al; sendAndApply(&ea); } void CGameHandler::startBattlePrimary(const CArmedInstance *army1, const CArmedInstance *army2, int3 tile, const CGHeroInstance *hero1, const CGHeroInstance *hero2, bool creatureBank, const CGTownInstance *town) //use hero=nullptr for no hero { engageIntoBattle(army1->tempOwner); engageIntoBattle(army2->tempOwner); static const CArmedInstance *armies[2]; armies[0] = army1; armies[1] = army2; static const CGHeroInstance*heroes[2]; heroes[0] = hero1; heroes[1] = hero2; setupBattle(tile, armies, heroes, creatureBank, town); //initializes stacks, places creatures on battlefield, blocks and informs player interfaces auto battleQuery = std::make_shared(this, gs->curB); queries.addQuery(battleQuery); boost::thread(&CGameHandler::runBattle, this); } void CGameHandler::startBattleI(const CArmedInstance *army1, const CArmedInstance *army2, int3 tile, bool creatureBank) { startBattlePrimary(army1, army2, tile, army1->ID == Obj::HERO ? static_cast(army1) : nullptr, army2->ID == Obj::HERO ? static_cast(army2) : nullptr, creatureBank); } void CGameHandler::startBattleI(const CArmedInstance *army1, const CArmedInstance *army2, bool creatureBank) { startBattleI(army1, army2, army2->visitablePos(), creatureBank); } void CGameHandler::changeSpells(const CGHeroInstance * hero, bool give, const std::set &spells) { ChangeSpells cs; cs.hid = hero->id; cs.spells = spells; cs.learn = give; sendAndApply(&cs); } void CGameHandler::sendMessageTo(CConnection &c, const std::string &message) { SystemMessage sm; sm.text = message; boost::unique_lock lock(*c.wmx); c << &sm; } void CGameHandler::giveHeroBonus(GiveBonus * bonus) { sendAndApply(bonus); } void CGameHandler::setMovePoints(SetMovePoints * smp) { sendAndApply(smp); } void CGameHandler::setManaPoints(ObjectInstanceID hid, int val) { SetMana sm; sm.hid = hid; sm.val = val; sm.absolute = true; sendAndApply(&sm); } void CGameHandler::giveHero(ObjectInstanceID id, PlayerColor player) { GiveHero gh; gh.id = id; gh.player = player; sendAndApply(&gh); } void CGameHandler::changeObjPos(ObjectInstanceID objid, int3 newPos, ui8 flags) { ChangeObjPos cop; cop.objid = objid; cop.nPos = newPos; cop.flags = flags; sendAndApply(&cop); } void CGameHandler::useScholarSkill(ObjectInstanceID fromHero, ObjectInstanceID toHero) { const CGHeroInstance * h1 = getHero(fromHero); const CGHeroInstance * h2 = getHero(toHero); int h1_scholarLevel = h1->valOfBonuses(Bonus::SECONDARY_SKILL_PREMY, SecondarySkill::SCHOLAR); int h2_scholarLevel = h2->valOfBonuses(Bonus::SECONDARY_SKILL_PREMY, SecondarySkill::SCHOLAR); if (h1_scholarLevel < h2_scholarLevel) { std::swap (h1,h2);//1st hero need to have higher scholar level for correct message std::swap(fromHero, toHero); } int ScholarLevel = std::max(h1_scholarLevel, h2_scholarLevel);//heroes can trade up to this level if (!ScholarLevel || !h1->hasSpellbook() || !h2->hasSpellbook()) return;//no scholar skill or no spellbook int h1Lvl = std::min(ScholarLevel, h1->maxSpellLevel()), h2Lvl = std::min(ScholarLevel, h2->maxSpellLevel());//heroes can receive this levels ChangeSpells cs1; cs1.learn = true; cs1.hid = toHero;//giving spells to first hero for (auto it : h1->spells) if (h2Lvl >= it.toSpell()->level && !vstd::contains(h2->spells, it))//hero can learn it and don't have it yet cs1.spells.insert(it);//spell to learn ChangeSpells cs2; cs2.learn = true; cs2.hid = fromHero; for (auto it : h2->spells) if (h1Lvl >= it.toSpell()->level && !vstd::contains(h1->spells, it)) cs2.spells.insert(it); if (!cs1.spells.empty() || !cs2.spells.empty())//create a message { InfoWindow iw; iw.player = h1->tempOwner; iw.components.push_back(Component(Component::SEC_SKILL, 18, ScholarLevel, 0)); iw.text.addTxt(MetaString::GENERAL_TXT, 139);//"%s, who has studied magic extensively, iw.text.addReplacement(h1->name); if (!cs2.spells.empty())//if found new spell - apply { iw.text.addTxt(MetaString::GENERAL_TXT, 140);//learns int size = cs2.spells.size(); for (auto it : cs2.spells) { iw.components.push_back(Component(Component::SPELL, it, 1, 0)); iw.text.addTxt(MetaString::SPELL_NAME, it.toEnum()); switch (size--) { case 2: iw.text.addTxt(MetaString::GENERAL_TXT, 141); case 1: break; default: iw.text << ", "; } } iw.text.addTxt(MetaString::GENERAL_TXT, 142);//from %s iw.text.addReplacement(h2->name); sendAndApply(&cs2); } if (!cs1.spells.empty() && !cs2.spells.empty()) { iw.text.addTxt(MetaString::GENERAL_TXT, 141);//and } if (!cs1.spells.empty()) { iw.text.addTxt(MetaString::GENERAL_TXT, 147);//teaches int size = cs1.spells.size(); for (auto it : cs1.spells) { iw.components.push_back(Component(Component::SPELL, it, 1, 0)); iw.text.addTxt(MetaString::SPELL_NAME, it.toEnum()); switch (size--) { case 2: iw.text.addTxt(MetaString::GENERAL_TXT, 141); case 1: break; default: iw.text << ", "; } } iw.text.addTxt(MetaString::GENERAL_TXT, 148);//from %s iw.text.addReplacement(h2->name); sendAndApply(&cs1); } sendAndApply(&iw); } } void CGameHandler::heroExchange(ObjectInstanceID hero1, ObjectInstanceID hero2) { auto h1 = getHero(hero1), h2 = getHero(hero2); if (getPlayerRelations(h1->getOwner(), h2->getOwner())) { auto exchange = std::make_shared(this, h1, h2); ExchangeDialog hex; hex.queryID = exchange->queryID; hex.heroes[0] = getHero(hero1); hex.heroes[1] = getHero(hero2); sendAndApply(&hex); useScholarSkill(hero1,hero2); queries.addQuery(exchange); } } void CGameHandler::sendToAllClients(CPackForClient * info) { logNetwork->trace("Sending to all clients a package of type %s", typeid(*info).name()); for (auto & elem : conns) { if(!elem->isOpen()) continue; boost::unique_lock lock(*(elem)->wmx); *elem << info; } } void CGameHandler::sendAndApply(CPackForClient * info) { sendToAllClients(info); gs->apply(info); } void CGameHandler::applyAndSend(CPackForClient * info) { gs->apply(info); sendToAllClients(info); } void CGameHandler::sendAndApply(CGarrisonOperationPack * info) { sendAndApply(static_cast(info)); checkVictoryLossConditionsForAll(); } void CGameHandler::sendAndApply(SetResources * info) { sendAndApply(static_cast(info)); checkVictoryLossConditionsForPlayer(info->player); } void CGameHandler::sendAndApply(NewStructures * info) { sendAndApply(static_cast(info)); checkVictoryLossConditionsForPlayer(getTown(info->tid)->tempOwner); } void CGameHandler::save(const std::string & filename) { logGlobal->info("Saving to %s", filename); const auto stem = FileInfo::GetPathStem(filename); const auto savefname = stem.to_string() + ".vsgm1"; CResourceHandler::get("local")->createResource(savefname); { logGlobal->info("Ordering clients to serialize..."); SaveGame sg(savefname); sendToAllClients(&sg); } try { { CSaveFile save(*CResourceHandler::get("local")->getResourceName(ResourceID(stem.to_string(), EResType::SERVER_SAVEGAME))); saveCommonState(save); logGlobal->info("Saving server state"); save << *this; } logGlobal->info("Game has been successfully saved!"); } catch(std::exception &e) { logGlobal->error("Failed to save game: %s", e.what()); } } void CGameHandler::close() { logGlobal->info("We have been requested to close."); serverShuttingDown = true; for (auto & elem : conns) { if(!elem->isOpen()) continue; boost::unique_lock lock(*(elem)->wmx); elem->close(); elem->connected = false; } } void CGameHandler::playerLeftGame(int cid) { for (auto & elem : conns) { if(elem->isOpen() && elem->connectionID == cid) { boost::unique_lock lock(*(elem)->wmx); elem->close(); elem->connected = false; break; } } } bool CGameHandler::arrangeStacks(ObjectInstanceID id1, ObjectInstanceID id2, ui8 what, SlotID p1, SlotID p2, si32 val, PlayerColor player) { const CArmedInstance * s1 = static_cast(getObjInstance(id1)), * s2 = static_cast(getObjInstance(id2)); const CCreatureSet &S1 = *s1, &S2 = *s2; StackLocation sl1(s1, p1), sl2(s2, p2); if (!sl1.slot.validSlot() || !sl2.slot.validSlot()) { complain("Invalid slot accessed!"); return false; } if (!isAllowedExchange(id1,id2)) { complain("Cannot exchange stacks between these two objects!\n"); return false; } // We can always put stacks into locked garrison, but not take them out of it auto notRemovable = [&](const CArmedInstance * army) { if (id1 != id2) // Stack arrangement inside locked garrison is allowed { auto g = dynamic_cast(army); if (g && !g->removableUnits) { complain("Stacks in this garrison are not removable!\n"); return true; } } return false; }; if (what==1) //swap { if (((s1->tempOwner != player && s1->tempOwner != PlayerColor::UNFLAGGABLE) && s1->getStackCount(p1)) || ((s2->tempOwner != player && s2->tempOwner != PlayerColor::UNFLAGGABLE) && s2->getStackCount(p2))) { complain("Can't take troops from another player!"); return false; } if (sl1.army == sl2.army && sl1.slot == sl2.slot) { complain("Cannot swap stacks - slots are the same!"); return false; } if (!s1->slotEmpty(p1) && !s2->slotEmpty(p2)) { if (notRemovable(sl1.army) || notRemovable(sl2.army)) return false; } if (s1->slotEmpty(p1) && notRemovable(sl2.army)) return false; else if (s2->slotEmpty(p2) && notRemovable(sl1.army)) return false; swapStacks(sl1, sl2); } else if (what==2)//merge { if ((s1->getCreature(p1) != s2->getCreature(p2) && complain("Cannot merge different creatures stacks!")) || (((s1->tempOwner != player && s1->tempOwner != PlayerColor::UNFLAGGABLE) && s2->getStackCount(p2)) && complain("Can't take troops from another player!"))) return false; if (s1->slotEmpty(p1) || s2->slotEmpty(p2)) { complain("Cannot merge empty stack!"); return false; } else if (notRemovable(sl1.army)) return false; moveStack(sl1, sl2); } else if (what==3) //split { const int countToMove = val - s2->getStackCount(p2); const int countLeftOnSrc = s1->getStackCount(p1) - countToMove; if ( (s1->tempOwner != player && countLeftOnSrc < s1->getStackCount(p1)) || (s2->tempOwner != player && val < s2->getStackCount(p2))) { complain("Can't move troops of another player!"); return false; } //general conditions checking if ((!vstd::contains(S1.stacks,p1) && complain("no creatures to split")) || (val<1 && complain("no creatures to split")) ) { return false; } if (vstd::contains(S2.stacks,p2)) //dest. slot not free - it must be "rebalancing"... { int total = s1->getStackCount(p1) + s2->getStackCount(p2); if ((total < val && complain("Cannot split that stack, not enough creatures!")) || (s1->getCreature(p1) != s2->getCreature(p2) && complain("Cannot rebalance different creatures stacks!")) ) { return false; } if (notRemovable(sl1.army)) { if (s1->getStackCount(p1) > countLeftOnSrc) return false; } else if (notRemovable(sl2.army)) { if (s2->getStackCount(p1) < countLeftOnSrc) return false; } moveStack(sl1, sl2, countToMove); //S2.slots[p2]->count = val; //S1.slots[p1]->count = total - val; } else //split one stack to the two { if (s1->getStackCount(p1) < val)//not enough creatures { complain("Cannot split that stack, not enough creatures!"); return false; } if (notRemovable(sl1.army)) return false; moveStack(sl1, sl2, val); } } return true; } PlayerColor CGameHandler::getPlayerAt(CConnection *c) const { std::set all; for (auto i=connections.cbegin(); i!=connections.cend(); i++) if (i->second == c) all.insert(i->first); switch(all.size()) { case 0: return PlayerColor::NEUTRAL; case 1: return *all.begin(); default: { //if we have more than one player at this connection, try to pick active one if (vstd::contains(all, gs->currentPlayer)) return gs->currentPlayer; else return PlayerColor::CANNOT_DETERMINE; //cannot say which player is it } } } bool CGameHandler::disbandCreature(ObjectInstanceID id, SlotID pos) { const CArmedInstance * s1 = static_cast(getObjInstance(id)); if (!vstd::contains(s1->stacks,pos)) { complain("Illegal call to disbandCreature - no such stack in army!"); return false; } eraseStack(StackLocation(s1, pos)); return true; } bool CGameHandler::buildStructure(ObjectInstanceID tid, BuildingID requestedID, bool force) { const CGTownInstance * t = getTown(tid); if (!t) COMPLAIN_RETF("No such town (ID=%s)!", tid); if (!t->town->buildings.count(requestedID)) COMPLAIN_RETF("Town of faction %s does not have info about building ID=%s!", t->town->faction->name % tid); if (t->hasBuilt(requestedID)) COMPLAIN_RETF("Building %s is already built in %s", t->town->buildings.at(requestedID)->Name() % t->name); const CBuilding * requestedBuilding = t->town->buildings.at(requestedID); //Vector with future list of built building and buildings in auto-mode that are not yet built. std::vector remainingAutoBuildings; std::set buildingsThatWillBe; //Check validity of request if (!force) { switch (requestedBuilding->mode) { case CBuilding::BUILD_NORMAL : if (canBuildStructure(t, requestedID) != EBuildingState::ALLOWED) COMPLAIN_RET("Cannot build that building!"); break; case CBuilding::BUILD_AUTO : case CBuilding::BUILD_SPECIAL: COMPLAIN_RET("This building can not be constructed normally!"); case CBuilding::BUILD_GRAIL : if (requestedBuilding->mode == CBuilding::BUILD_GRAIL) //needs grail { if (!t->visitingHero || !t->visitingHero->hasArt(ArtifactID::GRAIL)) COMPLAIN_RET("Cannot build this without grail!") else removeArtifact(ArtifactLocation(t->visitingHero, t->visitingHero->getArtPos(ArtifactID::GRAIL, false))); } break; } } //Performs stuff that has to be done before new building is built auto processBeforeBuiltStructure = [t, this](const BuildingID buildingID) { if (buildingID >= BuildingID::DWELL_FIRST) //dwelling { int level = (buildingID - BuildingID::DWELL_FIRST) % GameConstants::CREATURES_PER_TOWN; int upgradeNumber = (buildingID - BuildingID::DWELL_FIRST) / GameConstants::CREATURES_PER_TOWN; if (upgradeNumber >= t->town->creatures.at(level).size()) { complain(boost::str(boost::format("Error ecountered when building dwelling (bid=%s):" "no creature found (upgrade number %d, level %d!") % buildingID % upgradeNumber % level)); return; } CCreature * crea = VLC->creh->creatures.at(t->town->creatures.at(level).at(upgradeNumber)); SetAvailableCreatures ssi; ssi.tid = t->id; ssi.creatures = t->creatures; if (ssi.creatures[level].second.empty()) // first creature in a dwelling ssi.creatures[level].first = crea->growth; ssi.creatures[level].second.push_back(crea->idNumber); sendAndApply(&ssi); } if (t->subID == ETownType::DUNGEON && buildingID == BuildingID::PORTAL_OF_SUMMON) { setPortalDwelling(t); } }; //Performs stuff that has to be done after new building is built auto processAfterBuiltStructure = [t, this](const BuildingID buildingID) { if (buildingID <= BuildingID::MAGES_GUILD_5 || //it's mage guild (t->subID == ETownType::TOWER && buildingID == BuildingID::LIBRARY) || (t->subID == ETownType::CONFLUX && buildingID == BuildingID::GRAIL)) { if (t->visitingHero) giveSpells(t,t->visitingHero); if (t->garrisonHero) giveSpells(t,t->garrisonHero); } }; //Checks if all requirements will be met with expected building list "buildingsThatWillBe" auto areRequirementsFullfilled = [&](const BuildingID & buildID) { return buildingsThatWillBe.count(buildID); }; //Init the vectors for (auto & build : t->town->buildings) { if (t->hasBuilt(build.first)) buildingsThatWillBe.insert(build.first); else { if (build.second->mode == CBuilding::BUILD_AUTO) //not built auto building remainingAutoBuildings.push_back(build.second); } } //Prepare structure (list of building ids will be filled later) NewStructures ns; ns.tid = tid; ns.builded = force ? t->builded : (t->builded+1); std::queue buildingsToAdd; buildingsToAdd.push(requestedBuilding); while(!buildingsToAdd.empty()) { auto b = buildingsToAdd.front(); buildingsToAdd.pop(); ns.bid.insert(b->bid); buildingsThatWillBe.insert(b->bid); remainingAutoBuildings -= b; for (auto autoBuilding : remainingAutoBuildings) { if (autoBuilding->requirements.test(areRequirementsFullfilled)) buildingsToAdd.push(autoBuilding); } } // FIXME: it's done before NewStructures applied because otherwise town window wont be properly updated on client. That should be actually fixed on client and not on server. for (auto builtID : ns.bid) processBeforeBuiltStructure(builtID); //Take cost if (!force) { giveResources(t->tempOwner, -requestedBuilding->resources); } //We know what has been built, appluy changes. Do this as final step to properly update town window sendAndApply(&ns); //Other post-built events. To some logic like giving spells to work gamestate changes for new building must be already in place! for (auto builtID : ns.bid) processAfterBuiltStructure(builtID); // now when everything is built - reveal tiles for lookout tower FoWChange fw; fw.player = t->tempOwner; fw.mode = 1; getTilesInRange(fw.tiles, t->getSightCenter(), t->getSightRadius(), t->tempOwner, 1); sendAndApply(&fw); if (t->visitingHero) vistiCastleObjects (t, t->visitingHero); if (t->garrisonHero) vistiCastleObjects (t, t->garrisonHero); checkVictoryLossConditionsForPlayer(t->tempOwner); return true; } bool CGameHandler::razeStructure (ObjectInstanceID tid, BuildingID bid) { ///incomplete, simply erases target building const CGTownInstance * t = getTown(tid); if (!vstd::contains(t->builtBuildings, bid)) return false; RazeStructures rs; rs.tid = tid; rs.bid.insert(bid); rs.destroyed = t->destroyed + 1; sendAndApply(&rs); //TODO: Remove dwellers // if (t->subID == 4 && bid == 17) //Veil of Darkness // { // RemoveBonus rb(RemoveBonus::TOWN); // rb.whoID = t->id; // rb.source = Bonus::TOWN_STRUCTURE; // rb.id = 17; // sendAndApply(&rb); // } return true; } void CGameHandler::sendMessageToAll(const std::string &message) { SystemMessage sm; sm.text = message; sendToAllClients(&sm); } bool CGameHandler::recruitCreatures(ObjectInstanceID objid, ObjectInstanceID dstid, CreatureID crid, ui32 cram, si32 fromLvl) { const CGDwelling * dw = static_cast(getObj(objid)); const CArmedInstance *dst = nullptr; const CCreature *c = VLC->creh->creatures.at(crid); const bool warMachine = c->warMachine != ArtifactID::NONE; //TODO: test for owning //TODO: check if dst can recruit objects (e.g. hero is actually visiting object, town and source are same, etc) dst = dynamic_cast(getObj(dstid)); assert(dw && dst); //verify bool found = false; int level = 0; for (; level < dw->creatures.size(); level++) //iterate through all levels { if ((fromLvl != -1) && (level !=fromLvl)) continue; const auto &cur = dw->creatures.at(level); //current level info int i = 0; for (; i < cur.second.size(); i++) //look for crid among available creatures list on current level if (cur.second.at(i) == crid) break; if (i < cur.second.size()) { found = true; cram = std::min(cram, cur.first); //reduce recruited amount up to available amount break; } } SlotID slot = dst->getSlotFor(crid); if ((!found && complain("Cannot recruit: no such creatures!")) || (cram > VLC->creh->creatures.at(crid)->maxAmount(getPlayer(dst->tempOwner)->resources) && complain("Cannot recruit: lack of resources!")) || (cram<=0 && complain("Cannot recruit: cram <= 0!")) || (!slot.validSlot() && !warMachine && complain("Cannot recruit: no available slot!"))) { return false; } //recruit giveResources(dst->tempOwner, -(c->cost * cram)); SetAvailableCreatures sac; sac.tid = objid; sac.creatures = dw->creatures; sac.creatures[level].first -= cram; sendAndApply(&sac); if (warMachine) { const CGHeroInstance *h = dynamic_cast(dst); COMPLAIN_RET_FALSE_IF(!h, "Only hero can buy war machines"); ArtifactID artId = c->warMachine; COMPLAIN_RET_FALSE_IF(artId == ArtifactID::CATAPULT, "Catapult cannot be recruited!"); const CArtifact * art = artId.toArtifact(); COMPLAIN_RET_FALSE_IF(nullptr == art, "Invalid war machine artifact"); return giveHeroNewArtifact(h, art); } else { addToSlot(StackLocation(dst, slot), c, cram); } return true; } bool CGameHandler::upgradeCreature(ObjectInstanceID objid, SlotID pos, CreatureID upgID) { const CArmedInstance * obj = static_cast(getObjInstance(objid)); if (!obj->hasStackAtSlot(pos)) { COMPLAIN_RET("Cannot upgrade, no stack at slot " + boost::to_string(pos)); } UpgradeInfo ui; getUpgradeInfo(obj, pos, ui); PlayerColor player = obj->tempOwner; const PlayerState *p = getPlayer(player); int crQuantity = obj->stacks.at(pos)->count; int newIDpos= vstd::find_pos(ui.newID, upgID);//get position of new id in UpgradeInfo //check if upgrade is possible if ((ui.oldID<0 || newIDpos == -1) && complain("That upgrade is not possible!")) { return false; } TResources totalCost = ui.cost.at(newIDpos) * crQuantity; //check if player has enough resources if (!p->resources.canAfford(totalCost)) COMPLAIN_RET("Cannot upgrade, not enough resources!"); //take resources giveResources(player, -totalCost); //upgrade creature changeStackType(StackLocation(obj, pos), VLC->creh->creatures.at(upgID)); return true; } bool CGameHandler::changeStackType(const StackLocation &sl, const CCreature *c) { if (!sl.army->hasStackAtSlot(sl.slot)) COMPLAIN_RET("Cannot find a stack to change type"); SetStackType sst; sst.sl = sl; sst.type = c; sendAndApply(&sst); return true; } void CGameHandler::moveArmy(const CArmedInstance *src, const CArmedInstance *dst, bool allowMerging) { assert(src->canBeMergedWith(*dst, allowMerging)); while(src->stacksCount())//while there are unmoved creatures { auto i = src->Slots().begin(); //iterator to stack to move StackLocation sl(src, i->first); //location of stack to move SlotID pos = dst->getSlotFor(i->second->type); if (!pos.validSlot()) { //try to merge two other stacks to make place std::pair toMerge; if (dst->mergableStacks(toMerge, i->first) && allowMerging) { moveStack(StackLocation(dst, toMerge.first), StackLocation(dst, toMerge.second)); //merge toMerge.first into toMerge.second assert(!dst->hasStackAtSlot(toMerge.first)); //we have now a new free slot moveStack(sl, StackLocation(dst, toMerge.first)); //move stack to freed slot } else { complain("Unexpected failure during an attempt to move army from " + src->nodeName() + " to " + dst->nodeName() + "!"); return; } } else { moveStack(sl, StackLocation(dst, pos)); } } } bool CGameHandler::garrisonSwap(ObjectInstanceID tid) { const CGTownInstance * town = getTown(tid); if (!town->garrisonHero && town->visitingHero) //visiting => garrison, merge armies: town army => hero army { if (!town->visitingHero->canBeMergedWith(*town)) { complain("Cannot make garrison swap, not enough free slots!"); return false; } moveArmy(town, town->visitingHero, true); SetHeroesInTown intown; intown.tid = tid; intown.visiting = ObjectInstanceID(); intown.garrison = town->visitingHero->id; sendAndApply(&intown); return true; } else if (town->garrisonHero && !town->visitingHero) //move hero out of the garrison { //check if moving hero out of town will break 8 wandering heroes limit if (getHeroCount(town->garrisonHero->tempOwner,false) >= 8) { complain("Cannot move hero out of the garrison, there are already 8 wandering heroes!"); return false; } SetHeroesInTown intown; intown.tid = tid; intown.garrison = ObjectInstanceID(); intown.visiting = town->garrisonHero->id; sendAndApply(&intown); return true; } else if (!!town->garrisonHero && town->visitingHero) //swap visiting and garrison hero { SetHeroesInTown intown; intown.tid = tid; intown.garrison = town->visitingHero->id; intown.visiting = town->garrisonHero->id; sendAndApply(&intown); return true; } else { complain("Cannot swap garrison hero!"); return false; } } // With the amount of changes done to the function, it's more like transferArtifacts. // Function moves artifact from src to dst. If dst is not a backpack and is already occupied, old dst art goes to backpack and is replaced. bool CGameHandler::moveArtifact(const ArtifactLocation &al1, const ArtifactLocation &al2) { ArtifactLocation src = al1, dst = al2; const PlayerColor srcPlayer = src.owningPlayer(), dstPlayer = dst.owningPlayer(); const CArmedInstance *srcObj = src.relatedObj(), *dstObj = dst.relatedObj(); // Make sure exchange is even possible between the two heroes. if (!isAllowedExchange(srcObj->id, dstObj->id)) COMPLAIN_RET("That heroes cannot make any exchange!"); const CArtifactInstance *srcArtifact = src.getArt(); const CArtifactInstance *destArtifact = dst.getArt(); if (srcArtifact == nullptr) COMPLAIN_RET("No artifact to move!"); if (destArtifact && srcPlayer != dstPlayer) COMPLAIN_RET("Can't touch artifact on hero of another player!"); // Check if src/dest slots are appropriate for the artifacts exchanged. // Moving to the backpack is always allowed. if ((!srcArtifact || dst.slot < GameConstants::BACKPACK_START) && srcArtifact && !srcArtifact->canBePutAt(dst, true)) COMPLAIN_RET("Cannot move artifact!"); auto srcSlot = src.getSlot(); auto dstSlot = dst.getSlot(); if ((srcSlot && srcSlot->locked) || (dstSlot && dstSlot->locked)) COMPLAIN_RET("Cannot move artifact locks."); if (dst.slot >= GameConstants::BACKPACK_START && srcArtifact->artType->isBig()) COMPLAIN_RET("Cannot put big artifacts in backpack!"); if (src.slot == ArtifactPosition::MACH4 || dst.slot == ArtifactPosition::MACH4) COMPLAIN_RET("Cannot move catapult!"); if (dst.slot >= GameConstants::BACKPACK_START) vstd::amin(dst.slot, ArtifactPosition(GameConstants::BACKPACK_START + dst.getHolderArtSet()->artifactsInBackpack.size())); if (src.slot == dst.slot && src.artHolder == dst.artHolder) COMPLAIN_RET("Won't move artifact: Dest same as source!"); if (dst.slot < GameConstants::BACKPACK_START && destArtifact) //moving art to another slot { //old artifact must be removed first moveArtifact(dst, ArtifactLocation(dst.artHolder, ArtifactPosition( dst.getHolderArtSet()->artifactsInBackpack.size() + GameConstants::BACKPACK_START))); } MoveArtifact ma; ma.src = src; ma.dst = dst; sendAndApply(&ma); return true; } /** * Assembles or disassembles a combination artifact. * @param heroID ID of hero holding the artifact(s). * @param artifactSlot The worn slot ID of the combination- or constituent artifact. * @param assemble True for assembly operation, false for disassembly. * @param assembleTo If assemble is true, this represents the artifact ID of the combination * artifact to assemble to. Otherwise it's not used. */ bool CGameHandler::assembleArtifacts (ObjectInstanceID heroID, ArtifactPosition artifactSlot, bool assemble, ArtifactID assembleTo) { const CGHeroInstance * hero = getHero(heroID); const CArtifactInstance *destArtifact = hero->getArt(artifactSlot); if (!destArtifact) COMPLAIN_RET("assembleArtifacts: there is no such artifact instance!"); if (assemble) { CArtifact *combinedArt = VLC->arth->artifacts[assembleTo]; if (!combinedArt->constituents) COMPLAIN_RET("assembleArtifacts: Artifact being attempted to assemble is not a combined artifacts!"); if (!vstd::contains(destArtifact->assemblyPossibilities(hero), combinedArt)) COMPLAIN_RET("assembleArtifacts: It's impossible to assemble requested artifact!"); AssembledArtifact aa; aa.al = ArtifactLocation(hero, artifactSlot); aa.builtArt = combinedArt; sendAndApply(&aa); } else { if (!destArtifact->artType->constituents) COMPLAIN_RET("assembleArtifacts: Artifact being attempted to disassemble is not a combined artifact!"); DisassembledArtifact da; da.al = ArtifactLocation(hero, artifactSlot); sendAndApply(&da); } return true; } bool CGameHandler::buyArtifact(ObjectInstanceID hid, ArtifactID aid) { const CGHeroInstance * hero = getHero(hid); COMPLAIN_RET_FALSE_IF(nullptr == hero, "Invalid hero index"); const CGTownInstance * town = hero->visitedTown; COMPLAIN_RET_FALSE_IF(nullptr == town, "Hero not in town"); if (aid==ArtifactID::SPELLBOOK) { if ((!town->hasBuilt(BuildingID::MAGES_GUILD_1) && complain("Cannot buy a spellbook, no mage guild in the town!")) || (getResource(hero->getOwner(), Res::GOLD) < GameConstants::SPELLBOOK_GOLD_COST && complain("Cannot buy a spellbook, not enough gold!")) || (hero->getArt(ArtifactPosition::SPELLBOOK) && complain("Cannot buy a spellbook, hero already has a one!")) ) return false; giveResource(hero->getOwner(),Res::GOLD,-GameConstants::SPELLBOOK_GOLD_COST); giveHeroNewArtifact(hero, VLC->arth->artifacts[ArtifactID::SPELLBOOK], ArtifactPosition::SPELLBOOK); assert(hero->getArt(ArtifactPosition::SPELLBOOK)); giveSpells(town,hero); return true; } else { const CArtifact * art = aid.toArtifact(); COMPLAIN_RET_FALSE_IF(nullptr == art, "Invalid artifact index to buy"); COMPLAIN_RET_FALSE_IF(art->warMachine == CreatureID::NONE, "War machine artifact required"); COMPLAIN_RET_FALSE_IF(hero->hasArt(aid),"Hero already has this machine!"); const int price = art->price; COMPLAIN_RET_FALSE_IF(getPlayer(hero->getOwner())->resources.at(Res::GOLD) < price, "Not enough gold!"); if ((town->hasBuilt(BuildingID::BLACKSMITH) && town->town->warMachine == aid) || ((town->hasBuilt(BuildingID::BALLISTA_YARD, ETownType::STRONGHOLD)) && aid == ArtifactID::BALLISTA)) { giveResource(hero->getOwner(),Res::GOLD,-price); return giveHeroNewArtifact(hero, art); } else COMPLAIN_RET("This machine is unavailable here!"); } } bool CGameHandler::buyArtifact(const IMarket *m, const CGHeroInstance *h, Res::ERes rid, ArtifactID aid) { if(!h) COMPLAIN_RET("Only hero can buy artifacts!"); if (!vstd::contains(m->availableItemsIds(EMarketMode::RESOURCE_ARTIFACT), aid)) COMPLAIN_RET("That artifact is unavailable!"); int b1, b2; m->getOffer(rid, aid, b1, b2, EMarketMode::RESOURCE_ARTIFACT); if (getResource(h->tempOwner, rid) < b1) COMPLAIN_RET("You can't afford to buy this artifact!"); giveResource(h->tempOwner, rid, -b1); SetAvailableArtifacts saa; if (m->o->ID == Obj::TOWN) { saa.id = -1; saa.arts = CGTownInstance::merchantArtifacts; } else if (const CGBlackMarket *bm = dynamic_cast(m->o)) //black market { saa.id = bm->id.getNum(); saa.arts = bm->artifacts; } else COMPLAIN_RET("Wrong marktet..."); bool found = false; for (const CArtifact *&art : saa.arts) { if (art && art->id == aid) { art = nullptr; found = true; break; } } if (!found) COMPLAIN_RET("Cannot find selected artifact on the list"); sendAndApply(&saa); giveHeroNewArtifact(h, VLC->arth->artifacts[aid], ArtifactPosition::FIRST_AVAILABLE); return true; } bool CGameHandler::sellArtifact(const IMarket *m, const CGHeroInstance *h, ArtifactInstanceID aid, Res::ERes rid) { COMPLAIN_RET_FALSE_IF((!h), "Only hero can sell artifacts!"); const CArtifactInstance *art = h->getArtByInstanceId(aid); COMPLAIN_RET_FALSE_IF((!art), "There is no artifact to sell!"); COMPLAIN_RET_FALSE_IF((!art->artType->isTradable()), "Cannot sell a war machine or spellbook!"); int resVal = 0, dump = 1; m->getOffer(art->artType->id, rid, dump, resVal, EMarketMode::ARTIFACT_RESOURCE); removeArtifact(ArtifactLocation(h, h->getArtPos(art))); giveResource(h->tempOwner, rid, resVal); return true; } bool CGameHandler::buySecSkill(const IMarket *m, const CGHeroInstance *h, SecondarySkill skill) { if (!h) COMPLAIN_RET("You need hero to buy a skill!"); if (h->getSecSkillLevel(SecondarySkill(skill))) COMPLAIN_RET("Hero already know this skill"); if (!h->canLearnSkill()) COMPLAIN_RET("Hero can't learn any more skills"); if (h->type->heroClass->secSkillProbability.at(skill)==0)//can't learn this skill (like necromancy for most of non-necros) COMPLAIN_RET("The hero can't learn this skill!"); if (!vstd::contains(m->availableItemsIds(EMarketMode::RESOURCE_SKILL), skill)) COMPLAIN_RET("That skill is unavailable!"); if (getResource(h->tempOwner, Res::GOLD) < GameConstants::SKILL_GOLD_COST)//TODO: remove hardcoded resource\summ? COMPLAIN_RET("You can't afford to buy this skill"); giveResource(h->tempOwner, Res::GOLD, -GameConstants::SKILL_GOLD_COST); changeSecSkill(h, skill, 1, true); return true; } bool CGameHandler::tradeResources(const IMarket *market, ui32 val, PlayerColor player, ui32 id1, ui32 id2) { TResourceCap r1 = getPlayer(player)->resources.at(id1); vstd::amin(val, r1); //can't trade more resources than have int b1, b2; //base quantities for trade market->getOffer(id1, id2, b1, b2, EMarketMode::RESOURCE_RESOURCE); int units = val / b1; //how many base quantities we trade if (val%b1) //all offered units of resource should be used, if not -> somewhere in calculations must be an error { COMPLAIN_RET("Invalid deal, not all offered units of resource were used."); } giveResource(player, static_cast(id1), - b1 * units); giveResource(player, static_cast(id2), b2 * units); return true; } bool CGameHandler::sellCreatures(ui32 count, const IMarket *market, const CGHeroInstance * hero, SlotID slot, Res::ERes resourceID) { if(!hero) COMPLAIN_RET("Only hero can sell creatures!"); if (!vstd::contains(hero->Slots(), slot)) COMPLAIN_RET("Hero doesn't have any creature in that slot!"); const CStackInstance &s = hero->getStack(slot); if (s.count < count //can't sell more creatures than have || (hero->stacksCount() == 1 && hero->needsLastStack() && s.count == count)) //can't sell last stack { COMPLAIN_RET("Not enough creatures in army!"); } int b1, b2; //base quantities for trade market->getOffer(s.type->idNumber, resourceID, b1, b2, EMarketMode::CREATURE_RESOURCE); int units = count / b1; //how many base quantities we trade if (count%b1) //all offered units of resource should be used, if not -> somewhere in calculations must be an error { //TODO: complain? assert(0); } changeStackCount(StackLocation(hero, slot), -count); giveResource(hero->tempOwner, resourceID, b2 * units); return true; } bool CGameHandler::transformInUndead(const IMarket *market, const CGHeroInstance * hero, SlotID slot) { const CArmedInstance *army = nullptr; if (hero) army = hero; else army = dynamic_cast(market->o); if (!army) COMPLAIN_RET("Incorrect call to transform in undead!"); if (!army->hasStackAtSlot(slot)) COMPLAIN_RET("Army doesn't have any creature in that slot!"); const CStackInstance &s = army->getStack(slot); //resulting creature - bone dragons or skeletons CreatureID resCreature = CreatureID::SKELETON; if (s.hasBonusOfType(Bonus::DRAGON_NATURE) || (s.getCreatureID() == CreatureID::HYDRA) || (s.getCreatureID() == CreatureID::CHAOS_HYDRA)) resCreature = CreatureID::BONE_DRAGON; changeStackType(StackLocation(army, slot), resCreature.toCreature()); return true; } bool CGameHandler::sendResources(ui32 val, PlayerColor player, Res::ERes r1, PlayerColor r2) { const PlayerState *p2 = getPlayer(r2, false); if (!p2 || p2->status != EPlayerStatus::INGAME) { complain("Dest player must be in game!"); return false; } TResourceCap curRes1 = getPlayer(player)->resources.at(r1); vstd::amin(val, curRes1); giveResource(player, r1, -val); giveResource(r2, r1, val); return true; } bool CGameHandler::setFormation(ObjectInstanceID hid, ui8 formation) { const CGHeroInstance *h = getHero(hid); if (!h) { logGlobal->error("Hero doesn't exist!"); return false; } ChangeFormation cf; cf.hid = hid; cf.formation = formation; sendAndApply(&cf); return true; } bool CGameHandler::hireHero(const CGObjectInstance *obj, ui8 hid, PlayerColor player) { const PlayerState * p = getPlayer(player); const CGTownInstance * t = getTown(obj->id); //common preconditions // if ((p->resources.at(Res::GOLD)= GameConstants::MAX_HEROES_PER_PLAYER && complain("Cannot hire hero, only 8 wandering heroes are allowed!"))) if ((p->resources.at(Res::GOLD) < GameConstants::HERO_GOLD_COST && complain("Not enough gold for buying hero!")) || ((!t) && (getHeroCount(player, false) >= VLC->modh->settings.MAX_HEROES_ON_MAP_PER_PLAYER && complain("Cannot hire hero, too many wandering heroes already!"))) || ((t) && (getHeroCount(player, true) >= VLC->modh->settings.MAX_HEROES_AVAILABLE_PER_PLAYER && complain("Cannot hire hero, too many heroes garrizoned and wandering already!")))) { return false; } if (t) //tavern in town { if ((!t->hasBuilt(BuildingID::TAVERN) && complain("No tavern!")) || (t->visitingHero && complain("There is visiting hero - no place!"))) { return false; } } else if (obj->ID == Obj::TAVERN) { if (getTile(obj->visitablePos())->visitableObjects.back() != obj && complain("Tavern entry must be unoccupied!")) { return false; } } const CGHeroInstance *nh = p->availableHeroes.at(hid); if (!nh) { complain ("Hero is not available for hiring!"); return false; } HeroRecruited hr; hr.tid = obj->id; hr.hid = nh->subID; hr.player = player; hr.tile = obj->visitablePos() + nh->getVisitableOffset(); sendAndApply(&hr); std::map > pool = gs->unusedHeroesFromPool(); const CGHeroInstance *theOtherHero = p->availableHeroes.at(!hid); const CGHeroInstance *newHero = nullptr; if (theOtherHero) //on XXL maps all heroes can be imprisoned :( { newHero = gs->hpool.pickHeroFor(false, player, getNativeTown(player), pool, getRandomGenerator(), theOtherHero->type->heroClass); } SetAvailableHeroes sah; sah.player = player; if (newHero) { sah.hid[hid] = newHero->subID; sah.army[hid].clear(); sah.army[hid].setCreature(SlotID(0), newHero->type->initialArmy[0].creature, 1); } else { sah.hid[hid] = -1; } sah.hid[!hid] = theOtherHero ? theOtherHero->subID : -1; sendAndApply(&sah); giveResource(player, Res::GOLD, -GameConstants::HERO_GOLD_COST); if (t) { vistiCastleObjects (t, nh); giveSpells (t,nh); } return true; } bool CGameHandler::queryReply(QueryID qid, const JsonNode & answer, PlayerColor player) { boost::unique_lock lock(gsm); logGlobal->trace("Player %s attempts answering query %d with answer:", player, qid); logGlobal->trace(answer.toJson()); auto topQuery = queries.topQuery(player); COMPLAIN_RET_FALSE_IF(!topQuery, "This player doesn't have any queries!"); COMPLAIN_RET_FALSE_IF(topQuery->queryID != qid, "This player top query has different ID!"); COMPLAIN_RET_FALSE_IF(!topQuery->endsByPlayerAnswer(), "This query cannot be ended by player's answer!"); topQuery->setReply(answer); queries.popQuery(topQuery); return true; } static EndAction end_action; void CGameHandler::updateGateState() { BattleUpdateGateState db; db.state = gs->curB->si.gateState; if (gs->curB->si.wallState[EWallPart::GATE] == EWallState::DESTROYED) { db.state = EGateState::DESTROYED; } else if (db.state == EGateState::OPENED) { if (!gs->curB->battleGetStackByPos(BattleHex(ESiegeHex::GATE_OUTER), false) && !gs->curB->battleGetStackByPos(BattleHex(ESiegeHex::GATE_INNER), false)) { if (gs->curB->town->subID == ETownType::FORTRESS) { if (!gs->curB->battleGetStackByPos(BattleHex(ESiegeHex::GATE_BRIDGE), false)) db.state = EGateState::CLOSED; } else if (gs->curB->battleGetStackByPos(BattleHex(ESiegeHex::GATE_BRIDGE))) db.state = EGateState::BLOCKED; else db.state = EGateState::CLOSED; } } else if (gs->curB->battleGetStackByPos(BattleHex(ESiegeHex::GATE_BRIDGE), false)) db.state = EGateState::BLOCKED; else db.state = EGateState::CLOSED; if (db.state != gs->curB->si.gateState) sendAndApply(&db); } bool CGameHandler::makeBattleAction(BattleAction &ba) { bool ok = true; const CStack *stack = battleGetStackByID(ba.stackNumber); //may be nullptr if action is not about stack const CStack *destinationStack = ba.actionType == Battle::WALK_AND_ATTACK ? gs->curB->battleGetStackByPos(ba.additionalInfo) : ba.actionType == Battle::SHOOT ? gs->curB->battleGetStackByPos(ba.destinationTile) : nullptr; const bool isAboutActiveStack = stack && (stack == battleActiveStack()); logGlobal->trace( "Making action: type=%d; side=%d; stack=%s; dst=%s; additionalInfo=%d; stackAtDst=%s", ba.actionType, (int)ba.side, (stack ? stack->getName() : std::string("none")), ba.destinationTile, ba.additionalInfo, (destinationStack ? destinationStack->getName() : std::string("none"))); switch(ba.actionType) { case Battle::WALK: //walk case Battle::DEFEND: //defend case Battle::WAIT: //wait case Battle::WALK_AND_ATTACK: //walk or attack case Battle::SHOOT: //shoot case Battle::CATAPULT: //catapult case Battle::STACK_HEAL: //healing with First Aid Tent case Battle::DAEMON_SUMMONING: case Battle::MONSTER_SPELL: if (!stack) { complain("No such stack!"); return false; } if (!stack->alive()) { complain("This stack is dead: " + stack->nodeName()); return false; } if (battleTacticDist()) { if (stack && stack->side != battleGetTacticsSide()) { complain("This is not a stack of side that has tactics!"); return false; } } else if (!isAboutActiveStack) { complain("Action has to be about active stack!"); return false; } } auto wrapAction = [this](BattleAction &ba) { StartAction startAction(ba); sendAndApply(&startAction); return vstd::makeScopeGuard([&]() { sendAndApply(&end_action); }); }; switch(ba.actionType) { case Battle::END_TACTIC_PHASE: //wait case Battle::BAD_MORALE: case Battle::NO_ACTION: { auto wrapper = wrapAction(ba); break; } case Battle::WALK: { auto wrapper = wrapAction(ba); int walkedTiles = moveStack(ba.stackNumber,ba.destinationTile); //move if (!walkedTiles) complain("Stack failed movement!"); break; } case Battle::DEFEND: { //defensive stance SetStackEffect sse; Bonus bonus1(Bonus::STACK_GETS_TURN, Bonus::PRIMARY_SKILL, Bonus::OTHER, 20, -1, PrimarySkill::DEFENSE, Bonus::PERCENT_TO_ALL); Bonus bonus2(Bonus::STACK_GETS_TURN, Bonus::PRIMARY_SKILL, Bonus::OTHER, stack->valOfBonuses(Bonus::DEFENSIVE_STANCE), -1, PrimarySkill::DEFENSE, Bonus::ADDITIVE_VALUE); BonusList defence = *stack->getBonuses(Selector::typeSubtype(Bonus::PRIMARY_SKILL, PrimarySkill::DEFENSE)); int oldDefenceValue = defence.totalValue(); defence.push_back(std::make_shared(bonus1)); defence.push_back(std::make_shared(bonus2)); int difference = defence.totalValue() - oldDefenceValue; MetaString text; stack->addText(text, MetaString::GENERAL_TXT, 120); stack->addNameReplacement(text); text.addReplacement(difference); sse.battleLog.push_back(text); sse.effect.push_back(bonus1); sse.effect.push_back(bonus2); sse.stacks.push_back(ba.stackNumber); sendAndApply(&sse); //don't break - we share code with next case } case Battle::WAIT: { auto wrapper = wrapAction(ba); break; } case Battle::RETREAT: //retreat/flee { if (!gs->curB->battleCanFlee(gs->curB->sides.at(ba.side).color)) complain("Cannot retreat!"); else setBattleResult(BattleResult::ESCAPE, !ba.side); //surrendering side loses break; } case Battle::SURRENDER: { PlayerColor player = gs->curB->sides.at(ba.side).color; int cost = gs->curB->battleGetSurrenderCost(player); if (cost < 0) complain("Cannot surrender!"); else if (getResource(player, Res::GOLD) < cost) complain("Not enough gold to surrender!"); else { giveResource(player, Res::GOLD, -cost); setBattleResult(BattleResult::SURRENDER, !ba.side); //surrendering side loses } break; } case Battle::WALK_AND_ATTACK: //walk or attack { auto wrapper = wrapAction(ba); if (!stack || !destinationStack) { break; } BattleHex startingPos = stack->position; int distance = moveStack(ba.stackNumber, ba.destinationTile); logGlobal->trace("%s will attack %s", stack->nodeName(), destinationStack->nodeName()); if(stack->position != ba.destinationTile //we wasn't able to reach destination tile && !(stack->doubleWide() && (stack->position == ba.destinationTile.cloneInDirection(stack->destShiftDir(), false))) //nor occupy specified hex ) { complain("We cannot move this stack to its destination " + stack->getCreature()->namePl); ok = false; break; } if (destinationStack && stack && stack->ID == destinationStack->ID) //we should just move, it will be handled by following check { destinationStack = nullptr; } if (!destinationStack) { complain(boost::str(boost::format("walk and attack error: no stack at additionalInfo tile (%d)!\n") % ba.additionalInfo)); ok = false; break; } if (!CStack::isMeleeAttackPossible(stack, destinationStack)) { complain("Attack cannot be performed!"); ok = false; break; } //attack int totalAttacks = 1 + stack->getBonuses(Selector::type (Bonus::ADDITIONAL_ATTACK), (Selector::effectRange(Bonus::NO_LIMIT).Or(Selector::effectRange(Bonus::ONLY_MELEE_FIGHT))))->totalValue(); //all unspicified attacks + melee attacks for (int i = 0; i < totalAttacks; ++i) { if (stack && stack->alive() && //move can cause death, eg. by walking into the moat destinationStack->alive()) { BattleAttack bat; prepareAttack(bat, stack, destinationStack, (i ? 0 : distance), ba.additionalInfo); //no distance travelled on second attack //prepareAttack(bat, stack, stackAtEnd, 0, ba.additionalInfo); handleAttackBeforeCasting(&bat); //only before first attack sendAndApply(&bat); handleAfterAttackCasting(bat); } //counterattack if (i == 0 && destinationStack && !stack->hasBonusOfType(Bonus::BLOCKS_RETALIATION) && destinationStack->ableToRetaliate() && stack->alive()) //attacker may have died (fire shield) { BattleAttack bat; prepareAttack(bat, destinationStack, stack, 0, stack->position); bat.flags |= BattleAttack::COUNTER; sendAndApply(&bat); handleAfterAttackCasting(bat); } } //return if (stack->hasBonusOfType(Bonus::RETURN_AFTER_STRIKE) && startingPos != stack->position && stack->alive()) { moveStack(ba.stackNumber, startingPos); //NOTE: curStack->ID == ba.stackNumber (rev 1431) } break; } case Battle::SHOOT: { if (!gs->curB->battleCanShoot(stack, ba.destinationTile)) { complain("Cannot shoot!"); break; } if (!destinationStack) { complain("No target to shoot!"); break; } auto wrapper = wrapAction(ba); { BattleAttack bat; bat.flags |= BattleAttack::SHOT; prepareAttack(bat, stack, destinationStack, 0, ba.destinationTile); handleAttackBeforeCasting(&bat); sendAndApply(&bat); handleAfterAttackCasting(bat); } //ranged counterattack if (destinationStack->hasBonusOfType(Bonus::RANGED_RETALIATION) && !stack->hasBonusOfType(Bonus::BLOCKS_RANGED_RETALIATION) && destinationStack->ableToRetaliate() && stack->alive()) //attacker may have died (fire shield) { BattleAttack bat; prepareAttack(bat, destinationStack, stack, 0, stack->position); bat.flags |= BattleAttack::COUNTER | BattleAttack::SHOT; sendAndApply(&bat); handleAfterAttackCasting(bat); } //extra shot(s) for ballista, based on artillery skill if(stack->getCreature()->idNumber == CreatureID::BALLISTA) { const CGHeroInstance * attackingHero = gs->curB->battleGetFightingHero(ba.side); int ballistaBonusAttacks = attackingHero->valOfBonuses(Bonus::SECONDARY_SKILL_VAL2, SecondarySkill::ARTILLERY); while(destinationStack->alive() && ballistaBonusAttacks-- > 0) { BattleAttack bat2; bat2.flags |= BattleAttack::SHOT; prepareAttack(bat2, stack, destinationStack, 0, ba.destinationTile); sendAndApply(&bat2); } } //allow more than one additional attack int additionalAttacks = stack->getBonuses(Selector::type (Bonus::ADDITIONAL_ATTACK), (Selector::effectRange(Bonus::NO_LIMIT).Or(Selector::effectRange(Bonus::ONLY_DISTANCE_FIGHT))))->totalValue(); for(int i = 0; i < additionalAttacks; ++i) { if ( stack->alive() && destinationStack->alive() && stack->shots.canUse() ) { BattleAttack bat; bat.flags |= BattleAttack::SHOT; prepareAttack(bat, stack, destinationStack, 0, ba.destinationTile); sendAndApply(&bat); handleAfterAttackCasting(bat); } } break; } case Battle::CATAPULT: { auto getCatapultHitChance = [&](EWallPart::EWallPart part, const CHeroHandler::SBallisticsLevelInfo & sbi) -> int { switch(part) { case EWallPart::GATE: return sbi.gate; case EWallPart::KEEP: return sbi.keep; case EWallPart::BOTTOM_TOWER: case EWallPart::UPPER_TOWER: return sbi.tower; case EWallPart::BOTTOM_WALL: case EWallPart::BELOW_GATE: case EWallPart::OVER_GATE: case EWallPart::UPPER_WALL: return sbi.wall; default: return 0; } }; auto wrapper = wrapAction(ba); const CGHeroInstance * attackingHero = gs->curB->battleGetFightingHero(ba.side); CHeroHandler::SBallisticsLevelInfo sbi; if(stack->getCreature()->idNumber == CreatureID::CATAPULT) sbi = VLC->heroh->ballistics.at(attackingHero->valOfBonuses(Bonus::SECONDARY_SKILL_PREMY, SecondarySkill::BALLISTICS)); else //may need to use higher ballistics level for creatures in future for some cases to match original H3 (upgraded cyclops etc) { sbi = VLC->heroh->ballistics.at(1); sbi.shots += std::max(stack->valOfBonuses(Bonus::CATAPULT_EXTRA_SHOTS), 0); } auto wallPart = gs->curB->battleHexToWallPart(ba.destinationTile); if (!gs->curB->isWallPartPotentiallyAttackable(wallPart)) { complain("catapult tried to attack non-catapultable hex!"); break; } //in successive iterations damage is dealt but not yet subtracted from wall's HPs auto ¤tHP = gs->curB->si.wallState; if (currentHP.at(wallPart) == EWallState::DESTROYED || currentHP.at(wallPart) == EWallState::NONE) { complain("catapult tried to attack already destroyed wall part!"); break; } for (int g=0; g allowedTargets; for (size_t i=0; i< currentHP.size(); i++) { if(currentHP.at(i) != EWallState::DESTROYED && currentHP.at(i) != EWallState::NONE) allowedTargets.push_back(EWallPart::EWallPart(i)); } if (allowedTargets.empty()) break; attackedPart = *RandomGeneratorUtil::nextItem(allowedTargets, getRandomGenerator()); } } while (!hitSuccessfull); if (!hitSuccessfull) // break triggered - no target to shoot at break; CatapultAttack ca; //package for clients CatapultAttack::AttackInfo attack; attack.attackedPart = attackedPart; attack.destinationTile = ba.destinationTile; attack.damageDealt = 0; int dmgChance[] = { sbi.noDmg, sbi.oneDmg, sbi.twoDmg }; //dmgChance[i] - chance for doing i dmg when hit is successful int dmgRand = getRandomGenerator().nextInt(99); //accumulating dmgChance dmgChance[1] += dmgChance[0]; dmgChance[2] += dmgChance[1]; //calculating dealt damage for (int damage = 0; damage < ARRAY_COUNT(dmgChance); ++damage) { if (dmgRand <= dmgChance[damage]) { attack.damageDealt = damage; break; } } // attacked tile may have changed - update destination attack.destinationTile = gs->curB->wallPartToBattleHex(EWallPart::EWallPart(attack.attackedPart)); logGlobal->trace("Catapult attacks %d dealing %d damage", (int)attack.attackedPart, (int)attack.damageDealt); //removing creatures in turrets / keep if one is destroyed if (attack.damageDealt > 0 && (attackedPart == EWallPart::KEEP || attackedPart == EWallPart::BOTTOM_TOWER || attackedPart == EWallPart::UPPER_TOWER)) { int posRemove = -1; switch(attackedPart) { case EWallPart::KEEP: posRemove = -2; break; case EWallPart::BOTTOM_TOWER: posRemove = -3; break; case EWallPart::UPPER_TOWER: posRemove = -4; break; } BattleStacksRemoved bsr; for (auto & elem : gs->curB->stacks) { if (elem->position == posRemove) { bsr.stackIDs.insert(elem->ID); break; } } sendAndApply(&bsr); } ca.attacker = ba.stackNumber; ca.attackedParts.push_back(attack); sendAndApply(&ca); } //finish by scope guard break; } case Battle::STACK_HEAL: //healing with First Aid Tent { auto wrapper = wrapAction(ba); const CGHeroInstance * attackingHero = gs->curB->battleGetFightingHero(ba.side); const CStack *healer = gs->curB->battleGetStackByID(ba.stackNumber), *destStack = gs->curB->battleGetStackByPos(ba.destinationTile); if(healer == nullptr || destStack == nullptr || !healer->hasBonusOfType(Bonus::HEALER)) { complain("There is either no healer, no destination, or healer cannot heal :P"); } else { int32_t toHeal = healer->getCount() * std::max(10, attackingHero->valOfBonuses(Bonus::SECONDARY_SKILL_PREMY, SecondarySkill::FIRST_AID)); //TODO: allow resurrection for mods CHealth health = destStack->healthAfterHealed(toHeal, EHealLevel::HEAL, EHealPower::PERMANENT); if(toHeal == 0) { logGlobal->warn("Nothing to heal"); } else { StacksHealedOrResurrected shr; shr.lifeDrain = false; shr.tentHealing = true; shr.cure = false; shr.drainedFrom = ba.stackNumber; CHealthInfo hi; health.toInfo(hi); hi.stackId = destStack->ID; hi.delta = toHeal; shr.healedStacks.push_back(hi); sendAndApply(&shr); } } break; } case Battle::DAEMON_SUMMONING: //TODO: From Strategija: //Summon Demon is a level 2 spell. { const CStack *summoner = gs->curB->battleGetStackByID(ba.stackNumber), *destStack = gs->curB->battleGetStackByPos(ba.destinationTile, false); CreatureID summonedType(summoner->getBonusLocalFirst(Selector::type(Bonus::DAEMON_SUMMONING))->subtype);//in case summoner can summon more than one type of monsters... scream! BattleStackAdded bsa; bsa.side = summoner->side; bsa.creID = summonedType; ui64 risedHp = summoner->getCount() * summoner->valOfBonuses(Bonus::DAEMON_SUMMONING, bsa.creID.toEnum()); ui64 targetHealth = destStack->getCreature()->MaxHealth() * destStack->baseAmount; ui64 canRiseHp = std::min(targetHealth, risedHp); ui32 canRiseAmount = canRiseHp / VLC->creh->creatures.at(bsa.creID)->MaxHealth(); bsa.amount = std::min(canRiseAmount, destStack->baseAmount); bsa.pos = gs->curB->getAvaliableHex(bsa.creID, bsa.side, destStack->position); bsa.summoned = false; if (bsa.amount) //there's rare possibility single creature cannot rise desired type { auto wrapper = wrapAction(ba); BattleStacksRemoved bsr; //remove body bsr.stackIDs.insert(destStack->ID); sendAndApply(&bsr); sendAndApply(&bsa); BattleSetStackProperty ssp; ssp.stackID = ba.stackNumber; ssp.which = BattleSetStackProperty::CASTS; //reduce number of casts ssp.val = -1; ssp.absolute = false; sendAndApply(&ssp); } break; } case Battle::MONSTER_SPELL: { auto wrapper = wrapAction(ba); const CStack * stack = gs->curB->battleGetStackByID(ba.stackNumber); SpellID spellID = SpellID(ba.additionalInfo); BattleHex destination(ba.destinationTile); const std::shared_ptr randSpellcaster = stack->getBonusLocalFirst(Selector::type(Bonus::RANDOM_SPELLCASTER)); const std::shared_ptr spellcaster = stack->getBonusLocalFirst(Selector::typeSubtype(Bonus::SPELLCASTER, spellID)); //TODO special bonus for genies ability if (randSpellcaster && battleGetRandomStackSpell(getRandomGenerator(), stack, CBattleInfoCallback::RANDOM_AIMED) < 0) spellID = battleGetRandomStackSpell(getRandomGenerator(), stack, CBattleInfoCallback::RANDOM_GENIE); if (spellID < 0) complain("That stack can't cast spells!"); else { const CSpell * spell = SpellID(spellID).toSpell(); BattleSpellCastParameters parameters(gs->curB, stack, spell); parameters.spellLvl = 0; if (spellcaster) vstd::amax(parameters.spellLvl, spellcaster->val); if (randSpellcaster) vstd::amax(parameters.spellLvl, randSpellcaster->val); vstd::amin(parameters.spellLvl, 3); parameters.effectLevel = parameters.spellLvl; parameters.mode = ECastingMode::CREATURE_ACTIVE_CASTING; parameters.aimToHex(destination);//todo: allow multiple destinations parameters.cast(spellEnv); } break; } } if(ba.actionType == Battle::DAEMON_SUMMONING || ba.actionType == Battle::WAIT || ba.actionType == Battle::DEFEND || ba.actionType == Battle::SHOOT || ba.actionType == Battle::MONSTER_SPELL) handleDamageFromObstacle(stack); if(ba.stackNumber == gs->curB->activeStack || battleResult.get()) //active stack has moved or battle has finished battleMadeAction.setn(true); return ok; } void CGameHandler::playerMessage(PlayerColor player, const std::string &message, ObjectInstanceID currObj) { bool cheated = true; PlayerMessage temp_message(player, message, ObjectInstanceID(-1)); // don't inform other client on selected object sendAndApply(&temp_message); std::vector cheat; boost::split(cheat, message, boost::is_any_of(" ")); int obj = 0; if (cheat.size() == 2) { obj = std::atoi(cheat[1].c_str()); if (obj) currObj = ObjectInstanceID(obj); } const CGHeroInstance * hero = getHero(currObj); const CGTownInstance * town = getTown(currObj); if (!town && hero) town = hero->visitedTown; if (cheat.size() == 1 || obj) handleCheatCode(cheat[0], player, hero, town, cheated); else { for (const auto & i : gs->players) { if (i.first == PlayerColor::NEUTRAL) continue; if (cheat[1] == "ai") { if (i.second.human) continue; } else if (cheat[1] != "all" && cheat[1] != i.first.getStr()) continue; if (cheat[0] == "vcmiformenos" || cheat[0] == "vcmieagles" || cheat[0] == "vcmiungoliant") { handleCheatCode(cheat[0], i.first, nullptr, nullptr, cheated); } else if (cheat[0] == "vcmiarmenelos") { for (const auto & t : i.second.towns) { handleCheatCode(cheat[0], i.first, nullptr, t, cheated); } } else { for (const auto & h : i.second.heroes) { handleCheatCode(cheat[0], i.first, h, nullptr, cheated); } } } } if (cheated) { SystemMessage temp_message(VLC->generaltexth->allTexts.at(260)); sendAndApply(&temp_message); if(!player.isSpectator()) checkVictoryLossConditionsForPlayer(player);//Player enter win code or got required art\creature } } bool CGameHandler::makeCustomAction(BattleAction &ba) { switch(ba.actionType) { case Battle::HERO_SPELL: { COMPLAIN_RET_FALSE_IF(ba.side > 1, "Side must be 0 or 1!"); const CGHeroInstance *h = gs->curB->battleGetFightingHero(ba.side); COMPLAIN_RET_FALSE_IF((!h), "Wrong caster!"); const CSpell * s = SpellID(ba.additionalInfo).toSpell(); if (!s) { logGlobal->error("Wrong spell id (%d)!", ba.additionalInfo); return false; } BattleSpellCastParameters parameters(gs->curB, h, s); parameters.aimToHex(ba.destinationTile);//todo: allow multiple destinations parameters.mode = ECastingMode::HERO_CASTING; if (ba.selectedStack >= 0) parameters.aimToStack(gs->curB->battleGetStackByID(ba.selectedStack, false)); ESpellCastProblem::ESpellCastProblem escp = s->canBeCast(gs->curB, ECastingMode::HERO_CASTING, h);//todo: should we check aimed cast? if (escp != ESpellCastProblem::OK) { logGlobal->warn("Spell cannot be cast! Problem: %d", escp); return false; } StartAction start_action(ba); sendAndApply(&start_action); //start spell casting parameters.cast(spellEnv); sendAndApply(&end_action); if (!gs->curB->battleGetStackByID(gs->curB->activeStack)) { battleMadeAction.setn(true); } checkBattleStateChanges(); if (battleResult.get()) { battleMadeAction.setn(true); //battle will be ended by startBattle function //endBattle(gs->curB->tile, gs->curB->heroes[0], gs->curB->heroes[1]); } return true; } } return false; } void CGameHandler::stackEnchantedTrigger(const CStack * st) { auto bl = *(st->getBonuses(Selector::type(Bonus::ENCHANTED))); for(auto b : bl) { SetStackEffect sse; int val = bl.valOfBonuses(Selector::typeSubtype(b->type, b->subtype)); if(val > 3) { for(auto s : gs->curB->battleGetAllStacks()) { if(battleMatchOwner(st, s, true) && s->isValidTarget()) //all allied sse.stacks.push_back (s->ID); } } else sse.stacks.push_back (st->ID); const CSpell * sp = SpellID(b->subtype).toSpell(); const int level = ((val > 3) ? (val - 3) : val); sp->getEffects(sse.effect, level, false, 50); //this makes effect accumulate for at most 50 turns by default, but effect may be permanent and last till the end of battle sp->getEffects(sse.cumulativeEffects, level, true, 50); if(!sse.effect.empty() || !sse.cumulativeEffects.empty()) sendAndApply(&sse); } } void CGameHandler::stackTurnTrigger(const CStack *st) { BattleTriggerEffect bte; bte.stackID = st->ID; bte.effect = -1; bte.val = 0; bte.additionalInfo = 0; if (st->alive()) { //unbind if (st->hasBonus(Selector::type(Bonus::BIND_EFFECT))) { bool unbind = true; BonusList bl = *(st->getBonuses(Selector::type(Bonus::BIND_EFFECT))); std::set stacks = gs->curB-> batteAdjacentCreatures(st); for (auto b : bl) { const CStack * stack = gs->curB->battleGetStackByID(b->additionalInfo); //binding stack must be alive and adjacent if (stack) { if (vstd::contains(stacks, stack)) //binding stack is still present { unbind = false; } } } if (unbind) { BattleSetStackProperty ssp; ssp.which = BattleSetStackProperty::UNBIND; ssp.stackID = st->ID; sendAndApply(&ssp); } } //regeneration if (st->hasBonusOfType(Bonus::HP_REGENERATION)) { bte.effect = Bonus::HP_REGENERATION; bte.val = std::min((int)(st->MaxHealth() - st->getFirstHPleft()), st->valOfBonuses(Bonus::HP_REGENERATION)); } if (st->hasBonusOfType(Bonus::FULL_HP_REGENERATION)) { bte.effect = Bonus::HP_REGENERATION; bte.val = st->MaxHealth() - st->getFirstHPleft(); } if (bte.val) //anything to heal sendAndApply(&bte); if (st->hasBonusOfType(Bonus::POISON)) { const std::shared_ptr b = st->getBonusLocalFirst(Selector::source(Bonus::SPELL_EFFECT, SpellID::POISON).And(Selector::type(Bonus::STACK_HEALTH))); if (b) //TODO: what if not?... { bte.val = std::max (b->val - 10, -(st->valOfBonuses(Bonus::POISON))); if (bte.val < b->val) //(negative) poison effect increases - update it { bte.effect = Bonus::POISON; sendAndApply(&bte); } } } if (st->hasBonusOfType(Bonus::MANA_DRAIN) && !vstd::contains(st->state, EBattleStackState::DRAINED_MANA)) { const PlayerColor opponent = gs->curB->theOtherPlayer(gs->curB->battleGetOwner(st)); const CGHeroInstance * opponentHero = gs->curB->getHero(opponent); if (opponentHero) { ui32 manaDrained = st->valOfBonuses(Bonus::MANA_DRAIN); vstd::amin(manaDrained, opponentHero->mana); if (manaDrained) { bte.effect = Bonus::MANA_DRAIN; bte.val = manaDrained; bte.additionalInfo = opponentHero->id.getNum(); //for sanity sendAndApply(&bte); } } } if (st->isLiving() && !st->hasBonusOfType(Bonus::FEARLESS)) { bool fearsomeCreature = false; for (CStack * stack : gs->curB->stacks) { if (battleMatchOwner(st, stack) && stack->alive() && stack->hasBonusOfType(Bonus::FEAR)) { fearsomeCreature = true; break; } } if (fearsomeCreature) { if (getRandomGenerator().nextInt(99) < 10) //fixed 10% { bte.effect = Bonus::FEAR; sendAndApply(&bte); } } } BonusList bl = *(st->getBonuses(Selector::type(Bonus::ENCHANTER))); int side = gs->curB->whatSide(st->owner); if(st->canCast() && !gs->curB->sides.at(side).enchanterCounter) { bool cast = false; while (!bl.empty() && !cast) { auto bonus = *RandomGeneratorUtil::nextItem(bl, getRandomGenerator()); auto spellID = SpellID(bonus->subtype); const CSpell * spell = SpellID(spellID).toSpell(); bl.remove_if([&bonus](const Bonus* b){return b==bonus.get();}); BattleSpellCastParameters parameters(gs->curB, st, spell); parameters.spellLvl = bonus->val; parameters.effectLevel = bonus->val;//todo: recheck parameters.mode = ECastingMode::ENCHANTER_CASTING; cast = parameters.castIfPossible(spellEnv); if(cast) { //todo: move to mechanics BattleSetStackProperty ssp; ssp.which = BattleSetStackProperty::ENCHANTER_COUNTER; ssp.absolute = false; ssp.val = bonus->additionalInfo; //increase cooldown counter ssp.stackID = st->ID; sendAndApply(&ssp); } } } } } bool CGameHandler::handleDamageFromObstacle(const CStack * curStack, bool stackIsMoving) { if(!curStack->alive()) return false; bool containDamageFromMoat = false; for(auto & obstacle : getAllAffectedObstaclesByStack(curStack)) { if(!curStack->alive() || obstacle->stopsMovement() && stackIsMoving == true) return false; //we want to determine following vars depending on obstacle type int damage = -1; int effect = -1; bool oneTimeObstacle = false; //helper info const SpellCreatedObstacle * spellObstacle = dynamic_cast(obstacle.get()); //not nice but we may need spell params const ui8 side = curStack->side; //if enemy is defending (false = 0), side of enemy hero is 1 (true) const CGHeroInstance * hero = gs->curB->battleGetFightingHero(side);//FIXME: there may be no hero - landmines in Tower if(obstacle->obstacleType == CObstacleInstance::MOAT) { damage = battleGetMoatDmg(); if(!containDamageFromMoat) containDamageFromMoat = true; else continue; } else if(obstacle->obstacleType == CObstacleInstance::LAND_MINE) { if(!spellObstacle) COMPLAIN_RET("Invalid obstacle instance"); //You don't get hit by a Mine you can see. if(gs->curB->battleIsObstacleVisibleForSide(*obstacle, (BattlePerspective::BattlePerspective)side)) continue; oneTimeObstacle = true; effect = 82; const CSpell * sp = SpellID(SpellID::LAND_MINE).toSpell(); if(sp->isImmuneByStack(hero, curStack)) continue; damage = sp->calculateDamage(hero, curStack, spellObstacle->spellLevel, spellObstacle->casterSpellPower); //TODO even if obstacle wasn't created by hero (Tower "moat") it should deal dmg as if cast by hero, //if it is bigger than default dmg. Or is it just irrelevant H3 implementation quirk } else if(obstacle->obstacleType == CObstacleInstance::FIRE_WALL) { if(!spellObstacle) COMPLAIN_RET("Invalid obstacle instance"); const CSpell * sp = SpellID(SpellID::FIRE_WALL).toSpell(); if(sp->isImmuneByStack(hero, curStack)) continue; damage = sp->calculateDamage(hero, curStack, spellObstacle->spellLevel, spellObstacle->casterSpellPower); } else continue; BattleStackAttacked bsa; if(effect >= 0) { bsa.flags |= BattleStackAttacked::EFFECT; bsa.effect = effect; //makes POOF } bsa.damageAmount = damage; bsa.stackAttacked = curStack->ID; bsa.attackerID = -1; curStack->prepareAttacked(bsa, getRandomGenerator()); StacksInjured si; si.stacks.push_back(bsa); sendAndApply(&si); if(oneTimeObstacle) removeObstacle(*obstacle); } if(!curStack->alive()) return false; return true; } void CGameHandler::handleTimeEvents() { gs->map->events.sort(evntCmp); while(gs->map->events.size() && gs->map->events.front().firstOccurence+1 == gs->day) { CMapEvent ev = gs->map->events.front(); for (int player = 0; player < PlayerColor::PLAYER_LIMIT_I; player++) { auto color = PlayerColor(player); const PlayerState * pinfo = getPlayer(color, false); //do not output error if player does not exist if (pinfo //player exists && (ev.players & 1<human) || (ev.humanAffected && pinfo->human) ) ) { //give resources giveResources(color, ev.resources); //prepare dialog InfoWindow iw; iw.player = color; iw.text << ev.message; for (int i=0; imap->events.pop_front(); ev.firstOccurence += ev.nextOccurence; auto it = gs->map->events.begin(); while(it != gs->map->events.end() && it->earlierThanOrEqual(ev)) it++; gs->map->events.insert(it, ev); } else { gs->map->events.pop_front(); } } //TODO send only if changed UpdateMapEvents ume; ume.events = gs->map->events; sendAndApply(&ume); } void CGameHandler::handleTownEvents(CGTownInstance * town, NewTurn &n) { town->events.sort(evntCmp); while(town->events.size() && town->events.front().firstOccurence == gs->day) { PlayerColor player = town->tempOwner; CCastleEvent ev = town->events.front(); const PlayerState * pinfo = getPlayer(player, false); if (pinfo //player exists && (ev.players & 1<human) || (ev.humanAffected && pinfo->human))) { // dialog InfoWindow iw; iw.player = player; iw.text << ev.message; if (ev.resources.nonZero()) { TResources was = n.res[player]; n.res[player] += ev.resources; n.res[player].amax(0); for (int i=0; iresources.at(i) != n.res.at(player).at(i)) //if resource had changed, we add it to the dialog iw.components.push_back(Component(Component::RESOURCE,i,n.res.at(player).at(i)-was.at(i),0)); } for (auto & i : ev.buildings) { if (!town->hasBuilt(i)) { buildStructure(town->id, i, true); iw.components.push_back(Component(Component::BUILDING, town->subID, i, 0)); } } if (!ev.creatures.empty() && !vstd::contains(n.cres, town->id)) { n.cres[town->id].tid = town->id; n.cres[town->id].creatures = town->creatures; } auto & sac = n.cres[town->id]; for (si32 i=0;icreatures.at(i).second.empty() && ev.creatures.at(i) > 0)//there is dwelling { sac.creatures[i].first += ev.creatures.at(i); iw.components.push_back(Component(Component::CREATURE, town->creatures.at(i).second.back(), ev.creatures.at(i), 0)); } } sendAndApply(&iw); //show dialog } if (ev.nextOccurence) { town->events.pop_front(); ev.firstOccurence += ev.nextOccurence; auto it = town->events.begin(); while(it != town->events.end() && it->earlierThanOrEqual(ev)) it++; town->events.insert(it, ev); } else { town->events.pop_front(); } } //TODO send only if changed UpdateCastleEvents uce; uce.town = town->id; uce.events = town->events; sendAndApply(&uce); } bool CGameHandler::complain(const std::string &problem) { sendMessageToAll("Server encountered a problem: " + problem); logGlobal->error(problem); return true; } void CGameHandler::showGarrisonDialog(ObjectInstanceID upobj, ObjectInstanceID hid, bool removableUnits) { //PlayerColor player = getOwner(hid); auto upperArmy = dynamic_cast(getObj(upobj)); auto lowerArmy = dynamic_cast(getObj(hid)); assert(lowerArmy); assert(upperArmy); auto garrisonQuery = std::make_shared(this, upperArmy, lowerArmy); queries.addQuery(garrisonQuery); GarrisonDialog gd; gd.hid = hid; gd.objid = upobj; gd.removableUnits = removableUnits; gd.queryID = garrisonQuery->queryID; sendAndApply(&gd); } void CGameHandler::showThievesGuildWindow(PlayerColor player, ObjectInstanceID requestingObjId) { OpenWindow ow; ow.window = OpenWindow::THIEVES_GUILD; ow.id1 = player.getNum(); ow.id2 = requestingObjId.getNum(); sendAndApply(&ow); } bool CGameHandler::isAllowedExchange(ObjectInstanceID id1, ObjectInstanceID id2) { if (id1 == id2) return true; const CGObjectInstance *o1 = getObj(id1), *o2 = getObj(id2); if (!o1 || !o2) return true; //arranging stacks within an object should be always allowed if (o1 && o2) { if (o1->ID == Obj::TOWN) { const CGTownInstance *t = static_cast(o1); if (t->visitingHero == o2 || t->garrisonHero == o2) return true; } if (o2->ID == Obj::TOWN) { const CGTownInstance *t = static_cast(o2); if (t->visitingHero == o1 || t->garrisonHero == o1) return true; } if (o1->ID == Obj::HERO && o2->ID == Obj::HERO) { const CGHeroInstance *h1 = static_cast(o1); const CGHeroInstance *h2 = static_cast(o2); // two heroes in same town (garrisoned and visiting) if (h1->visitedTown != nullptr && h2->visitedTown != nullptr && h1->visitedTown == h2->visitedTown) return true; } //Ongoing garrison exchange if (auto dialog = std::dynamic_pointer_cast(queries.topQuery(o1->tempOwner))) { if (dialog->exchangingArmies.at(0) == o1 && dialog->exchangingArmies.at(1) == o2) return true; if (dialog->exchangingArmies.at(1) == o1 && dialog->exchangingArmies.at(0) == o2) return true; } } return false; } void CGameHandler::objectVisited(const CGObjectInstance * obj, const CGHeroInstance * h) { logGlobal->debug("%s visits %s (%d:%d)", h->nodeName(), obj->getObjectName(), obj->ID, obj->subID); auto visitQuery = std::make_shared(this, obj, h, obj->visitablePos()); queries.addQuery(visitQuery); //TODO real visit pos HeroVisit hv; hv.obj = obj; hv.hero = h; hv.player = h->tempOwner; hv.starting = true; sendAndApply(&hv); obj->onHeroVisit(h); queries.popIfTop(visitQuery); //visit ends here if no queries were created } void CGameHandler::objectVisitEnded(const CObjectVisitQuery &query) { logGlobal->debug("%s visit ends.\n", query.visitingHero->nodeName()); HeroVisit hv; hv.player = query.players.front(); hv.obj = nullptr; //not necessary, moreover may have been deleted in the meantime hv.hero = query.visitingHero; assert(hv.hero); hv.starting = false; sendAndApply(&hv); } bool CGameHandler::buildBoat(ObjectInstanceID objid) { const IShipyard *obj = IShipyard::castFrom(getObj(objid)); if (obj->shipyardStatus() != IBoatGenerator::GOOD) { complain("Cannot build boat in this shipyard!"); return false; } else if (obj->o->ID == Obj::TOWN && !static_cast(obj)->hasBuilt(BuildingID::SHIPYARD)) { complain("Cannot build boat in the town - no shipyard!"); return false; } const PlayerColor playerID = obj->o->tempOwner; TResources boatCost; obj->getBoatCost(boatCost); TResources aviable = getPlayer(playerID)->resources; if (!aviable.canAfford(boatCost)) { complain("Not enough resources to build a boat!"); return false; } int3 tile = obj->bestLocation(); if (!gs->map->isInTheMap(tile)) { complain("Cannot find appropriate tile for a boat!"); return false; } //take boat cost giveResources(playerID, -boatCost); //create boat NewObject no; no.ID = Obj::BOAT; no.subID = obj->getBoatType(); no.pos = tile + int3(1,0,0); sendAndApply(&no); return true; } void CGameHandler::engageIntoBattle(PlayerColor player) { //notify interfaces PlayerBlocked pb; pb.player = player; pb.reason = PlayerBlocked::UPCOMING_BATTLE; pb.startOrEnd = PlayerBlocked::BLOCKADE_STARTED; sendAndApply(&pb); } void CGameHandler::checkVictoryLossConditions(const std::set & playerColors) { for (auto playerColor : playerColors) { if (getPlayer(playerColor, false)) checkVictoryLossConditionsForPlayer(playerColor); } } void CGameHandler::checkVictoryLossConditionsForAll() { std::set playerColors; for (int i = 0; i < PlayerColor::PLAYER_LIMIT_I; ++i) { playerColors.insert(PlayerColor(i)); } checkVictoryLossConditions(playerColors); } void CGameHandler::checkVictoryLossConditionsForPlayer(PlayerColor player) { const PlayerState * p = getPlayer(player); if (p->status != EPlayerStatus::INGAME) return; auto victoryLossCheckResult = gs->checkForVictoryAndLoss(player); if (victoryLossCheckResult.victory() || victoryLossCheckResult.loss()) { InfoWindow iw; getVictoryLossMessage(player, victoryLossCheckResult, iw); sendAndApply(&iw); PlayerEndsGame peg; peg.player = player; peg.victoryLossCheckResult = victoryLossCheckResult; sendAndApply(&peg); if (victoryLossCheckResult.victory()) { //one player won -> all enemies lost for (auto i = gs->players.cbegin(); i!=gs->players.cend(); i++) { if (i->first != player && getPlayer(i->first)->status == EPlayerStatus::INGAME) { peg.player = i->first; peg.victoryLossCheckResult = getPlayerRelations(player, i->first) == PlayerRelations::ALLIES ? victoryLossCheckResult : victoryLossCheckResult.invert(); // ally of winner InfoWindow iw; getVictoryLossMessage(player, peg.victoryLossCheckResult, iw); iw.player = i->first; sendAndApply(&iw); sendAndApply(&peg); } } if (p->human) { serverShuttingDown = true; if (gs->scenarioOps->campState) { std::vector crossoverHeroes; for (CGHeroInstance * hero : gs->map->heroesOnMap) { if (hero->tempOwner == player) { // keep all heroes from the winning player crossoverHeroes.push_back(hero); } else if (vstd::contains(gs->scenarioOps->campState->getCurrentScenario().keepHeroes, HeroTypeID(hero->subID))) { // keep hero whether lost or won (like Xeron in AB campaign) crossoverHeroes.push_back(hero); } } // keep lost heroes which are in heroes pool for (auto & heroPair : gs->hpool.heroesPool) { if (vstd::contains(gs->scenarioOps->campState->getCurrentScenario().keepHeroes, HeroTypeID(heroPair.first))) { crossoverHeroes.push_back(heroPair.second.get()); } } gs->scenarioOps->campState->setCurrentMapAsConquered(crossoverHeroes); //Request clients to change connection mode PrepareForAdvancingCampaign pfac; sendAndApply(&pfac); //Change connection mode if (getPlayer(player)->human && getStartInfo()->campState) { for (auto connection : conns) connection->prepareForSendingHeroes(); } UpdateCampaignState ucs; ucs.camp = gs->scenarioOps->campState; sendAndApply(&ucs); } } } else { //copy heroes vector to avoid iterator invalidation as removal change PlayerState auto hlp = p->heroes; for (auto h : hlp) //eliminate heroes { if (h.get()) removeObject(h); } //player lost -> all his objects become unflagged (neutral) for (auto obj : gs->map->objects) //unflag objs { if (obj.get() && obj->tempOwner == player) setOwner(obj, PlayerColor::NEUTRAL); } //eliminating one player may cause victory of another: std::set playerColors; //do not copy player state (CBonusSystemNode) by value for (auto &p : gs->players) //players may have different colors, iterate over players and not integers { if (p.first != player) playerColors.insert(p.first); } //notify all players for (auto pc : playerColors) { if (getPlayer(pc)->status == EPlayerStatus::INGAME) { InfoWindow iw; getVictoryLossMessage(player, victoryLossCheckResult.invert(), iw); iw.player = pc; sendAndApply(&iw); } } checkVictoryLossConditions(playerColors); } auto playerInfo = getPlayer(gs->currentPlayer, false); // If we are called before the actual game start, there might be no current player if (playerInfo && playerInfo->status != EPlayerStatus::INGAME) { // If player making turn has lost his turn must be over as well states.setFlag(gs->currentPlayer, &PlayerStatus::makingTurn, false); } } } void CGameHandler::getVictoryLossMessage(PlayerColor player, const EVictoryLossCheckResult & victoryLossCheckResult, InfoWindow & out) const { out.player = player; out.text.clear(); out.text << victoryLossCheckResult.messageToSelf; // hackish, insert one player-specific string, if applicable if (victoryLossCheckResult.messageToSelf.find("%s") != std::string::npos) out.text.addReplacement(MetaString::COLOR, player.getNum()); out.components.push_back(Component(Component::FLAG, player.getNum(), 0, 0)); } bool CGameHandler::dig(const CGHeroInstance *h) { for (auto i = gs->map->objects.cbegin(); i != gs->map->objects.cend(); i++) //unflag objs { if (*i && (*i)->ID == Obj::HOLE && (*i)->pos == h->getPosition()) { complain("Cannot dig - there is already a hole under the hero!"); return false; } } if (h->diggingStatus() != EDiggingStatus::CAN_DIG) //checks for terrain and movement COMPLAIN_RETF("Hero cannot dig (error code %d)!", h->diggingStatus()); //create a hole NewObject no; no.ID = Obj::HOLE; no.pos = h->getPosition(); no.subID = 0; sendAndApply(&no); //take MPs SetMovePoints smp; smp.hid = h->id; smp.val = 0; sendAndApply(&smp); InfoWindow iw; iw.player = h->tempOwner; if (gs->map->grailPos == h->getPosition()) { iw.text.addTxt(MetaString::GENERAL_TXT, 58); //"Congratulations! After spending many hours digging here, your hero has uncovered the " iw.text.addTxt(MetaString::ART_NAMES, ArtifactID::GRAIL); iw.soundID = soundBase::ULTIMATEARTIFACT; giveHeroNewArtifact(h, VLC->arth->artifacts[ArtifactID::GRAIL], ArtifactPosition::PRE_FIRST); //give grail sendAndApply(&iw); iw.soundID = soundBase::invalid; iw.text.clear(); iw.text.addTxt(MetaString::ART_DESCR, ArtifactID::GRAIL); sendAndApply(&iw); } else { iw.text.addTxt(MetaString::GENERAL_TXT, 59); //"Nothing here. \n Where could it be?" iw.soundID = soundBase::Dig; sendAndApply(&iw); } return true; } void CGameHandler::attackCasting(const BattleAttack & bat, Bonus::BonusType attackMode, const CStack * attacker) { if (attacker->hasBonusOfType(attackMode)) { std::set spellsToCast; TBonusListPtr spells = attacker->getBonuses(Selector::type(attackMode)); for (const std::shared_ptr sf : *spells) { spellsToCast.insert(SpellID(sf->subtype)); } for (SpellID spellID : spellsToCast) { const CStack * oneOfAttacked = nullptr; for (auto & elem : bat.bsa) { if ((elem.newHealth.fullUnits > 0 || elem.newHealth.firstHPleft > 0) && !elem.isSecondary()) //apply effects only to first target stack if it's alive { oneOfAttacked = gs->curB->battleGetStackByID(elem.stackAttacked); break; } } bool castMe = false; if (oneOfAttacked == nullptr) { logGlobal->debug("attackCasting: all attacked creatures have been killed"); return; } int spellLevel = 0; TBonusListPtr spellsByType = attacker->getBonuses(Selector::typeSubtype(attackMode, spellID)); for (const std::shared_ptr sf : *spellsByType) { vstd::amax(spellLevel, sf->additionalInfo % 1000); //pick highest level int meleeRanged = sf->additionalInfo / 1000; if (meleeRanged == 0 || (meleeRanged == 1 && bat.shot()) || (meleeRanged == 2 && !bat.shot())) castMe = true; } int chance = attacker->valOfBonuses((Selector::typeSubtype(attackMode, spellID))); vstd::amin(chance, 100); const CSpell * spell = SpellID(spellID).toSpell(); if(spell->canBeCastAt(gs->curB, ECastingMode::AFTER_ATTACK_CASTING, attacker, oneOfAttacked->position) != ESpellCastProblem::OK) continue; //check if spell should be cast (probability handling) if (getRandomGenerator().nextInt(99) >= chance) continue; //casting if (castMe) //stacks use 0 spell power. If needed, default = 3 or custom value is used { logGlobal->debug("battle spell cast"); BattleSpellCastParameters parameters(gs->curB, attacker, spell); parameters.spellLvl = spellLevel; parameters.effectLevel = spellLevel; parameters.aimToStack(oneOfAttacked); parameters.mode = ECastingMode::AFTER_ATTACK_CASTING; parameters.cast(spellEnv); } } } } void CGameHandler::handleAttackBeforeCasting(BattleAttack *bat) { const CStack * attacker = gs->curB->battleGetStackByID(bat->stackAttacking); attackCasting(*bat, Bonus::SPELL_BEFORE_ATTACK, attacker); //no death stare / acid breath needed? // filter possibly dead stacks bat->bsa.erase(std::remove_if(bat->bsa.begin(), bat->bsa.end(), [this](const BattleStackAttacked &bsa) { return battleGetStackByID(bsa.stackAttacked) == nullptr; }), bat->bsa.end()); } void CGameHandler::handleAfterAttackCasting(const BattleAttack & bat) { const CStack * attacker = gs->curB->battleGetStackByID(bat.stackAttacking); if (!attacker || bat.bsa.empty()) // can be already dead return; const CStack * defender = gs->curB->battleGetStackByID(bat.bsa.at(0).stackAttacked); if(!defender) return;//already dead auto cast = [=](SpellID spellID, int power) { const CSpell * spell = SpellID(spellID).toSpell(); BattleSpellCastParameters parameters(gs->curB, attacker, spell); parameters.spellLvl = 0; parameters.effectLevel = 0; parameters.aimToStack(defender); parameters.effectPower = power; parameters.mode = ECastingMode::AFTER_ATTACK_CASTING; parameters.cast(spellEnv); }; attackCasting(bat, Bonus::SPELL_AFTER_ATTACK, attacker); if(!defender->alive()) { //don't try death stare or acid breath on dead stack (crash!) return; } if(attacker->hasBonusOfType(Bonus::DEATH_STARE)) { // mechanics of Death Stare as in H3: // each gorgon have 10% chance to kill (counted separately in H3) -> binomial distribution //original formula x = min(x, (gorgons_count + 9)/10); double chanceToKill = attacker->valOfBonuses(Bonus::DEATH_STARE, 0) / 100.0f; vstd::amin(chanceToKill, 1); //cap at 100% std::binomial_distribution<> distribution(attacker->getCount(), chanceToKill); int staredCreatures = distribution(getRandomGenerator().getStdGenerator()); double cap = 1 / std::max(chanceToKill, (double)(0.01));//don't divide by 0 int maxToKill = (attacker->getCount() + cap - 1) / cap; //not much more than chance * count vstd::amin(staredCreatures, maxToKill); staredCreatures += (attacker->level() * attacker->valOfBonuses(Bonus::DEATH_STARE, 1)) / defender->level(); if(staredCreatures) { //TODO: death stare was not originally available for multiple-hex attacks, but... cast(SpellID::DEATH_STARE, staredCreatures); } } if(!defender->alive()) return; int acidDamage = 0; TBonusListPtr acidBreath = attacker->getBonuses(Selector::type(Bonus::ACID_BREATH)); for(const std::shared_ptr b : *acidBreath) { if(b->additionalInfo > getRandomGenerator().nextInt(99)) acidDamage += b->val; } if(acidDamage) cast(SpellID::ACID_BREATH_DAMAGE, acidDamage * attacker->getCount()); if(!defender->alive()) return; if(attacker->hasBonusOfType(Bonus::TRANSMUTATION) && defender->isLiving()) //transmutation mechanics, similar to WoG werewolf ability { double chanceToTrigger = attacker->valOfBonuses(Bonus::TRANSMUTATION) / 100.0f; vstd::amin(chanceToTrigger, 1); //cap at 100% if(getRandomGenerator().getDoubleRange(0, 1)() > chanceToTrigger) return; int bonusAdditionalInfo = attacker->getBonus(Selector::type(Bonus::TRANSMUTATION))->additionalInfo; if(defender->getCreature()->idNumber == bonusAdditionalInfo || (bonusAdditionalInfo == -1 && defender->getCreature()->idNumber == attacker->getCreature()->idNumber)) return; BattleStackAdded resurrectInfo; resurrectInfo.pos = defender->position; resurrectInfo.side = defender->side; if(bonusAdditionalInfo != -1) resurrectInfo.creID = (CreatureID)bonusAdditionalInfo; else resurrectInfo.creID = attacker->getCreature()->idNumber; if(attacker->hasBonusOfType((Bonus::TRANSMUTATION), 0)) resurrectInfo.amount = std::max((defender->getCount() * defender->MaxHealth()) / resurrectInfo.creID.toCreature()->MaxHealth(), 1u); else if (attacker->hasBonusOfType((Bonus::TRANSMUTATION), 1)) resurrectInfo.amount = defender->getCount(); else return; //wrong subtype BattleStacksRemoved victimInfo; victimInfo.stackIDs.insert(bat.bsa.at(0).stackAttacked); sendAndApply(&victimInfo); sendAndApply(&resurrectInfo); } } void CGameHandler::visitObjectOnTile(const TerrainTile &t, const CGHeroInstance * h) { if (!t.visitableObjects.empty()) { //to prevent self-visiting heroes on space press if (t.visitableObjects.back() != h) objectVisited(t.visitableObjects.back(), h); else if (t.visitableObjects.size() > 1) objectVisited(*(t.visitableObjects.end()-2),h); } } bool CGameHandler::sacrificeCreatures(const IMarket *market, const CGHeroInstance *hero, SlotID slot, ui32 count) { if (!hero) COMPLAIN_RET("You need hero to sacrifice creature!"); int oldCount = hero->getStackCount(slot); if (oldCount < count) COMPLAIN_RET("Not enough creatures to sacrifice!") else if (oldCount == count && hero->stacksCount() == 1 && hero->needsLastStack()) COMPLAIN_RET("Cannot sacrifice last creature!"); int crid = hero->getStack(slot).type->idNumber; changeStackCount(StackLocation(hero, slot), -count); int dump, exp; market->getOffer(crid, 0, dump, exp, EMarketMode::CREATURE_EXP); exp *= count; changePrimSkill(hero, PrimarySkill::EXPERIENCE, hero->calculateXp(exp)); return true; } bool CGameHandler::sacrificeArtifact(const IMarket * m, const CGHeroInstance * hero, ArtifactPosition slot) { if (!hero) COMPLAIN_RET("You need hero to sacrifice artifact!"); ArtifactLocation al(hero, slot); const CArtifactInstance *a = al.getArt(); COMPLAIN_RET_FALSE_IF(!a,"Cannot find artifact to sacrifice!"); int dmp, expToGive; const CArtifactInstance * art = hero->getArt(slot); COMPLAIN_RET_FALSE_IF((!art), "No artifact at position to sacrifice!"); si32 typId = art->artType->id; m->getOffer(typId, 0, dmp, expToGive, EMarketMode::ARTIFACT_EXP); removeArtifact(al); changePrimSkill(hero, PrimarySkill::EXPERIENCE, expToGive); return true; } void CGameHandler::makeStackDoNothing(const CStack * next) { BattleAction doNothing; doNothing.actionType = Battle::NO_ACTION; doNothing.additionalInfo = 0; doNothing.destinationTile = -1; doNothing.side = next->side; doNothing.stackNumber = next->ID; makeAutomaticAction(next, doNothing); } bool CGameHandler::insertNewStack(const StackLocation &sl, const CCreature *c, TQuantity count) { if (sl.army->hasStackAtSlot(sl.slot)) COMPLAIN_RET("Slot is already taken!"); if (!sl.slot.validSlot()) COMPLAIN_RET("Cannot insert stack to that slot!"); InsertNewStack ins; ins.sl = sl; ins.stack = CStackBasicDescriptor(c, count); sendAndApply(&ins); return true; } bool CGameHandler::eraseStack(const StackLocation &sl, bool forceRemoval) { if (!sl.army->hasStackAtSlot(sl.slot)) COMPLAIN_RET("Cannot find a stack to erase"); if (sl.army->stacksCount() == 1 //from the last stack && sl.army->needsLastStack() //that must be left && !forceRemoval) //ignore above conditions if we are forcing removal { COMPLAIN_RET("Cannot erase the last stack!"); } EraseStack es; es.sl = sl; sendAndApply(&es); return true; } bool CGameHandler::changeStackCount(const StackLocation &sl, TQuantity count, bool absoluteValue) { TQuantity currentCount = sl.army->getStackCount(sl.slot); if ((absoluteValue && count < 0) || (!absoluteValue && -count > currentCount)) { COMPLAIN_RET("Cannot take more stacks than present!"); } if ((currentCount == -count && !absoluteValue) || (!count && absoluteValue)) { eraseStack(sl); } else { ChangeStackCount csc; csc.sl = sl; csc.count = count; csc.absoluteValue = absoluteValue; sendAndApply(&csc); } return true; } bool CGameHandler::addToSlot(const StackLocation &sl, const CCreature *c, TQuantity count) { const CCreature *slotC = sl.army->getCreature(sl.slot); if (!slotC) //slot is empty insertNewStack(sl, c, count); else if (c == slotC) changeStackCount(sl, count); else { COMPLAIN_RET("Cannot add " + c->namePl + " to slot " + boost::lexical_cast(sl.slot) + "!"); } return true; } void CGameHandler::tryJoiningArmy(const CArmedInstance *src, const CArmedInstance *dst, bool removeObjWhenFinished, bool allowMerging) { if (removeObjWhenFinished) removeAfterVisit(src); if (!src->canBeMergedWith(*dst, allowMerging)) { if (allowMerging) //do that, add all matching creatures. { bool cont = true; while (cont) { for (auto i = src->stacks.begin(); i != src->stacks.end(); i++)//while there are unmoved creatures { SlotID pos = dst->getSlotFor(i->second->type); if (pos.validSlot()) { moveStack(StackLocation(src, i->first), StackLocation(dst, pos)); cont = true; break; //or iterator crashes } cont = false; } } } showGarrisonDialog(src->id, dst->id, true); //show garrison window and optionally remove ourselves from map when player ends } else //merge { moveArmy(src, dst, allowMerging); } } bool CGameHandler::moveStack(const StackLocation &src, const StackLocation &dst, TQuantity count) { if (!src.army->hasStackAtSlot(src.slot)) COMPLAIN_RET("No stack to move!"); if (dst.army->hasStackAtSlot(dst.slot) && dst.army->getCreature(dst.slot) != src.army->getCreature(src.slot)) COMPLAIN_RET("Cannot move: stack of different type at destination pos!"); if (!dst.slot.validSlot()) COMPLAIN_RET("Cannot move stack to that slot!"); if (count == -1) { count = src.army->getStackCount(src.slot); } if (src.army != dst.army //moving away && count == src.army->getStackCount(src.slot) //all creatures && src.army->stacksCount() == 1 //from the last stack && src.army->needsLastStack()) //that must be left { COMPLAIN_RET("Cannot move away the last creature!"); } RebalanceStacks rs; rs.src = src; rs.dst = dst; rs.count = count; sendAndApply(&rs); return true; } bool CGameHandler::swapStacks(const StackLocation &sl1, const StackLocation &sl2) { if (!sl1.army->hasStackAtSlot(sl1.slot)) return moveStack(sl2, sl1); else if (!sl2.army->hasStackAtSlot(sl2.slot)) return moveStack(sl1, sl2); else { SwapStacks ss; ss.sl1 = sl1; ss.sl2 = sl2; sendAndApply(&ss); return true; } } void CGameHandler::runBattle() { setBattle(gs->curB); assert(gs->curB); //TODO: pre-tactic stuff, call scripts etc. //tactic round { while (gs->curB->tacticDistance && !battleResult.get()) boost::this_thread::sleep(boost::posix_time::milliseconds(50)); } //initial stacks appearance triggers, e.g. built-in bonus spells auto initialStacks = gs->curB->stacks; //use temporary variable to outclude summoned stacks added to gs->curB->stacks from processing for (CStack * stack : initialStacks) { if (stack->hasBonusOfType(Bonus::SUMMON_GUARDIANS)) { const std::shared_ptr summonInfo = stack->getBonus(Selector::type(Bonus::SUMMON_GUARDIANS)); auto accessibility = getAccesibility(); CreatureID creatureData = CreatureID(summonInfo->subtype); std::vector targetHexes; const bool targetIsBig = stack->getCreature()->isDoubleWide(); //target = creature to guard const bool guardianIsBig = creatureData.toCreature()->isDoubleWide(); /*Chosen idea for two hex units was to cover all possible surrounding hexes of target unit with as small number of stacks as possible. For one-hex targets there are four guardians - front, back and one per side (up + down). Two-hex targets are wider and the difference is there are two guardians per side to cover 3 hexes + extra hex in the front Additionally, there are special cases for starting positions etc., where guardians would be outside of battlefield if spawned normally*/ if (!guardianIsBig) targetHexes = stack->getSurroundingHexes(); else summonGuardiansHelper(targetHexes, stack->position, stack->side, targetIsBig); for (auto hex : targetHexes) { if (accessibility.accessible(hex, guardianIsBig, stack->side)) //without this multiple creatures can occupy one hex { BattleStackAdded newStack; newStack.amount = std::max(1, (int)(stack->getCount() * 0.01 * summonInfo->val)); newStack.creID = creatureData.num; newStack.side = stack->side; newStack.summoned = true; newStack.pos = hex.hex; sendAndApply(&newStack); } } } stackEnchantedTrigger(stack); } //spells opening battle for (int i = 0; i < 2; ++i) { auto h = gs->curB->battleGetFightingHero(i); if (h) { TBonusListPtr bl = h->getBonuses(Selector::type(Bonus::OPENING_BATTLE_SPELL)); for (auto b : *bl) { const CSpell * spell = SpellID(b->subtype).toSpell(); BattleSpellCastParameters parameters(gs->curB, h, spell); parameters.spellLvl = 3; parameters.effectLevel = 3; parameters.mode = ECastingMode::PASSIVE_CASTING; parameters.enchantPower = b->val; parameters.castIfPossible(spellEnv); } } } bool firstRound = true;//FIXME: why first round is -1? //main loop while (!battleResult.get()) //till the end of the battle ;] { BattleNextRound bnr; bnr.round = gs->curB->round + 1; logGlobal->debug("Round %d", bnr.round); sendAndApply(&bnr); auto obstacles = gs->curB->obstacles; //we copy container, because we're going to modify it for (auto &obstPtr : obstacles) { if (const SpellCreatedObstacle *sco = dynamic_cast(obstPtr.get())) if (sco->turnsRemaining == 0) removeObstacle(*obstPtr); } const BattleInfo & curB = *gs->curB; for(auto stack : curB.stacks) { if(stack->alive() && !firstRound) stackEnchantedTrigger(stack); } //stack loop const CStack *next; while (!battleResult.get() && (next = curB.getNextStack()) && next->willMove()) { std::set stacksToRemove; for (auto stack : curB.stacks) { if (vstd::contains(stack->state, EBattleStackState::GHOST_PENDING)) stacksToRemove.insert(stack); } for (auto stack : stacksToRemove) { BattleStacksRemoved bsr; bsr.stackIDs.insert(stack->ID); sendAndApply(&bsr); } //check for bad morale => freeze int nextStackMorale = next->MoraleVal(); if (nextStackMorale < 0 && !(NBonus::hasOfType(gs->curB->battleGetFightingHero(0), Bonus::BLOCK_MORALE) || NBonus::hasOfType(gs->curB->battleGetFightingHero(1), Bonus::BLOCK_MORALE)) //checking if gs->curB->heroes have (or don't have) morale blocking bonuses) ) { if (getRandomGenerator().nextInt(23) < -2 * nextStackMorale) { //unit loses its turn - empty freeze action BattleAction ba; ba.actionType = Battle::BAD_MORALE; ba.additionalInfo = 1; ba.side = next->side; ba.stackNumber = next->ID; makeAutomaticAction(next, ba); continue; } } if (next->hasBonusOfType(Bonus::ATTACKS_NEAREST_CREATURE)) //while in berserk { logGlobal->debug("Handle Berserk effect"); std::pair attackInfo = curB.getNearestStack(next, boost::none); if (attackInfo.first != nullptr) { BattleAction attack; attack.actionType = Battle::WALK_AND_ATTACK; attack.side = next->side; attack.stackNumber = next->ID; attack.additionalInfo = attackInfo.first->position; attack.destinationTile = attackInfo.second; makeAutomaticAction(next, attack); logGlobal->debug("Attacked nearest target %s", attackInfo.first->nodeName()); } else { makeStackDoNothing(next); logGlobal->debug("No target found"); } continue; } const CGHeroInstance * curOwner = battleGetOwnerHero(next); if ((next->position < 0 || next->getCreature()->idNumber == CreatureID::BALLISTA) //arrow turret or ballista && (!curOwner || getRandomGenerator().nextInt(99) >= curOwner->valOfBonuses(Bonus::MANUAL_CONTROL, CreatureID::BALLISTA))) { BattleAction attack; attack.actionType = Battle::SHOOT; attack.side = next->side; attack.stackNumber = next->ID; for (auto & elem : gs->curB->stacks) { if (elem->owner != next->owner && elem->isValidTarget()) { attack.destinationTile = elem->position; break; } } makeAutomaticAction(next, attack); continue; } if (next->getCreature()->idNumber == CreatureID::CATAPULT) { const auto & attackableBattleHexes = curB.getAttackableBattleHexes(); if (attackableBattleHexes.empty()) { makeStackDoNothing(next); continue; } if (!curOwner || getRandomGenerator().nextInt(99) >= curOwner->valOfBonuses(Bonus::MANUAL_CONTROL, CreatureID::CATAPULT)) { BattleAction attack; attack.destinationTile = *RandomGeneratorUtil::nextItem(attackableBattleHexes, getRandomGenerator()); attack.actionType = Battle::CATAPULT; attack.additionalInfo = 0; attack.side = next->side; attack.stackNumber = next->ID; makeAutomaticAction(next, attack); continue; } } if (next->getCreature()->idNumber == CreatureID::FIRST_AID_TENT) { TStacks possibleStacks = battleGetStacksIf([=](const CStack * s) { return s->owner == next->owner && s->canBeHealed(); }); if (!possibleStacks.size()) { makeStackDoNothing(next); continue; } if (!curOwner || getRandomGenerator().nextInt(99) >= curOwner->valOfBonuses(Bonus::MANUAL_CONTROL, CreatureID::FIRST_AID_TENT)) { RandomGeneratorUtil::randomShuffle(possibleStacks, getRandomGenerator()); const CStack * toBeHealed = possibleStacks.front(); BattleAction heal; heal.actionType = Battle::STACK_HEAL; heal.additionalInfo = 0; heal.destinationTile = toBeHealed->position; heal.side = next->side; heal.stackNumber = next->ID; makeAutomaticAction(next, heal); continue; } } int numberOfAsks = 1; bool breakOuter = false; do {//ask interface and wait for answer if (!battleResult.get()) { stackTurnTrigger(next); //various effects if (vstd::contains(next->state, EBattleStackState::FEAR)) { makeStackDoNothing(next); //end immediately if stack was affected by fear } else { logGlobal->trace("Activating %s", next->nodeName()); auto nextId = next->ID; BattleSetActiveStack sas; sas.stack = nextId; sendAndApply(&sas); auto actionWasMade = [&]() -> bool { if (battleMadeAction.data)//active stack has made its action return true; if (battleResult.get())// battle is finished return true; if (next == nullptr)//active stack was been removed return true; return !next->alive();//active stack is dead }; boost::unique_lock lock(battleMadeAction.mx); battleMadeAction.data = false; while (!actionWasMade()) { battleMadeAction.cond.wait(lock); if (battleGetStackByID(nextId, false) != next) next = nullptr; //it may be removed, while we wait } } } if (battleResult.get()) //don't touch it, battle could be finished while waiting got action { breakOuter = true; break; } //we're after action, all results applied checkBattleStateChanges(); //check if this action ended the battle if (next != nullptr) { //check for good morale nextStackMorale = next->MoraleVal(); if (!vstd::contains(next->state,EBattleStackState::HAD_MORALE) //only one extra move per turn possible && !vstd::contains(next->state,EBattleStackState::DEFENDING) && !next->waited() && !vstd::contains(next->state, EBattleStackState::FEAR) && next->alive() && nextStackMorale > 0 && !(NBonus::hasOfType(gs->curB->battleGetFightingHero(0), Bonus::BLOCK_MORALE) || NBonus::hasOfType(gs->curB->battleGetFightingHero(1), Bonus::BLOCK_MORALE)) //checking if gs->curB->heroes have (or don't have) morale blocking bonuses ) { if (getRandomGenerator().nextInt(23) < nextStackMorale) //this stack hasn't got morale this turn { BattleTriggerEffect bte; bte.stackID = next->ID; bte.effect = Bonus::MORALE; bte.val = 1; bte.additionalInfo = 0; sendAndApply(&bte); //play animation ++numberOfAsks; //move this stack once more } } } --numberOfAsks; } while (numberOfAsks > 0); if (breakOuter) { break; } } firstRound = false; } endBattle(gs->curB->tile, gs->curB->battleGetFightingHero(0), gs->curB->battleGetFightingHero(1)); } bool CGameHandler::makeAutomaticAction(const CStack *stack, BattleAction &ba) { BattleSetActiveStack bsa; bsa.stack = stack->ID; bsa.askPlayerInterface = false; sendAndApply(&bsa); bool ret = makeBattleAction(ba); checkBattleStateChanges(); return ret; } void CGameHandler::giveHeroArtifact(const CGHeroInstance *h, const CArtifactInstance *a, ArtifactPosition pos) { assert(a->artType); ArtifactLocation al; al.artHolder = const_cast(h); ArtifactPosition slot = ArtifactPosition::PRE_FIRST; if (pos < 0) { if (pos == ArtifactPosition::FIRST_AVAILABLE) slot = a->firstAvailableSlot(h); else slot = a->firstBackpackSlot(h); } else { slot = pos; } al.slot = slot; if (slot < 0 || !a->canBePutAt(al)) { complain("Cannot put artifact in that slot!"); return; } putArtifact(al, a); } void CGameHandler::putArtifact(const ArtifactLocation &al, const CArtifactInstance *a) { PutArtifact pa; pa.art = a; pa.al = al; sendAndApply(&pa); } bool CGameHandler::giveHeroNewArtifact(const CGHeroInstance * h, const CArtifact * art) { COMPLAIN_RET_FALSE_IF(art->possibleSlots.at(ArtBearer::HERO).empty(), "Not a hero artifact!"); ArtifactPosition slot = art->possibleSlots.at(ArtBearer::HERO).front(); COMPLAIN_RET_FALSE_IF(nullptr != h->getArt(slot, false), "Hero already has artifact in slot"); giveHeroNewArtifact(h, art, slot); return true; } void CGameHandler::giveHeroNewArtifact(const CGHeroInstance *h, const CArtifact *artType, ArtifactPosition pos) { CArtifactInstance *a = nullptr; if (!artType->constituents) { a = new CArtifactInstance(); } else { a = new CCombinedArtifactInstance(); } a->artType = artType; //*NOT* via settype -> all bonus-related stuff must be done by NewArtifact apply NewArtifact na; na.art = a; sendAndApply(&na); // -> updates a!!!, will create a on other machines giveHeroArtifact(h, a, pos); } void CGameHandler::setBattleResult(BattleResult::EResult resultType, int victoriusSide) { boost::unique_lock guard(battleResult.mx); if (battleResult.data) { complain((boost::format("The battle result has been already set (to %d, asked to %d)") % battleResult.data->result % resultType).str()); return; } auto br = new BattleResult(); br->result = resultType; br->winner = victoriusSide; //surrendering side loses gs->curB->calculateCasualties(br->casualties); battleResult.data = br; } void CGameHandler::commitPackage(CPackForClient *pack) { sendAndApply(pack); } void CGameHandler::spawnWanderingMonsters(CreatureID creatureID) { std::vector::iterator tile; std::vector tiles; getFreeTiles(tiles); ui32 amount = tiles.size() / 200; //Chance is 0.5% for each tile RandomGeneratorUtil::randomShuffle(tiles, getRandomGenerator()); logGlobal->trace("Spawning wandering monsters. Found %d free tiles. Creature type: %d", tiles.size(), creatureID.num); const CCreature *cre = VLC->creh->creatures.at(creatureID); for (int i = 0; i < amount; ++i) { tile = tiles.begin(); logGlobal->trace("\tSpawning monster at %s", tile->toString()); putNewMonster(creatureID, cre->getRandomAmount(std::rand), *tile); tiles.erase(tile); //not use it again } } void CGameHandler::handleCheatCode(std::string & cheat, PlayerColor player, const CGHeroInstance * hero, const CGTownInstance * town, bool & cheated) { if (cheat == "vcmiistari") { if (!hero) return; ///Give hero spellbook if (!hero->hasSpellbook()) giveHeroNewArtifact(hero, VLC->arth->artifacts[ArtifactID::SPELLBOOK], ArtifactPosition::SPELLBOOK); ///Give all spells with bonus (to allow banned spells) GiveBonus giveBonus(GiveBonus::HERO); giveBonus.id = hero->id.getNum(); giveBonus.bonus = Bonus(Bonus::PERMANENT, Bonus::SPELLS_OF_LEVEL, Bonus::OTHER, 0, 0); //start with level 0 to skip abilities for (int level = 1; level <= GameConstants::SPELL_LEVELS; level++) { giveBonus.bonus.subtype = level; sendAndApply(&giveBonus); } ///Give mana SetMana sm; sm.hid = hero->id; sm.val = 999; sm.absolute = true; sendAndApply(&sm); } else if (cheat == "vcmiarmenelos") { if (!town) return; ///Build all buildings in selected town for (auto & build : town->town->buildings) { if (!town->hasBuilt(build.first) && !build.second->Name().empty() && build.first != BuildingID::SHIP) { buildStructure(town->id, build.first, true); } } } else if (cheat == "vcmiainur" || cheat == "vcmiangband" || cheat == "vcmiglaurung") { if (!hero) return; ///Gives N creatures into each slot std::map> creatures; creatures.insert(std::make_pair("vcmiainur", std::make_pair(13, 5))); //5 archangels creatures.insert(std::make_pair("vcmiangband", std::make_pair(66, 10))); //10 black knights creatures.insert(std::make_pair("vcmiglaurung", std::make_pair(133, 5000))); //5000 crystal dragons const CCreature * creature = VLC->creh->creatures.at(creatures[cheat].first); for (int i = 0; i < GameConstants::ARMY_SIZE; i++) if (!hero->hasStackAtSlot(SlotID(i))) insertNewStack(StackLocation(hero, SlotID(i)), creature, creatures[cheat].second); } else if (cheat == "vcminoldor") { if (!hero) return; ///Give all war machines to hero if (!hero->getArt(ArtifactPosition::MACH1)) giveHeroNewArtifact(hero, VLC->arth->artifacts[ArtifactID::BALLISTA], ArtifactPosition::MACH1); if (!hero->getArt(ArtifactPosition::MACH2)) giveHeroNewArtifact(hero, VLC->arth->artifacts[ArtifactID::AMMO_CART], ArtifactPosition::MACH2); if (!hero->getArt(ArtifactPosition::MACH3)) giveHeroNewArtifact(hero, VLC->arth->artifacts[ArtifactID::FIRST_AID_TENT], ArtifactPosition::MACH3); } else if (cheat == "vcmiforgeofnoldorking") { if (!hero) return; ///Give hero all artifacts except war machines, spell scrolls and spell book for (int g = 7; g < VLC->arth->artifacts.size(); ++g) //including artifacts from mods giveHeroNewArtifact(hero, VLC->arth->artifacts[g], ArtifactPosition::PRE_FIRST); } else if (cheat == "vcmiglorfindel") { if (!hero) return; ///selected hero gains a new level changePrimSkill(hero, PrimarySkill::EXPERIENCE, VLC->heroh->reqExp(hero->level + 1) - VLC->heroh->reqExp(hero->level)); } else if (cheat == "vcminahar") { if (!hero) return; ///Give 1000000 movement points to hero SetMovePoints smp; smp.hid = hero->id; smp.val = 1000000; sendAndApply(&smp); GiveBonus gb(GiveBonus::HERO); gb.bonus.type = Bonus::FREE_SHIP_BOARDING; gb.bonus.duration = Bonus::ONE_DAY; gb.bonus.source = Bonus::OTHER; gb.id = hero->id.getNum(); giveHeroBonus(&gb); } else if (cheat == "vcmiformenos") { ///Give resources to player TResources resources; resources[Res::GOLD] = 100000; for (Res::ERes i = Res::WOOD; i < Res::GOLD; vstd::advance(i, 1)) resources[i] = 100; giveResources(player, resources); } else if (cheat == "vcmisilmaril") { ///Player wins PlayerCheated pc; pc.player = player; pc.winningCheatCode = true; sendAndApply(&pc); } else if (cheat == "vcmimelkor") { ///Player looses PlayerCheated pc; pc.player = player; pc.losingCheatCode = true; sendAndApply(&pc); } else if (cheat == "vcmieagles" || cheat == "vcmiungoliant") { ///Reveal or conceal FoW FoWChange fc; fc.mode = (cheat == "vcmieagles" ? 1 : 0); fc.player = player; const auto & fowMap = gs->getPlayerTeam(player)->fogOfWarMap; auto hlp_tab = new int3[gs->map->width * gs->map->height * (gs->map->twoLevel ? 2 : 1)]; int lastUnc = 0; for (int i = 0; i < gs->map->width; i++) for (int j = 0; j < gs->map->height; j++) for (int k = 0; k < (gs->map->twoLevel ? 2 : 1); k++) if (!fowMap.at(i).at(j).at(k) || !fc.mode) hlp_tab[lastUnc++] = int3(i, j, k); fc.tiles.insert(hlp_tab, hlp_tab + lastUnc); delete [] hlp_tab; sendAndApply(&fc); } else cheated = false; } void CGameHandler::removeObstacle(const CObstacleInstance &obstacle) { ObstaclesRemoved obsRem; obsRem.obstacles.insert(obstacle.uniqueID); sendAndApply(&obsRem); } void CGameHandler::synchronizeArtifactHandlerLists() { UpdateArtHandlerLists uahl; uahl.treasures = VLC->arth->treasures; uahl.minors = VLC->arth->minors; uahl.majors = VLC->arth->majors; uahl.relics = VLC->arth->relics; sendAndApply(&uahl); } bool CGameHandler::isValidObject(const CGObjectInstance *obj) const { return vstd::contains(gs->map->objects, obj); } bool CGameHandler::isBlockedByQueries(const CPack *pack, PlayerColor player) { if (!strcmp(typeid(*pack).name(), typeid(PlayerMessage).name())) return false; auto query = queries.topQuery(player); if (query && query->blocksPack(pack)) { complain(boost::str(boost::format("Player %s has to answer queries before attempting any further actions. Top query is %s!") % player % query->toString())); return true; } return false; } void CGameHandler::removeAfterVisit(const CGObjectInstance *object) { //If the object is being visited, there must be a matching query for (const auto &query : queries.allQueries()) { if (auto someVistQuery = std::dynamic_pointer_cast(query)) { if (someVistQuery->visitedObject == object) { someVistQuery->removeObjectAfterVisit = true; return; } } } //If we haven't returned so far, there is no query and no visit, call was wrong assert("This function needs to be called during the object visit!"); } void CGameHandler::changeFogOfWar(int3 center, ui32 radius, PlayerColor player, bool hide) { std::unordered_set tiles; getTilesInRange(tiles, center, radius, player, hide? -1 : 1); if (hide) { std::unordered_set observedTiles; //do not hide tiles observed by heroes. May lead to disastrous AI problems auto p = getPlayer(player); for (auto h : p->heroes) { getTilesInRange(observedTiles, h->getSightCenter(), h->getSightRadius(), h->tempOwner, -1); } for (auto t : p->towns) { getTilesInRange(observedTiles, t->getSightCenter(), t->getSightRadius(), t->tempOwner, -1); } for (auto tile : observedTiles) vstd::erase_if_present (tiles, tile); } changeFogOfWar(tiles, player, hide); } void CGameHandler::changeFogOfWar(std::unordered_set &tiles, PlayerColor player, bool hide) { FoWChange fow; fow.tiles = tiles; fow.player = player; fow.mode = hide? 0 : 1; sendAndApply(&fow); } bool CGameHandler::isVisitCoveredByAnotherQuery(const CGObjectInstance *obj, const CGHeroInstance *hero) { if (auto topQuery = queries.topQuery(hero->getOwner())) if (auto visit = std::dynamic_pointer_cast(topQuery)) return !(visit->visitedObject == obj && visit->visitingHero == hero); return true; } CasualtiesAfterBattle::CasualtiesAfterBattle(const CArmedInstance * _army, BattleInfo *bat): army(_army) { heroWithDeadCommander = ObjectInstanceID(); PlayerColor color = army->tempOwner; if(color == PlayerColor::UNFLAGGABLE) color = PlayerColor::NEUTRAL; for(CStack * st : bat->stacks) { if(vstd::contains(st->state, EBattleStackState::SUMMONED)) //don't take into account temporary summoned stacks continue; if(st->owner != color) //remove only our stacks continue; logGlobal->debug("Calculating casualties for %s", st->nodeName()); st->health.takeResurrected(); if(st->slot == SlotID::ARROW_TOWERS_SLOT) { logGlobal->debug("Ignored arrow towers stack."); } else if(st->slot == SlotID::WAR_MACHINES_SLOT) { auto warMachine = st->type->warMachine; if(warMachine == ArtifactID::NONE) { logGlobal->error("Invalid creature in war machine virtual slot. Stack: %s", st->nodeName()); } //catapult artifact remain even if "creature" killed in siege else if(warMachine != ArtifactID::CATAPULT && st->getCount() <= 0) { logGlobal->debug("War machine has been destroyed"); auto hero = dynamic_ptr_cast (army); if (hero) removedWarMachines.push_back (ArtifactLocation(hero, hero->getArtPos(warMachine, true))); else logGlobal->error("War machine in army without hero"); } } else if(st->slot == SlotID::SUMMONED_SLOT_PLACEHOLDER) { if(st->alive() && st->getCount() > 0) { logGlobal->debug("Permanently summoned %d units.", st->getCount()); const CreatureID summonedType = st->type->idNumber; summoned[summonedType] += st->getCount(); } } else if(st->slot == SlotID::COMMANDER_SLOT_PLACEHOLDER) { if (nullptr == st->base) { logGlobal->error("Stack with no base in commander slot. Stack: %s", st->nodeName()); } else { auto c = dynamic_cast (st->base); if(c) { auto h = dynamic_cast (army); if(h && h->commander == c && (st->getCount() == 0 || !st->alive())) { logGlobal->debug("Commander is dead."); heroWithDeadCommander = army->id; //TODO: unify commander handling } } else logGlobal->error("Stack with invalid instance in commander slot. Stack: %s", st->nodeName()); } } else if(st->base && !army->slotEmpty(st->slot)) { logGlobal->debug("Count: %d; base count: %d", st->getCount(), army->getStackCount(st->slot)); if(st->getCount() == 0 || !st->alive()) { logGlobal->debug("Stack has been destroyed."); StackLocation sl(army, st->slot); newStackCounts.push_back(TStackAndItsNewCount(sl, 0)); } else if(st->getCount() < army->getStackCount(st->slot)) { logGlobal->debug("Stack lost %d units.", army->getStackCount(st->slot) - st->getCount()); StackLocation sl(army, st->slot); newStackCounts.push_back(TStackAndItsNewCount(sl, st->getCount())); } else if(st->getCount() > army->getStackCount(st->slot)) { logGlobal->debug("Stack gained %d units.", st->getCount() - army->getStackCount(st->slot)); StackLocation sl(army, st->slot); newStackCounts.push_back(TStackAndItsNewCount(sl, st->getCount())); } } else { logGlobal->warn("Unable to process stack: %s", st->nodeName()); } } } void CasualtiesAfterBattle::updateArmy(CGameHandler *gh) { for (TStackAndItsNewCount &ncount : newStackCounts) { if (ncount.second > 0) gh->changeStackCount(ncount.first, ncount.second, true); else gh->eraseStack(ncount.first, true); } for (auto summoned_iter : summoned) { SlotID slot = army->getSlotFor(summoned_iter.first); if (slot.validSlot()) { StackLocation location(army, slot); gh->addToSlot(location, summoned_iter.first.toCreature(), summoned_iter.second); } else { //even if it will be possible to summon anything permanently it should be checked for free slot //necromancy is handled separately gh->complain("No free slot to put summoned creature"); } } for (auto al : removedWarMachines) { gh->removeArtifact(al); } if (heroWithDeadCommander != ObjectInstanceID()) { SetCommanderProperty scp; scp.heroid = heroWithDeadCommander; scp.which = SetCommanderProperty::ALIVE; scp.amount = 0; gh->sendAndApply(&scp); } } CGameHandler::FinishingBattleHelper::FinishingBattleHelper(std::shared_ptr Query, int RemainingBattleQueriesCount) { assert(Query->result); assert(Query->bi); auto &result = *Query->result; auto &info = *Query->bi; winnerHero = result.winner != 0 ? info.sides[1].hero : info.sides[0].hero; loserHero = result.winner != 0 ? info.sides[0].hero : info.sides[1].hero; victor = info.sides[result.winner].color; loser = info.sides[!result.winner].color; remainingBattleQueriesCount = RemainingBattleQueriesCount; } CGameHandler::FinishingBattleHelper::FinishingBattleHelper() { winnerHero = loserHero = nullptr; remainingBattleQueriesCount = 0; } CRandomGenerator & CGameHandler::getRandomGenerator() { return CRandomGenerator::getDefault(); } ///ServerSpellCastEnvironment ServerSpellCastEnvironment::ServerSpellCastEnvironment(CGameHandler * gh): gh(gh) { } void ServerSpellCastEnvironment::sendAndApply(CPackForClient * info) const { gh->sendAndApply(info); } CRandomGenerator & ServerSpellCastEnvironment::getRandomGenerator() const { return gh->getRandomGenerator(); } void ServerSpellCastEnvironment::complain(const std::string& problem) const { gh->complain(problem); } const CGameInfoCallback * ServerSpellCastEnvironment::getCb() const { return gh; } const CMap * ServerSpellCastEnvironment::getMap() const { return gh->gameState()->map; } bool ServerSpellCastEnvironment::moveHero(ObjectInstanceID hid, int3 dst, bool teleporting) const { return gh->moveHero(hid, dst, teleporting, false); } void ServerSpellCastEnvironment::genericQuery(Query * request, PlayerColor color, std::function callback) const { auto query = std::make_shared(&gh->queries, color, callback); request->queryID = query->queryID; gh->queries.addQuery(query); gh->sendAndApply(request); }