{

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, ui8 teleporting, PlayerColor asker = PlayerColor::NEUTRAL) const override;

mutable CGameHandler * gh;

{

virtual bool applyOnGH(CGameHandler *gh, CConnection *c, void *pack, PlayerColor player) const =0;

virtual ~CBaseForGHApply(){}

template<typename U> static CBaseForGHApply *getApplier(const U * t=nullptr)

{

return new CApplyOnGH<U>;

}

{

bool applyOnGH(CGameHandler *gh, CConnection *c, void *pack, PlayerColor player) const

{

T *ptr = static_cast<T*>(pack);

ptr->c = c;

ptr->player = player;

return ptr->applyGh(gh);

}

{

logGlobal->errorStream() << "Cannot apply on GH plain CPack!";

assert(0);

return false;

{

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;

}

{

boost::unique_lock<boost::mutex> l(mx);

players[player];

{

boost::unique_lock<boost::mutex> l(mx);

if(players.find(player) != players.end())

{

return players[player].*flag;

}

else

{

throw std::runtime_error("No such player!");

}

{

boost::unique_lock<boost::mutex> l(mx);

if(players.find(player) != players.end())

{

players[player].*flag = val;

}

else

{

throw std::runtime_error("No such player!");

}

cv.notify_all();

{

changeSecSkill(hero, skill, 1, 0);

expGiven(hero);

{

// required exp for at least 1 lvl-up hasn't been reached

if(!hero->gainsLevel())

{

return;

}

// give primary skill

logGlobal->traceStream() << hero->name << " got level "<< hero->level;

auto primarySkill = hero->nextPrimarySkill();

SetPrimSkill sps;

sps.id = hero->id;

sps.which = primarySkill;

sps.abs = false;

sps.val = 1;

sendAndApply(&sps);

HeroLevelUp hlu;

hlu.hero = hero;

hlu.primskill = primarySkill;

hlu.skills = hero->getLevelUpProposedSecondarySkills();

if(hlu.skills.size() == 0)

{

sendAndApply(&hlu);

levelUpHero(hero);

}

else if(hlu.skills.size() == 1 || hero->tempOwner == PlayerColor::NEUTRAL) //choose skill automatically

{

sendAndApply(&hlu);

levelUpHero(hero, *RandomGeneratorUtil::nextItem(hlu.skills, hero->skillsInfo.rand));

}

else if(hlu.skills.size() > 1)

{

auto levelUpQuery = make_shared<CHeroLevelUpDialogQuery>(hlu);

hlu.queryID = levelUpQuery->queryID;

queries.addQuery(levelUpQuery);

sendAndApply(&hlu);

//level up will be called on query reply

}

{

SetCommanderProperty scp;

auto hero = dynamic_cast<const CGHeroInstance *>(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 <ui8> > skillLevels, std::vector <ui8> 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);

{

if (!c->gainsLevel())

{

return;

}

CommanderLevelUp clu;

auto hero = dynamic_cast<const CGHeroInstance *>(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, gs->getRandomGenerator()));

}

else if(skillAmount > 1) //apply and ask for secondary skill

{

auto commanderLevelUp = make_shared<CCommanderLevelUpDialogQuery>(clu);

clu.queryID = commanderLevelUp->queryID;

queries.addQuery(commanderLevelUp);

sendAndApply(&clu);

}

{

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())

{

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);

}

{

SetSecSkill sss;

sss.id = hero->id;

sss.which = which;

sss.val = val;

sss.abs = abs;

sendAndApply(&sss);

if(which == SecondarySkill::WISDOM)

{

if(hero && hero->visitedTown)

giveSpells(hero->visitedTown, hero);

}

{

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] () -> shared_ptr<CBattleQuery>

{

for(auto &q : queries.allQueries())

{

if(auto bq = std::dynamic_pointer_cast<CBattleQuery>(q))

if(bq->bi == gs->curB)

return bq;

}

return shared_ptr<CBattleQuery>();

};

auto battleQuery = findBattleQuery();

if(!battleQuery)

{

logGlobal->errorStream() << "Cannot find battle query!";

if(gs->initialOpts->mode == StartInfo::DUEL)

{

battleQuery = make_shared<CBattleQuery>(gs->curB);

}

}

if(battleQuery != queries.topQuery(gs->curB->sides[0].color))

complain("Player " + boost::lexical_cast<std::string>(gs->curB->sides[0].color) + " although in battle has no battle query at the top!");

battleQuery->result = *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<FinishingBattleHelper>(battleQuery, gs->initialOpts->mode == StartInfo::DUEL, queriedPlayers);

CasualtiesAfterBattle cab1(bEndArmy1, gs->curB), cab2(bEndArmy2, gs->curB); //calculate casualties before deleting battle

if(finishingBattle->duel)

{

duelFinished();

sendAndApply(battleResult.data); //after this point casualties objects are destroyed

return;

}

ChangeSpells cs; //for Eagle Eye

if(finishingBattle->winnerHero)

{

if(int eagleEyeLevel = finishingBattle->winnerHero->getSecSkillLevel(SecondarySkill::EAGLE_EYE))

{

int maxLevel = eagleEyeLevel + 1;

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 <= maxLevel && !vstd::contains(finishingBattle->winnerHero->spells, sp->id) && gs->getRandomGenerator().nextInt(99) < eagleEyeChance)

cs.spells.insert(sp->id);

}

}

std::vector<ui32> arts; //display them in window

if (result == BattleResult::NORMAL && finishingBattle->winnerHero)

{

if (finishingBattle->loserHero)

{

auto artifactsWorn = finishingBattle->loserHero->artifactsWorn; //TODO: wrap it into a function, somehow (boost::variant -_-)

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)

{

arts.push_back (art->artType->id);

ma.dst = ArtifactLocation (finishingBattle->winnerHero, art->firstAvailableSlot(finishingBattle->winnerHero));

sendAndApply(&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();

arts.push_back (art->artType->id);

ma.dst = ArtifactLocation (finishingBattle->winnerHero, art->firstAvailableSlot(finishingBattle->winnerHero));

sendAndApply(&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())

{

arts.push_back (art->artType->id);

ma.dst = ArtifactLocation (finishingBattle->winnerHero, art->firstAvailableSlot(finishingBattle->winnerHero));

sendAndApply(&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())

{

arts.push_back (art->artType->id);

ma.dst = ArtifactLocation (finishingBattle->winnerHero, art->firstAvailableSlot(finishingBattle->winnerHero));

sendAndApply(&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 id : arts) //TODO; separate function to display loot for various ojects?

{

iw.components.push_back (Component (Component::ARTIFACT, id, 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.takeFromArmy(this);

cab2.takeFromArmy(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)

{

RemoveObject ro(hero2->id);

sendAndApply(&ro);

}

//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)

{

LOG_TRACE(logGlobal);

finishingBattle->remainingBattleQueriesCount--;

logGlobal->traceStream() << "Decremented queries count to " << 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);

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)

{

logGlobal->traceStream() << "post-victory visit";

visitObjectOnTile(*getTile(finishingBattle->winnerHero->getPosition()), finishingBattle->winnerHero);

}

visitObjectAfterVictory = false;

//handle victory/loss of engaged players

std::set<PlayerColor> 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(1))

sah.hid[1] = another->subID;

else

sah.hid[1] = -1;

sendAndApply(&sah);

}

{

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 && gs->getRandomGenerator().nextInt(23) < attackerLuck)

{

bat.flags |= BattleAttack::LUCKY;

}

if (VLC->modh->settings.data["hardcodedFeatures"]["NEGATIVE_LUCK"].Bool()) // negative luck enabled

{

if (attackerLuck < 0 && gs->getRandomGenerator().nextInt(23) < abs(attackerLuck))

{

bat.flags |= BattleAttack::UNLUCKY;

}

}

}

if(gs->getRandomGenerator().nextInt(99) < att->valOfBonuses(Bonus::DOUBLE_DAMAGE_CHANCE))

{

bat.flags |= BattleAttack::DEATH_BLOW;

}

if(att->getCreature()->idNumber == CreatureID::BALLISTA)

{

static const int artilleryLvlToChance[] = {0, 50, 75, 100};

const CGHeroInstance * owner = gs->curB->getHero(att->owner);

int chance = artilleryLvlToChance[owner->getSecSkillLevel(SecondarySkill::ARTILLERY)];

if(chance > gs->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<const CStack*> 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 Bonus * 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?

std::set<const CStack*> attackedCreatures = SpellID(bonus->subtype).toSpell()->getAffectedStacks(gs->curB, ECastingMode::SPELL_LIKE_ATTACK, att->owner, bonus->val, targetHex, att);

//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);

}

}

}

{

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, gs->curB->battleGetOwner(att), gs->curB->battleGetOwner(def),

bat.shot(), distance, bat.lucky(), bat.unlucky(), bat.deathBlow(), bat.ballistaDoubleDmg(), gs->getRandomGenerator());

def->prepareAttacked(bsa, gs->getRandomGenerator()); //calculate casualties

//life drain handling

if (att->hasBonusOfType(Bonus::LIFE_DRAIN) && def->isLiving())

{

StacksHealedOrResurrected shi;

shi.lifeDrain = true;

shi.tentHealing = false;

shi.drainedFrom = def->ID;

StacksHealedOrResurrected::HealInfo hi;

hi.stackID = att->ID;

hi.healedHP = att->calculateHealedHealthPoints(bsa.damageAmount * att->valOfBonuses (Bonus::LIFE_DRAIN) / 100, true);

hi.lowLevelResurrection = false;

shi.healedStacks.push_back(hi);

if (hi.healedHP > 0)

{

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->hasBonusOfType(Bonus::FIRE_SHIELD) && !att->hasBonusOfType (Bonus::FIRE_IMMUNITY))

{

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 = (bsa.damageAmount * def->valOfBonuses(Bonus::FIRE_SHIELD)) / 100; //TODO: scale with attack/defense

att->prepareAttacked(bsa2, gameState()->getRandomGenerator());

bat.bsa.push_back(bsa2);

}

{

setThreadName("CGameHandler::handleConnection");

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<boost::mutex> lock(*c.rmx);

c >> player >> requestID >> pack; //get the package

if(!pack)

{

logGlobal ->errorStream() << boost::format("Received a null package marked as request %d from player %d") % requestID % player;

}

packType = typeList.getTypeID(pack); //get the id of type

logGlobal->traceStream() << boost::format("Received client message (request %d by player %d) of type with ID=%d (%s).\n")

% requestID % player.getNum() % packType % typeid(*pack).name();

}

//prepare struct informing that action was applied

auto sendPackageResponse = [&](bool succesfullyApplied)

{

PackageApplied applied;

applied.player = player;

applied.result = succesfullyApplied;

applied.packType = packType;

applied.requestID = requestID;

boost::unique_lock<boost::mutex> lock(*c.wmx);

c << &applied;

};

CBaseForGHApply *apply = applier->apps[packType]; //and appropriae applier object

if(isBlockedByQueries(pack, player))

{

sendPackageResponse(false);

}

else if(apply)

{

const bool result = apply->applyOnGH(this,&c,pack, player);

if(!result)

complain("Got false in applying... that request must have been fishy!");

logGlobal->traceStream() << "Message successfully applied (result=" << result << ")!";

sendPackageResponse(true);

}

else

{

logGlobal->errorStream() << "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

{

assert(!c.connected); //make sure that connection has been marked as broken

logGlobal->errorStream() << e.what();

end2 = true;

}

catch(...)

{

end2 = true;

handleException();

throw;

}

logGlobal->errorStream() << "Ended handling connection";

{

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));

}

if(curStack->position == 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))

{

if(curStack->attackerOwned)

{

if(accessibility.accessible(dest+1, curStack))

dest += BattleHex::RIGHT;

}

else

{

if(accessibility.accessible(dest-1, curStack))

dest += BattleHex::LEFT;

}

}

if((stackAtEnd && stackAtEnd!=curStack && stackAtEnd->alive()) || !accessibility.accessible(dest, curStack))

{

complain("Given destination is not accessible!");

return 0;

}

std::pair< std::vector<BattleHex>, int > path = gs->curB->getPath(curStack->position, dest, curStack);