mirror of
https://github.com/vcmi/vcmi.git
synced 2024-12-24 22:14:36 +02:00
BattleAI: rework movement when no targtes
This commit is contained in:
Andrii Danylchenko
parent
033a585e4b
commit
601ced3749
@ -28,6 +28,22 @@ int64_t AttackPossibility::attackValue() const
|
||||
return damageDiff();
|
||||
}
|
||||
|
||||
int64_t AttackPossibility::calculateDpsReduce(
|
||||
const battle::Unit * attacker,
|
||||
const battle::Unit * defender,
|
||||
uint64_t damageDealt,
|
||||
std::shared_ptr<CBattleInfoCallback> cb)
|
||||
{
|
||||
vstd::amin(damageDealt, defender->getAvailableHealth());
|
||||
|
||||
auto enemyDamageBeforeAttack = cb->battleEstimateDamage(BattleAttackInfo(defender, attacker, defender->canShoot()));
|
||||
auto enemiesKilled = damageDealt / defender->MaxHealth() + (damageDealt % defender->MaxHealth() >= defender->getFirstHPleft() ? 1 : 0);
|
||||
auto enemyDps = (enemyDamageBeforeAttack.first + enemyDamageBeforeAttack.second) / 2;
|
||||
auto dpsPerEnemy = enemyDps / (double)defender->getCount();
|
||||
|
||||
return (int64_t)(dpsPerEnemy * (enemiesKilled + damageDealt / (double)defender->MaxHealth()) / 2);
|
||||
}
|
||||
|
||||
int64_t AttackPossibility::evaluateBlockedShootersDmg(const BattleAttackInfo & attackInfo, BattleHex hex, const HypotheticBattle * state)
|
||||
{
|
||||
int64_t res = 0;
|
||||
@ -136,15 +152,9 @@ AttackPossibility AttackPossibility::evaluate(const BattleAttackInfo & attackInf
|
||||
vstd::amin(retaliation.second, ap.attackerState->getAvailableHealth());
|
||||
|
||||
damageDealt = (attackDmg.first + attackDmg.second) / 2;
|
||||
enemyDpsReduce = calculateDpsReduce(attacker, defender, damageDealt, getCbc());
|
||||
ap.attackerState->afterAttack(attackInfo.shooting, false);
|
||||
|
||||
auto enemiesKilled = damageDealt / u->MaxHealth() + (damageDealt % u->MaxHealth() >= u->getFirstHPleft() ? 1 : 0);
|
||||
auto enemyDps = (enemyDamageBeforeAttack.first + enemyDamageBeforeAttack.second) / 2;
|
||||
|
||||
enemyDpsReduce = enemiesKilled
|
||||
? (int64_t)(enemyDps * enemiesKilled / (double)u->getCount())
|
||||
: (int64_t)(enemyDps / (double)u->getCount() * damageDealt / u->getFirstHPleft());
|
||||
|
||||
//FIXME: use ranged retaliation
|
||||
damageReceived = 0;
|
||||
ourDpsReduce = 0;
|
||||
@ -152,11 +162,8 @@ AttackPossibility AttackPossibility::evaluate(const BattleAttackInfo & attackInf
|
||||
if (!attackInfo.shooting && defenderState->ableToRetaliate() && !counterAttacksBlocked)
|
||||
{
|
||||
damageReceived = (retaliation.first + retaliation.second) / 2;
|
||||
ourDpsReduce = calculateDpsReduce(defender, attacker, damageReceived, getCbc());
|
||||
defenderState->afterAttack(attackInfo.shooting, true);
|
||||
|
||||
auto ourUnitsKilled = damageReceived / attacker->MaxHealth() + (damageReceived % attacker->MaxHealth() >= attacker->getFirstHPleft() ? 1 : 0);
|
||||
|
||||
ourDpsReduce = (int64_t)(damageDealt * ourUnitsKilled / (double)attacker->getCount());
|
||||
}
|
||||
|
||||
bool isEnemy = state->battleMatchOwner(attacker, u);
|
||||
|
||||
@ -13,6 +13,8 @@
|
||||
#include "common.h"
|
||||
#include "StackWithBonuses.h"
|
||||
|
||||
#define BATTLE_TRACE_LEVEL 0
|
||||
|
||||
class AttackPossibility
|
||||
{
|
||||
public:
|
||||
@ -36,6 +38,12 @@ public:
|
||||
|
||||
static AttackPossibility evaluate(const BattleAttackInfo & attackInfo, BattleHex hex, const HypotheticBattle * state);
|
||||
|
||||
static int64_t calculateDpsReduce(
|
||||
const battle::Unit * attacker,
|
||||
const battle::Unit * defender,
|
||||
uint64_t damageDealt,
|
||||
std::shared_ptr<CBattleInfoCallback> cb);
|
||||
|
||||
private:
|
||||
static int64_t evaluateBlockedShootersDmg(const BattleAttackInfo & attackInfo, BattleHex hex, const HypotheticBattle * state);
|
||||
};
|
||||
|
||||
@ -94,7 +94,10 @@ void CBattleAI::init(std::shared_ptr<Environment> ENV, std::shared_ptr<CBattleCa
|
||||
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->type->idNumber == CreatureID::CATAPULT)
|
||||
@ -162,84 +165,83 @@ BattleAction CBattleAI::activeStack( const CStack * stack )
|
||||
|
||||
PotentialTargets targets(stack, &hb);
|
||||
BattleExchangeEvaluator scoreEvaluator(cb, env);
|
||||
auto moveTarget = scoreEvaluator.findMoveTowardsUnreachable(stack, targets, hb);
|
||||
|
||||
int64_t score = EvaluationResult::INEFFECTIVE_SCORE;
|
||||
|
||||
if(!targets.possibleAttacks.empty())
|
||||
{
|
||||
#if BATTLE_TRACE_LEVEL==1
|
||||
logAi->trace("Evaluating attack for %s", stack->getDescription());
|
||||
#endif
|
||||
|
||||
auto evaluationResult = scoreEvaluator.findBestTarget(stack, targets, hb);
|
||||
auto & bestAttack = evaluationResult.bestAttack;
|
||||
|
||||
//TODO: consider more complex spellcast evaluation, f.e. because "re-retaliation" during enemy move in same turn for melee attack etc.
|
||||
if(bestSpellcast.is_initialized() && bestSpellcast->value > bestAttack.damageDiff())
|
||||
{
|
||||
// return because spellcast value is damage dealt and score is dps reduce
|
||||
return BattleAction::makeCreatureSpellcast(stack, bestSpellcast->dest, bestSpellcast->spell->id);
|
||||
}
|
||||
|
||||
if(evaluationResult.score > score)
|
||||
{
|
||||
auto & target = bestAttack;
|
||||
score = evaluationResult.score;
|
||||
std::string action;
|
||||
|
||||
if(evaluationResult.wait)
|
||||
{
|
||||
return BattleAction::makeWait(stack);
|
||||
result = BattleAction::makeWait(stack);
|
||||
action = "wait";
|
||||
}
|
||||
|
||||
if(evaluationResult.score == EvaluationResult::INEFFECTIVE_SCORE)
|
||||
else if(bestAttack.attack.shooting)
|
||||
{
|
||||
return BattleAction::makeDefend(stack);
|
||||
}
|
||||
|
||||
if(bestAttack.attack.shooting)
|
||||
{
|
||||
auto &target = bestAttack;
|
||||
logAi->debug("BattleAI: %s -> %s x %d, shot, 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::makeShotAttack(stack, bestAttack.attack.defender);
|
||||
result = BattleAction::makeShotAttack(stack, bestAttack.attack.defender);
|
||||
action = "shot";
|
||||
}
|
||||
else
|
||||
{
|
||||
auto &target = bestAttack;
|
||||
logAi->debug("BattleAI: %s -> %s x %d, mellee, 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()
|
||||
);
|
||||
result = BattleAction::makeMeleeAttack(stack, bestAttack.attack.defender->getPosition(), bestAttack.from);
|
||||
action = "mellee";
|
||||
}
|
||||
|
||||
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()->identifier,
|
||||
bestAttack.affectedUnits[0]->unitType()->identifier,
|
||||
(int)bestAttack.affectedUnits[0]->getCount(), action, (int)bestAttack.from, (int)bestAttack.attack.attacker->getPosition().hex,
|
||||
bestAttack.attack.chargedFields, bestAttack.attack.attacker->Speed(0, true),
|
||||
bestAttack.damageDealt, bestAttack.damageReceived, bestAttack.attackValue()
|
||||
);
|
||||
}
|
||||
}
|
||||
else if(bestSpellcast.is_initialized())
|
||||
{
|
||||
return BattleAction::makeCreatureSpellcast(stack, bestSpellcast->dest, bestSpellcast->spell->id);
|
||||
}
|
||||
else
|
||||
|
||||
//ThreatMap threatsToUs(stack); // These lines may be usefull but they are't used in the code.
|
||||
if(moveTarget.score > score)
|
||||
{
|
||||
score = moveTarget.score;
|
||||
|
||||
if(stack->waited())
|
||||
{
|
||||
//ThreatMap threatsToUs(stack); // These lines may be usefull but they are't used in the code.
|
||||
auto dists = cb->getReachability(stack);
|
||||
if(!targets.unreachableEnemies.empty())
|
||||
{
|
||||
auto closestEnemy = vstd::minElementByFun(targets.unreachableEnemies, [&](const battle::Unit * enemy) -> int
|
||||
{
|
||||
return dists.distToNearestNeighbour(stack, enemy);
|
||||
});
|
||||
|
||||
if(dists.distToNearestNeighbour(stack, *closestEnemy) < GameConstants::BFIELD_SIZE)
|
||||
{
|
||||
return goTowardsNearest(stack, (*closestEnemy)->getAttackableHexes(stack));
|
||||
}
|
||||
}
|
||||
result = goTowardsNearest(stack, moveTarget.positions);
|
||||
}
|
||||
else
|
||||
{
|
||||
return BattleAction::makeWait(stack);
|
||||
result = BattleAction::makeWait(stack);
|
||||
}
|
||||
}
|
||||
|
||||
if(score > EvaluationResult::INEFFECTIVE_SCORE)
|
||||
{
|
||||
return result;
|
||||
}
|
||||
|
||||
if(!stack->hasBonusOfType(Bonus::FLYING)
|
||||
&& stack->unitSide() == BattleSide::ATTACKER
|
||||
&& cb->battleGetSiegeLevel() >= CGTownInstance::CITADEL)
|
||||
@ -264,7 +266,7 @@ BattleAction CBattleAI::activeStack( const CStack * stack )
|
||||
logAi->error("Exception occurred in %s %s",__FUNCTION__, e.what());
|
||||
}
|
||||
|
||||
return BattleAction::makeDefend(stack);
|
||||
return result;
|
||||
}
|
||||
|
||||
BattleAction CBattleAI::goTowardsNearest(const CStack * stack, std::vector<BattleHex> hexes) const
|
||||
|
||||
@ -11,6 +11,18 @@
|
||||
#include "BattleExchangeVariant.h"
|
||||
#include "../../lib/CStack.h"
|
||||
|
||||
AttackerValue::AttackerValue()
|
||||
{
|
||||
value = 0;
|
||||
isRetalitated = false;
|
||||
}
|
||||
|
||||
MoveTarget::MoveTarget()
|
||||
:positions()
|
||||
{
|
||||
score = EvaluationResult::INEFFECTIVE_SCORE;
|
||||
}
|
||||
|
||||
int64_t BattleExchangeVariant::trackAttack(const AttackPossibility & ap, HypotheticBattle * state)
|
||||
{
|
||||
auto affectedUnits = ap.affectedUnits;
|
||||
@ -31,6 +43,7 @@ int64_t BattleExchangeVariant::trackAttack(const AttackPossibility & ap, Hypothe
|
||||
|
||||
dpsScore += attackValue;
|
||||
|
||||
#if BATTLE_TRACE_LEVEL==1
|
||||
logAi->trace(
|
||||
"%s -> %s, ap attack, %s, dps: %d, score: %d",
|
||||
ap.attack.attacker->getDescription(),
|
||||
@ -38,6 +51,7 @@ int64_t BattleExchangeVariant::trackAttack(const AttackPossibility & ap, Hypothe
|
||||
ap.attack.shooting ? "shot" : "mellee",
|
||||
ap.damageDealt,
|
||||
attackValue);
|
||||
#endif
|
||||
|
||||
return attackValue;
|
||||
}
|
||||
@ -56,13 +70,20 @@ int64_t BattleExchangeVariant::trackAttack(
|
||||
|
||||
TDmgRange retalitation;
|
||||
BattleAttackInfo bai(attacker.get(), defender.get(), shooting);
|
||||
|
||||
if(shooting)
|
||||
{
|
||||
bai.attackerPos.setXY(8, 5);
|
||||
}
|
||||
|
||||
auto attack = cb->battleEstimateDamage(bai, &retalitation);
|
||||
int64_t attackDamage = (attack.first + attack.second) / 2;
|
||||
int64_t defenderDpsReduce = calculateDpsReduce(attacker.get(), defender.get(), attackDamage, cb);
|
||||
int64_t defenderDpsReduce = AttackPossibility::calculateDpsReduce(attacker.get(), defender.get(), attackDamage, cb);
|
||||
int64_t attackerDpsReduce = 0;
|
||||
|
||||
if(!evaluateOnly)
|
||||
{
|
||||
#if BATTLE_TRACE_LEVEL==1
|
||||
logAi->trace(
|
||||
"%s -> %s, normal attack, %s, dps: %d, %d",
|
||||
attacker->getDescription(),
|
||||
@ -70,6 +91,7 @@ int64_t BattleExchangeVariant::trackAttack(
|
||||
shooting ? "shot" : "mellee",
|
||||
attackDamage,
|
||||
defenderDpsReduce);
|
||||
#endif
|
||||
|
||||
if(isOurAttack)
|
||||
{
|
||||
@ -88,16 +110,18 @@ int64_t BattleExchangeVariant::trackAttack(
|
||||
if(retalitation.second != 0)
|
||||
{
|
||||
auto retalitationDamage = (retalitation.first + retalitation.second) / 2;
|
||||
attackerDpsReduce = calculateDpsReduce(defender.get(), attacker.get(), retalitationDamage, cb);
|
||||
attackerDpsReduce = AttackPossibility::calculateDpsReduce(defender.get(), attacker.get(), retalitationDamage, cb);
|
||||
|
||||
if(!evaluateOnly)
|
||||
{
|
||||
#if BATTLE_TRACE_LEVEL==1
|
||||
logAi->trace(
|
||||
"%s -> %s, retalitation, dps: %d, %d",
|
||||
defender->getDescription(),
|
||||
attacker->getDescription(),
|
||||
retalitationDamage,
|
||||
attackerDpsReduce);
|
||||
#endif
|
||||
|
||||
if(isOurAttack)
|
||||
{
|
||||
@ -118,30 +142,16 @@ int64_t BattleExchangeVariant::trackAttack(
|
||||
|
||||
auto score = defenderDpsReduce - attackerDpsReduce;
|
||||
|
||||
#if BATTLE_TRACE_LEVEL==1
|
||||
if(!score)
|
||||
{
|
||||
logAi->trace("Zero %d %d", defenderDpsReduce, attackerDpsReduce);
|
||||
}
|
||||
#endif
|
||||
|
||||
return score;
|
||||
}
|
||||
|
||||
int64_t BattleExchangeVariant::calculateDpsReduce(
|
||||
const battle::Unit * attacker,
|
||||
const battle::Unit * defender,
|
||||
uint64_t damageDealt,
|
||||
std::shared_ptr<CBattleInfoCallback> cb) const
|
||||
{
|
||||
vstd::amin(damageDealt, defender->getAvailableHealth());
|
||||
|
||||
auto enemyDamageBeforeAttack = cb->battleEstimateDamage(BattleAttackInfo(defender, attacker, defender->canShoot()));
|
||||
auto enemiesKilled = damageDealt / defender->MaxHealth() + (damageDealt % defender->MaxHealth() >= defender->getFirstHPleft() ? 1 : 0);
|
||||
auto enemyDps = (enemyDamageBeforeAttack.first + enemyDamageBeforeAttack.second) / 2;
|
||||
|
||||
return (int64_t)(enemyDps * enemiesKilled / (double)defender->getCount()
|
||||
+ enemyDps / (double)defender->getCount() * ((damageDealt - defender->getFirstHPleft()) % defender->MaxHealth()) / defender->MaxHealth());
|
||||
};
|
||||
|
||||
EvaluationResult BattleExchangeEvaluator::findBestTarget(const battle::Unit * activeStack, PotentialTargets & targets, HypotheticBattle & hb)
|
||||
{
|
||||
EvaluationResult result(targets.bestAction());
|
||||
@ -150,7 +160,7 @@ EvaluationResult BattleExchangeEvaluator::findBestTarget(const battle::Unit * ac
|
||||
|
||||
for(auto & ap : targets.possibleAttacks)
|
||||
{
|
||||
int64_t score = calculateExchange(ap);
|
||||
int64_t score = calculateExchange(ap, targets, hb);
|
||||
|
||||
if(score > result.score)
|
||||
{
|
||||
@ -161,7 +171,9 @@ EvaluationResult BattleExchangeEvaluator::findBestTarget(const battle::Unit * ac
|
||||
|
||||
if(!activeStack->waited())
|
||||
{
|
||||
#if BATTLE_TRACE_LEVEL==1
|
||||
logAi->trace("Evaluating waited attack for %s", activeStack->getDescription());
|
||||
#endif
|
||||
|
||||
hb.getForUpdate(activeStack->unitId())->waiting = true;
|
||||
hb.getForUpdate(activeStack->unitId())->waitedThisTurn = true;
|
||||
@ -170,7 +182,7 @@ EvaluationResult BattleExchangeEvaluator::findBestTarget(const battle::Unit * ac
|
||||
|
||||
for(auto & ap : targets.possibleAttacks)
|
||||
{
|
||||
int64_t score = calculateExchange(ap);
|
||||
int64_t score = calculateExchange(ap, targets, hb);
|
||||
|
||||
if(score > result.score)
|
||||
{
|
||||
@ -184,8 +196,94 @@ EvaluationResult BattleExchangeEvaluator::findBestTarget(const battle::Unit * ac
|
||||
return result;
|
||||
}
|
||||
|
||||
MoveTarget BattleExchangeEvaluator::findMoveTowardsUnreachable(const battle::Unit * activeStack, PotentialTargets & targets, HypotheticBattle & hb)
|
||||
{
|
||||
MoveTarget result;
|
||||
BattleExchangeVariant ev;
|
||||
|
||||
if(targets.unreachableEnemies.empty())
|
||||
return result;
|
||||
|
||||
updateReachabilityMap(hb);
|
||||
|
||||
auto dists = cb->getReachability(activeStack);
|
||||
auto speed = activeStack->Speed();
|
||||
|
||||
for(const battle::Unit * enemy : targets.unreachableEnemies)
|
||||
{
|
||||
int64_t stackScore = EvaluationResult::INEFFECTIVE_SCORE;
|
||||
|
||||
std::vector<const battle::Unit *> adjacentStacks = getAdjacentUnits(enemy);
|
||||
auto closestStack = *vstd::minElementByFun(adjacentStacks, [&](const battle::Unit * u) -> int64_t
|
||||
{
|
||||
return dists.distToNearestNeighbour(activeStack, u) * 100000 - activeStack->getTotalHealth();
|
||||
});
|
||||
|
||||
auto distance = dists.distToNearestNeighbour(activeStack, closestStack);
|
||||
|
||||
if(distance >= GameConstants::BFIELD_SIZE)
|
||||
continue;
|
||||
|
||||
if(distance <= speed)
|
||||
continue;
|
||||
|
||||
auto turnsToRich = (distance - 1) / speed + 1;
|
||||
auto hexes = closestStack->getSurroundingHexes();
|
||||
|
||||
for(auto hex : hexes)
|
||||
{
|
||||
auto bai = BattleAttackInfo(activeStack, closestStack, cb->battleCanShoot(activeStack));
|
||||
auto attack = AttackPossibility::evaluate(bai, hex, &hb);
|
||||
|
||||
attack.shootersBlockedDmg = 0; // we do not want to count on it, it is not for sure
|
||||
|
||||
auto score = calculateExchange(attack, targets, hb) / turnsToRich;
|
||||
|
||||
if(result.score < score)
|
||||
{
|
||||
result.score = score;
|
||||
result.positions = closestStack->getAttackableHexes(activeStack);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
std::vector<const battle::Unit *> BattleExchangeEvaluator::getAdjacentUnits(const battle::Unit * blockerUnit)
|
||||
{
|
||||
std::queue<const battle::Unit *> queue;
|
||||
std::vector<const battle::Unit *> checkedStacks;
|
||||
|
||||
queue.push(blockerUnit);
|
||||
|
||||
while(!queue.empty())
|
||||
{
|
||||
auto stack = queue.front();
|
||||
|
||||
queue.pop();
|
||||
checkedStacks.push_back(stack);
|
||||
|
||||
auto hexes = stack->getSurroundingHexes();
|
||||
for(auto hex : hexes)
|
||||
{
|
||||
auto neighbor = cb->battleGetStackByPos(hex);
|
||||
|
||||
if(neighbor && neighbor->unitSide() == stack->unitSide() && !vstd::contains(checkedStacks, neighbor))
|
||||
{
|
||||
queue.push(neighbor);
|
||||
checkedStacks.push_back(neighbor);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return checkedStacks;
|
||||
}
|
||||
|
||||
std::vector<const battle::Unit *> BattleExchangeEvaluator::getExchangeUnits(
|
||||
const AttackPossibility & ap)
|
||||
const AttackPossibility & ap,
|
||||
PotentialTargets & targets,
|
||||
HypotheticBattle & hb)
|
||||
{
|
||||
auto hexes = ap.attack.defender->getHexes();
|
||||
|
||||
@ -201,9 +299,33 @@ std::vector<const battle::Unit *> BattleExchangeEvaluator::getExchangeUnits(
|
||||
|
||||
vstd::removeDuplicates(allReachableUnits);
|
||||
|
||||
auto copy = allReachableUnits;
|
||||
for(auto unit : copy)
|
||||
{
|
||||
for(auto adjacentUnit : getAdjacentUnits(unit))
|
||||
{
|
||||
auto unitWithBonuses = hb.battleGetUnitByID(adjacentUnit->unitId());
|
||||
|
||||
if(vstd::contains(targets.unreachableEnemies, adjacentUnit)
|
||||
&& !vstd::contains(allReachableUnits, unitWithBonuses))
|
||||
{
|
||||
allReachableUnits.push_back(unitWithBonuses);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
vstd::removeDuplicates(allReachableUnits);
|
||||
|
||||
if(!vstd::contains(allReachableUnits, ap.attack.attacker))
|
||||
{
|
||||
allReachableUnits.push_back(ap.attack.attacker);
|
||||
}
|
||||
|
||||
if(allReachableUnits.size() < 2)
|
||||
{
|
||||
#if BATTLE_TRACE_LEVEL==1
|
||||
logAi->trace("Reachability map contains only %d stacks", allReachableUnits.size());
|
||||
#endif
|
||||
|
||||
return exchangeUnits;
|
||||
}
|
||||
@ -220,16 +342,21 @@ std::vector<const battle::Unit *> BattleExchangeEvaluator::getExchangeUnits(
|
||||
return exchangeUnits;
|
||||
}
|
||||
|
||||
int64_t BattleExchangeEvaluator::calculateExchange(const AttackPossibility & ap)
|
||||
int64_t BattleExchangeEvaluator::calculateExchange(
|
||||
const AttackPossibility & ap,
|
||||
PotentialTargets & targets,
|
||||
HypotheticBattle & hb)
|
||||
{
|
||||
#if BATTLE_TRACE_LEVEL==1
|
||||
logAi->trace("Battle exchange at %d", ap.attack.shooting ? ap.dest : ap.from);
|
||||
#endif
|
||||
|
||||
std::vector<const battle::Unit *> ourStacks;
|
||||
std::vector<const battle::Unit *> enemyStacks;
|
||||
|
||||
enemyStacks.push_back(ap.attack.defender);
|
||||
|
||||
std::vector<const battle::Unit *> exchangeUnits = getExchangeUnits(ap);
|
||||
std::vector<const battle::Unit *> exchangeUnits = getExchangeUnits(ap, targets, hb);
|
||||
|
||||
if(exchangeUnits.empty())
|
||||
{
|
||||
@ -250,7 +377,6 @@ int64_t BattleExchangeEvaluator::calculateExchange(const AttackPossibility & ap)
|
||||
{
|
||||
bool isOur = cb->battleMatchOwner(ap.attack.attacker, unit, true);
|
||||
auto & attackerQueue = isOur ? ourStacks : enemyStacks;
|
||||
auto & oppositeQueue = isOur ? enemyStacks : ourStacks;
|
||||
|
||||
if(!vstd::contains(attackerQueue, unit))
|
||||
{
|
||||
@ -268,13 +394,11 @@ int64_t BattleExchangeEvaluator::calculateExchange(const AttackPossibility & ap)
|
||||
|
||||
auto attacker = exchangeBattle.getForUpdate(activeUnit->unitId());
|
||||
|
||||
if(!attacker->alive() || oppositeQueue.empty())
|
||||
if(!attacker->alive())
|
||||
{
|
||||
logAi->trace(
|
||||
"Attacker [%s] dead(%d) or opposite queue empty(%d)",
|
||||
attacker->getDescription(),
|
||||
attacker->alive() ? 0 : 1,
|
||||
oppositeQueue.size());
|
||||
#if BATTLE_TRACE_LEVEL==1
|
||||
logAi->trace( "Attacker is dead");
|
||||
#endif
|
||||
|
||||
continue;
|
||||
}
|
||||
@ -283,7 +407,7 @@ int64_t BattleExchangeEvaluator::calculateExchange(const AttackPossibility & ap)
|
||||
|
||||
if(!isOur || !exchangeBattle.getForUpdate(targetUnit->unitId())->alive())
|
||||
{
|
||||
targetUnit = *vstd::maxElementByFun(oppositeQueue, [&](const battle::Unit * u) -> int64_t
|
||||
auto estimateAttack = [&](const battle::Unit * u) -> int64_t
|
||||
{
|
||||
auto stackWithBonuses = exchangeBattle.getForUpdate(u->unitId());
|
||||
auto score = v.trackAttack(
|
||||
@ -294,10 +418,43 @@ int64_t BattleExchangeEvaluator::calculateExchange(const AttackPossibility & ap)
|
||||
cb,
|
||||
true);
|
||||
|
||||
#if BATTLE_TRACE_LEVEL==1
|
||||
logAi->trace("Best target selector %s->%s score = %d", attacker->getDescription(), u->getDescription(), score);
|
||||
#endif
|
||||
|
||||
return score;
|
||||
};
|
||||
|
||||
if(!oppositeQueue.empty())
|
||||
{
|
||||
targetUnit = *vstd::maxElementByFun(oppositeQueue, estimateAttack);
|
||||
}
|
||||
else
|
||||
{
|
||||
auto reachable = exchangeBattle.battleGetUnitsIf([&](const battle::Unit * u) -> bool
|
||||
{
|
||||
if(!u->alive() || u->unitSide() == attacker->unitSide())
|
||||
return false;
|
||||
|
||||
return vstd::contains_if(reachabilityMap[u->getPosition()], [&](const battle::Unit * other) -> bool
|
||||
{
|
||||
return attacker->unitId() == other->unitId();
|
||||
});
|
||||
});
|
||||
|
||||
if(!reachable.empty())
|
||||
{
|
||||
targetUnit = *vstd::maxElementByFun(reachable, estimateAttack);
|
||||
}
|
||||
else
|
||||
{
|
||||
#if BATTLE_TRACE_LEVEL==1
|
||||
logAi->trace("Battle queue is empty and no reachable enemy.");
|
||||
#endif
|
||||
|
||||
continue;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
auto defender = exchangeBattle.getForUpdate(targetUnit->unitId());
|
||||
@ -334,7 +491,9 @@ int64_t BattleExchangeEvaluator::calculateExchange(const AttackPossibility & ap)
|
||||
|
||||
v.adjustPositions(melleeAttackers, ap, reachabilityMap);
|
||||
|
||||
#if BATTLE_TRACE_LEVEL==1
|
||||
logAi->trace("Exchange score: %ld", v.getScore());
|
||||
#endif
|
||||
|
||||
return v.getScore();
|
||||
}
|
||||
@ -419,6 +578,16 @@ void BattleExchangeEvaluator::updateReachabilityMap(HypotheticBattle & hb)
|
||||
|
||||
for(const battle::Unit * unit : turnQueue)
|
||||
{
|
||||
if(turnBattle.battleCanShoot(unit))
|
||||
{
|
||||
for(BattleHex hex = BattleHex::TOP_LEFT; hex.isValid(); hex = hex + 1)
|
||||
{
|
||||
reachabilityMap[hex].push_back(unit);
|
||||
}
|
||||
|
||||
continue;
|
||||
}
|
||||
|
||||
auto unitReachability = turnBattle.getReachability(unit);
|
||||
|
||||
for(BattleHex hex = BattleHex::TOP_LEFT; hex.isValid(); hex = hex + 1)
|
||||
@ -453,6 +622,8 @@ bool BattleExchangeEvaluator::checkPositionBlocksOurStacks(HypotheticBattle & hb
|
||||
{
|
||||
int blockingScore = 0;
|
||||
|
||||
auto activeUnitDamage = activeUnit->getMinDamage(hb.battleCanShoot(activeUnit)) * activeUnit->getCount();
|
||||
|
||||
for(int turn = 0; turn < turnOrder.size(); turn++)
|
||||
{
|
||||
auto & turnQueue = turnOrder[turn];
|
||||
@ -466,6 +637,11 @@ bool BattleExchangeEvaluator::checkPositionBlocksOurStacks(HypotheticBattle & hb
|
||||
if(unit->unitId() == unitToUpdate->unitId() || cb->battleMatchOwner(unit, activeUnit, false))
|
||||
continue;
|
||||
|
||||
auto blockedUnitDamage = unit->getMinDamage(hb.battleCanShoot(unit)) * unit->getCount();
|
||||
|
||||
if(blockedUnitDamage < activeUnitDamage)
|
||||
continue;
|
||||
|
||||
auto unitReachability = turnBattle.getReachability(unit);
|
||||
|
||||
for(BattleHex hex = BattleHex::TOP_LEFT; hex.isValid(); hex = hex + 1)
|
||||
@ -498,7 +674,9 @@ bool BattleExchangeEvaluator::checkPositionBlocksOurStacks(HypotheticBattle & hb
|
||||
}
|
||||
}
|
||||
|
||||
#if BATTLE_TRACE_LEVEL==1
|
||||
logAi->trace("Position %d, blocking score %d", position.hex, blockingScore);
|
||||
#endif
|
||||
|
||||
return blockingScore > 50;
|
||||
}
|
||||
|
||||
@ -20,10 +20,30 @@ struct AttackerValue
|
||||
bool isRetalitated;
|
||||
BattleHex position;
|
||||
|
||||
AttackerValue()
|
||||
AttackerValue();
|
||||
};
|
||||
|
||||
struct MoveTarget
|
||||
{
|
||||
int64_t score;
|
||||
std::vector<BattleHex> positions;
|
||||
|
||||
MoveTarget();
|
||||
};
|
||||
|
||||
struct EvaluationResult
|
||||
{
|
||||
static const int64_t INEFFECTIVE_SCORE = -1000000;
|
||||
|
||||
AttackPossibility bestAttack;
|
||||
MoveTarget bestMove;
|
||||
bool wait;
|
||||
int64_t score;
|
||||
bool defend;
|
||||
|
||||
EvaluationResult(const AttackPossibility & ap)
|
||||
:wait(false), score(0), bestAttack(ap), defend(false)
|
||||
{
|
||||
value = 0;
|
||||
isRetalitated = false;
|
||||
}
|
||||
};
|
||||
|
||||
@ -55,27 +75,6 @@ public:
|
||||
private:
|
||||
int64_t dpsScore;
|
||||
std::map<uint32_t, AttackerValue> attackerValue;
|
||||
|
||||
int64_t calculateDpsReduce(
|
||||
const battle::Unit * attacker,
|
||||
const battle::Unit * defender,
|
||||
uint64_t damageDealt,
|
||||
std::shared_ptr<CBattleInfoCallback> cb) const;
|
||||
};
|
||||
|
||||
struct EvaluationResult
|
||||
{
|
||||
static const int64_t INEFFECTIVE_SCORE = -1000000;
|
||||
|
||||
AttackPossibility bestAttack;
|
||||
bool wait;
|
||||
int64_t score;
|
||||
bool defend;
|
||||
|
||||
EvaluationResult(AttackPossibility & ap)
|
||||
:wait(false), score(0), bestAttack(ap), defend(false)
|
||||
{
|
||||
}
|
||||
};
|
||||
|
||||
class BattleExchangeEvaluator
|
||||
@ -93,8 +92,10 @@ public:
|
||||
}
|
||||
|
||||
EvaluationResult findBestTarget(const battle::Unit * activeStack, PotentialTargets & targets, HypotheticBattle & hb);
|
||||
int64_t calculateExchange(const AttackPossibility & ap);
|
||||
int64_t calculateExchange(const AttackPossibility & ap, PotentialTargets & targets, HypotheticBattle & hb);
|
||||
void updateReachabilityMap(HypotheticBattle & hb);
|
||||
std::vector<const battle::Unit *> getExchangeUnits(const AttackPossibility & ap);
|
||||
std::vector<const battle::Unit *> getExchangeUnits(const AttackPossibility & ap, PotentialTargets & targets, HypotheticBattle & hb);
|
||||
bool checkPositionBlocksOurStacks(HypotheticBattle & hb, const battle::Unit * unit, BattleHex position);
|
||||
MoveTarget findMoveTowardsUnreachable(const battle::Unit * activeStack, PotentialTargets & targets, HypotheticBattle & hb);
|
||||
std::vector<const battle::Unit *> getAdjacentUnits(const battle::Unit * unit);
|
||||
};
|
||||
@ -13,9 +13,7 @@
|
||||
|
||||
PotentialTargets::PotentialTargets(const battle::Unit * attacker, const HypotheticBattle * state)
|
||||
{
|
||||
auto attIter = state->stackStates.find(attacker->unitId());
|
||||
const battle::Unit * attackerInfo = (attIter == state->stackStates.end()) ? attacker : attIter->second.get();
|
||||
|
||||
auto attackerInfo = state->battleGetUnitByID(attacker->unitId());
|
||||
auto reachability = state->getReachability(attackerInfo);
|
||||
auto avHexes = state->battleGetAvailableHexes(reachability, attackerInfo);
|
||||
|
||||
@ -112,10 +110,10 @@ int64_t PotentialTargets::bestActionValue() const
|
||||
return bestAction().attackValue();
|
||||
}
|
||||
|
||||
AttackPossibility PotentialTargets::bestAction() const
|
||||
const 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 possibleAttacks.at(0);
|
||||
//return *vstd::maxElementByFun(possibleAttacks, [](const AttackPossibility &ap) { return ap.attackValue(); } );
|
||||
}
|
||||
|
||||
@ -19,6 +19,6 @@ public:
|
||||
PotentialTargets(){};
|
||||
PotentialTargets(const battle::Unit * attacker, const HypotheticBattle * state);
|
||||
|
||||
AttackPossibility bestAction() const;
|
||||
const AttackPossibility & bestAction() const;
|
||||
int64_t bestActionValue() const;
|
||||
};
|
||||
|
||||
@ -27,7 +27,9 @@
|
||||
namespace NKAI
|
||||
{
|
||||
|
||||
// our to enemy strength ratio constants
|
||||
const float SAFE_ATTACK_CONSTANT = 1.2;
|
||||
const float RETREAT_THRESHOLD = 0.3;
|
||||
|
||||
//one thread may be turn of AI and another will be handling a side effect for AI2
|
||||
boost::thread_specific_ptr<CCallback> cb;
|
||||
@ -202,6 +204,9 @@ void AIGateway::gameOver(PlayerColor player, const EVictoryLossCheckResult & vic
|
||||
logAi->debug("AIGateway: Player %d (%s) lost. It's me. What a disappointment! :(", player, player.getStr());
|
||||
}
|
||||
|
||||
// some whitespace to flush stream
|
||||
logAi->debug(std::string(200, ' '));
|
||||
|
||||
finish();
|
||||
}
|
||||
}
|
||||
@ -498,7 +503,7 @@ boost::optional<BattleAction> AIGateway::makeSurrenderRetreatDecision(
|
||||
double fightRatio = battleState.getOurStrength() / (double)battleState.getEnemyStrength();
|
||||
|
||||
// if we have no towns - things are already bad, so retreat is not an option.
|
||||
if(cb->getTownsInfo().size() && fightRatio < 0.3 && battleState.canFlee)
|
||||
if(cb->getTownsInfo().size() && fightRatio < RETREAT_THRESHOLD && battleState.canFlee)
|
||||
{
|
||||
return BattleAction::makeRetreat(battleState.ourSide);
|
||||
}
|
||||
|
||||
@ -70,7 +70,12 @@ int ReachabilityInfo::distToNearestNeighbour(
|
||||
const battle::Unit * defender,
|
||||
BattleHex * chosenHex) const
|
||||
{
|
||||
auto attackableHexes = defender->getAttackableHexes(attacker);
|
||||
auto attackableHexes = defender->getHexes();
|
||||
|
||||
if(attacker->doubleWide())
|
||||
{
|
||||
vstd::concatenate(attackableHexes, battle::Unit::getHexes(defender->occupiedHex(), true, attacker->unitSide()));
|
||||
}
|
||||
|
||||
return distToNearestNeighbour(attackableHexes, chosenHex);
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue
Block a user