Revert "Merge branch 'fix-battle-ai' into develop"

This reverts commit b489816d29f15a6d0a0abc5827887294bc08db03, reversing
changes made to 5ee7061ab76bff92ab7f579c137dd19c2710908e.

AI/BattleAI/AttackPossibility.cpp

@@ -12,10 +12,6 @@
 #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
-#include "../../lib/spells/CSpellHandler.h"
-#include "../../lib/spells/ISpellMechanics.h"
-#include "../../lib/spells/ObstacleCasterProxy.h"
-#include "../../lib/battle/CObstacleInstance.h"
 
 uint64_t averageDmg(const DamageRange & range)
 {
@@ -29,55 +25,9 @@ void DamageCache::cacheDamage(const battle::Unit * attacker, const battle::Unit
 	damageCache[attacker->unitId()][defender->unitId()] = static_cast<float>(damage) / attacker->getCount();
 }
 
-void DamageCache::buildObstacleDamageCache(std::shared_ptr<HypotheticBattle> hb, BattleSide side)
-{
-	for(const auto & obst : hb->battleGetAllObstacles(side))
-	{
-		auto spellObstacle = dynamic_cast<const SpellCreatedObstacle *>(obst.get());
-
-		if(!spellObstacle || !obst->triggersEffects())
-			continue;
-
-		auto triggerAbility = VLC->spells()->getById(obst->getTrigger());
-		auto triggerIsNegative = triggerAbility->isNegative() || triggerAbility->isDamage();
-
-		if(!triggerIsNegative)
-			continue;
-
-		const auto * hero = hb->battleGetFightingHero(spellObstacle->casterSide);
-		auto caster = spells::ObstacleCasterProxy(hb->getSidePlayer(spellObstacle->casterSide), hero, *spellObstacle);
-
-		auto affectedHexes = obst->getAffectedTiles();
-		auto stacks = hb->battleGetUnitsIf([](const battle::Unit * u) -> bool { return u->alive(); });
-
-		for(auto stack : stacks)
-		{
-			std::shared_ptr<HypotheticBattle> inner = std::make_shared<HypotheticBattle>(hb->env, hb);
-			auto cast = spells::BattleCast(hb.get(), &caster, spells::Mode::PASSIVE, obst->getTrigger().toSpell());
-			auto updated = inner->getForUpdate(stack->unitId());
-
-			spells::Target target;
-			target.push_back(spells::Destination(updated.get()));
-
-			cast.castEval(inner->getServerCallback(), target);
-
-			auto damageDealt = stack->getAvailableHealth() - updated->getAvailableHealth();
-
-			for(auto hex : affectedHexes)
-			{
-				obstacleDamage[hex][stack->unitId()] = damageDealt;
-			}
-		}
-	}
-}
 
 void DamageCache::buildDamageCache(std::shared_ptr<HypotheticBattle> hb, BattleSide side)
 {
-	if(parent == nullptr)
-	{
-		buildObstacleDamageCache(hb, side);
-	}
-
 	auto stacks = hb->battleGetUnitsIf([=](const battle::Unit * u) -> bool
 		{
 			return u->isValidTarget();
@@ -120,23 +70,6 @@ int64_t DamageCache::getDamage(const battle::Unit * attacker, const battle::Unit
 	return damageCache[attacker->unitId()][defender->unitId()] * attacker->getCount();
 }
 
-int64_t DamageCache::getObstacleDamage(BattleHex hex, const battle::Unit * defender)
-{
-	if(parent)
-		return parent->getObstacleDamage(hex, defender);
-
-	auto damages = obstacleDamage.find(hex);
-
-	if(damages == obstacleDamage.end())
-		return 0;
-
-	auto damage = damages->second.find(defender->unitId());
-
-	return damage == damages->second.end()
-		? 0
-		: damage->second;
-}
-
 int64_t DamageCache::getOriginalDamage(const battle::Unit * attacker, const battle::Unit * defender, std::shared_ptr<CBattleInfoCallback> hb)
 {
 	if(parent)
@@ -355,15 +288,6 @@ AttackPossibility AttackPossibility::evaluate(
 			{
 				retaliatedUnits.push_back(attacker);
 			}
-
-			auto obstacleDamage = damageCache.getObstacleDamage(hex, attacker);
-
-			if(obstacleDamage > 0)
-			{
-				ap.attackerDamageReduce += calculateDamageReduce(nullptr, attacker, obstacleDamage, damageCache, state);
-
-				ap.attackerState->damage(obstacleDamage);
-			}
 		}
 
 		// ensure the defender is also affected

AI/BattleAI/AttackPossibility.h

@@ -18,18 +18,14 @@ class DamageCache
 {
 private:
 	std::unordered_map<uint32_t, std::unordered_map<uint32_t, float>> damageCache;
-	std::map<BattleHex, std::unordered_map<uint32_t, int64_t>> obstacleDamage;
 	DamageCache * parent;
 
-	void buildObstacleDamageCache(std::shared_ptr<HypotheticBattle> hb, BattleSide side);
-
 public:
 	DamageCache() : parent(nullptr) {}
 	DamageCache(DamageCache * parent) : parent(parent) {}
 
 	void cacheDamage(const battle::Unit * attacker, const battle::Unit * defender, std::shared_ptr<CBattleInfoCallback> hb);
 	int64_t getDamage(const battle::Unit * attacker, const battle::Unit * defender, std::shared_ptr<CBattleInfoCallback> hb);
-	int64_t getObstacleDamage(BattleHex hex, const battle::Unit * defender);
 	int64_t getOriginalDamage(const battle::Unit * attacker, const battle::Unit * defender, std::shared_ptr<CBattleInfoCallback> hb);
 	void buildDamageCache(std::shared_ptr<HypotheticBattle> hb, BattleSide side);
 };

AI/BattleAI/BattleEvaluator.cpp

@@ -226,36 +226,11 @@ BattleAction BattleEvaluator::selectStackAction(const CStack * stack)
 					{
 						return BattleAction::makeDefend(stack);
 					}
-
-					auto enemyMellee = hb->getUnitsIf([this](const battle::Unit * u) -> bool
-						{
-							return u->unitSide() == BattleSide::ATTACKER && !hb->battleCanShoot(u);
-						});
-
-					bool isTargetOutsideFort = bestAttack.dest.getY() < GameConstants::BFIELD_WIDTH - 4;
-					bool siegeDefense = stack->unitSide() == BattleSide::DEFENDER
-						&& !bestAttack.attack.shooting
-						&& hb->battleGetFortifications().hasMoat
-						&& !enemyMellee.empty()
-						&& isTargetOutsideFort;
-
-					if(siegeDefense)
+					else
 					{
-						logAi->trace("Evaluating exchange at %d self-defense", stack->getPosition().hex);
-
-						BattleAttackInfo bai(stack, stack, 0, false);
-						AttackPossibility apDefend(stack->getPosition(), stack->getPosition(), bai);
-
-						float defenseValue = scoreEvaluator.evaluateExchange(apDefend, 0, *targets, damageCache, hb);
-
-						if((defenseValue > score && score <= 0) || (defenseValue > 2 * score && score > 0))
-						{
-							return BattleAction::makeDefend(stack);
-						}
+						activeActionMade = true;
+						return BattleAction::makeMeleeAttack(stack, bestAttack.attack.defenderPos, bestAttack.from);
 					}
-					
-					activeActionMade = true;
-					return BattleAction::makeMeleeAttack(stack, bestAttack.attack.defenderPos, bestAttack.from);
 				}
 			}
 		}

AI/BattleAI/BattleExchangeVariant.cpp

@@ -28,12 +28,6 @@ float BattleExchangeVariant::trackAttack(
 	std::shared_ptr<HypotheticBattle> hb,
 	DamageCache & damageCache)
 {
-	if(!ap.attackerState)
-	{
-		logAi->trace("Skipping fake ap attack");
-		return 0;
-	}
-
 	auto attacker = hb->getForUpdate(ap.attack.attacker->unitId());
 
 	float attackValue = ap.attackValue();

AI/BattleAI/PotentialTargets.cpp

@@ -10,7 +10,6 @@
 #include "StdInc.h"
 #include "PotentialTargets.h"
 #include "../../lib/CStack.h"//todo: remove
-#include "../../lib/mapObjects/CGTownInstance.h"
 
 PotentialTargets::PotentialTargets(
 	const battle::Unit * attacker,