1
0
mirror of https://github.com/vcmi/vcmi.git synced 2024-12-16 10:19:47 +02:00
vcmi/AI/StupidAI/StupidAI.cpp

334 lines
9.8 KiB
C++
Raw Normal View History

/*
* StupidAI.cpp, part of VCMI engine
*
* Authors: listed in file AUTHORS in main folder
*
* License: GNU General Public License v2.0 or later
* Full text of license available in license.txt file, in main folder
*
*/
#include "StdInc.h"
#include "../../lib/AI_Base.h"
#include "StupidAI.h"
#include "../../lib/CStack.h"
#include "../../CCallback.h"
#include "../../lib/CCreatureHandler.h"
2023-08-17 18:18:14 +02:00
#include "../../lib/battle/BattleAction.h"
2023-08-28 17:59:12 +02:00
#include "../../lib/battle/BattleInfo.h"
static std::shared_ptr<CBattleCallback> cbc;
CStupidAI::CStupidAI()
: side(-1)
2023-07-24 22:01:18 +02:00
, wasWaitingForRealize(false)
, wasUnlockingGs(false)
{
2010-12-25 03:43:40 +02:00
print("created");
}
CStupidAI::~CStupidAI()
{
2010-12-25 03:43:40 +02:00
print("destroyed");
2023-07-24 22:01:18 +02:00
if(cb)
{
//Restore previous state of CB - it may be shared with the main AI (like VCAI)
cb->waitTillRealize = wasWaitingForRealize;
cb->unlockGsWhenWaiting = wasUnlockingGs;
}
}
void CStupidAI::initBattleInterface(std::shared_ptr<Environment> ENV, std::shared_ptr<CBattleCallback> CB)
{
2010-12-25 03:43:40 +02:00
print("init called, saving ptr to IBattleCallback");
env = ENV;
cbc = cb = CB;
2023-07-24 22:01:18 +02:00
wasWaitingForRealize = CB->waitTillRealize;
wasUnlockingGs = CB->unlockGsWhenWaiting;
CB->waitTillRealize = false;
CB->unlockGsWhenWaiting = false;
}
2023-08-20 13:53:25 +02:00
void CStupidAI::initBattleInterface(std::shared_ptr<Environment> ENV, std::shared_ptr<CBattleCallback> CB, AutocombatPreferences autocombatPreferences)
{
initBattleInterface(ENV, CB);
}
2023-08-28 17:59:12 +02:00
void CStupidAI::actionFinished(const BattleID & battleID, const BattleAction &action)
{
2010-12-25 03:43:40 +02:00
print("actionFinished called");
}
2023-08-28 17:59:12 +02:00
void CStupidAI::actionStarted(const BattleID & battleID, const BattleAction &action)
{
2010-12-25 03:43:40 +02:00
print("actionStarted called");
}
class EnemyInfo
{
public:
const CStack * s;
int adi, adr;
std::vector<BattleHex> attackFrom; //for melee fight
2016-12-12 20:13:43 +02:00
EnemyInfo(const CStack * _s) : s(_s), adi(0), adr(0)
{}
2023-08-28 17:59:12 +02:00
void calcDmg(const BattleID & battleID, const CStack * ourStack)
{
// FIXME: provide distance info for Jousting bonus
DamageEstimation retal;
2023-08-28 17:59:12 +02:00
DamageEstimation dmg = cbc->getBattle(battleID)->battleEstimateDamage(ourStack, s, 0, &retal);
adi = static_cast<int>((dmg.damage.min + dmg.damage.max) / 2);
adr = static_cast<int>((retal.damage.min + retal.damage.max) / 2);
}
bool operator==(const EnemyInfo& ei) const
{
return s == ei.s;
}
};
bool isMoreProfitable(const EnemyInfo &ei1, const EnemyInfo& ei2)
{
return (ei1.adi-ei1.adr) < (ei2.adi - ei2.adr);
}
2023-08-28 17:59:12 +02:00
static bool willSecondHexBlockMoreEnemyShooters(const BattleID & battleID, const BattleHex &h1, const BattleHex &h2)
{
int shooters[2] = {0}; //count of shooters on hexes
for(int i = 0; i < 2; i++)
{
for (auto & neighbour : (i ? h2 : h1).neighbouringTiles())
2023-08-28 17:59:12 +02:00
if(const auto * s = cbc->getBattle(battleID)->battleGetUnitByPos(neighbour))
if(s->isShooter())
shooters[i]++;
}
return shooters[0] < shooters[1];
}
2023-08-28 17:59:12 +02:00
void CStupidAI::yourTacticPhase(const BattleID & battleID, int distance)
2023-07-18 20:43:53 +02:00
{
2023-08-28 17:59:12 +02:00
cb->battleMakeTacticAction(battleID, BattleAction::makeEndOFTacticPhase(cb->getBattle(battleID)->battleGetTacticsSide()));
2023-07-18 20:43:53 +02:00
}
2023-08-28 17:59:12 +02:00
void CStupidAI::activeStack(const BattleID & battleID, const CStack * stack)
{
//boost::this_thread::sleep_for(boost::chrono::seconds(2));
print("activeStack called for " + stack->nodeName());
2023-08-28 17:59:12 +02:00
ReachabilityInfo dists = cb->getBattle(battleID)->getReachability(stack);
std::vector<EnemyInfo> enemiesShootable, enemiesReachable, enemiesUnreachable;
if(stack->creatureId() == CreatureID::CATAPULT)
{
BattleAction attack;
static const std::vector<int> wallHexes = {50, 183, 182, 130, 78, 29, 12, 95};
Spells configuration version 2 (effect-based) * Indirect spell effects loading * Json serializer improvements * spell->canBeCastAt do not allow useless cast for any spell * Added proxy caster class for spell-created obstacles * Handle damage from spell-created obstacles inside mechanics * Experimental GameState integration/regression tests * Ignore mod settings and load only "vcmi" mod when running tests * fixed https://bugs.vcmi.eu/view.php?id=2765 (with tests) * Huge improvements of BattleAI regarding spell casts * AI can cast almost any combat spell except TELEPORT, SACRIFICE and obstacle placement spells. * Possible fix for https://bugs.vcmi.eu/view.php?id=1811 * CStack factored out to several classes * [Battle] Allowed RETURN_AFTER_STRIKE effect on server side to be optional * [Battle] Allowed BattleAction have multiple destinations * [Spells] Converted limit|immunity to target condition * [Spells] Use partial configuration reload for backward compatibility handling * [Tests] Started tests for CUnitState * Partial fixes of fire shield effect * [Battle] Do HP calculations in 64 bits * [BattleAI] Use threading for spell cast evaluation * [BattleAI] Made AI be able to evaluate modified turn order (on hypothetical battle state) * Implemented https://bugs.vcmi.eu/view.php?id=2811 * plug rare freeze when hypnotized unit shots vertically * Correctly apply ONLY_MELEE_FIGHT / ONLY_DISTANCE_FIGHT for unit damage, attack & defense * [BattleAI] Try to not waste a cast if battle is actually won already * Extended JsonSerializeFormat API * fixed https://bugs.vcmi.eu/view.php?id=2847 * Any unit effect can be now chained (not only damage like Chain Lightning) ** only damage effect for now actually uses "chainFactor" * Possible quick fix for https://bugs.vcmi.eu/view.php?id=2860
2017-07-20 06:08:49 +02:00
auto seletectedHex = *RandomGeneratorUtil::nextItem(wallHexes, CRandomGenerator::getDefault());
attack.aimToHex(seletectedHex);
attack.actionType = EActionType::CATAPULT;
attack.side = side;
attack.stackNumber = stack->unitId();
2023-08-28 17:59:12 +02:00
cb->battleMakeUnitAction(battleID, attack);
return;
}
else if(stack->hasBonusOfType(BonusType::SIEGE_WEAPON))
{
2023-08-28 17:59:12 +02:00
cb->battleMakeUnitAction(battleID, BattleAction::makeDefend(stack));
return;
}
2023-08-28 17:59:12 +02:00
for (const CStack *s : cb->getBattle(battleID)->battleGetStacks(CBattleInfoEssentials::ONLY_ENEMY))
{
2023-08-28 17:59:12 +02:00
if(cb->getBattle(battleID)->battleCanShoot(stack, s->getPosition()))
{
enemiesShootable.push_back(s);
}
else
{
2023-08-28 17:59:12 +02:00
std::vector<BattleHex> avHexes = cb->getBattle(battleID)->battleGetAvailableHexes(stack, false);
for (BattleHex hex : avHexes)
{
if(CStack::isMeleeAttackPossible(stack, s, hex))
{
std::vector<EnemyInfo>::iterator i = std::find(enemiesReachable.begin(), enemiesReachable.end(), s);
if(i == enemiesReachable.end())
{
enemiesReachable.push_back(s);
i = enemiesReachable.begin() + (enemiesReachable.size() - 1);
}
i->attackFrom.push_back(hex);
}
}
Spells configuration version 2 (effect-based) * Indirect spell effects loading * Json serializer improvements * spell->canBeCastAt do not allow useless cast for any spell * Added proxy caster class for spell-created obstacles * Handle damage from spell-created obstacles inside mechanics * Experimental GameState integration/regression tests * Ignore mod settings and load only "vcmi" mod when running tests * fixed https://bugs.vcmi.eu/view.php?id=2765 (with tests) * Huge improvements of BattleAI regarding spell casts * AI can cast almost any combat spell except TELEPORT, SACRIFICE and obstacle placement spells. * Possible fix for https://bugs.vcmi.eu/view.php?id=1811 * CStack factored out to several classes * [Battle] Allowed RETURN_AFTER_STRIKE effect on server side to be optional * [Battle] Allowed BattleAction have multiple destinations * [Spells] Converted limit|immunity to target condition * [Spells] Use partial configuration reload for backward compatibility handling * [Tests] Started tests for CUnitState * Partial fixes of fire shield effect * [Battle] Do HP calculations in 64 bits * [BattleAI] Use threading for spell cast evaluation * [BattleAI] Made AI be able to evaluate modified turn order (on hypothetical battle state) * Implemented https://bugs.vcmi.eu/view.php?id=2811 * plug rare freeze when hypnotized unit shots vertically * Correctly apply ONLY_MELEE_FIGHT / ONLY_DISTANCE_FIGHT for unit damage, attack & defense * [BattleAI] Try to not waste a cast if battle is actually won already * Extended JsonSerializeFormat API * fixed https://bugs.vcmi.eu/view.php?id=2847 * Any unit effect can be now chained (not only damage like Chain Lightning) ** only damage effect for now actually uses "chainFactor" * Possible quick fix for https://bugs.vcmi.eu/view.php?id=2860
2017-07-20 06:08:49 +02:00
if(!vstd::contains(enemiesReachable, s) && s->getPosition().isValid())
enemiesUnreachable.push_back(s);
}
}
for ( auto & enemy : enemiesReachable )
2023-08-28 17:59:12 +02:00
enemy.calcDmg(battleID, stack);
for ( auto & enemy : enemiesShootable )
2023-08-28 17:59:12 +02:00
enemy.calcDmg(battleID, stack);
if(enemiesShootable.size())
2010-12-25 03:43:40 +02:00
{
const EnemyInfo &ei= *std::max_element(enemiesShootable.begin(), enemiesShootable.end(), isMoreProfitable);
2023-08-28 17:59:12 +02:00
cb->battleMakeUnitAction(battleID, BattleAction::makeShotAttack(stack, ei.s));
return;
2010-12-25 03:43:40 +02:00
}
else if(enemiesReachable.size())
{
const EnemyInfo &ei= *std::max_element(enemiesReachable.begin(), enemiesReachable.end(), &isMoreProfitable);
2023-08-28 17:59:12 +02:00
BattleHex targetHex = *std::max_element(ei.attackFrom.begin(), ei.attackFrom.end(), [&](auto a, auto b) { return willSecondHexBlockMoreEnemyShooters(battleID, a, b);});
cb->battleMakeUnitAction(battleID, BattleAction::makeMeleeAttack(stack, ei.s->getPosition(), targetHex));
return;
}
2012-09-28 19:48:29 +03:00
else if(enemiesUnreachable.size()) //due to #955 - a buggy battle may occur when there are no enemies
{
auto closestEnemy = vstd::minElementByFun(enemiesUnreachable, [&](const EnemyInfo & ei) -> int
{
return dists.distToNearestNeighbour(stack, ei.s);
});
if(dists.distToNearestNeighbour(stack, closestEnemy->s) < GameConstants::BFIELD_SIZE)
{
2023-08-28 17:59:12 +02:00
cb->battleMakeUnitAction(battleID, goTowards(battleID, stack, closestEnemy->s->getAttackableHexes(stack)));
return;
}
}
2023-08-28 17:59:12 +02:00
cb->battleMakeUnitAction(battleID, BattleAction::makeDefend(stack));
return;
2010-12-25 03:43:40 +02:00
}
2023-08-28 17:59:12 +02:00
void CStupidAI::battleAttack(const BattleID & battleID, const BattleAttack *ba)
2010-12-25 03:43:40 +02:00
{
print("battleAttack called");
}
2023-08-28 17:59:12 +02:00
void CStupidAI::battleStacksAttacked(const BattleID & battleID, const std::vector<BattleStackAttacked> & bsa, bool ranged)
2010-12-25 03:43:40 +02:00
{
print("battleStacksAttacked called");
}
2023-08-28 17:59:12 +02:00
void CStupidAI::battleEnd(const BattleID & battleID, const BattleResult *br, QueryID queryID)
2010-12-25 03:43:40 +02:00
{
print("battleEnd called");
}
// void CStupidAI::battleResultsApplied()
// {
// print("battleResultsApplied called");
// }
2010-12-25 03:43:40 +02:00
2023-08-28 17:59:12 +02:00
void CStupidAI::battleNewRoundFirst(const BattleID & battleID, int round)
2010-12-25 03:43:40 +02:00
{
print("battleNewRoundFirst called");
}
2023-08-28 17:59:12 +02:00
void CStupidAI::battleNewRound(const BattleID & battleID, int round)
2010-12-25 03:43:40 +02:00
{
print("battleNewRound called");
}
2023-08-28 17:59:12 +02:00
void CStupidAI::battleStackMoved(const BattleID & battleID, const CStack * stack, std::vector<BattleHex> dest, int distance, bool teleport)
2010-12-25 03:43:40 +02:00
{
print("battleStackMoved called");
2010-12-25 03:43:40 +02:00
}
2023-08-28 17:59:12 +02:00
void CStupidAI::battleSpellCast(const BattleID & battleID, const BattleSpellCast *sc)
2010-12-25 03:43:40 +02:00
{
print("battleSpellCast called");
}
2023-08-28 17:59:12 +02:00
void CStupidAI::battleStacksEffectsSet(const BattleID & battleID, const SetStackEffect & sse)
2010-12-25 03:43:40 +02:00
{
print("battleStacksEffectsSet called");
}
2023-08-28 17:59:12 +02:00
void CStupidAI::battleStart(const BattleID & battleID, const CCreatureSet *army1, const CCreatureSet *army2, int3 tile, const CGHeroInstance *hero1, const CGHeroInstance *hero2, bool Side, bool replayAllowed)
2010-12-25 03:43:40 +02:00
{
print("battleStart called");
side = Side;
}
2023-08-28 17:59:12 +02:00
void CStupidAI::battleCatapultAttacked(const BattleID & battleID, const CatapultAttack & ca)
2010-12-25 03:43:40 +02:00
{
print("battleCatapultAttacked called");
}
void CStupidAI::print(const std::string &text) const
{
2016-08-13 16:44:37 +02:00
logAi->trace("CStupidAI [%p]: %s", this, text);
}
2023-08-28 17:59:12 +02:00
BattleAction CStupidAI::goTowards(const BattleID & battleID, const CStack * stack, std::vector<BattleHex> hexes) const
{
2023-08-28 17:59:12 +02:00
auto reachability = cb->getBattle(battleID)->getReachability(stack);
auto avHexes = cb->getBattle(battleID)->battleGetAvailableHexes(reachability, stack, false);
if(!avHexes.size() || !hexes.size()) //we are blocked or dest is blocked
{
return BattleAction::makeDefend(stack);
}
std::sort(hexes.begin(), hexes.end(), [&](BattleHex h1, BattleHex h2) -> bool
{
return reachability.distances[h1] < reachability.distances[h2];
});
for(auto hex : hexes)
{
if(vstd::contains(avHexes, hex))
return BattleAction::makeMove(stack, hex);
if(stack->coversPos(hex))
{
logAi->warn("Warning: already standing on neighbouring tile!");
//We shouldn't even be here...
return BattleAction::makeDefend(stack);
}
}
BattleHex bestNeighbor = hexes.front();
if(reachability.distances[bestNeighbor] > GameConstants::BFIELD_SIZE)
{
return BattleAction::makeDefend(stack);
}
if(stack->hasBonusOfType(BonusType::FLYING))
{
// Flying stack doesn't go hex by hex, so we can't backtrack using predecessors.
// We just check all available hexes and pick the one closest to the target.
auto nearestAvailableHex = vstd::minElementByFun(avHexes, [&](BattleHex hex) -> int
{
return BattleHex::getDistance(bestNeighbor, hex);
});
return BattleAction::makeMove(stack, *nearestAvailableHex);
}
else
{
BattleHex currentDest = bestNeighbor;
while(1)
{
if(!currentDest.isValid())
{
logAi->error("CBattleAI::goTowards: internal error");
return BattleAction::makeDefend(stack);
}
if(vstd::contains(avHexes, currentDest))
return BattleAction::makeMove(stack, currentDest);
currentDest = reachability.predecessors[currentDest];
}
}
}