Split BattleAI::activeStack into several smaller methods

AI/BattleAI/BattleAI.cpp

@@ -93,48 +93,24 @@ void CBattleAI::initBattleInterface(std::shared_ptr<Environment> ENV, std::share
 	movesSkippedByDefense = 0;
 }
 
-BattleAction CBattleAI::activeStack( const CStack * stack )
+BattleAction CBattleAI::useHealingTent(const CStack *stack)
 {
-	LOG_TRACE_PARAMS(logAi, "stack: %s", stack->nodeName());
-
-	BattleAction result = BattleAction::makeDefend(stack);
-	setCbc(cb); //TODO: make solid sure that AIs always use their callbacks (need to take care of event handlers too)
-
-	try
-	{
-		if(stack->creatureId() == CreatureID::CATAPULT)
-			return useCatapult(stack);
-		if(stack->hasBonusOfType(BonusType::SIEGE_WEAPON) && stack->hasBonusOfType(BonusType::HEALER))
-		{
 	auto healingTargets = cb->battleGetStacks(CBattleInfoEssentials::ONLY_MINE);
 	std::map<int, const CStack*> woundHpToStack;
-			for(auto stack : healingTargets)
+	for(const auto * stack : healingTargets)
+	{
 		if(auto woundHp = stack->getMaxHealth() - stack->getFirstHPleft())
 			woundHpToStack[woundHp] = stack;
+	}
+
 	if(woundHpToStack.empty())
 		return BattleAction::makeDefend(stack);
 	else
 		return BattleAction::makeHeal(stack, woundHpToStack.rbegin()->second); //last element of the woundHpToStack is the most wounded stack
-		}
+}
 
-		attemptCastingSpell();
+std::optional<PossibleSpellcast> CBattleAI::findBestCreatureSpell(const CStack *stack)
-
+{
-		if(cb->battleIsFinished() || !stack->alive())
-		{
-			//spellcast may finish battle or kill active stack
-			//send special preudo-action
-			BattleAction cancel;
-			cancel.actionType = EActionType::CANCEL;
-			return cancel;
-		}
-
-		if(auto action = considerFleeingOrSurrendering())
-			return *action;
-		//best action is from effective owner point if view, we are effective owner as we received "activeStack"
-
-
-		//evaluate casting spell for spellcasting stack
-		std::optional<PossibleSpellcast> bestSpellcast(std::nullopt);
 	//TODO: faerie dragon type spell should be selected by server
 	SpellID creatureSpellToCast = cb->battleGetRandomStackSpell(CRandomGenerator::getDefault(), stack, CBattleInfoCallback::RANDOM_AIMED);
 	if(stack->hasBonusOfType(BonusType::SPELLCASTER) && stack->canCast() && creatureSpellToCast != SpellID::NONE)
@@ -157,10 +133,17 @@ BattleAction CBattleAI::activeStack( const CStack * stack )
 			std::sort(possibleCasts.begin(), possibleCasts.end(), [&](const PossibleSpellcast & lhs, const PossibleSpellcast & rhs) { return lhs.value > rhs.value; });
 			if(!possibleCasts.empty() && possibleCasts.front().value > 0)
 			{
-					bestSpellcast = std::optional<PossibleSpellcast>(possibleCasts.front());
+				return possibleCasts.front();
 			}
 		}
 	}
+	return std::nullopt;
+}
+
+BattleAction CBattleAI::selectStackAction(const CStack * stack)
+{
+	//evaluate casting spell for spellcasting stack
+	std::optional<PossibleSpellcast> bestSpellcast = findBestCreatureSpell(stack);
 
 	HypotheticBattle hb(env.get(), cb);
 
@@ -170,6 +153,13 @@ BattleAction CBattleAI::activeStack( const CStack * stack )
 
 	int64_t score = EvaluationResult::INEFFECTIVE_SCORE;
 
+
+	if(targets.possibleAttacks.empty() && bestSpellcast.has_value())
+	{
+		movesSkippedByDefense = 0;
+		return BattleAction::makeCreatureSpellcast(stack, bestSpellcast->dest, bestSpellcast->spell->id);
+	}
+
 	if(!targets.possibleAttacks.empty())
 	{
 #if BATTLE_TRACE_LEVEL>=1
@@ -190,39 +180,37 @@ BattleAction CBattleAI::activeStack( const CStack * stack )
 		if(evaluationResult.score > score)
 		{
 			score = evaluationResult.score;
-				std::string action;
 
+			logAi->debug("BattleAI: %s -> %s x %d, from %d curpos %d dist %d speed %d: +%lld -%lld = %lld",
+				bestAttack.attackerState->unitType()->getJsonKey(),
+				bestAttack.affectedUnits[0]->unitType()->getJsonKey(),
+				(int)bestAttack.affectedUnits[0]->getCount(),
+				(int)bestAttack.from,
+				(int)bestAttack.attack.attacker->getPosition().hex,
+				bestAttack.attack.chargeDistance,
+				bestAttack.attack.attacker->speed(0, true),
+				bestAttack.defenderDamageReduce,
+				bestAttack.attackerDamageReduce, bestAttack.attackValue()
+			);
+
+			if (moveTarget.score <= score)
+			{
 				if(evaluationResult.wait)
 				{
-					result = BattleAction::makeWait(stack);
+					return BattleAction::makeWait(stack);
-					action = "wait";
 				}
 				else if(bestAttack.attack.shooting)
 				{
-					result = BattleAction::makeShotAttack(stack, bestAttack.attack.defender);
-					action = "shot";
 					movesSkippedByDefense = 0;
+					return BattleAction::makeShotAttack(stack, bestAttack.attack.defender);
 				}
 				else
 				{
-					result = BattleAction::makeMeleeAttack(stack, bestAttack.attack.defender->getPosition(), bestAttack.from);
-					action = "melee";
 					movesSkippedByDefense = 0;
-				}
+					return BattleAction::makeMeleeAttack(stack, bestAttack.attack.defender->getPosition(), bestAttack.from);
-
+				}
-				logAi->debug("BattleAI: %s -> %s x %d, %s, from %d curpos %d dist %d speed %d: +%lld -%lld = %lld",
-					bestAttack.attackerState->unitType()->getJsonKey(),
-					bestAttack.affectedUnits[0]->unitType()->getJsonKey(),
-					(int)bestAttack.affectedUnits[0]->getCount(), action, (int)bestAttack.from, (int)bestAttack.attack.attacker->getPosition().hex,
-					bestAttack.attack.chargeDistance, bestAttack.attack.attacker->speed(0, true),
-					bestAttack.defenderDamageReduce, bestAttack.attackerDamageReduce, bestAttack.attackValue()
-				);
 			}
 		}
-		else if(bestSpellcast.has_value())
-		{
-			movesSkippedByDefense = 0;
-			return BattleAction::makeCreatureSpellcast(stack, bestSpellcast->dest, bestSpellcast->spell->id);
 	}
 
 	//ThreatMap threatsToUs(stack); // These lines may be usefull but they are't used in the code.
@@ -232,11 +220,11 @@ BattleAction CBattleAI::activeStack( const CStack * stack )
 
 		if(stack->waited())
 		{
-				result = goTowardsNearest(stack, moveTarget.positions);
+			return goTowardsNearest(stack, moveTarget.positions);
 		}
 		else
 		{
-				result = BattleAction::makeWait(stack);
+			return BattleAction::makeWait(stack);
 		}
 	}
 
@@ -252,11 +240,44 @@ BattleAction CBattleAI::activeStack( const CStack * stack )
 			movesSkippedByDefense = 0;
 
 			if(stack->doubleWide() && vstd::contains(brokenWallMoat, stack->getPosition()))
-					result = BattleAction::makeMove(stack, stack->getPosition().cloneInDirection(BattleHex::RIGHT));
+				return BattleAction::makeMove(stack, stack->getPosition().cloneInDirection(BattleHex::RIGHT));
 			else
-					result = goTowardsNearest(stack, brokenWallMoat);
+				return goTowardsNearest(stack, brokenWallMoat);
 		}
 	}
+
+	return BattleAction::makeDefend(stack);
+}
+
+BattleAction CBattleAI::activeStack( const CStack * stack )
+{
+	LOG_TRACE_PARAMS(logAi, "stack: %s", stack->nodeName());
+
+	BattleAction result = BattleAction::makeDefend(stack);
+	setCbc(cb); //TODO: make solid sure that AIs always use their callbacks (need to take care of event handlers too)
+
+	try
+	{
+		if(stack->creatureId() == CreatureID::CATAPULT)
+			return useCatapult(stack);
+		if(stack->hasBonusOfType(BonusType::SIEGE_WEAPON) && stack->hasBonusOfType(BonusType::HEALER))
+			return useHealingTent(stack);
+
+		attemptCastingSpell();
+
+		if(cb->battleIsFinished() || !stack->alive())
+		{
+			//spellcast may finish battle or kill active stack
+			//send special preudo-action
+			BattleAction cancel;
+			cancel.actionType = EActionType::CANCEL;
+			return cancel;
+		}
+
+		if(auto action = considerFleeingOrSurrendering())
+			return *action;
+
+		result = selectStackAction(stack);
 	}
 	catch(boost::thread_interrupted &)
 	{

AI/BattleAI/BattleAI.h

@@ -77,6 +77,10 @@ public:
 
 	void print(const std::string &text) const;
 	BattleAction useCatapult(const CStack *stack);
+	BattleAction useHealingTent(const CStack *stack);
+	BattleAction selectStackAction(const CStack * stack);
+	std::optional<PossibleSpellcast> findBestCreatureSpell(const CStack *stack);
+
 	void battleStart(const CCreatureSet * army1, const CCreatureSet * army2, int3 tile, const CGHeroInstance * hero1, const CGHeroInstance * hero2, bool Side) override;
 	//void actionFinished(const BattleAction &action) override;//occurs AFTER every action taken by any stack or by the hero
 	//void actionStarted(const BattleAction &action) override;//occurs BEFORE every action taken by any stack or by the hero

client/CPlayerInterface.cpp

@@ -774,6 +774,14 @@ BattleAction CPlayerInterface::activeStack(const CStack * stack) //called when i
 	logGlobal->trace("Awaiting command for %s", stack->nodeName());
 	auto stackId = stack->unitId();
 	auto stackName = stack->nodeName();
+
+	assert(!cb->battleIsFinished());
+	if (cb->battleIsFinished())
+	{
+		logGlobal->error("Received CPlayerInterface::activeStack after battle is finished!");
+		return BattleAction::makeDefend(stack);
+	}
+
 	if (autofightingAI)
 	{
 		if (isAutoFightOn)

client/Client.cpp

@@ -683,7 +683,6 @@ void CClient::stopPlayerBattleAction(PlayerColor color)
 		}
 		playerActionThreads.erase(color);
 	}
-
 }
 
 void CClient::stopAllBattleActions()