Merge pull request #609 from viciious/improve_battleai

Improve battle AI

AI/BattleAI/AttackPossibility.cpp

@@ -9,62 +9,125 @@
  */
 #include "StdInc.h"
 #include "AttackPossibility.h"
+#include "../../lib/CStack.h" // TODO: remove
+                              // Eventually only IBattleInfoCallback and battle::Unit should be used, 
+                              // CUnitState should be private and CStack should be removed completely
 
-AttackPossibility::AttackPossibility(BattleHex tile_, const BattleAttackInfo & attack_)
+AttackPossibility::AttackPossibility(BattleHex from, BattleHex dest, const BattleAttackInfo & attack)
-	: tile(tile_),
+	: from(from), dest(dest), attack(attack)
-	attack(attack_)
 {
 }
 
-
 int64_t AttackPossibility::damageDiff() const
 {
-	//TODO: use target priority from HypotheticBattle
+	return damageDealt - damageReceived - collateralDamage + shootersBlockedDmg;
-	const auto dealtDmgValue = damageDealt;
-	const auto receivedDmgValue = damageReceived;
-
-	int64_t diff = 0;
-
-	//friendly fire or not
-	if(attack.attacker->unitSide() == attack.defender->unitSide())
-		diff = -dealtDmgValue - receivedDmgValue;
-	else
-		diff = dealtDmgValue - receivedDmgValue;
-
-	//mind control
-	auto actualSide = getCbc()->playerToSide(getCbc()->battleGetOwner(attack.attacker));
-	if(actualSide && actualSide.get() != attack.attacker->unitSide())
-		diff = -diff;
-	return diff;
 }
 
 int64_t AttackPossibility::attackValue() const
 {
-	return damageDiff() + tacticImpact;
+	return damageDiff();
 }
 
-AttackPossibility AttackPossibility::evaluate(const BattleAttackInfo & attackInfo, BattleHex hex)
+int64_t AttackPossibility::evaluateBlockedShootersDmg(const BattleAttackInfo & attackInfo, BattleHex hex, const HypotheticBattle * state)
 {
+	int64_t res = 0;
+
+	if(attackInfo.shooting)
+		return 0;
+
+	auto attacker = attackInfo.attacker;
+	auto hexes = attacker->getSurroundingHexes(hex);
+	for(BattleHex tile : hexes)
+	{
+		auto st = state->battleGetUnitByPos(tile, true);
+		if(!st || !state->battleMatchOwner(st, attacker))
+			continue;
+		if(!state->battleCanShoot(st))
+			continue;
+
+		BattleAttackInfo rangeAttackInfo(st, attacker, true);
+		rangeAttackInfo.defenderPos = hex;
+
+		BattleAttackInfo meleeAttackInfo(st, attacker, false);
+		meleeAttackInfo.defenderPos = hex;
+
+		auto rangeDmg = getCbc()->battleEstimateDamage(rangeAttackInfo);
+		auto meleeDmg = getCbc()->battleEstimateDamage(meleeAttackInfo);
+
+		int64_t gain = (rangeDmg.first + rangeDmg.second - meleeDmg.first - meleeDmg.second) / 2 + 1;
+		res += gain;
+	}
+
+	return res;
+}
+
+AttackPossibility AttackPossibility::evaluate(const BattleAttackInfo & attackInfo, BattleHex hex, const HypotheticBattle * state)
+{
+	auto attacker = attackInfo.attacker;
+	auto defender = attackInfo.defender;
 	const std::string cachingStringBlocksRetaliation = "type_BLOCKS_RETALIATION";
 	static const auto selectorBlocksRetaliation = Selector::type(Bonus::BLOCKS_RETALIATION);
+	const auto attackerSide = getCbc()->playerToSide(getCbc()->battleGetOwner(attacker));
+	const bool counterAttacksBlocked = attacker->hasBonus(selectorBlocksRetaliation, cachingStringBlocksRetaliation);
 
-	const bool counterAttacksBlocked = attackInfo.attacker->hasBonus(selectorBlocksRetaliation, cachingStringBlocksRetaliation);
+	AttackPossibility bestAp(hex, BattleHex::INVALID, attackInfo);
 
-	AttackPossibility ap(hex, attackInfo);
+	std::vector<BattleHex> defenderHex;
+	if(attackInfo.shooting)
+		defenderHex = defender->getHexes();
+	else
+		defenderHex = CStack::meleeAttackHexes(attacker, defender, hex);
 
-	ap.attackerState = attackInfo.attacker->acquireState();
+	for(BattleHex defHex : defenderHex)
+	{
+		if(defHex == hex) // should be impossible but check anyway
+			continue;
+
+		AttackPossibility ap(hex, defHex, attackInfo);
+		ap.attackerState = attacker->acquireState();
+		ap.shootersBlockedDmg = bestAp.shootersBlockedDmg;
 
 		const int totalAttacks = ap.attackerState->getTotalAttacks(attackInfo.shooting);
 
-	if(!attackInfo.shooting)
+		if (!attackInfo.shooting)
 			ap.attackerState->setPosition(hex);
 
-	auto defenderState = attackInfo.defender->acquireState();
+		std::vector<const battle::Unit*> units;
+
+		if (attackInfo.shooting)
+			units = state->getAttackedBattleUnits(attacker, defHex, true, BattleHex::INVALID);
+		else
+			units = state->getAttackedBattleUnits(attacker, defHex, false, hex);
+
+		// ensure the defender is also affected
+		bool addDefender = true;
+		for(auto unit : units)
+		{
+			if (unit->unitId() == defender->unitId())
+			{
+				addDefender = false;
+				break;
+			}
+		}
+
+		if(addDefender)
+			units.push_back(defender);
+
+		for(auto u : units)
+		{
+			if(!ap.attackerState->alive())
+				break;
+
+			assert(u->unitId() != attacker->unitId());
+
+			auto defenderState = u->acquireState();
 			ap.affectedUnits.push_back(defenderState);
 
 			for(int i = 0; i < totalAttacks; i++)
 			{
-		TDmgRange retaliation(0,0);
+				si64 damageDealt, damageReceived;
+
+				TDmgRange retaliation(0, 0);
 				auto attackDmg = getCbc()->battleEstimateDamage(ap.attack, &retaliation);
 
 				vstd::amin(attackDmg.first, defenderState->getAvailableHealth());
@@ -73,25 +136,55 @@ AttackPossibility AttackPossibility::evaluate(const BattleAttackInfo & attackInf
 				vstd::amin(retaliation.first, ap.attackerState->getAvailableHealth());
 				vstd::amin(retaliation.second, ap.attackerState->getAvailableHealth());
 
-		ap.damageDealt += (attackDmg.first + attackDmg.second) / 2;
+				damageDealt = (attackDmg.first + attackDmg.second) / 2;
-
 				ap.attackerState->afterAttack(attackInfo.shooting, false);
 
 				//FIXME: use ranged retaliation
-		if(!attackInfo.shooting && defenderState->ableToRetaliate() && !counterAttacksBlocked)
+				damageReceived = 0;
+				if (!attackInfo.shooting && defenderState->ableToRetaliate() && !counterAttacksBlocked)
 				{
-			ap.damageReceived += (retaliation.first + retaliation.second) / 2;
+					damageReceived = (retaliation.first + retaliation.second) / 2;
 					defenderState->afterAttack(attackInfo.shooting, true);
 				}
 
-		ap.attackerState->damage(ap.damageReceived);
+				bool isEnemy = state->battleMatchOwner(attacker, u);
-		defenderState->damage(ap.damageDealt);
 
-		if(!ap.attackerState->alive() || !defenderState->alive())
+				// this includes enemy units as well as attacker units under enemy's mind control
-			break;
+				if(isEnemy)
+					ap.damageDealt += damageDealt;
+
+				// damaging attacker's units (even those under enemy's mind control) is considered friendly fire
+				if(attackerSide == u->unitSide())
+					ap.collateralDamage += damageDealt;
+
+				if(u->unitId() == defender->unitId() || 
+					(!attackInfo.shooting && CStack::isMeleeAttackPossible(u, attacker, hex)))
+				{
+					//FIXME: handle RANGED_RETALIATION ?
+					ap.damageReceived += damageReceived;
 				}
 
-	//TODO other damage related to attack (eg. fire shield and other abilities)
+				ap.attackerState->damage(damageReceived);
+				defenderState->damage(damageDealt);
 
-	return ap;
+				if (!ap.attackerState->alive() || !defenderState->alive())
+					break;
+			}
+		}
+
+		if(!bestAp.dest.isValid() || ap.attackValue() > bestAp.attackValue())
+			bestAp = ap;
+	}
+
+	// check how much damage we gain from blocking enemy shooters on this hex
+	bestAp.shootersBlockedDmg = evaluateBlockedShootersDmg(attackInfo, hex, state);
+
+	logAi->debug("BattleAI best AP: %s -> %s at %d from %d, affects %d units: %lld %lld %lld %lld",
+		attackInfo.attacker->unitType()->identifier,
+		attackInfo.defender->unitType()->identifier,
+		(int)bestAp.dest, (int)bestAp.from, (int)bestAp.affectedUnits.size(),
+		bestAp.damageDealt, bestAp.damageReceived, bestAp.collateralDamage, bestAp.shootersBlockedDmg);
+
+	//TODO other damage related to attack (eg. fire shield and other abilities)
+	return bestAp;
 }

AI/BattleAI/AttackPossibility.h

@@ -16,7 +16,8 @@
 class AttackPossibility
 {
 public:
-	BattleHex tile; //tile from which we attack
+	BattleHex from; //tile from which we attack
+	BattleHex dest; //tile which we attack
 	BattleAttackInfo attack;
 
 	std::shared_ptr<battle::CUnitState> attackerState;
@@ -25,12 +26,16 @@ public:
 
 	int64_t damageDealt = 0;
 	int64_t damageReceived = 0; //usually by counter-attack
-	int64_t tacticImpact = 0;
+	int64_t collateralDamage = 0; // friendly fire (usually by two-hex attacks)
+	int64_t shootersBlockedDmg = 0;
 
-	AttackPossibility(BattleHex tile_, const BattleAttackInfo & attack_);
+	AttackPossibility(BattleHex from, BattleHex dest, const BattleAttackInfo & attack_);
 
 	int64_t damageDiff() const;
 	int64_t attackValue() const;
 
-	static AttackPossibility evaluate(const BattleAttackInfo & attackInfo, BattleHex hex);
+	static AttackPossibility evaluate(const BattleAttackInfo & attackInfo, BattleHex hex, const HypotheticBattle * state);
+
+private:
+	static int64_t evaluateBlockedShootersDmg(const BattleAttackInfo & attackInfo, BattleHex hex, const HypotheticBattle * state);
 };

AI/BattleAI/BattleAI.cpp

@@ -18,7 +18,9 @@
 #include "../../lib/CThreadHelper.h"
 #include "../../lib/spells/CSpellHandler.h"
 #include "../../lib/spells/ISpellMechanics.h"
-#include "../../lib/CStack.h"//todo: remove
+#include "../../lib/CStack.h" // TODO: remove
+                              // Eventually only IBattleInfoCallback and battle::Unit should be used, 
+                              // CUnitState should be private and CStack should be removed completely
 
 #define LOGL(text) print(text)
 #define LOGFL(text, formattingEl) print(boost::str(boost::format(text) % formattingEl))
@@ -154,7 +156,8 @@ BattleAction CBattleAI::activeStack( const CStack * stack )
 		HypotheticBattle hb(getCbc());
 
 		PotentialTargets targets(stack, &hb);
-		if(targets.possibleAttacks.size())
+
+		if(!targets.possibleAttacks.empty())
 		{
 			AttackPossibility bestAttack = targets.bestAction();
 
@@ -164,7 +167,18 @@ BattleAction CBattleAI::activeStack( const CStack * stack )
 			else if(bestAttack.attack.shooting)
 				return BattleAction::makeShotAttack(stack, bestAttack.attack.defender);
 			else
-				return BattleAction::makeMeleeAttack(stack, bestAttack.attack.defender->getPosition(), bestAttack.tile);
+			{
+				auto &target = bestAttack;
+				logAi->debug("BattleAI: %s -> %s %d from, %d curpos %d dist %d speed %d: %lld %lld %lld",
+					target.attackerState->unitType()->identifier,
+					target.affectedUnits[0]->unitType()->identifier,
+					(int)target.affectedUnits.size(), (int)target.from, (int)bestAttack.attack.attacker->getPosition().hex,
+					bestAttack.attack.chargedFields, bestAttack.attack.attacker->Speed(0, true),
+					target.damageDealt, target.damageReceived, target.attackValue()
+				);
+
+				return BattleAction::makeMeleeAttack(stack,	bestAttack.attack.defender->getPosition(), bestAttack.from);
+			}
 		}
 		else if(bestSpellcast.is_initialized())
 		{

AI/BattleAI/PotentialTargets.cpp

@@ -53,7 +53,7 @@ PotentialTargets::PotentialTargets(const battle::Unit * attacker, const Hypothet
 			if(hex.isValid() && !shooting)
 				bai.chargedFields = reachability.distances[hex];
 
-			return AttackPossibility::evaluate(bai, hex);
+			return AttackPossibility::evaluate(bai, hex, state);
 		};
 
 		if(forceTarget)
@@ -70,20 +70,45 @@ PotentialTargets::PotentialTargets(const battle::Unit * attacker, const Hypothet
 		else
 		{
 			for(BattleHex hex : avHexes)
-				if(CStack::isMeleeAttackPossible(attackerInfo, defender, hex))
+			{
-					possibleAttacks.push_back(GenerateAttackInfo(false, hex));
+				if(!CStack::isMeleeAttackPossible(attackerInfo, defender, hex))
+					continue;
+
+				auto bai = GenerateAttackInfo(false, hex);
+				if(!bai.affectedUnits.empty())
+					possibleAttacks.push_back(bai);
+			}
 
 			if(!vstd::contains_if(possibleAttacks, [=](const AttackPossibility & pa) { return pa.attack.defender->unitId() == defender->unitId(); }))
 				unreachableEnemies.push_back(defender);
 		}
 	}
+
+	boost::sort(possibleAttacks, [](const AttackPossibility & lhs, const AttackPossibility & rhs) -> bool
+	{
+		if(lhs.collateralDamage > rhs.collateralDamage)
+			return false;
+		if(lhs.collateralDamage < rhs.collateralDamage)
+			return true;
+		return (lhs.damageDealt + lhs.shootersBlockedDmg - lhs.damageReceived > rhs.damageDealt + rhs.shootersBlockedDmg - rhs.damageReceived);
+	});
+
+	if (!possibleAttacks.empty())
+	{
+		auto &bestAp = possibleAttacks[0];
+
+		logGlobal->info("Battle AI best: %s -> %s at %d from %d, affects %d units: %lld %lld %lld %lld",
+			bestAp.attack.attacker->unitType()->identifier,
+			state->battleGetUnitByPos(bestAp.dest)->unitType()->identifier,
+			(int)bestAp.dest, (int)bestAp.from, (int)bestAp.affectedUnits.size(),
+			bestAp.damageDealt, bestAp.damageReceived, bestAp.collateralDamage, bestAp.shootersBlockedDmg);
+	}
 }
 
-int PotentialTargets::bestActionValue() const
+int64_t PotentialTargets::bestActionValue() const
 {
 	if(possibleAttacks.empty())
 		return 0;
-
 	return bestAction().attackValue();
 }
 
@@ -91,6 +116,6 @@ AttackPossibility PotentialTargets::bestAction() const
 {
 	if(possibleAttacks.empty())
 		throw std::runtime_error("No best action, since we don't have any actions");
-
+	return possibleAttacks[0];
-	return *vstd::maxElementByFun(possibleAttacks, [](const AttackPossibility &ap) { return ap.attackValue(); } );
+	//return *vstd::maxElementByFun(possibleAttacks, [](const AttackPossibility &ap) { return ap.attackValue(); } );
 }

AI/BattleAI/PotentialTargets.h

@@ -20,5 +20,5 @@ public:
 	PotentialTargets(const battle::Unit * attacker, const HypotheticBattle * state);
 
 	AttackPossibility bestAction() const;
-	int bestActionValue() const;
+	int64_t bestActionValue() const;
 };

client/CMT.cpp

@@ -108,6 +108,8 @@ static void setScreenRes(int w, int h, int bpp, bool fullscreen, int displayInde
 void playIntro();
 static void mainLoop();
 
+static CBasicLogConfigurator *logConfig;
+
 #ifndef VCMI_WINDOWS
 #ifndef _GNU_SOURCE
 #define _GNU_SOURCE
@@ -230,8 +232,8 @@ int main(int argc, char * argv[])
 	console->start();
 
 	const bfs::path logPath = VCMIDirs::get().userCachePath() / "VCMI_Client_log.txt";
-	CBasicLogConfigurator logConfig(logPath, console);
+	logConfig = new CBasicLogConfigurator(logPath, console);
-	logConfig.configureDefault();
+	logConfig->configureDefault();
 	logGlobal->info(NAME);
 	logGlobal->info("Creating console and configuring logger: %d ms", pomtime.getDiff());
 	logGlobal->info("The log file will be saved to %s", logPath);
@@ -292,7 +294,7 @@ int main(int argc, char * argv[])
 	setSettingInteger("general/saveFrequency", "savefrequency", 1);
 
 	// Initialize logging based on settings
-	logConfig.configure();
+	logConfig->configure();
 	logGlobal->debug("settings = %s", settings.toJsonNode().toJson());
 
 	// Some basic data validation to produce better error messages in cases of incorrect install
@@ -1434,6 +1436,13 @@ void handleQuit(bool ask)
 			SDL_Quit();
 		}
 
+		if(logConfig != nullptr)
+		{
+			logConfig->deconfigure();
+			delete logConfig;
+			logConfig = nullptr;
+		}
+
 		std::cout << "Ending...\n";
 		exit(0);
 	};

client/gui/CAnimation.h

@@ -13,6 +13,14 @@
 #include "Geometries.h"
 #include "../../lib/GameConstants.h"
 
+#ifdef IN
+#undef IN
+#endif
+
+#ifdef OUT
+#undef OUT
+#endif
+
 struct SDL_Surface;
 class JsonNode;
 class CDefFile;

client/mapHandler.h

@@ -15,6 +15,14 @@
 #include "gui/Geometries.h"
 #include "SDL.h"
 
+#ifdef IN
+#undef IN
+#endif
+
+#ifdef OUT
+#undef OUT
+#endif
+
 class CGObjectInstance;
 class CGHeroInstance;
 class CGBoat;

lib/CStack.cpp

@@ -252,22 +252,61 @@ void CStack::prepareAttacked(BattleStackAttacked & bsa, vstd::RNG & rand, std::s
 	bsa.newState.operation = UnitChanges::EOperation::RESET_STATE;
 }
 
-bool CStack::isMeleeAttackPossible(const battle::Unit * attacker, const battle::Unit * defender, BattleHex attackerPos, BattleHex defenderPos)
+std::vector<BattleHex> CStack::meleeAttackHexes(const battle::Unit * attacker, const battle::Unit * defender, BattleHex attackerPos, BattleHex defenderPos)
 {
-	if(!attackerPos.isValid())
+	int mask = 0;
+	std::vector<BattleHex> res;
+
+	if (!attackerPos.isValid())
 		attackerPos = attacker->getPosition();
-	if(!defenderPos.isValid())
+	if (!defenderPos.isValid())
 		defenderPos = defender->getPosition();
 
-	return
+	BattleHex otherAttackerPos = attackerPos + (attacker->unitSide() == BattleSide::ATTACKER ? -1 : 1);
-		(BattleHex::mutualPosition(attackerPos, defenderPos) >= 0)//front <=> front
+	BattleHex otherDefenderPos = defenderPos + (defender->unitSide() == BattleSide::ATTACKER ? -1 : 1);
-		|| (attacker->doubleWide()//back <=> front
-			&& BattleHex::mutualPosition(attackerPos + (attacker->unitSide() == BattleSide::ATTACKER ? -1 : 1), defenderPos) >= 0)
-		|| (defender->doubleWide()//front <=> back
-			&& BattleHex::mutualPosition(attackerPos, defenderPos + (defender->unitSide() == BattleSide::ATTACKER ? -1 : 1)) >= 0)
-		|| (defender->doubleWide() && attacker->doubleWide()//back <=> back
-			&& BattleHex::mutualPosition(attackerPos + (attacker->unitSide() == BattleSide::ATTACKER ? -1 : 1), defenderPos + (defender->unitSide() == BattleSide::ATTACKER ? -1 : 1)) >= 0);
 
+	if(BattleHex::mutualPosition(attackerPos, defenderPos) >= 0) //front <=> front
+	{
+		if((mask & 1) == 0)
+		{
+			mask |= 1;
+			res.push_back(defenderPos);
+		}
+	}
+	if (attacker->doubleWide() //back <=> front
+		&& BattleHex::mutualPosition(otherAttackerPos, defenderPos) >= 0)
+	{
+		if((mask & 1) == 0)
+		{
+			mask |= 1;
+			res.push_back(defenderPos);
+		}
+	}
+	if (defender->doubleWide()//front <=> back
+		&& BattleHex::mutualPosition(attackerPos, otherDefenderPos) >= 0)
+	{
+		if((mask & 2) == 0)
+		{
+			mask |= 2;
+			res.push_back(otherDefenderPos);
+		}
+	}
+	if (defender->doubleWide() && attacker->doubleWide()//back <=> back
+		&& BattleHex::mutualPosition(otherAttackerPos, otherDefenderPos) >= 0)
+	{
+		if((mask & 2) == 0)
+		{
+			mask |= 2;
+			res.push_back(otherDefenderPos);
+		}
+	}
+
+	return res;
+}
+
+bool CStack::isMeleeAttackPossible(const battle::Unit * attacker, const battle::Unit * defender, BattleHex attackerPos, BattleHex defenderPos)
+{
+	return !meleeAttackHexes(attacker, defender, attackerPos, defenderPos).empty();
 }
 
 std::string CStack::getName() const

lib/CStack.h

@@ -55,6 +55,7 @@ public:
 	std::vector<si32> activeSpells() const; //returns vector of active spell IDs sorted by time of cast
 	const CGHeroInstance * getMyHero() const; //if stack belongs to hero (directly or was by him summoned) returns hero, nullptr otherwise
 
+	static std::vector<BattleHex> meleeAttackHexes(const battle::Unit * attacker, const battle::Unit * defender, BattleHex attackerPos = BattleHex::INVALID, BattleHex defenderPos = BattleHex::INVALID);
 	static bool isMeleeAttackPossible(const battle::Unit * attacker, const battle::Unit * defender, BattleHex attackerPos = BattleHex::INVALID, BattleHex defenderPos = BattleHex::INVALID);
 
 	BattleHex::EDir destShiftDir() const;

lib/battle/BattleAttackInfo.cpp

@@ -19,6 +19,8 @@ BattleAttackInfo::BattleAttackInfo(const battle::Unit * Attacker, const battle::
 	chargedFields = 0;
 	additiveBonus = 0.0;
 	multBonus = 1.0;
+	attackerPos = BattleHex::INVALID;
+	defenderPos = BattleHex::INVALID;
 }
 
 BattleAttackInfo BattleAttackInfo::reverse() const
@@ -26,6 +28,7 @@ BattleAttackInfo BattleAttackInfo::reverse() const
 	BattleAttackInfo ret = *this;
 
 	std::swap(ret.attacker, ret.defender);
+	std::swap(ret.defenderPos, ret.attackerPos);
 
 	ret.shooting = false;
 	ret.chargedFields = 0;

lib/battle/BattleAttackInfo.h

@@ -15,11 +15,16 @@ namespace battle
 	class CUnitState;
 }
 
+#include "BattleHex.h"
+
 struct DLL_LINKAGE BattleAttackInfo
 {
 	const battle::Unit * attacker;
 	const battle::Unit * defender;
 
+	BattleHex attackerPos;
+	BattleHex defenderPos;
+
 	bool shooting;
 	int chargedFields;
 

lib/battle/CBattleInfoCallback.cpp

@@ -667,37 +667,45 @@ bool CBattleInfoCallback::battleCanAttack(const CStack * stack, const CStack * t
 	return target->alive();
 }
 
-bool CBattleInfoCallback::battleCanShoot(const battle::Unit * attacker, BattleHex dest) const
+bool CBattleInfoCallback::battleCanShoot(const battle::Unit * attacker) const
 {
 	RETURN_IF_NOT_BATTLE(false);
 
-	if(battleTacticDist()) //no shooting during tactics
+	if (battleTacticDist()) //no shooting during tactics
 		return false;
 
-	const battle::Unit * defender = battleGetUnitByPos(dest);
+	if (!attacker)
-
+		return false;
-	if(!attacker || !defender)
+	if (attacker->creatureIndex() == CreatureID::CATAPULT) //catapult cannot attack creatures
 		return false;
 
 	//forgetfulness
 	TBonusListPtr forgetfulList = attacker->getBonuses(Selector::type(Bonus::FORGETFULL));
-	if(!forgetfulList->empty())
+	if (!forgetfulList->empty())
 	{
 		int forgetful = forgetfulList->valOfBonuses(Selector::type(Bonus::FORGETFULL));
 
 		//advanced+ level
-		if(forgetful > 1)
+		if (forgetful > 1)
 			return false;
 	}
 
-	if(attacker->creatureIndex() == CreatureID::CATAPULT && defender) //catapult cannot attack creatures
+	return attacker->canShoot()	&& (!battleIsUnitBlocked(attacker)
+			|| attacker->hasBonusOfType(Bonus::FREE_SHOOTING));
+}
+
+bool CBattleInfoCallback::battleCanShoot(const battle::Unit * attacker, BattleHex dest) const
+{
+	RETURN_IF_NOT_BATTLE(false);
+
+	const battle::Unit * defender = battleGetUnitByPos(dest);
+	if(!attacker || !defender)
 		return false;
 
-	return attacker->canShoot()
+	if(battleMatchOwner(attacker, defender) && defender->alive())
-		&& battleMatchOwner(attacker, defender)
+		return battleCanShoot(attacker);
-		&& defender->alive()
+
-		&& (!battleIsUnitBlocked(attacker)
+	return false;
-		|| attacker->hasBonusOfType(Bonus::FREE_SHOOTING));
 }
 
 TDmgRange CBattleInfoCallback::calculateDmgRange(const BattleAttackInfo & info) const
@@ -897,8 +905,11 @@ TDmgRange CBattleInfoCallback::calculateDmgRange(const BattleAttackInfo & info)
 	if(info.shooting)
 	{
 		//wall / distance penalty + advanced air shield
-		const bool distPenalty = battleHasDistancePenalty(attackerBonuses, info.attacker->getPosition(), info.defender->getPosition());
+		BattleHex attackerPos = info.attackerPos.isValid() ? info.attackerPos : info.attacker->getPosition();
-		const bool obstaclePenalty = battleHasWallPenalty(attackerBonuses, info.attacker->getPosition(), info.defender->getPosition());
+		BattleHex defenderPos = info.defenderPos.isValid() ? info.defenderPos : info.defender->getPosition();
+
+		const bool distPenalty = battleHasDistancePenalty(attackerBonuses, attackerPos, defenderPos);
+		const bool obstaclePenalty = battleHasWallPenalty(attackerBonuses, attackerPos, defenderPos);
 
 		if(distPenalty || defenderBonuses->hasBonus(isAdvancedAirShield, cachingStrAdvAirShield))
 			multBonus *= 0.5;
@@ -1340,11 +1351,11 @@ ReachabilityInfo CBattleInfoCallback::getFlyingReachability(const ReachabilityIn
 	return ret;
 }
 
-AttackableTiles CBattleInfoCallback::getPotentiallyAttackableHexes (const CStack* attacker, BattleHex destinationTile, BattleHex attackerPos) const
+AttackableTiles CBattleInfoCallback::getPotentiallyAttackableHexes (const  battle::Unit* attacker, BattleHex destinationTile, BattleHex attackerPos) const
 {
 	//does not return hex attacked directly
 	//TODO: apply rotation to two-hex attackers
-	bool isAttacker = attacker->side == BattleSide::ATTACKER;
+	bool isAttacker = attacker->unitSide() == BattleSide::ATTACKER;
 
 	AttackableTiles at;
 	RETURN_IF_NOT_BATTLE(at);
@@ -1369,8 +1380,8 @@ AttackableTiles CBattleInfoCallback::getPotentiallyAttackableHexes (const CStack
 		{
 			if((BattleHex::mutualPosition(tile, destinationTile) > -1 && BattleHex::mutualPosition(tile, hex) > -1)) //adjacent both to attacker's head and attacked tile
 			{
-				const CStack * st = battleGetStackByPos(tile, true);
+				auto st = battleGetUnitByPos(tile, true);
-				if(st && st->owner != attacker->owner) //only hostile stacks - does it work well with Berserk?
+				if(st && battleMatchOwner(st, attacker)) //only hostile stacks - does it work well with Berserk?
 				{
 					at.hostileCreaturePositions.insert(tile);
 				}
@@ -1391,18 +1402,21 @@ AttackableTiles CBattleInfoCallback::getPotentiallyAttackableHexes (const CStack
 		for(BattleHex tile : hexes)
 		{
 			//friendly stacks can also be damaged by Dragon Breath
-			if(battleGetStackByPos(tile, true))
+			auto st = battleGetUnitByPos(tile, true);
+			if(st && st != attacker)
 			{
-				if(battleGetStackByPos(tile, true) != attacker)
 				at.friendlyCreaturePositions.insert(tile);
 			}
 		}
 	}
-	else if(attacker->hasBonusOfType(Bonus::TWO_HEX_ATTACK_BREATH) && BattleHex::mutualPosition(destinationTile, hex) > -1) //only adjacent hexes are subject of dragon breath calculation
+	else if(attacker->hasBonusOfType(Bonus::TWO_HEX_ATTACK_BREATH))
+	{
+		int pos = BattleHex::mutualPosition(destinationTile, hex);
+		if (pos > -1) //only adjacent hexes are subject of dragon breath calculation
 		{
 			std::vector<BattleHex> hexes; //only one, in fact
 			int pseudoVector = destinationTile.hex - hex;
-		switch(pseudoVector)
+			switch (pseudoVector)
 			{
 			case 1:
 			case -1:
@@ -1419,17 +1433,19 @@ AttackableTiles CBattleInfoCallback::getPotentiallyAttackableHexes (const CStack
 				BattleHex::checkAndPush(destinationTile.hex + pseudoVector + (((hex / WN) % 2) ? 1 : 0), hexes);
 				break;
 			}
-		for(BattleHex tile : hexes)
+			for (BattleHex tile : hexes)
 			{
 				//friendly stacks can also be damaged by Dragon Breath
-			if(battleGetStackByPos(tile, true))
+				auto st = battleGetUnitByPos(tile, true);
+				if (st != nullptr)
 					at.friendlyCreaturePositions.insert(tile);
 			}
 		}
+	}
 	return at;
 }
 
-AttackableTiles CBattleInfoCallback::getPotentiallyShootableHexes(const CStack * attacker, BattleHex destinationTile, BattleHex attackerPos) const
+AttackableTiles CBattleInfoCallback::getPotentiallyShootableHexes(const  battle::Unit * attacker, BattleHex destinationTile, BattleHex attackerPos) const
 {
 	//does not return hex attacked directly
 	AttackableTiles at;
@@ -1445,6 +1461,36 @@ AttackableTiles CBattleInfoCallback::getPotentiallyShootableHexes(const CStack *
 	return at;
 }
 
+std::vector<const battle::Unit*> CBattleInfoCallback::getAttackedBattleUnits(const battle::Unit* attacker, BattleHex destinationTile, bool rangedAttack, BattleHex attackerPos) const
+{
+	std::vector<const battle::Unit*> units;
+	RETURN_IF_NOT_BATTLE(units);
+
+	AttackableTiles at;
+
+	if (rangedAttack)
+		at = getPotentiallyShootableHexes(attacker, destinationTile, attackerPos);
+	else
+		at = getPotentiallyAttackableHexes(attacker, destinationTile, attackerPos);
+
+	units = battleGetUnitsIf([=](const battle::Unit * unit)
+	{
+		if (unit->isGhost() || !unit->alive())
+			return false;
+
+		for (BattleHex hex : battle::Unit::getHexes(unit->getPosition(), unit->doubleWide(), unit->unitSide()))
+		{
+			if (vstd::contains(at.hostileCreaturePositions, hex))
+				return true;
+			if (vstd::contains(at.friendlyCreaturePositions, hex))
+				return true;
+		}
+		return false;
+	});
+
+	return units;
+}
+
 std::set<const CStack*> CBattleInfoCallback::getAttackedCreatures(const CStack* attacker, BattleHex destinationTile, bool rangedAttack, BattleHex attackerPos) const
 {
 	std::set<const CStack*> attackedCres;

lib/battle/CBattleInfoCallback.h

@@ -89,6 +89,7 @@ public:
 
 	bool battleCanAttack(const CStack * stack, const CStack * target, BattleHex dest) const; //determines if stack with given ID can attack target at the selected destination
 	bool battleCanShoot(const battle::Unit * attacker, BattleHex dest) const; //determines if stack with given ID shoot at the selected destination
+	bool battleCanShoot(const battle::Unit * attacker) const; //determines if stack with given ID shoot in principle
 	bool battleIsUnitBlocked(const battle::Unit * unit) const; //returns true if there is neighboring enemy stack
 	std::set<const battle::Unit *> battleAdjacentUnits(const battle::Unit * unit) const;
 
@@ -123,8 +124,9 @@ public:
 	bool isInTacticRange(BattleHex dest) const;
 	si8 battleGetTacticDist() const; //returns tactic distance for calling player or 0 if this player is not in tactic phase (for ALL_KNOWING actual distance for tactic side)
 
-	AttackableTiles getPotentiallyAttackableHexes(const CStack* attacker, BattleHex destinationTile, BattleHex attackerPos) const; //TODO: apply rotation to two-hex attacker
+	AttackableTiles getPotentiallyAttackableHexes(const  battle::Unit* attacker, BattleHex destinationTile, BattleHex attackerPos) const; //TODO: apply rotation to two-hex attacker
-	AttackableTiles getPotentiallyShootableHexes(const CStack* attacker, BattleHex destinationTile, BattleHex attackerPos) const;
+	AttackableTiles getPotentiallyShootableHexes(const  battle::Unit* attacker, BattleHex destinationTile, BattleHex attackerPos) const;
+	std::vector<const battle::Unit *> getAttackedBattleUnits(const battle::Unit* attacker, BattleHex destinationTile, bool rangedAttack, BattleHex attackerPos = BattleHex::INVALID) const; //calculates range of multi-hex attacks
 	std::set<const CStack*> getAttackedCreatures(const CStack* attacker, BattleHex destinationTile, bool rangedAttack, BattleHex attackerPos = BattleHex::INVALID) const; //calculates range of multi-hex attacks
 	bool isToReverse(BattleHex hexFrom, BattleHex hexTo, bool curDir /*if true, creature is in attacker's direction*/, bool toDoubleWide, bool toDir) const; //determines if creature should be reversed (it stands on hexFrom and should 'see' hexTo)
 	bool isToReverseHlp(BattleHex hexFrom, BattleHex hexTo, bool curDir) const; //helper for isToReverse

lib/logging/CBasicLogConfigurator.cpp

@@ -140,3 +140,10 @@ EConsoleTextColor::EConsoleTextColor CBasicLogConfigurator::getConsoleColor(cons
 	else
 		throw std::runtime_error("Color " + colorName + " unknown.");
 }
+
+void CBasicLogConfigurator::deconfigure()
+{
+	auto l = CLogger::getGlobalLogger();
+	if(l != nullptr)
+		l->clearTargets();
+}

lib/logging/CBasicLogConfigurator.h

@@ -29,6 +29,10 @@ public:
 
 	/// Configures a default logging system by adding the console target and the file target to the global logger.
 	void configureDefault();
+
+	/// Removes all targets from the global logger.
+	void deconfigure();
+
 private:
 	// Gets ELogLevel enum from string. (Should be moved to CLogger as a separate function?)
 	// Throws: std::runtime_error

lib/logging/CLogger.cpp

@@ -402,3 +402,8 @@ void CLogFileTarget::write(const LogRecord & record)
 
 const CLogFormatter & CLogFileTarget::getFormatter() const { return formatter; }
 void CLogFileTarget::setFormatter(const CLogFormatter & formatter) { this->formatter = formatter; }
+
+CLogFileTarget::~CLogFileTarget()
+{
+	file.close();
+}

lib/logging/CLogger.h

@@ -213,6 +213,7 @@ public:
 	/// Constructs a CLogFileTarget and opens the file designated by filePath. If the append parameter is true, the file
 	/// will be appended to. Otherwise the file designated by filePath will be truncated before being opened.
 	explicit CLogFileTarget(boost::filesystem::path filePath, bool append = true);
+	~CLogFileTarget();
 
 	const CLogFormatter & getFormatter() const;
 	void setFormatter(const CLogFormatter & formatter);

server/CVCMIServer.cpp

@@ -956,6 +956,7 @@ int main(int argc, char * argv[])
 	CAndroidVMHelper envHelper;
 	envHelper.callStaticVoidMethod(CAndroidVMHelper::NATIVE_METHODS_DEFAULT_CLASS, "killServer");
 #endif
+	logConfig.deconfigure();
 	vstd::clear_pointer(VLC);
 	return 0;
 }