games/vcmi
1
0
Fork 0
mirror of https://github.com/vcmi/vcmi.git synced 2024-12-14 10:12:59 +02:00
Code Issues Releases Activity

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

Browse Source 
This reverts commit b489816d29, reversing
changes made to 5ee7061ab7.
This commit is contained in:
Xilmi 2024-09-03 20:57:05 +02:00
parent 64fad53532
commit dfa992951b
5 changed files with 3 additions and 115 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

76
AI/BattleAI/AttackPossibility.cpp
View File

@ -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

4
AI/BattleAI/AttackPossibility.h
View File

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

31
AI/BattleAI/BattleEvaluator.cpp
View File

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

6
AI/BattleAI/BattleExchangeVariant.cpp
View File

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

1
AI/BattleAI/PotentialTargets.cpp
View File

@ -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,