vcmi-0.98/ 0000775 0000000 0000000 00000000000 12506717576 0012430 5 ustar 00root root 0000000 0000000 vcmi-0.98/.gitignore 0000664 0000000 0000000 00000000606 12506717576 0014422 0 ustar 00root root 0000000 0000000 /client/vcmiclient
/server/vcmiserver
/launcher/vcmilauncher
/launcher/vcmilauncher_automoc.cpp
*.dll
*.exe
*.depend
*.o
*.a
*.so
*.res
*.layout
*.pro.user
*.pro.user.*
/CMakeLists.txt.user
CMakeCache.txt
CMakeFiles
Makefile
cmake_install.cmake
install_manifest.txt
*_cotire.cmake
cotire
moc_*.cpp
qrc_*.cpp
ui_*.h
/CPackConfig.cmake
/CPackSourceConfig.cmake
build-*
CMakeLists.txt.user.*
vcmi-0.98/.travis.yml 0000664 0000000 0000000 00000003641 12506717576 0014545 0 ustar 00root root 0000000 0000000 language: cpp
before_install:
#new boost
- sudo add-apt-repository --yes ppa:boost-latest/ppa
#new GCC
- sudo add-apt-repository --yes ppa:ubuntu-toolchain-r/test
#new Clang
- sudo add-apt-repository --yes ppa:h-rayflood/llvm
#new SDL2
- sudo add-apt-repository --yes ppa:zoogie/sdl2-snapshots
#new Qt
- sudo add-apt-repository --yes ppa:beineri/opt-qt532
#new FFmpeg
- sudo add-apt-repository --yes ppa:jon-severinsson/ffmpeg
#new CMake
- sudo add-apt-repository --yes ppa:andykimpe/cmake
- sudo apt-get update -qq
- sudo apt-get install -qq $SUPPORT
- sudo apt-get install -qq $PACKAGE
- sudo apt-get install -qq cmake libboost1.55-all-dev zlib1g-dev
- sudo apt-get install -qq libsdl2-dev libsdl2-image-dev libsdl2-mixer-dev libsdl2-ttf-dev
- sudo apt-get install -qq libavformat-dev libswscale-dev
- sudo apt-get install -qq qt53declarative
#setup compiler
- source /opt/qt53/bin/qt53-env.sh
- export CC=${REAL_CC} CXX=${REAL_CXX}
before_script:
- mkdir build
- cd build
- cmake ..
script:
- make
env:
- ignore=this
matrix:
exclude:
- env: ignore=this
include:
- compiler: clang # fails all the time - missing packages?
env: REAL_CC=clang-3.2 REAL_CXX=clang++-3.2 PACKAGE=clang-3.2 SUPPORT=g++-4.8
- compiler: clang
env: REAL_CC=clang-3.3 REAL_CXX=clang++-3.3 PACKAGE=clang-3.3 SUPPORT=g++-4.8
- compiler: clang
env: REAL_CC=clang-3.4 REAL_CXX=clang++-3.4 PACKAGE=clang-3.4 SUPPORT=g++-4.8
#- compiler: gcc # fails due to running out of memory - vcmi need too much of it for successfull compilation
# env: REAL_CC=gcc-4.7 REAL_CXX=g++-4.7 PACKAGE=g++-4.7 SUPPORT=
#- compiler: gcc # same as 4.7
# env: REAL_CC=gcc-4.8 REAL_CXX=g++-4.8 PACKAGE=g++-4.8 SUPPORT=
notifications:
email:
recipients:
- vcmi.fail@mixaill.tk
- saven.ivan@gmail.com
on_success: change
on_failure: always
vcmi-0.98/AI/ 0000775 0000000 0000000 00000000000 12506717576 0012721 5 ustar 00root root 0000000 0000000 vcmi-0.98/AI/BattleAI/ 0000775 0000000 0000000 00000000000 12506717576 0014346 5 ustar 00root root 0000000 0000000 vcmi-0.98/AI/BattleAI/BattleAI.cbp 0000664 0000000 0000000 00000005636 12506717576 0016473 0 ustar 00root root 0000000 0000000
vcmi-0.98/AI/BattleAI/BattleAI.cpp 0000664 0000000 0000000 00000051553 12506717576 0016510 0 ustar 00root root 0000000 0000000 #include "StdInc.h"
#include "../../lib/AI_Base.h"
#include "BattleAI.h"
#include "../../lib/BattleState.h"
#include "../../CCallback.h"
#include "../../lib/CCreatureHandler.h"
#include "../../lib/spells/CSpellHandler.h"
#include "../../lib/VCMI_Lib.h"
using boost::optional;
static shared_ptr cbc;
#define LOGL(text) print(text)
#define LOGFL(text, formattingEl) print(boost::str(boost::format(text) % formattingEl))
struct Priorities
{
double manaValue;
double generalResourceValueModifier;
std::vector resourceTypeBaseValues;
std::function stackEvaluator;
Priorities()
{
manaValue = 0.;
generalResourceValueModifier = 1.;
range::copy(VLC->objh->resVals, std::back_inserter(resourceTypeBaseValues));
stackEvaluator = [](const CStack*){ return 1.0; };
}
};
Priorities *priorities = nullptr;
namespace {
int distToNearestNeighbour(BattleHex hex, const ReachabilityInfo::TDistances& dists, BattleHex *chosenHex = nullptr)
{
int ret = 1000000;
for(BattleHex n : hex.neighbouringTiles())
{
if(dists[n] >= 0 && dists[n] < ret)
{
ret = dists[n];
if(chosenHex)
*chosenHex = n;
}
}
return ret;
}
bool isCloser(const EnemyInfo & ei1, const EnemyInfo & ei2, const ReachabilityInfo::TDistances & dists)
{
return distToNearestNeighbour(ei1.s->position, dists) < distToNearestNeighbour(ei2.s->position, dists);
}
}
template
auto sum(const Container & c, Pred p) -> decltype(p(*std::begin(c)))
{
double ret = 0;
for(const auto &element : c)
{
ret += p(element);
}
return ret;
}
CBattleAI::CBattleAI(void)
: side(-1)
{
print("created");
}
CBattleAI::~CBattleAI(void)
{
print("destroyed");
if(cb)
{
//Restore previous state of CB - it may be shared with the main AI (like VCAI)
cb->waitTillRealize = wasWaitingForRealize;
cb->unlockGsWhenWaiting = wasUnlockingGs;
}
}
void CBattleAI::init(shared_ptr CB)
{
print("init called, saving ptr to IBattleCallback");
cbc = cb = CB;
playerID = *CB->getPlayerID();; //TODO should be sth in callback
wasWaitingForRealize = cb->waitTillRealize;
wasUnlockingGs = CB->unlockGsWhenWaiting;
CB->waitTillRealize = true;
CB->unlockGsWhenWaiting = false;
}
static bool thereRemainsEnemy()
{
return !cbc->battleIsFinished();
}
BattleAction CBattleAI::activeStack( const CStack * stack )
{
LOG_TRACE_PARAMS(logAi, "stack: %s", stack->nodeName()) ;
cbc = cb; //TODO: make solid sure that AIs always use their callbacks (need to take care of event handlers too)
try
{
print("activeStack called for " + stack->nodeName());
if(stack->type->idNumber == CreatureID::CATAPULT)
return useCatapult(stack);
if(stack->hasBonusOfType(Bonus::SIEGE_WEAPON) && stack->hasBonusOfType(Bonus::HEALER))
{
auto healingTargets = cb->battleGetStacks(CBattleInfoEssentials::ONLY_MINE);
std::map woundHpToStack;
for(auto stack : healingTargets)
if(auto woundHp = stack->MaxHealth() - stack->firstHPleft)
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
}
if(cb->battleCanCastSpell())
attemptCastingSpell();
if(!thereRemainsEnemy())
return BattleAction();
if(auto action = considerFleeingOrSurrendering())
return *action;
if(cb->battleGetStacks(CBattleInfoEssentials::ONLY_ENEMY).empty())
{
//We apparently won battle by casting spell, return defend... (accessing cb may cause trouble)
return BattleAction::makeDefend(stack);
}
PotentialTargets targets(stack);
if(targets.possibleAttacks.size())
{
auto hlp = targets.bestAction();
if(hlp.attack.shooting)
return BattleAction::makeShotAttack(stack, hlp.enemy);
else
return BattleAction::makeMeleeAttack(stack, hlp.enemy, hlp.tile);
}
else
{
if(stack->waited())
{
ThreatMap threatsToUs(stack);
auto dists = cbc->battleGetDistances(stack);
const EnemyInfo &ei= *range::min_element(targets.unreachableEnemies, std::bind(isCloser, _1, _2, std::ref(dists)));
if(distToNearestNeighbour(ei.s->position, dists) < GameConstants::BFIELD_SIZE)
{
return goTowards(stack, ei.s->position);
}
}
else
{
return BattleAction::makeWait(stack);
}
}
}
catch(std::exception &e)
{
logAi->errorStream() << "Exception occurred in " << __FUNCTION__ << " " << e.what();
}
return BattleAction::makeDefend(stack);
}
void CBattleAI::actionFinished(const BattleAction &action)
{
print("actionFinished called");
}
void CBattleAI::actionStarted(const BattleAction &action)
{
print("actionStarted called");
}
void CBattleAI::battleAttack(const BattleAttack *ba)
{
print("battleAttack called");
}
void CBattleAI::battleStacksAttacked(const std::vector & bsa)
{
print("battleStacksAttacked called");
}
void CBattleAI::battleEnd(const BattleResult *br)
{
print("battleEnd called");
}
void CBattleAI::battleNewRoundFirst(int round)
{
print("battleNewRoundFirst called");
}
void CBattleAI::battleNewRound(int round)
{
print("battleNewRound called");
}
void CBattleAI::battleStackMoved(const CStack * stack, std::vector dest, int distance)
{
print("battleStackMoved called");;
}
void CBattleAI::battleSpellCast(const BattleSpellCast *sc)
{
print("battleSpellCast called");
}
void CBattleAI::battleStacksEffectsSet(const SetStackEffect & sse)
{
print("battleStacksEffectsSet called");
}
void CBattleAI::battleStart(const CCreatureSet *army1, const CCreatureSet *army2, int3 tile, const CGHeroInstance *hero1, const CGHeroInstance *hero2, bool Side)
{
print("battleStart called");
side = Side;
}
void CBattleAI::battleStacksHealedRes(const std::vector > & healedStacks, bool lifeDrain, bool tentHeal, si32 lifeDrainFrom)
{
print("battleStacksHealedRes called");
}
void CBattleAI::battleNewStackAppeared(const CStack * stack)
{
print("battleNewStackAppeared called");
}
void CBattleAI::battleObstaclesRemoved(const std::set & removedObstacles)
{
print("battleObstaclesRemoved called");
}
void CBattleAI::battleCatapultAttacked(const CatapultAttack & ca)
{
print("battleCatapultAttacked called");
}
void CBattleAI::battleStacksRemoved(const BattleStacksRemoved & bsr)
{
print("battleStacksRemoved called");
}
void CBattleAI::print(const std::string &text) const
{
logAi->traceStream() << "CBattleAI [" << this <<"]: " << text;
}
BattleAction CBattleAI::goTowards(const CStack * stack, BattleHex destination)
{
assert(destination.isValid());
auto avHexes = cb->battleGetAvailableHexes(stack, false);
auto reachability = cb->getReachability(stack);
if(vstd::contains(avHexes, destination))
return BattleAction::makeMove(stack, destination);
auto destNeighbours = destination.neighbouringTiles();
if(vstd::contains_if(destNeighbours, [&](BattleHex n) { return stack->coversPos(destination); }))
{
logAi->warnStream() << "Warning: already standing on neighbouring tile!";
//We shouldn't even be here...
return BattleAction::makeDefend(stack);
}
vstd::erase_if(destNeighbours, [&](BattleHex hex){ return !reachability.accessibility.accessible(hex, stack); });
if(!avHexes.size() || !destNeighbours.size()) //we are blocked or dest is blocked
{
print("goTowards: Stack cannot move! That's " + stack->nodeName());
return BattleAction::makeDefend(stack);
}
if(stack->hasBonusOfType(Bonus::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 distToDestNeighbour = [&](BattleHex hex) -> int
{
auto nearestNeighbourToHex = vstd::minElementByFun(destNeighbours, [&](BattleHex a)
{
return BattleHex::getDistance(a, hex);
});
return BattleHex::getDistance(*nearestNeighbourToHex, hex);
};
auto nearestAvailableHex = vstd::minElementByFun(avHexes, distToDestNeighbour);
return BattleAction::makeMove(stack, *nearestAvailableHex);
}
else
{
BattleHex bestNeighbor = destination;
if(distToNearestNeighbour(destination, reachability.distances, &bestNeighbor) > GameConstants::BFIELD_SIZE)
{
print("goTowards: Cannot reach");
return BattleAction::makeDefend(stack);
}
BattleHex currentDest = bestNeighbor;
while(1)
{
assert(currentDest.isValid());
if(vstd::contains(avHexes, currentDest))
return BattleAction::makeMove(stack, currentDest);
currentDest = reachability.predecessors[currentDest];
}
}
}
BattleAction CBattleAI::useCatapult(const CStack * stack)
{
throw std::runtime_error("The method or operation is not implemented.");
}
enum SpellTypes
{
OFFENSIVE_SPELL, TIMED_EFFECT, OTHER
};
SpellTypes spellType(const CSpell *spell)
{
if (spell->isOffensiveSpell())
return OFFENSIVE_SPELL;
if (spell->hasEffects())
return TIMED_EFFECT;
return OTHER;
}
struct PossibleSpellcast
{
const CSpell *spell;
BattleHex dest;
};
struct CurrentOffensivePotential
{
std::map ourAttacks;
std::map enemyAttacks;
CurrentOffensivePotential(ui8 side)
{
for(auto stack : cbc->battleGetStacks())
{
if(stack->attackerOwned == !side)
ourAttacks[stack] = PotentialTargets(stack);
else
enemyAttacks[stack] = PotentialTargets(stack);
}
}
int potentialValue()
{
int ourPotential = 0, enemyPotential = 0;
for(auto &p : ourAttacks)
ourPotential += p.second.bestAction().attackValue();
for(auto &p : enemyAttacks)
enemyPotential += p.second.bestAction().attackValue();
return ourPotential - enemyPotential;
}
};
//
// //set has its own order, so remove_if won't work. TODO - reuse for map
// template
// void erase_if(std::set &setContainer, Predicate pred)
// {
// auto itr = setContainer.begin();
// auto endItr = setContainer.end();
// while(itr != endItr)
// {
// auto tmpItr = itr++;
// if(pred(*tmpItr))
// setContainer.erase(tmpItr);
// }
// }
void CBattleAI::attemptCastingSpell()
{
LOGL("Casting spells sounds like fun. Let's see...");
auto hero = cb->battleGetMyHero();
//auto known = cb->battleGetFightingHero(side);
//Get all spells we can cast
std::vector possibleSpells;
vstd::copy_if(VLC->spellh->objects, std::back_inserter(possibleSpells), [this] (const CSpell *s) -> bool
{
auto problem = cbc->battleCanCastThisSpell(s);
return problem == ESpellCastProblem::OK;
});
LOGFL("I can cast %d spells.", possibleSpells.size());
vstd::erase_if(possibleSpells, [](const CSpell *s)
{return spellType(s) == OTHER; });
LOGFL("I know about workings of %d of them.", possibleSpells.size());
//Get possible spell-target pairs
std::vector possibleCasts;
for(auto spell : possibleSpells)
{
for(auto hex : getTargetsToConsider(spell))
{
PossibleSpellcast ps = {spell, hex};
possibleCasts.push_back(ps);
}
}
LOGFL("Found %d spell-target combinations.", possibleCasts.size());
if(possibleCasts.empty())
return;
std::map valueOfStack;
for(auto stack : cb->battleGetStacks())
{
PotentialTargets pt(stack);
valueOfStack[stack] = pt.bestActionValue();
}
auto evaluateSpellcast = [&] (const PossibleSpellcast &ps) -> int
{
const int skillLevel = hero->getSpellSchoolLevel(ps.spell);
const int spellPower = hero->getPrimSkillLevel(PrimarySkill::SPELL_POWER);
switch(spellType(ps.spell))
{
case OFFENSIVE_SPELL:
{
int damageDealt = 0, damageReceived = 0;
auto stacksSuffering = ps.spell->getAffectedStacks(cb.get(), ECastingMode::HERO_CASTING, playerID, skillLevel, ps.dest, hero);
if(stacksSuffering.empty())
return -1;
for(auto stack : stacksSuffering)
{
const int dmg = ps.spell->calculateDamage(hero, stack, skillLevel, spellPower);
if(stack->owner == playerID)
damageReceived += dmg;
else
damageDealt += dmg;
}
const int damageDiff = damageDealt - damageReceived;
LOGFL("Casting %s on hex %d would deal %d damage points among %d stacks.",
ps.spell->name % ps.dest % damageDiff % stacksSuffering.size());
//TODO tactic effect too
return damageDiff;
}
case TIMED_EFFECT:
{
StackWithBonuses swb;
swb.stack = cb->battleGetStackByPos(ps.dest);
if(!swb.stack)
return -1;
Bonus pseudoBonus;
pseudoBonus.sid = ps.spell->id;
pseudoBonus.val = skillLevel;
pseudoBonus.turnsRemain = 1; //TODO
CStack::stackEffectToFeature(swb.bonusesToAdd, pseudoBonus);
HypotheticChangesToBattleState state;
state.bonusesOfStacks[swb.stack] = &swb;
PotentialTargets pt(swb.stack, state);
auto newValue = pt.bestActionValue();
auto oldValue = valueOfStack[swb.stack];
auto gain = newValue - oldValue;
if(swb.stack->owner != playerID) //enemy
gain = -gain;
LOGFL("Casting %s on %s would improve the stack by %d points (from %d to %d)",
ps.spell->name % swb.stack->nodeName() % gain % (oldValue) % (newValue));
return gain;
}
default:
assert(0);
return 0;
}
};
auto castToPerform = *vstd::maxElementByFun(possibleCasts, evaluateSpellcast);
LOGFL("Best spell is %s. Will cast.", castToPerform.spell->name);
BattleAction spellcast;
spellcast.actionType = Battle::HERO_SPELL;
spellcast.additionalInfo = castToPerform.spell->id;
spellcast.destinationTile = castToPerform.dest;
spellcast.side = side;
spellcast.stackNumber = (!side) ? -1 : -2;
cb->battleMakeAction(&spellcast);
}
std::vector CBattleAI::getTargetsToConsider( const CSpell *spell ) const
{
if(spell->getTargetType() == CSpell::NO_TARGET)
{
//Spell can be casted anywhere, all hexes are potentially considerable.
std::vector ret;
for(int i = 0; i < GameConstants::BFIELD_SIZE; i++)
if(BattleHex(i).isAvailable())
ret.push_back(i);
return ret;
}
else
{
//TODO when massive effect -> doesn't matter where cast
return cbc->battleGetPossibleTargets(playerID, spell);
}
}
boost::optional CBattleAI::considerFleeingOrSurrendering()
{
if(cb->battleCanSurrender(playerID))
{
}
if(cb->battleCanFlee())
{
}
return boost::none;
}
ThreatMap::ThreatMap(const CStack *Endangered) : endangered(Endangered)
{
sufferedDamage.fill(0);
for(const CStack *enemy : cbc->battleGetStacks())
{
//Consider only stacks of different owner
if(enemy->attackerOwned == endangered->attackerOwned)
continue;
//Look-up which tiles can be melee-attacked
std::array meleeAttackable;
meleeAttackable.fill(false);
auto enemyReachability = cbc->getReachability(enemy);
for(int i = 0; i < GameConstants::BFIELD_SIZE; i++)
{
if(enemyReachability.isReachable(i))
{
meleeAttackable[i] = true;
for(auto n : BattleHex(i).neighbouringTiles())
meleeAttackable[n] = true;
}
}
//Gather possible assaults
for(int i = 0; i < GameConstants::BFIELD_SIZE; i++)
{
if(cbc->battleCanShoot(enemy, i))
threatMap[i].push_back(BattleAttackInfo(enemy, endangered, true));
else if(meleeAttackable[i])
{
BattleAttackInfo bai(enemy, endangered, false);
bai.chargedFields = std::max(BattleHex::getDistance(enemy->position, i) - 1, 0); //TODO check real distance (BFS), not just metric
threatMap[i].push_back(BattleAttackInfo(bai));
}
}
}
for(int i = 0; i < GameConstants::BFIELD_SIZE; i++)
{
sufferedDamage[i] = sum(threatMap[i], [](const BattleAttackInfo &bai) -> int
{
auto dmg = cbc->calculateDmgRange(bai);
return (dmg.first + dmg.second)/2;
});
}
}
const TBonusListPtr StackWithBonuses::getAllBonuses(const CSelector &selector, const CSelector &limit, const CBonusSystemNode *root /*= nullptr*/, const std::string &cachingStr /*= ""*/) const
{
TBonusListPtr ret = make_shared();
const TBonusListPtr originalList = stack->getAllBonuses(selector, limit, root, cachingStr);
range::copy(*originalList, std::back_inserter(*ret));
for(auto &bonus : bonusesToAdd)
{
if(selector(&bonus) && (!limit || !limit(&bonus)))
ret->push_back(&bonus);
}
//TODO limiters?
return ret;
}
int AttackPossibility::damageDiff() const
{
if (!priorities)
priorities = new Priorities;
const auto dealtDmgValue = priorities->stackEvaluator(enemy) * damageDealt;
const auto receivedDmgValue = priorities->stackEvaluator(attack.attacker) * damageReceived;
return dealtDmgValue - receivedDmgValue;
}
int AttackPossibility::attackValue() const
{
return damageDiff() + tacticImpact;
}
AttackPossibility AttackPossibility::evaluate(const BattleAttackInfo &AttackInfo, const HypotheticChangesToBattleState &state, BattleHex hex)
{
auto attacker = AttackInfo.attacker;
auto enemy = AttackInfo.defender;
const int remainingCounterAttacks = getValOr(state.counterAttacksLeft, enemy, enemy->counterAttacks);
const bool counterAttacksBlocked = attacker->hasBonusOfType(Bonus::BLOCKS_RETALIATION) || enemy->hasBonusOfType(Bonus::NO_RETALIATION);
const int totalAttacks = 1 + AttackInfo.attackerBonuses->getBonuses(Selector::type(Bonus::ADDITIONAL_ATTACK), (Selector::effectRange (Bonus::NO_LIMIT).Or(Selector::effectRange(Bonus::ONLY_MELEE_FIGHT))))->totalValue();
AttackPossibility ap = {enemy, hex, AttackInfo, 0, 0, 0};
auto curBai = AttackInfo; //we'll modify here the stack counts
for(int i = 0; i < totalAttacks; i++)
{
std::pair retaliation(0,0);
auto attackDmg = cbc->battleEstimateDamage(curBai, &retaliation);
ap.damageDealt = (attackDmg.first + attackDmg.second) / 2;
ap.damageReceived = (retaliation.first + retaliation.second) / 2;
if(remainingCounterAttacks <= i || counterAttacksBlocked)
ap.damageReceived = 0;
curBai.attackerCount = attacker->count - attacker->countKilledByAttack(ap.damageReceived).first;
curBai.defenderCount = enemy->count - enemy->countKilledByAttack(ap.damageDealt).first;
if(!curBai.attackerCount)
break;
//TODO what about defender? should we break? but in pessimistic scenario defender might be alive
}
//TODO other damage related to attack (eg. fire shield and other abilities)
//Limit damages by total stack health
vstd::amin(ap.damageDealt, enemy->count * enemy->MaxHealth() - (enemy->MaxHealth() - enemy->firstHPleft));
vstd::amin(ap.damageReceived, attacker->count * attacker->MaxHealth() - (attacker->MaxHealth() - attacker->firstHPleft));
return ap;
}
PotentialTargets::PotentialTargets(const CStack *attacker, const HypotheticChangesToBattleState &state /*= HypotheticChangesToBattleState()*/)
{
auto dists = cbc->battleGetDistances(attacker);
auto avHexes = cbc->battleGetAvailableHexes(attacker, false);
for(const CStack *enemy : cbc->battleGetStacks())
{
//Consider only stacks of different owner
if(enemy->attackerOwned == attacker->attackerOwned)
continue;
auto GenerateAttackInfo = [&](bool shooting, BattleHex hex) -> AttackPossibility
{
auto bai = BattleAttackInfo(attacker, enemy, shooting);
bai.attackerBonuses = getValOr(state.bonusesOfStacks, bai.attacker, bai.attacker);
bai.defenderBonuses = getValOr(state.bonusesOfStacks, bai.defender, bai.defender);
if(hex.isValid())
{
assert(dists[hex] <= attacker->Speed());
bai.chargedFields = dists[hex];
}
return AttackPossibility::evaluate(bai, state, hex);
};
if(cbc->battleCanShoot(attacker, enemy->position))
{
possibleAttacks.push_back(GenerateAttackInfo(true, BattleHex::INVALID));
}
else
{
for(BattleHex hex : avHexes)
if(CStack::isMeleeAttackPossible(attacker, enemy, hex))
possibleAttacks.push_back(GenerateAttackInfo(false, hex));
if(!vstd::contains_if(possibleAttacks, [=](const AttackPossibility &pa) { return pa.enemy == enemy; }))
unreachableEnemies.push_back(enemy);
}
}
}
AttackPossibility PotentialTargets::bestAction() const
{
if(possibleAttacks.empty())
throw std::runtime_error("No best action, since we don't have any actions");
return *vstd::maxElementByFun(possibleAttacks, [](const AttackPossibility &ap) { return ap.attackValue(); } );
}
int PotentialTargets::bestActionValue() const
{
if(possibleAttacks.empty())
return 0;
return bestAction().attackValue();
}
void EnemyInfo::calcDmg(const CStack * ourStack)
{
TDmgRange retal, dmg = cbc->battleEstimateDamage(ourStack, s, &retal);
adi = (dmg.first + dmg.second) / 2;
adr = (retal.first + retal.second) / 2;
}
vcmi-0.98/AI/BattleAI/BattleAI.h 0000664 0000000 0000000 00000013460 12506717576 0016150 0 ustar 00root root 0000000 0000000 #pragma once
#include "../../lib/BattleHex.h"
#include "../../lib/HeroBonus.h"
#include "../../lib/CBattleCallback.h"
class CSpell;
class StackWithBonuses : public IBonusBearer
{
public:
const CStack *stack;
mutable std::vector bonusesToAdd;
virtual const TBonusListPtr getAllBonuses(const CSelector &selector, const CSelector &limit, const CBonusSystemNode *root = nullptr, const std::string &cachingStr = "") const override;
};
struct EnemyInfo
{
const CStack * s;
int adi, adr;
std::vector attackFrom; //for melee fight
EnemyInfo(const CStack * _s) : s(_s)
{}
void calcDmg(const CStack * ourStack);
bool operator==(const EnemyInfo& ei) const
{
return s == ei.s;
}
};
//FIXME: unused function
/*
static bool willSecondHexBlockMoreEnemyShooters(const BattleHex &h1, const BattleHex &h2)
{
int shooters[2] = {0}; //count of shooters on hexes
for(int i = 0; i < 2; i++)
BOOST_FOREACH(BattleHex neighbour, (i ? h2 : h1).neighbouringTiles())
if(const CStack *s = cbc->battleGetStackByPos(neighbour))
if(s->getCreature()->isShooting())
shooters[i]++;
return shooters[0] < shooters[1];
}
*/
struct ThreatMap
{
std::array, GameConstants::BFIELD_SIZE> threatMap; // [hexNr] -> enemies able to strike
const CStack *endangered;
std::array sufferedDamage;
ThreatMap(const CStack *Endangered);
};
struct HypotheticChangesToBattleState
{
std::map bonusesOfStacks;
std::map counterAttacksLeft;
};
struct AttackPossibility
{
const CStack *enemy; //redundant (to attack.defender) but looks nice
BattleHex tile; //tile from which we attack
BattleAttackInfo attack;
int damageDealt;
int damageReceived; //usually by counter-attack
int tacticImpact;
int damageDiff() const;
int attackValue() const;
static AttackPossibility evaluate(const BattleAttackInfo &AttackInfo, const HypotheticChangesToBattleState &state, BattleHex hex);
};
template
const Val getValOr(const std::map &Map, const Key &key, const Val2 defaultValue)
{
//returning references here won't work: defaultValue must be converted into Val, creating temporary
auto i = Map.find(key);
if(i != Map.end())
return i->second;
else
return defaultValue;
}
struct PotentialTargets
{
std::vector possibleAttacks;
std::vector unreachableEnemies;
//std::function GenerateAttackInfo; //args: shooting, destHex
PotentialTargets(){};
PotentialTargets(const CStack *attacker, const HypotheticChangesToBattleState &state = HypotheticChangesToBattleState());
AttackPossibility bestAction() const;
int bestActionValue() const;
};
class CBattleAI : public CBattleGameInterface
{
int side;
shared_ptr cb;
//Previous setting of cb
bool wasWaitingForRealize, wasUnlockingGs;
void print(const std::string &text) const;
public:
CBattleAI(void);
~CBattleAI(void);
void init(shared_ptr CB) 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
BattleAction activeStack(const CStack * stack) override; //called when it's turn of that stack
void battleAttack(const BattleAttack *ba) override; //called when stack is performing attack
void battleStacksAttacked(const std::vector & bsa) override; //called when stack receives damage (after battleAttack())
void battleEnd(const BattleResult *br) override;
//void battleResultsApplied() override; //called when all effects of last battle are applied
void battleNewRoundFirst(int round) override; //called at the beginning of each turn before changes are applied;
void battleNewRound(int round) override; //called at the beginning of each turn, round=-1 is the tactic phase, round=0 is the first "normal" turn
void battleStackMoved(const CStack * stack, std::vector dest, int distance) override;
void battleSpellCast(const BattleSpellCast *sc) override;
void battleStacksEffectsSet(const SetStackEffect & sse) override;//called when a specific effect is set to stacks
//void battleTriggerEffect(const BattleTriggerEffect & bte) override;
void battleStart(const CCreatureSet *army1, const CCreatureSet *army2, int3 tile, const CGHeroInstance *hero1, const CGHeroInstance *hero2, bool side) override; //called by engine when battle starts; side=0 - left, side=1 - right
void battleStacksHealedRes(const std::vector > & healedStacks, bool lifeDrain, bool tentHeal, si32 lifeDrainFrom) override; //called when stacks are healed / resurrected first element of pair - stack id, second - healed hp
void battleNewStackAppeared(const CStack * stack) override; //not called at the beginning of a battle or by resurrection; called eg. when elemental is summoned
void battleObstaclesRemoved(const std::set & removedObstacles) override; //called when a certain set of obstacles is removed from batlefield; IDs of them are given
void battleCatapultAttacked(const CatapultAttack & ca) override; //called when catapult makes an attack
void battleStacksRemoved(const BattleStacksRemoved & bsr) override; //called when certain stack is completely removed from battlefield
BattleAction goTowards(const CStack * stack, BattleHex hex );
BattleAction useCatapult(const CStack * stack);
boost::optional considerFleeingOrSurrendering();
void attemptCastingSpell();
std::vector getTargetsToConsider(const CSpell *spell) const;
};
vcmi-0.98/AI/BattleAI/BattleAI.vcxproj 0000664 0000000 0000000 00000017425 12506717576 0017421 0 ustar 00root root 0000000 0000000
Debug
Win32
Debug
x64
RD
Win32
RD
x64
{C0300513-E845-43B4-9A4F-E8817EAEF57C}
BattleAI
DynamicLibrary
true
MultiByte
v120_xp
DynamicLibrary
true
MultiByte
v120_xp
DynamicLibrary
false
true
MultiByte
v120_xp
DynamicLibrary
false
true
MultiByte
v120_xp
$(VCMI_Out)\AI\
$(VCMI_Out)\AI\
..
$(VCMI_Out)\AI\
Use
StdInc.h
/Zm159 %(AdditionalOptions)
VCMI_lib.lib;%(AdditionalDependencies)
..\..\..\libs;..\..;..
Level3
Disabled
Use
StdInc.h
/Zm159 %(AdditionalOptions)
VCMI_lib.lib;%(AdditionalDependencies)
Use
StdInc.h
/Zm159 %(AdditionalOptions)
VCMI_lib.lib;%(AdditionalDependencies)
..\..\..\libs;..\..
Use
StdInc.h
/Zm159 %(AdditionalOptions)
VCMI_lib.lib;%(AdditionalDependencies)
%(PreprocessorDefinitions)
Create
StdInc.h
Create
Create
Create
vcmi-0.98/AI/BattleAI/CMakeLists.txt 0000664 0000000 0000000 00000001073 12506717576 0017107 0 ustar 00root root 0000000 0000000 project(battleAI)
cmake_minimum_required(VERSION 2.6)
include_directories(${Boost_INCLUDE_DIRS} ${CMAKE_HOME_DIRECTORY} ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_HOME_DIRECTORY}/lib)
set(battleAI_SRCS
StdInc.cpp
BattleAI.cpp
main.cpp
)
add_library(BattleAI SHARED ${battleAI_SRCS})
target_link_libraries(BattleAI vcmi)
set_target_properties(BattleAI PROPERTIES ${PCH_PROPERTIES})
cotire(BattleAI)
if (NOT APPLE) # Already inside vcmiclient bundle
install(TARGETS BattleAI RUNTIME DESTINATION ${AI_LIB_DIR} LIBRARY DESTINATION ${AI_LIB_DIR})
endif()
vcmi-0.98/AI/BattleAI/StdInc.cpp 0000664 0000000 0000000 00000000066 12506717576 0016240 0 ustar 00root root 0000000 0000000 // Creates the precompiled header
#include "StdInc.h" vcmi-0.98/AI/BattleAI/StdInc.h 0000664 0000000 0000000 00000000354 12506717576 0015705 0 ustar 00root root 0000000 0000000 #pragma once
#include "../../Global.h"
// This header should be treated as a pre compiled header file(PCH) in the compiler building settings.
// Here you can add specific libraries and macros which are specific to this project. vcmi-0.98/AI/BattleAI/main.cpp 0000664 0000000 0000000 00000001264 12506717576 0016001 0 ustar 00root root 0000000 0000000 #include "StdInc.h"
#include "../../lib/AI_Base.h"
#include "BattleAI.h"
#ifdef __GNUC__
#define strcpy_s(a, b, c) strncpy(a, c, b)
#endif
#ifdef VCMI_ANDROID
#define GetGlobalAiVersion BattleAI_GetGlobalAiVersion
#define GetAiName BattleAI_GetAiName
#define GetNewBattleAI BattleAI_GetNewBattleAI
#endif
static const char *g_cszAiName = "Battle AI";
extern "C" DLL_EXPORT int GetGlobalAiVersion()
{
return AI_INTERFACE_VER;
}
extern "C" DLL_EXPORT void GetAiName(char* name)
{
strcpy_s(name, strlen(g_cszAiName) + 1, g_cszAiName);
}
extern "C" DLL_EXPORT void GetNewBattleAI(shared_ptr &out)
{
out = make_shared();
}
vcmi-0.98/AI/CMakeLists.txt 0000664 0000000 0000000 00000000643 12506717576 0015464 0 ustar 00root root 0000000 0000000 project(AI)
cmake_minimum_required(VERSION 2.8)
find_package(Fuzzylite)
if(NOT MSVC)
add_definitions(-DFL_CPP11)
set(FL_CPP11 ON CACHE BOOL "")
endif()
if (NOT FL_FOUND)
set(FL_BUILD_BINARY OFF CACHE BOOL "")
set(FL_BUILD_SHARED OFF CACHE BOOL "")
add_subdirectory(FuzzyLite/fuzzylite)
endif()
add_subdirectory(BattleAI)
add_subdirectory(StupidAI)
add_subdirectory(EmptyAI)
add_subdirectory(VCAI) vcmi-0.98/AI/EmptyAI/ 0000775 0000000 0000000 00000000000 12506717576 0014231 5 ustar 00root root 0000000 0000000 vcmi-0.98/AI/EmptyAI/CEmptyAI.cpp 0000664 0000000 0000000 00000002422 12506717576 0016350 0 ustar 00root root 0000000 0000000 #include "StdInc.h"
#include "CEmptyAI.h"
#include "../../lib/CRandomGenerator.h"
void CEmptyAI::init(shared_ptr CB)
{
cb = CB;
human=false;
playerID = *cb->getMyColor();
//logAi->infoStream() << "EmptyAI initialized.";
}
void CEmptyAI::yourTurn()
{
cb->endTurn();
}
void CEmptyAI::heroGotLevel(const CGHeroInstance *hero, PrimarySkill::PrimarySkill pskill, std::vector &skills, QueryID queryID)
{
cb->selectionMade(CRandomGenerator::getDefault().nextInt(skills.size() - 1), queryID);
}
void CEmptyAI::commanderGotLevel(const CCommanderInstance * commander, std::vector skills, QueryID queryID)
{
cb->selectionMade(CRandomGenerator::getDefault().nextInt(skills.size() - 1), queryID);
}
void CEmptyAI::showBlockingDialog(const std::string &text, const std::vector &components, QueryID askID, const int soundID, bool selection, bool cancel)
{
cb->selectionMade(0, askID);
}
void CEmptyAI::showTeleportDialog(TeleportChannelID channel, std::vector exits, bool impassable, QueryID askID)
{
cb->selectionMade(0, askID);
}
void CEmptyAI::showGarrisonDialog(const CArmedInstance *up, const CGHeroInstance *down, bool removableUnits, QueryID queryID)
{
cb->selectionMade(0, queryID);
}
vcmi-0.98/AI/EmptyAI/CEmptyAI.h 0000664 0000000 0000000 00000001730 12506717576 0016016 0 ustar 00root root 0000000 0000000 #pragma once
#include "../../lib/AI_Base.h"
#include "../../CCallback.h"
struct HeroMoveDetails;
class CEmptyAI : public CGlobalAI
{
shared_ptr cb;
public:
void init(shared_ptr CB) override;
void yourTurn() override;
void heroGotLevel(const CGHeroInstance *hero, PrimarySkill::PrimarySkill pskill, std::vector &skills, QueryID queryID) override;
void commanderGotLevel (const CCommanderInstance * commander, std::vector skills, QueryID queryID) override;
void showBlockingDialog(const std::string &text, const std::vector &components, QueryID askID, const int soundID, bool selection, bool cancel) override;
void showTeleportDialog(TeleportChannelID channel, std::vector exits, bool impassable, QueryID askID) override;
void showGarrisonDialog(const CArmedInstance *up, const CGHeroInstance *down, bool removableUnits, QueryID queryID) override;
};
#define NAME "EmptyAI 0.1"
vcmi-0.98/AI/EmptyAI/CMakeLists.txt 0000664 0000000 0000000 00000000735 12506717576 0016776 0 ustar 00root root 0000000 0000000 project(emptyAI)
cmake_minimum_required(VERSION 2.6)
include_directories(${Boost_INCLUDE_DIRS} ${CMAKE_HOME_DIRECTORY} ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_HOME_DIRECTORY}/lib)
set(emptyAI_SRCS
CEmptyAI.cpp
exp_funcs.cpp
)
add_library(EmptyAI SHARED ${emptyAI_SRCS})
target_link_libraries(EmptyAI vcmi)
if (NOT APPLE) # Already inside vcmiclient bundle
install(TARGETS EmptyAI RUNTIME DESTINATION ${AI_LIB_DIR} LIBRARY DESTINATION ${AI_LIB_DIR})
endif()
vcmi-0.98/AI/EmptyAI/EmptyAI.cbp 0000664 0000000 0000000 00000005775 12506717576 0016245 0 ustar 00root root 0000000 0000000
vcmi-0.98/AI/EmptyAI/EmptyAI.vcxproj 0000664 0000000 0000000 00000022606 12506717576 0017164 0 ustar 00root root 0000000 0000000
Debug
Win32
Debug
x64
RD
Win32
RD
x64
Create
Create
Create
Create
{C41C4EB6-6F74-4F37-9FB0-9FA6BF377837}
EmptyAI
DynamicLibrary
true
MultiByte
v120_xp
DynamicLibrary
true
MultiByte
v120_xp
DynamicLibrary
false
true
MultiByte
v120_xp
DynamicLibrary
false
true
MultiByte
v120_xp
$(VCMI_Out)\AI\
$(IncludePath)
$(LibraryPath)
$(VCMI_Out)\AI\
..
$(VCMI_Out)\AI\
Level3
Disabled
%(AdditionalIncludeDirectories)
Use
StdInc.h
%(PreprocessorDefinitions)
/Zm130 %(AdditionalOptions)
true
VCMI_lib.lib;%(AdditionalDependencies)
$(OutDir)EmptyAI.dll
..\..\..\libs;..\..
Level3
Disabled
%(AdditionalIncludeDirectories)
Use
StdInc.h
_WINDLL;%(PreprocessorDefinitions)
true
VCMI_lib.lib;%(AdditionalDependencies)
$(OutDir)EmptyAI.dll
Level3
MaxSpeed
true
true
%(AdditionalIncludeDirectories)
Use
StdInc.h
_WINDLL;%(PreprocessorDefinitions)
/Zm130 %(AdditionalOptions)
true
true
true
VCMI_lib.lib;%(AdditionalDependencies)
$(OutDir)EmptyAI.dll
..\..\..\libs;..\..
Level3
MaxSpeed
true
true
%(AdditionalIncludeDirectories)
Use
StdInc.h
_WINDLL;%(PreprocessorDefinitions)
/Zm130 %(AdditionalOptions)
true
true
true
VCMI_lib.lib;%(AdditionalDependencies)
$(OutDir)EmptyAI.dll
vcmi-0.98/AI/EmptyAI/StdInc.cpp 0000664 0000000 0000000 00000000066 12506717576 0016123 0 ustar 00root root 0000000 0000000 // Creates the precompiled header
#include "StdInc.h" vcmi-0.98/AI/EmptyAI/StdInc.h 0000664 0000000 0000000 00000000354 12506717576 0015570 0 ustar 00root root 0000000 0000000 #pragma once
#include "../../Global.h"
// This header should be treated as a pre compiled header file(PCH) in the compiler building settings.
// Here you can add specific libraries and macros which are specific to this project. vcmi-0.98/AI/EmptyAI/exp_funcs.cpp 0000664 0000000 0000000 00000000523 12506717576 0016727 0 ustar 00root root 0000000 0000000 #include "StdInc.h"
#include "CEmptyAI.h"
std::set ais;
extern "C" DLL_EXPORT int GetGlobalAiVersion()
{
return AI_INTERFACE_VER;
}
extern "C" DLL_EXPORT void GetAiName(char* name)
{
strcpy(name,NAME);
}
extern "C" DLL_EXPORT void GetNewAI(shared_ptr &out)
{
out = make_shared();
} vcmi-0.98/AI/GeniusAI.brain 0000664 0000000 0000000 00000012342 12506717576 0015404 0 ustar 00root root 0000000 0000000 o 34 16 17
R
o 34 16 17
R
o 47 16
R
o 101 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 24
R
o 98 16 17
R
o 98 16 17
R
o 100 16
R
o 38 16
R
o 61 16
R
o 53 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
R
o 53 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
R
o 53 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
R
o 53 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
R
o 53 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
R
o 53 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
R
o 53 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
R
o 53 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
R
o 28 16
R
o 81 16
R
o 83 25
R
o 31 16
R
o 57 24
R
o 23 16
R
o 102 16
R
o 37 24
R
o 51 16
R
t 0 0 25
R
t 0 1 25
R
t 0 2 25
R
t 0 3 25
R
t 0 4 25
R
t 0 5 25
R
t 0 6 25
R
t 0 7 25
R
t 0 8 25
R
t 0 9 25
R
t 0 10 25
R
t 0 11 25
R
t 0 12 25
R
t 0 13 25
R
t 0 14 25
R
t 0 15 25
R
t 0 16 25
R
t 0 17 25
R
t 0 18 25
R
t 0 19 25
R
t 0 20 25
R
t 0 21 25
R
t 0 22 25
R
t 0 23 25
R
t 0 30 25
R
t 0 31 25
R
t 0 32 25
R
t 0 33 25
R
t 0 34 25
R
t 0 35 25
R
t 0 36 25
R
t 0 37 25
R
t 0 38 25
R
t 0 39 25
R
t 0 40 25
R
t 0 41 25
R
t 0 42 25
R
t 0 43 25
R
t 1 0 25
R
t 1 1 25
R
t 1 2 25
R
t 1 3 25
R
t 1 4 25
R
t 1 5 25
R
t 1 6 25
R
t 1 7 25
R
t 1 8 25
R
t 1 9 25
R
t 1 10 25
R
t 1 11 25
R
t 1 12 25
R
t 1 13 25
R
t 1 14 25
R
t 1 15 25
R
t 1 16 25
R
t 1 17 25
R
t 1 18 25
R
t 1 19 25
R
t 1 20 25
R
t 1 21 25
R
t 1 22 25
R
t 1 23 25
R
t 1 30 25
R
t 1 31 25
R
t 1 32 25
R
t 1 33 25
R
t 1 34 25
R
t 1 35 25
R
t 1 36 25
R
t 1 37 25
R
t 1 38 25
R
t 1 39 25
R
t 1 40 25
R
t 1 41 25
R
t 1 42 25
R
t 1 43 25
R
t 2 0 25
R
t 2 1 25
R
t 2 2 25
R
t 2 3 25
R
t 2 4 25
R
t 2 5 25
R
t 2 6 25
R
t 2 7 25
R
t 2 8 25
R
t 2 9 25
R
t 2 10 25
R
t 2 11 25
R
t 2 12 25
R
t 2 13 25
R
t 2 14 25
R
t 2 15 25
R
t 2 16 25
R
t 2 17 25
R
t 2 18 25
R
t 2 19 25
R
t 2 20 25
R
t 2 21 25
R
t 2 22 25
R
t 2 23 25
R
t 2 30 25
R
t 2 31 25
R
t 2 32 25
R
t 2 33 25
R
t 2 34 25
R
t 2 35 25
R
t 2 36 25
R
t 2 37 25
R
t 2 38 25
R
t 2 39 25
R
t 2 40 25
R
t 2 41 25
R
t 2 42 25
R
t 2 43 25
R
t 3 0 25
R
t 3 1 25
R
t 3 2 25
R
t 3 3 25
R
t 3 4 25
R
t 3 5 25
R
t 3 6 25
R
t 3 7 25
R
t 3 8 25
R
t 3 9 25
R
t 3 10 25
R
t 3 11 25
R
t 3 12 25
R
t 3 13 25
R
t 3 14 25
R
t 3 15 25
R
t 3 16 25
R
t 3 17 25
R
t 3 18 25
R
t 3 19 25
R
t 3 20 25
R
t 3 21 25
R
t 3 22 25
R
t 3 23 25
R
t 3 30 25
R
t 3 31 25
R
t 3 32 25
R
t 3 33 25
R
t 3 34 25
R
t 3 35 25
R
t 3 36 25
R
t 3 37 25
R
t 3 38 25
R
t 3 39 25
R
t 3 40 25
R
t 3 41 25
R
t 3 42 25
R
t 3 43 25
R
t 4 0 25
R
t 4 1 25
R
t 4 2 25
R
t 4 3 25
R
t 4 4 25
R
t 4 5 25
R
t 4 6 25
R
t 4 7 25
R
t 4 8 25
R
t 4 9 25
R
t 4 10 25
R
t 4 11 25
R
t 4 12 25
R
t 4 13 25
R
t 4 14 25
R
t 4 15 25
R
t 4 16 25
R
t 4 17 25
R
t 4 18 25
R
t 4 19 25
R
t 4 20 25
R
t 4 21 25
R
t 4 22 25
R
t 4 23 25
R
t 4 30 25
R
t 4 31 25
R
t 4 32 25
R
t 4 33 25
R
t 4 34 25
R
t 4 35 25
R
t 4 36 25
R
t 4 37 25
R
t 4 38 25
R
t 4 39 25
R
t 4 40 25
R
t 4 41 25
R
t 4 42 25
R
t 4 43 25
R
t 5 0 25
R
t 5 1 25
R
t 5 2 25
R
t 5 3 25
R
t 5 4 25
R
t 5 5 25
R
t 5 6 25
R
t 5 7 25
R
t 5 8 25
R
t 5 9 25
R
t 5 10 25
R
t 5 11 25
R
t 5 12 25
R
t 5 13 25
R
t 5 14 25
R
t 5 15 25
R
t 5 16 25
R
t 5 17 25
R
t 5 18 25
R
t 5 19 25
R
t 5 20 25
R
t 5 21 25
R
t 5 22 25
R
t 5 23 25
R
t 5 30 25
R
t 5 31 25
R
t 5 32 25
R
t 5 33 25
R
t 5 34 25
R
t 5 35 25
R
t 5 36 25
R
t 5 37 25
R
t 5 38 25
R
t 5 39 25
R
t 5 40 25
R
t 5 41 25
R
t 5 42 25
R
t 5 43 25
R
t 6 0 25
R
t 6 1 25
R
t 6 2 25
R
t 6 3 25
R
t 6 4 25
R
t 6 5 25
R
t 6 6 25
R
t 6 7 25
R
t 6 8 25
R
t 6 9 25
R
t 6 10 25
R
t 6 11 25
R
t 6 12 25
R
t 6 13 25
R
t 6 14 25
R
t 6 15 25
R
t 6 16 25
R
t 6 17 25
R
t 6 18 25
R
t 6 19 25
R
t 6 20 25
R
t 6 21 25
R
t 6 22 25
R
t 6 23 25
R
t 6 30 25
R
t 6 31 25
R
t 6 32 25
R
t 6 33 25
R
t 6 34 25
R
t 6 35 25
R
t 6 36 25
R
t 6 37 25
R
t 6 38 25
R
t 6 39 25
R
t 6 40 25
R
t 6 41 25
R
t 6 42 25
R
t 6 43 25
R
t 7 0 25
R
t 7 1 25
R
t 7 2 25
R
t 7 3 25
R
t 7 4 25
R
t 7 5 25
R
t 7 6 25
R
t 7 7 25
R
t 7 8 25
R
t 7 9 25
R
t 7 10 25
R
t 7 11 25
R
t 7 12 25
R
t 7 13 25
R
t 7 14 25
R
t 7 15 25
R
t 7 16 25
R
t 7 17 25
R
t 7 18 25
R
t 7 19 25
R
t 7 20 25
R
t 7 21 25
R
t 7 22 25
R
t 7 23 25
R
t 7 30 25
R
t 7 31 25
R
t 7 32 25
R
t 7 33 25
R
t 7 34 25
R
t 7 35 25
R
t 7 36 25
R
t 7 37 25
R
t 7 38 25
R
t 7 39 25
R
t 7 40 25
R
t 7 41 25
R
t 7 42 25
R
t 7 43 25
R
t 8 0 25
R
t 8 1 25
R
t 8 2 25
R
t 8 3 25
R
t 8 4 25
R
t 8 5 25
R
t 8 6 25
R
t 8 7 25
R
t 8 8 25
R
t 8 9 25
R
t 8 10 25
R
t 8 11 25
R
t 8 12 25
R
t 8 13 25
R
t 8 14 25
R
t 8 15 25
R
t 8 16 25
R
t 8 17 25
R
t 8 18 25
R
t 8 19 25
R
t 8 20 25
R
t 8 21 25
R
t 8 22 25
R
t 8 23 25
R
t 8 30 25
R
t 8 31 25
R
t 8 32 25
R
t 8 33 25
R
t 8 34 25
R
t 8 35 25
R
t 8 36 25
R
t 8 37 25
R
t 8 38 25
R
t 8 39 25
R
t 8 40 25
R
t 8 41 25
R
t 8 42 25
R
t 8 43 25
R
vcmi-0.98/AI/StupidAI/ 0000775 0000000 0000000 00000000000 12506717576 0014403 5 ustar 00root root 0000000 0000000 vcmi-0.98/AI/StupidAI/CMakeLists.txt 0000664 0000000 0000000 00000001073 12506717576 0017144 0 ustar 00root root 0000000 0000000 project(stupidAI)
cmake_minimum_required(VERSION 2.6)
include_directories(${Boost_INCLUDE_DIRS} ${CMAKE_HOME_DIRECTORY} ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_HOME_DIRECTORY}/lib)
set(stupidAI_SRCS
StdInc.cpp
StupidAI.cpp
main.cpp
)
add_library(StupidAI SHARED ${stupidAI_SRCS})
target_link_libraries(StupidAI vcmi)
set_target_properties(StupidAI PROPERTIES ${PCH_PROPERTIES})
cotire(StupidAI)
if (NOT APPLE) # Already inside vcmiclient bundle
install(TARGETS StupidAI RUNTIME DESTINATION ${AI_LIB_DIR} LIBRARY DESTINATION ${AI_LIB_DIR})
endif()
vcmi-0.98/AI/StupidAI/StdInc.cpp 0000664 0000000 0000000 00000000066 12506717576 0016275 0 ustar 00root root 0000000 0000000 // Creates the precompiled header
#include "StdInc.h" vcmi-0.98/AI/StupidAI/StdInc.h 0000664 0000000 0000000 00000000354 12506717576 0015742 0 ustar 00root root 0000000 0000000 #pragma once
#include "../../Global.h"
// This header should be treated as a pre compiled header file(PCH) in the compiler building settings.
// Here you can add specific libraries and macros which are specific to this project. vcmi-0.98/AI/StupidAI/StupidAI.cbp 0000664 0000000 0000000 00000006054 12506717576 0016560 0 ustar 00root root 0000000 0000000
vcmi-0.98/AI/StupidAI/StupidAI.cpp 0000664 0000000 0000000 00000022113 12506717576 0016570 0 ustar 00root root 0000000 0000000 #include "StdInc.h"
#include "../../lib/AI_Base.h"
#include "StupidAI.h"
#include "../../lib/BattleState.h"
#include "../../CCallback.h"
#include "../../lib/CCreatureHandler.h"
static shared_ptr cbc;
CStupidAI::CStupidAI(void)
: side(-1)
{
print("created");
}
CStupidAI::~CStupidAI(void)
{
print("destroyed");
}
void CStupidAI::init(shared_ptr CB)
{
print("init called, saving ptr to IBattleCallback");
cbc = cb = CB;
}
void CStupidAI::actionFinished(const BattleAction &action)
{
print("actionFinished called");
}
void CStupidAI::actionStarted(const BattleAction &action)
{
print("actionStarted called");
}
struct EnemyInfo
{
const CStack * s;
int adi, adr;
std::vector attackFrom; //for melee fight
EnemyInfo(const CStack * _s) : s(_s)
{}
void calcDmg(const CStack * ourStack)
{
TDmgRange retal, dmg = cbc->battleEstimateDamage(ourStack, s, &retal);
adi = (dmg.first + dmg.second) / 2;
adr = (retal.first + retal.second) / 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);
}
namespace {
int distToNearestNeighbour(BattleHex hex, const ReachabilityInfo::TDistances& dists, BattleHex *chosenHex = nullptr)
{
int ret = 1000000;
for(auto & n: hex.neighbouringTiles())
{
if(dists[n] >= 0 && dists[n] < ret)
{
ret = dists[n];
if(chosenHex)
*chosenHex = n;
}
}
return ret;
}
bool isCloser(const EnemyInfo & ei1, const EnemyInfo & ei2, const ReachabilityInfo::TDistances & dists)
{
return distToNearestNeighbour(ei1.s->position, dists) < distToNearestNeighbour(ei2.s->position, dists);
}
}
static bool willSecondHexBlockMoreEnemyShooters(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())
if(const CStack *s = cbc->battleGetStackByPos(neighbour))
if(s->getCreature()->isShooting())
shooters[i]++;
return shooters[0] < shooters[1];
}
BattleAction CStupidAI::activeStack( const CStack * stack )
{
//boost::this_thread::sleep(boost::posix_time::seconds(2));
print("activeStack called for " + stack->nodeName());
auto dists = cb->battleGetDistances(stack);
std::vector enemiesShootable, enemiesReachable, enemiesUnreachable;
if(stack->type->idNumber == CreatureID::CATAPULT)
{
BattleAction attack;
static const std::vector wallHexes = {50, 183, 182, 130, 62, 29, 12, 95};
attack.destinationTile = *RandomGeneratorUtil::nextItem(wallHexes, CRandomGenerator::getDefault());
attack.actionType = Battle::CATAPULT;
attack.additionalInfo = 0;
attack.side = side;
attack.stackNumber = stack->ID;
return attack;
}
else if(stack->hasBonusOfType(Bonus::SIEGE_WEAPON))
{
return BattleAction::makeDefend(stack);
}
for (const CStack *s : cb->battleGetStacks(CBattleCallback::ONLY_ENEMY))
{
if(cb->battleCanShoot(stack, s->position))
{
enemiesShootable.push_back(s);
}
else
{
std::vector avHexes = cb->battleGetAvailableHexes(stack, false);
for (BattleHex hex : avHexes)
{
if(CStack::isMeleeAttackPossible(stack, s, hex))
{
std::vector::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);
}
}
if(!vstd::contains(enemiesReachable, s) && s->position.isValid())
enemiesUnreachable.push_back(s);
}
}
if(enemiesShootable.size())
{
const EnemyInfo &ei= *std::max_element(enemiesShootable.begin(), enemiesShootable.end(), isMoreProfitable);
return BattleAction::makeShotAttack(stack, ei.s);
}
else if(enemiesReachable.size())
{
const EnemyInfo &ei= *std::max_element(enemiesReachable.begin(), enemiesReachable.end(), &isMoreProfitable);
return BattleAction::makeMeleeAttack(stack, ei.s, *std::max_element(ei.attackFrom.begin(), ei.attackFrom.end(), &willSecondHexBlockMoreEnemyShooters));
}
else if(enemiesUnreachable.size()) //due to #955 - a buggy battle may occur when there are no enemies
{
assert(enemiesUnreachable.size());
const EnemyInfo &ei= *std::min_element(enemiesUnreachable.begin(), enemiesUnreachable.end(), std::bind(isCloser, _1, _2, std::ref(dists)));
assert(ei.s);
if(distToNearestNeighbour(ei.s->position, dists) < GameConstants::BFIELD_SIZE)
{
return goTowards(stack, ei.s->position);
}
}
return BattleAction::makeDefend(stack);
}
void CStupidAI::battleAttack(const BattleAttack *ba)
{
print("battleAttack called");
}
void CStupidAI::battleStacksAttacked(const std::vector & bsa)
{
print("battleStacksAttacked called");
}
void CStupidAI::battleEnd(const BattleResult *br)
{
print("battleEnd called");
}
// void CStupidAI::battleResultsApplied()
// {
// print("battleResultsApplied called");
// }
void CStupidAI::battleNewRoundFirst(int round)
{
print("battleNewRoundFirst called");
}
void CStupidAI::battleNewRound(int round)
{
print("battleNewRound called");
}
void CStupidAI::battleStackMoved(const CStack * stack, std::vector dest, int distance)
{
print("battleStackMoved called");;
}
void CStupidAI::battleSpellCast(const BattleSpellCast *sc)
{
print("battleSpellCast called");
}
void CStupidAI::battleStacksEffectsSet(const SetStackEffect & sse)
{
print("battleStacksEffectsSet called");
}
void CStupidAI::battleStart(const CCreatureSet *army1, const CCreatureSet *army2, int3 tile, const CGHeroInstance *hero1, const CGHeroInstance *hero2, bool Side)
{
print("battleStart called");
side = Side;
}
void CStupidAI::battleStacksHealedRes(const std::vector > & healedStacks, bool lifeDrain, bool tentHeal, si32 lifeDrainFrom)
{
print("battleStacksHealedRes called");
}
void CStupidAI::battleNewStackAppeared(const CStack * stack)
{
print("battleNewStackAppeared called");
}
void CStupidAI::battleObstaclesRemoved(const std::set & removedObstacles)
{
print("battleObstaclesRemoved called");
}
void CStupidAI::battleCatapultAttacked(const CatapultAttack & ca)
{
print("battleCatapultAttacked called");
}
void CStupidAI::battleStacksRemoved(const BattleStacksRemoved & bsr)
{
print("battleStacksRemoved called");
}
void CStupidAI::print(const std::string &text) const
{
logAi->traceStream() << "CStupidAI [" << this <<"]: " << text;
}
BattleAction CStupidAI::goTowards(const CStack * stack, BattleHex destination)
{
assert(destination.isValid());
auto avHexes = cb->battleGetAvailableHexes(stack, false);
auto reachability = cb->getReachability(stack);
if(vstd::contains(avHexes, destination))
return BattleAction::makeMove(stack, destination);
auto destNeighbours = destination.neighbouringTiles();
if(vstd::contains_if(destNeighbours, [&](BattleHex n) { return stack->coversPos(destination); }))
{
logAi->warnStream() << "Warning: already standing on neighbouring tile!";
//We shouldn't even be here...
return BattleAction::makeDefend(stack);
}
vstd::erase_if(destNeighbours, [&](BattleHex hex){ return !reachability.accessibility.accessible(hex, stack); });
if(!avHexes.size() || !destNeighbours.size()) //we are blocked or dest is blocked
{
print("goTowards: Stack cannot move! That's " + stack->nodeName());
return BattleAction::makeDefend(stack);
}
if(stack->hasBonusOfType(Bonus::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 distToDestNeighbour = [&](BattleHex hex) -> int
{
auto nearestNeighbourToHex = vstd::minElementByFun(destNeighbours, [&](BattleHex a)
{
return BattleHex::getDistance(a, hex);
});
return BattleHex::getDistance(*nearestNeighbourToHex, hex);
};
auto nearestAvailableHex = vstd::minElementByFun(avHexes, distToDestNeighbour);
return BattleAction::makeMove(stack, *nearestAvailableHex);
}
else
{
BattleHex bestNeighbor = destination;
if(distToNearestNeighbour(destination, reachability.distances, &bestNeighbor) > GameConstants::BFIELD_SIZE)
{
print("goTowards: Cannot reach");
return BattleAction::makeDefend(stack);
}
BattleHex currentDest = bestNeighbor;
while(1)
{
assert(currentDest.isValid());
if(vstd::contains(avHexes, currentDest))
return BattleAction::makeMove(stack, currentDest);
currentDest = reachability.predecessors[currentDest];
}
}
}
void CStupidAI::saveGame(COSer & h, const int version)
{
//TODO to be implemented with saving/loading during the battles
assert(0);
}
void CStupidAI::loadGame(CISer & h, const int version)
{
//TODO to be implemented with saving/loading during the battles
assert(0);
}
vcmi-0.98/AI/StupidAI/StupidAI.h 0000664 0000000 0000000 00000005517 12506717576 0016246 0 ustar 00root root 0000000 0000000 #pragma once
#include "../../lib/BattleHex.h"
class CStupidAI : public CBattleGameInterface
{
int side;
shared_ptr cb;
void print(const std::string &text) const;
public:
CStupidAI(void);
~CStupidAI(void);
void init(shared_ptr CB) 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
BattleAction activeStack(const CStack * stack) override; //called when it's turn of that stack
void battleAttack(const BattleAttack *ba) override; //called when stack is performing attack
void battleStacksAttacked(const std::vector & bsa) override; //called when stack receives damage (after battleAttack())
void battleEnd(const BattleResult *br) override;
//void battleResultsApplied() override; //called when all effects of last battle are applied
void battleNewRoundFirst(int round) override; //called at the beginning of each turn before changes are applied;
void battleNewRound(int round) override; //called at the beginning of each turn, round=-1 is the tactic phase, round=0 is the first "normal" turn
void battleStackMoved(const CStack * stack, std::vector dest, int distance) override;
void battleSpellCast(const BattleSpellCast *sc) override;
void battleStacksEffectsSet(const SetStackEffect & sse) override;//called when a specific effect is set to stacks
//void battleTriggerEffect(const BattleTriggerEffect & bte) override;
void battleStart(const CCreatureSet *army1, const CCreatureSet *army2, int3 tile, const CGHeroInstance *hero1, const CGHeroInstance *hero2, bool side) override; //called by engine when battle starts; side=0 - left, side=1 - right
void battleStacksHealedRes(const std::vector > & healedStacks, bool lifeDrain, bool tentHeal, si32 lifeDrainFrom) override; //called when stacks are healed / resurrected first element of pair - stack id, second - healed hp
void battleNewStackAppeared(const CStack * stack) override; //not called at the beginning of a battle or by resurrection; called eg. when elemental is summoned
void battleObstaclesRemoved(const std::set & removedObstacles) override; //called when a certain set of obstacles is removed from batlefield; IDs of them are given
void battleCatapultAttacked(const CatapultAttack & ca) override; //called when catapult makes an attack
void battleStacksRemoved(const BattleStacksRemoved & bsr) override; //called when certain stack is completely removed from battlefield
BattleAction goTowards(const CStack * stack, BattleHex hex );
virtual void saveGame(COSer & h, const int version) override;
virtual void loadGame(CISer & h, const int version) override;
};
vcmi-0.98/AI/StupidAI/StupidAI.vcxproj 0000664 0000000 0000000 00000017407 12506717576 0017513 0 ustar 00root root 0000000 0000000
Debug
Win32
Debug
x64
RD
Win32
RD
x64
{15DABC90-234A-4B6B-9EEB-777C4768B82B}
StupidAI
DynamicLibrary
true
MultiByte
v120_xp
DynamicLibrary
true
MultiByte
v120_xp
DynamicLibrary
false
true
MultiByte
v120_xp
DynamicLibrary
false
true
MultiByte
v120_xp
$(VCMI_Out)\AI\
$(VCMI_Out)\AI\
..
$(VCMI_Out)\AI\
Use
StdInc.h
/Zm150 %(AdditionalOptions)
VCMI_lib.lib;%(AdditionalDependencies)
-Zm150 %(AdditionalOptions)
..\..\..\libs;..\..;..
Use
StdInc.h
/Zm150 %(AdditionalOptions)
VCMI_lib.lib;%(AdditionalDependencies)
Use
StdInc.h
/Zm150 %(AdditionalOptions)
VCMI_lib.lib;%(AdditionalDependencies)
..\..\..\libs;..\..
Use
StdInc.h
/Zm150 %(AdditionalOptions)
VCMI_lib.lib;%(AdditionalDependencies)
%(PreprocessorDefinitions)
Create
StdInc.h
Create
Create
Create
vcmi-0.98/AI/StupidAI/main.cpp 0000664 0000000 0000000 00000001270 12506717576 0016033 0 ustar 00root root 0000000 0000000 #include "StdInc.h"
#include "../../lib/AI_Base.h"
#include "StupidAI.h"
#ifdef __GNUC__
#define strcpy_s(a, b, c) strncpy(a, c, b)
#endif
#ifdef VCMI_ANDROID
#define GetGlobalAiVersion StupidAI_GetGlobalAiVersion
#define GetAiName StupidAI_GetAiName
#define GetNewBattleAI StupidAI_GetNewBattleAI
#endif
static const char *g_cszAiName = "Stupid AI 0.1";
extern "C" DLL_EXPORT int GetGlobalAiVersion()
{
return AI_INTERFACE_VER;
}
extern "C" DLL_EXPORT void GetAiName(char* name)
{
strcpy_s(name, strlen(g_cszAiName) + 1, g_cszAiName);
}
extern "C" DLL_EXPORT void GetNewBattleAI(shared_ptr &out)
{
out = make_shared();
}
vcmi-0.98/AI/VCAI/ 0000775 0000000 0000000 00000000000 12506717576 0013443 5 ustar 00root root 0000000 0000000 vcmi-0.98/AI/VCAI/AIUtility.cpp 0000664 0000000 0000000 00000032107 12506717576 0016027 0 ustar 00root root 0000000 0000000 #include "StdInc.h"
#include "AIUtility.h"
#include "VCAI.h"
#include "Fuzzy.h"
#include "../../lib/UnlockGuard.h"
#include "../../lib/CConfigHandler.h"
#include "../../lib/CHeroHandler.h"
#include "../../lib/mapObjects/CBank.h"
/*
* AIUtility.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
*
*/
extern boost::thread_specific_ptr cb;
extern boost::thread_specific_ptr ai;
extern FuzzyHelper *fh;
//extern static const int3 dirs[8];
const CGObjectInstance * ObjectIdRef::operator->() const
{
return cb->getObj(id, false);
}
ObjectIdRef::operator const CGObjectInstance*() const
{
return cb->getObj(id, false);
}
ObjectIdRef::ObjectIdRef(ObjectInstanceID _id) : id(_id)
{
}
ObjectIdRef::ObjectIdRef(const CGObjectInstance *obj) : id(obj->id)
{
}
bool ObjectIdRef::operator<(const ObjectIdRef &rhs) const
{
return id < rhs.id;
}
HeroPtr::HeroPtr(const CGHeroInstance *H)
{
if(!H)
{
//init from nullptr should equal to default init
*this = HeroPtr();
return;
}
h = H;
name = h->name;
hid = H->id;
// infosCount[ai->playerID][hid]++;
}
HeroPtr::HeroPtr()
{
h = nullptr;
hid = ObjectInstanceID();
}
HeroPtr::~HeroPtr()
{
// if(hid >= 0)
// infosCount[ai->playerID][hid]--;
}
bool HeroPtr::operator<(const HeroPtr &rhs) const
{
return hid < rhs.hid;
}
const CGHeroInstance * HeroPtr::get(bool doWeExpectNull /*= false*/) const
{
//TODO? check if these all assertions every time we get info about hero affect efficiency
//
//behave terribly when attempting unauthorized access to hero that is not ours (or was lost)
assert(doWeExpectNull || h);
if(h)
{
auto obj = cb->getObj(hid);
const bool owned = obj && obj->tempOwner == ai->playerID;
if(doWeExpectNull && !owned)
{
return nullptr;
}
else
{
assert(obj);
assert(owned);
}
}
return h;
}
const CGHeroInstance * HeroPtr::operator->() const
{
return get();
}
bool HeroPtr::validAndSet() const
{
return get(true);
}
const CGHeroInstance * HeroPtr::operator*() const
{
return get();
}
void foreach_tile_pos(std::function foo)
{
// some micro-optimizations since this function gets called a LOT
// callback pointer is thread-specific and slow to retrieve -> read map size only once
int3 mapSize = cb->getMapSize();
for(int i = 0; i < mapSize.x; i++)
for(int j = 0; j < mapSize.y; j++)
for(int k = 0; k < mapSize.z; k++)
foo(int3(i,j,k));
}
void foreach_tile_pos(CCallback * cbp, std::function foo)
{
int3 mapSize = cbp->getMapSize();
for(int i = 0; i < mapSize.x; i++)
for(int j = 0; j < mapSize.y; j++)
for(int k = 0; k < mapSize.z; k++)
foo(cbp, int3(i,j,k));
}
void foreach_neighbour(const int3 &pos, std::function foo)
{
CCallback * cbp = cb.get(); // avoid costly retrieval of thread-specific pointer
for(const int3 &dir : dirs)
{
const int3 n = pos + dir;
if(cbp->isInTheMap(n))
foo(pos+dir);
}
}
void foreach_neighbour(CCallback * cbp, const int3 &pos, std::function foo)
{
for(const int3 &dir : dirs)
{
const int3 n = pos + dir;
if(cbp->isInTheMap(n))
foo(cbp, pos+dir);
}
}
std::string strFromInt3(int3 pos)
{
std::ostringstream oss;
oss << pos;
return oss.str();
}
bool CDistanceSorter::operator ()(const CGObjectInstance *lhs, const CGObjectInstance *rhs)
{
const CGPathNode *ln = ai->myCb->getPathsInfo(hero)->getPathInfo(lhs->visitablePos()),
*rn = ai->myCb->getPathsInfo(hero)->getPathInfo(rhs->visitablePos());
if(ln->turns != rn->turns)
return ln->turns < rn->turns;
return (ln->moveRemains > rn->moveRemains);
}
bool compareMovement(HeroPtr lhs, HeroPtr rhs)
{
return lhs->movement > rhs->movement;
}
ui64 evaluateDanger(crint3 tile)
{
const TerrainTile *t = cb->getTile(tile, false);
if(!t) //we can know about guard but can't check its tile (the edge of fow)
return 190000000; //MUCH
ui64 objectDanger = 0, guardDanger = 0;
auto visObjs = cb->getVisitableObjs(tile);
if(visObjs.size())
objectDanger = evaluateDanger(visObjs.back());
int3 guardPos = cb->getGuardingCreaturePosition(tile);
if(guardPos.x >= 0 && guardPos != tile)
guardDanger = evaluateDanger(guardPos);
//TODO mozna odwiedzic blockvis nie ruszajac straznika
return std::max(objectDanger, guardDanger);
}
ui64 evaluateDanger(crint3 tile, const CGHeroInstance *visitor)
{
const TerrainTile *t = cb->getTile(tile, false);
if(!t) //we can know about guard but can't check its tile (the edge of fow)
return 190000000; //MUCH
ui64 objectDanger = 0, guardDanger = 0;
auto visitableObjects = cb->getVisitableObjs(tile);
// in some scenarios hero happens to be "under" the object (eg town). Then we consider ONLY the hero.
if(vstd::contains_if(visitableObjects, objWithID))
vstd::erase_if(visitableObjects, [](const CGObjectInstance * obj)
{
return !objWithID(obj);
});
if(const CGObjectInstance * dangerousObject = vstd::backOrNull(visitableObjects))
{
objectDanger = evaluateDanger(dangerousObject); //unguarded objects can also be dangerous or unhandled
if (objectDanger)
{
//TODO: don't downcast objects AI shouldn't know about!
auto armedObj = dynamic_cast(dangerousObject);
if (armedObj)
{
float tacticalAdvantage = fh->getTacticalAdvantage(visitor, armedObj);
objectDanger *= tacticalAdvantage; //this line tends to go infinite for allied towns (?)
}
}
if (dangerousObject->ID == Obj::SUBTERRANEAN_GATE)
{ //check guard on the other side of the gate
auto it = ai->knownSubterraneanGates.find(dangerousObject);
if (it != ai->knownSubterraneanGates.end())
{
auto guards = cb->getGuardingCreatures(it->second->visitablePos());
for (auto cre : guards)
{
vstd::amax (guardDanger, evaluateDanger(cre) *
fh->getTacticalAdvantage(visitor, dynamic_cast(cre)));
}
}
}
}
auto guards = cb->getGuardingCreatures(tile);
for (auto cre : guards)
{
vstd::amax (guardDanger, evaluateDanger(cre) * fh->getTacticalAdvantage(visitor, dynamic_cast(cre))); //we are interested in strongest monster around
}
//TODO mozna odwiedzic blockvis nie ruszajac straznika
return std::max(objectDanger, guardDanger);
}
ui64 evaluateDanger(const CGObjectInstance *obj)
{
if(obj->tempOwner < PlayerColor::PLAYER_LIMIT && cb->getPlayerRelations(obj->tempOwner, ai->playerID) != PlayerRelations::ENEMIES) //owned or allied objects don't pose any threat
return 0;
switch(obj->ID)
{
case Obj::HERO:
{
InfoAboutHero iah;
cb->getHeroInfo(obj, iah);
return iah.army.getStrength();
}
case Obj::TOWN:
case Obj::GARRISON: case Obj::GARRISON2: //garrison
{
InfoAboutTown iat;
cb->getTownInfo(obj, iat);
return iat.army.getStrength();
}
case Obj::MONSTER:
{
//TODO!!!!!!!!
const CGCreature *cre = dynamic_cast(obj);
return cre->getArmyStrength();
}
case Obj::CREATURE_GENERATOR1:
{
const CGDwelling *d = dynamic_cast(obj);
return d->getArmyStrength();
}
case Obj::MINE:
case Obj::ABANDONED_MINE:
{
const CArmedInstance * a = dynamic_cast(obj);
return a->getArmyStrength();
}
case Obj::CRYPT: //crypt
case Obj::CREATURE_BANK: //crebank
case Obj::DRAGON_UTOPIA:
case Obj::SHIPWRECK: //shipwreck
case Obj::DERELICT_SHIP: //derelict ship
// case Obj::PYRAMID:
return fh->estimateBankDanger (dynamic_cast(obj));
case Obj::PYRAMID:
{
if(obj->subID == 0)
return fh->estimateBankDanger (dynamic_cast(obj));
else
return 0;
}
default:
return 0;
}
}
bool compareDanger(const CGObjectInstance *lhs, const CGObjectInstance *rhs)
{
return evaluateDanger(lhs) < evaluateDanger(rhs);
}
bool isSafeToVisit(HeroPtr h, crint3 tile)
{
const ui64 heroStrength = h->getTotalStrength(),
dangerStrength = evaluateDanger(tile, *h);
if(dangerStrength)
{
if(heroStrength / SAFE_ATTACK_CONSTANT > dangerStrength)
{
logAi->traceStream() << boost::format("It's safe for %s to visit tile %s") % h->name % tile;
return true;
}
else
return false;
}
return true; //there's no danger
}
bool canBeEmbarkmentPoint(const TerrainTile *t, bool fromWater)
{
//tile must be free of with unoccupied boat
return !t->blocked
|| (!fromWater && t->visitableObjects.size() == 1 && t->topVisitableId() == Obj::BOAT);
//do not try to board when in water sector
}
int3 whereToExplore(HeroPtr h)
{
TimeCheck tc ("where to explore");
int radius = h->getSightRadious();
int3 hpos = h->visitablePos();
SectorMap sm(h);
//look for nearby objs -> visit them if they're close enouh
const int DIST_LIMIT = 3;
std::vector nearbyVisitableObjs;
for (int x = hpos.x - DIST_LIMIT; x <= hpos.x + DIST_LIMIT; ++x) //get only local objects instead of all possible objects on the map
{
for (int y = hpos.y - DIST_LIMIT; y <= hpos.y + DIST_LIMIT; ++y)
{
for (auto obj : cb->getVisitableObjs (int3(x,y,hpos.z), false))
{
int3 op = obj->visitablePos();
CGPath p;
ai->myCb->getPathsInfo(h.get())->getPath(op, p);
if (p.nodes.size() && p.endPos() == op && p.nodes.size() <= DIST_LIMIT)
if (ai->isGoodForVisit(obj, h, sm))
nearbyVisitableObjs.push_back(obj);
}
}
}
vstd::removeDuplicates (nearbyVisitableObjs); //one object may occupy multiple tiles
boost::sort(nearbyVisitableObjs, CDistanceSorter(h.get()));
if(nearbyVisitableObjs.size())
return nearbyVisitableObjs.back()->visitablePos();
try //check if nearby tiles allow us to reveal anything - this is quick
{
return ai->explorationBestNeighbour(hpos, radius, h);
}
catch(cannotFulfillGoalException &e)
{
//perform exhaustive search
return ai->explorationNewPoint(h);
}
}
bool isBlockedBorderGate(int3 tileToHit)
{
return cb->getTile(tileToHit)->topVisitableId() == Obj::BORDER_GATE &&
(dynamic_cast (cb->getTile(tileToHit)->visitableObjects.back()))->wasMyColorVisited (ai->playerID);
}
int howManyTilesWillBeDiscovered(const int3 &pos, int radious, CCallback * cbp)
{ //TODO: do not explore dead-end boundaries
int ret = 0;
for(int x = pos.x - radious; x <= pos.x + radious; x++)
{
for(int y = pos.y - radious; y <= pos.y + radious; y++)
{
int3 npos = int3(x,y,pos.z);
if(cbp->isInTheMap(npos) && pos.dist2d(npos) - 0.5 < radious && !cbp->isVisible(npos))
{
if (!boundaryBetweenTwoPoints (pos, npos, cbp))
ret++;
}
}
}
return ret;
}
bool boundaryBetweenTwoPoints (int3 pos1, int3 pos2, CCallback * cbp) //determines if two points are separated by known barrier
{
int xMin = std::min (pos1.x, pos2.x);
int xMax = std::max (pos1.x, pos2.x);
int yMin = std::min (pos1.y, pos2.y);
int yMax = std::max (pos1.y, pos2.y);
for (int x = xMin; x <= xMax; ++x)
{
for (int y = yMin; y <= yMax; ++y)
{
int3 tile = int3(x, y, pos1.z); //use only on same level, ofc
if (abs(pos1.dist2d(tile) - pos2.dist2d(tile)) < 1.5)
{
if (!(cbp->isVisible(tile) && cbp->getTile(tile)->blocked)) //if there's invisible or unblocked tile between, it's good
return false;
}
}
}
return true; //if all are visible and blocked, we're at dead end
}
int howManyTilesWillBeDiscovered(int radious, int3 pos, crint3 dir)
{
return howManyTilesWillBeDiscovered(pos + dir, radious, cb.get());
}
void getVisibleNeighbours(const std::vector &tiles, std::vector &out)
{
for(const int3 &tile : tiles)
{
foreach_neighbour(tile, [&](int3 neighbour)
{
if(cb->isVisible(neighbour))
out.push_back(neighbour);
});
}
}
ui64 howManyReinforcementsCanGet(HeroPtr h, const CGTownInstance *t)
{
ui64 ret = 0;
int freeHeroSlots = GameConstants::ARMY_SIZE - h->stacksCount();
std::vector toMove;
for(auto const slot : t->Slots())
{
//can be merged woth another stack?
SlotID dst = h->getSlotFor(slot.second->getCreatureID());
if(h->hasStackAtSlot(dst))
ret += t->getPower(slot.first);
else
toMove.push_back(slot.second);
}
boost::sort(toMove, [](const CStackInstance *lhs, const CStackInstance *rhs)
{
return lhs->getPower() < rhs->getPower();
});
for (auto & stack : boost::adaptors::reverse(toMove))
{
if(freeHeroSlots)
{
ret += stack->getPower();
freeHeroSlots--;
}
else
break;
}
return ret;
}
bool compareHeroStrength(HeroPtr h1, HeroPtr h2)
{
return h1->getTotalStrength() < h2->getTotalStrength();
}
bool compareArmyStrength(const CArmedInstance *a1, const CArmedInstance *a2)
{
return a1->getArmyStrength() < a2->getArmyStrength();
}
vcmi-0.98/AI/VCAI/AIUtility.h 0000664 0000000 0000000 00000011246 12506717576 0015475 0 ustar 00root root 0000000 0000000 #pragma once
#include "../../lib/VCMI_Lib.h"
#include "../../lib/CBuildingHandler.h"
#include "../../lib/CCreatureHandler.h"
#include "../../lib/CTownHandler.h"
#include "../../lib/spells/CSpellHandler.h"
#include "../../lib/Connection.h"
#include "../../lib/CGameState.h"
#include "../../lib/mapping/CMap.h"
#include "../../lib/NetPacks.h"
#include "../../lib/CStopWatch.h"
/*
* AIUtility.h, 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
*
*/
typedef const int3& crint3;
typedef const std::string& crstring;
const int HERO_GOLD_COST = 2500;
const int GOLD_MINE_PRODUCTION = 1000, WOOD_ORE_MINE_PRODUCTION = 2, RESOURCE_MINE_PRODUCTION = 1;
const int ACTUAL_RESOURCE_COUNT = 7;
const int ALLOWED_ROAMING_HEROES = 8;
//implementation-dependent
extern const double SAFE_ATTACK_CONSTANT;
extern const int GOLD_RESERVE;
//provisional class for AI to store a reference to an owned hero object
//checks if it's valid on access, should be used in place of const CGHeroInstance*
struct HeroPtr
{
const CGHeroInstance *h;
ObjectInstanceID hid;
public:
std::string name;
HeroPtr();
HeroPtr(const CGHeroInstance *H);
~HeroPtr();
operator bool() const
{
return validAndSet();
}
bool operator<(const HeroPtr &rhs) const;
const CGHeroInstance *operator->() const;
const CGHeroInstance *operator*() const; //not that consistent with -> but all interfaces use CGHeroInstance*, so it's convenient
const CGHeroInstance *get(bool doWeExpectNull = false) const;
bool validAndSet() const;
template void serialize(Handler &h, const int version)
{
h & this->h & hid & name;
}
};
enum BattleState
{
NO_BATTLE,
UPCOMING_BATTLE,
ONGOING_BATTLE,
ENDING_BATTLE
};
// AI lives in a dangerous world. CGObjectInstances under pointer may got deleted/hidden.
// This class stores object id, so we can detect when we lose access to the underlying object.
struct ObjectIdRef
{
ObjectInstanceID id;
const CGObjectInstance *operator->() const;
operator const CGObjectInstance *() const;
ObjectIdRef(ObjectInstanceID _id);
ObjectIdRef(const CGObjectInstance *obj);
bool operator<(const ObjectIdRef &rhs) const;
template void serialize(Handler &h, const int version)
{
h & id;
}
};
struct TimeCheck
{
CStopWatch time;
std::string txt;
TimeCheck(crstring TXT) : txt(TXT)
{
}
~TimeCheck()
{
logAi->traceStream() << boost::format("Time of %s was %d ms.") % txt % time.getDiff();
}
};
struct AtScopeExit
{
std::function foo;
AtScopeExit(const std::function &FOO) : foo(FOO)
{}
~AtScopeExit()
{
foo();
}
};
class ObjsVector : public std::vector
{
private:
};
template
bool objWithID(const CGObjectInstance *obj)
{
return obj->ID == id;
}
std::string strFromInt3(int3 pos);
void foreach_tile_pos(std::function foo);
void foreach_tile_pos(CCallback * cbp, std::function foo); // avoid costly retrieval of thread-specific pointer
void foreach_neighbour(const int3 &pos, std::function foo);
void foreach_neighbour(CCallback * cbp, const int3 &pos, std::function foo); // avoid costly retrieval of thread-specific pointer
int howManyTilesWillBeDiscovered(const int3 &pos, int radious, CCallback * cbp);
int howManyTilesWillBeDiscovered(int radious, int3 pos, crint3 dir);
void getVisibleNeighbours(const std::vector &tiles, std::vector &out);
bool canBeEmbarkmentPoint(const TerrainTile *t, bool fromWater);
bool isBlockedBorderGate(int3 tileToHit);
bool isWeeklyRevisitable (const CGObjectInstance * obj);
bool shouldVisit (HeroPtr h, const CGObjectInstance * obj);
ui64 evaluateDanger(const CGObjectInstance *obj);
ui64 evaluateDanger(crint3 tile, const CGHeroInstance *visitor);
bool isSafeToVisit(HeroPtr h, crint3 tile);
bool boundaryBetweenTwoPoints (int3 pos1, int3 pos2, CCallback * cbp);
bool compareMovement(HeroPtr lhs, HeroPtr rhs);
bool compareHeroStrength(HeroPtr h1, HeroPtr h2);
bool compareArmyStrength(const CArmedInstance *a1, const CArmedInstance *a2);
ui64 howManyReinforcementsCanGet(HeroPtr h, const CGTownInstance *t);
int3 whereToExplore(HeroPtr h);
class CDistanceSorter
{
const CGHeroInstance * hero;
public:
CDistanceSorter(const CGHeroInstance * hero): hero(hero) {}
bool operator ()(const CGObjectInstance *lhs, const CGObjectInstance *rhs);
};
vcmi-0.98/AI/VCAI/CMakeLists.txt 0000664 0000000 0000000 00000001630 12506717576 0016203 0 ustar 00root root 0000000 0000000 project(VCAI)
cmake_minimum_required(VERSION 2.6)
if (FL_FOUND)
include_directories(${Boost_INCLUDE_DIRS} ${CMAKE_HOME_DIRECTORY} ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_HOME_DIRECTORY}/lib ${FL_INCLUDE_DIRS})
else()
include_directories(${Boost_INCLUDE_DIRS} ${CMAKE_HOME_DIRECTORY} ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_HOME_DIRECTORY}/lib ${CMAKE_HOME_DIRECTORY}/AI/FuzzyLite/fuzzylite)
endif()
set(VCAI_SRCS
StdInc.cpp
VCAI.cpp
Goals.cpp
AIUtility.cpp
main.cpp
Fuzzy.cpp
)
add_library(VCAI SHARED ${VCAI_SRCS})
if (FL_FOUND)
target_link_libraries(VCAI ${FL_LIBRARIES} vcmi)
else()
target_link_libraries(VCAI fl-static vcmi)
endif()
set_target_properties(VCAI PROPERTIES ${PCH_PROPERTIES})
cotire(VCAI)
if (NOT APPLE) # Already inside vcmiclient bundle
install(TARGETS VCAI RUNTIME DESTINATION ${AI_LIB_DIR} LIBRARY DESTINATION ${AI_LIB_DIR})
endif()
vcmi-0.98/AI/VCAI/Fuzzy.cpp 0000664 0000000 0000000 00000042270 12506717576 0015303 0 ustar 00root root 0000000 0000000 #include "StdInc.h"
#include "Fuzzy.h"
#include
#include "../../lib/mapObjects/MapObjects.h"
#include "../../lib/mapObjects/CommonConstructors.h"
#include "../../lib/CCreatureHandler.h"
#include "../../lib/VCMI_Lib.h"
#include "../../CCallback.h"
#include "VCAI.h"
/*
* Fuzzy.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
*
*/
#define MIN_AI_STRENGHT (0.5f) //lower when combat AI gets smarter
#define UNGUARDED_OBJECT (100.0f) //we consider unguarded objects 100 times weaker than us
struct BankConfig;
class IObjectInfo;
class CBankInfo;
class Engine;
class InputVariable;
class CGTownInstance;
using namespace vstd;
//using namespace Goals;
FuzzyHelper *fh;
extern boost::thread_specific_ptr cb;
extern boost::thread_specific_ptr ai;
engineBase::engineBase()
{
engine.addRuleBlock(&rules);
}
void engineBase::configure()
{
engine.configure("Minimum", "Maximum", "Minimum", "AlgebraicSum", "Centroid");
logAi->infoStream() << engine.toString();
}
void engineBase::addRule(const std::string &txt)
{
rules.addRule(fl::Rule::parse(txt, &engine));
}
struct armyStructure
{
float walkers, shooters, flyers;
ui32 maxSpeed;
};
armyStructure evaluateArmyStructure (const CArmedInstance * army)
{
ui64 totalStrenght = army->getArmyStrength();
double walkersStrenght = 0;
double flyersStrenght = 0;
double shootersStrenght = 0;
ui32 maxSpeed = 0;
for(auto s : army->Slots())
{
bool walker = true;
if (s.second->type->hasBonusOfType(Bonus::SHOOTER))
{
shootersStrenght += s.second->getPower();
walker = false;
}
if (s.second->type->hasBonusOfType(Bonus::FLYING))
{
flyersStrenght += s.second->getPower();
walker = false;
}
if (walker)
walkersStrenght += s.second->getPower();
amax (maxSpeed, s.second->type->valOfBonuses(Bonus::STACKS_SPEED));
}
armyStructure as;
as.walkers = walkersStrenght / totalStrenght;
as.shooters = shootersStrenght / totalStrenght;
as.flyers = flyersStrenght / totalStrenght;
as.maxSpeed = maxSpeed;
assert(as.walkers || as.flyers || as.shooters);
return as;
}
FuzzyHelper::FuzzyHelper()
{
initTacticalAdvantage();
ta.configure();
initVisitTile();
vt.configure();
}
void FuzzyHelper::initTacticalAdvantage()
{
try
{
ta.ourShooters = new fl::InputVariable("OurShooters");
ta.ourWalkers = new fl::InputVariable("OurWalkers");
ta.ourFlyers = new fl::InputVariable("OurFlyers");
ta.enemyShooters = new fl::InputVariable("EnemyShooters");
ta.enemyWalkers = new fl::InputVariable("EnemyWalkers");
ta.enemyFlyers = new fl::InputVariable("EnemyFlyers");
//Tactical advantage calculation
std::vector helper =
{
ta.ourShooters, ta.ourWalkers, ta.ourFlyers, ta.enemyShooters, ta.enemyWalkers, ta.enemyFlyers
};
for (auto val : helper)
{
ta.engine.addInputVariable(val);
val->addTerm(new fl::Ramp("FEW", 0.6, 0.0));
val->addTerm(new fl::Ramp("MANY", 0.4, 1));
val->setRange(0.0, 1.0);
}
ta.ourSpeed = new fl::InputVariable("OurSpeed");
ta.enemySpeed = new fl::InputVariable("EnemySpeed");
helper = {ta.ourSpeed, ta.enemySpeed};
for (auto val : helper)
{
ta.engine.addInputVariable(val);
val->addTerm(new fl::Ramp("LOW", 6.5, 3));
val->addTerm(new fl::Triangle("MEDIUM", 5.5, 10.5));
val->addTerm(new fl::Ramp("HIGH", 8.5, 16));
val->setRange(0, 25);
}
ta.castleWalls = new fl::InputVariable("CastleWalls");
ta.engine.addInputVariable(ta.castleWalls);
{
fl::Rectangle* none = new fl::Rectangle("NONE", CGTownInstance::NONE, CGTownInstance::NONE + (CGTownInstance::FORT - CGTownInstance::NONE) * 0.5f);
ta.castleWalls->addTerm(none);
fl::Trapezoid* medium = new fl::Trapezoid("MEDIUM", (CGTownInstance::FORT - CGTownInstance::NONE) * 0.5f, CGTownInstance::FORT,
CGTownInstance::CITADEL, CGTownInstance::CITADEL + (CGTownInstance::CASTLE - CGTownInstance::CITADEL) * 0.5f);
ta.castleWalls->addTerm(medium);
fl::Ramp* high = new fl::Ramp("HIGH", CGTownInstance::CITADEL - 0.1, CGTownInstance::CASTLE);
ta.castleWalls->addTerm(high);
ta.castleWalls->setRange(CGTownInstance::NONE, CGTownInstance::CASTLE);
}
ta.bankPresent = new fl::InputVariable("Bank");
ta.engine.addInputVariable(ta.bankPresent);
{
fl::Rectangle* termFalse = new fl::Rectangle("FALSE", 0.0, 0.5f);
ta.bankPresent->addTerm(termFalse);
fl::Rectangle* termTrue = new fl::Rectangle("TRUE", 0.5f, 1);
ta.bankPresent->addTerm(termTrue);
ta.bankPresent->setRange(0, 1);
}
ta.threat = new fl::OutputVariable("Threat");
ta.engine.addOutputVariable(ta.threat);
ta.threat->addTerm(new fl::Ramp("LOW", 1, MIN_AI_STRENGHT));
ta.threat->addTerm(new fl::Triangle("MEDIUM", 0.8, 1.2));
ta.threat->addTerm(new fl::Ramp("HIGH", 1, 1.5));
ta.threat->setRange(MIN_AI_STRENGHT, 1.5);
ta.addRule("if OurShooters is MANY and EnemySpeed is LOW then Threat is LOW");
ta.addRule("if OurShooters is MANY and EnemyShooters is FEW then Threat is LOW");
ta.addRule("if OurSpeed is LOW and EnemyShooters is MANY then Threat is HIGH");
ta.addRule("if OurSpeed is HIGH and EnemyShooters is MANY then Threat is LOW");
ta.addRule("if OurWalkers is FEW and EnemyShooters is MANY then Threat is somewhat LOW");
ta.addRule("if OurShooters is MANY and EnemySpeed is HIGH then Threat is somewhat HIGH");
//just to cover all cases
ta.addRule("if OurShooters is FEW and EnemySpeed is HIGH then Threat is MEDIUM");
ta.addRule("if EnemySpeed is MEDIUM then Threat is MEDIUM");
ta.addRule("if EnemySpeed is LOW and OurShooters is FEW then Threat is MEDIUM");
ta.addRule("if Bank is TRUE and OurShooters is MANY then Threat is somewhat HIGH");
ta.addRule("if Bank is TRUE and EnemyShooters is MANY then Threat is LOW");
ta.addRule("if CastleWalls is HIGH and OurWalkers is MANY then Threat is very HIGH");
ta.addRule("if CastleWalls is HIGH and OurFlyers is MANY and OurShooters is MANY then Threat is MEDIUM");
ta.addRule("if CastleWalls is MEDIUM and OurShooters is MANY and EnemyWalkers is MANY then Threat is LOW");
}
catch (fl::Exception & pe)
{
logAi->errorStream() << "initTacticalAdvantage " << ": " << pe.getWhat();
}
}
ui64 FuzzyHelper::estimateBankDanger (const CBank * bank)
{
//this one is not fuzzy anymore, just calculate weighted average
auto objectInfo = VLC->objtypeh->getHandlerFor(bank->ID, bank->subID)->getObjectInfo(bank->appearance);
CBankInfo * bankInfo = dynamic_cast (objectInfo.get());
ui64 totalStrength = 0;
ui8 totalChance = 0;
for (auto config : bankInfo->getPossibleGuards())
{
totalStrength += config.second.totalStrength * config.first;
totalChance += config.first;
}
return totalStrength / totalChance;
}
float FuzzyHelper::getTacticalAdvantage (const CArmedInstance *we, const CArmedInstance *enemy)
{
float output = 1;
try
{
armyStructure ourStructure = evaluateArmyStructure(we);
armyStructure enemyStructure = evaluateArmyStructure(enemy);
ta.ourWalkers->setInputValue(ourStructure.walkers);
ta.ourShooters->setInputValue(ourStructure.shooters);
ta.ourFlyers->setInputValue(ourStructure.flyers);
ta.ourSpeed->setInputValue(ourStructure.maxSpeed);
ta.enemyWalkers->setInputValue(enemyStructure.walkers);
ta.enemyShooters->setInputValue(enemyStructure.shooters);
ta.enemyFlyers->setInputValue(enemyStructure.flyers);
ta.enemySpeed->setInputValue(enemyStructure.maxSpeed);
bool bank = dynamic_cast (enemy);
if (bank)
ta.bankPresent->setInputValue(1);
else
ta.bankPresent->setInputValue(0);
const CGTownInstance * fort = dynamic_cast (enemy);
if (fort)
{
ta.castleWalls->setInputValue(fort->fortLevel());
}
else
ta.castleWalls->setInputValue(0);
//engine.process(TACTICAL_ADVANTAGE);//TODO: Process only Tactical_Advantage
ta.engine.process();
output = ta.threat->getOutputValue();
}
catch (fl::Exception & fe)
{
logAi->errorStream() << "getTacticalAdvantage " << ": " << fe.getWhat();
}
if (output < 0 || (output != output))
{
fl::InputVariable* tab[] = {ta.bankPresent, ta.castleWalls, ta.ourWalkers, ta.ourShooters, ta.ourFlyers, ta.ourSpeed, ta.enemyWalkers, ta.enemyShooters, ta.enemyFlyers, ta.enemySpeed};
std::string names[] = {"bankPresent", "castleWalls", "ourWalkers", "ourShooters", "ourFlyers", "ourSpeed", "enemyWalkers", "enemyShooters", "enemyFlyers", "enemySpeed" };
std::stringstream log("Warning! Fuzzy engine doesn't cover this set of parameters: ");
for (int i = 0; i < boost::size(tab); i++)
log << names[i] << ": " << tab[i]->getInputValue() << " ";
logAi->errorStream() << log.str();
assert(false);
}
return output;
}
FuzzyHelper::TacticalAdvantage::~TacticalAdvantage()
{
//TODO: smart pointers?
delete ourWalkers;
delete ourShooters;
delete ourFlyers;
delete enemyWalkers;
delete enemyShooters;
delete enemyFlyers;
delete ourSpeed;
delete enemySpeed;
delete bankPresent;
delete castleWalls;
delete threat;
}
//shared_ptr chooseSolution (std::vector> & vec)
Goals::TSubgoal FuzzyHelper::chooseSolution (Goals::TGoalVec vec)
{
if (vec.empty()) //no possibilities found
return sptr(Goals::Invalid());
//a trick to switch between heroes less often - calculatePaths is costly
auto sortByHeroes = [](const Goals::TSubgoal & lhs, const Goals::TSubgoal & rhs) -> bool
{
return lhs->hero.h < rhs->hero.h;
};
boost::sort (vec, sortByHeroes);
for (auto g : vec)
{
setPriority(g);
}
auto compareGoals = [](const Goals::TSubgoal & lhs, const Goals::TSubgoal & rhs) -> bool
{
return lhs->priority < rhs->priority;
};
boost::sort (vec, compareGoals);
return vec.back();
}
float FuzzyHelper::evaluate (Goals::Explore & g)
{
return 1;
}
float FuzzyHelper::evaluate (Goals::RecruitHero & g)
{
return 1; //just try to recruit hero as one of options
}
FuzzyHelper::EvalVisitTile::~EvalVisitTile()
{
delete strengthRatio;
delete heroStrength;
delete turnDistance;
delete missionImportance;
}
void FuzzyHelper::initVisitTile()
{
try
{
vt.strengthRatio = new fl::InputVariable("strengthRatio"); //hero must be strong enough to defeat guards
vt.heroStrength = new fl::InputVariable("heroStrength"); //we want to use weakest possible hero
vt.turnDistance = new fl::InputVariable("turnDistance"); //we want to use hero who is near
vt.missionImportance = new fl::InputVariable("lockedMissionImportance"); //we may want to preempt hero with low-priority mission
vt.value = new fl::OutputVariable("Value");
vt.value->setMinimum(0);
vt.value->setMaximum(5);
std::vector helper = {vt.strengthRatio, vt.heroStrength, vt.turnDistance, vt.missionImportance};
for (auto val : helper)
{
vt.engine.addInputVariable(val);
}
vt.engine.addOutputVariable(vt.value);
vt.strengthRatio->addTerm(new fl::Ramp("LOW", SAFE_ATTACK_CONSTANT, 0));
vt.strengthRatio->addTerm(new fl::Ramp("HIGH", SAFE_ATTACK_CONSTANT, SAFE_ATTACK_CONSTANT * 3));
vt.strengthRatio->setRange(0, SAFE_ATTACK_CONSTANT * 3 );
//strength compared to our main hero
vt.heroStrength->addTerm(new fl::Ramp("LOW", 0.2, 0));
vt.heroStrength->addTerm(new fl::Triangle("MEDIUM", 0.2, 0.8));
vt.heroStrength->addTerm(new fl::Ramp("HIGH", 0.5, 1));
vt.heroStrength->setRange(0.0, 1.0);
vt.turnDistance->addTerm(new fl::Ramp("SMALL", 0.5, 0));
vt.turnDistance->addTerm(new fl::Triangle("MEDIUM", 0.1, 0.8));
vt.turnDistance->addTerm(new fl::Ramp("LONG", 0.5, 3));
vt.turnDistance->setRange(0.0, 3.0);
vt.missionImportance->addTerm(new fl::Ramp("LOW", 2.5, 0));
vt.missionImportance->addTerm(new fl::Triangle("MEDIUM", 2, 3));
vt.missionImportance->addTerm(new fl::Ramp("HIGH", 2.5, 5));
vt.missionImportance->setRange(0.0, 5.0);
//an issue: in 99% cases this outputs center of mass (2.5) regardless of actual input :/
//should be same as "mission Importance" to keep consistency
vt.value->addTerm(new fl::Ramp("LOW", 2.5, 0));
vt.value->addTerm(new fl::Triangle("MEDIUM", 2, 3)); //can't be center of mass :/
vt.value->addTerm(new fl::Ramp("HIGH", 2.5, 5));
vt.value->setRange(0.0,5.0);
//use unarmed scouts if possible
vt.addRule("if strengthRatio is HIGH and heroStrength is LOW then Value is very HIGH");
//we may want to use secondary hero(es) rather than main hero
vt.addRule("if strengthRatio is HIGH and heroStrength is MEDIUM then Value is somewhat HIGH");
vt.addRule("if strengthRatio is HIGH and heroStrength is HIGH then Value is somewhat LOW");
//don't assign targets to heroes who are too weak, but prefer targets of our main hero (in case we need to gather army)
vt.addRule("if strengthRatio is LOW and heroStrength is LOW then Value is very LOW");
//attempt to arm secondary heroes is not stupid
vt.addRule("if strengthRatio is LOW and heroStrength is MEDIUM then Value is somewhat HIGH");
vt.addRule("if strengthRatio is LOW and heroStrength is HIGH then Value is LOW");
//do not cancel important goals
vt.addRule("if lockedMissionImportance is HIGH then Value is very LOW");
vt.addRule("if lockedMissionImportance is MEDIUM then Value is somewhat LOW");
vt.addRule("if lockedMissionImportance is LOW then Value is HIGH");
//pick nearby objects if it's easy, avoid long walks
vt.addRule("if turnDistance is SMALL then Value is HIGH");
vt.addRule("if turnDistance is MEDIUM then Value is MEDIUM");
vt.addRule("if turnDistance is LONG then Value is LOW");
}
catch (fl::Exception & fe)
{
logAi->errorStream() << "visitTile " << ": " << fe.getWhat();
}
}
float FuzzyHelper::evaluate (Goals::VisitTile & g)
{
//we assume that hero is already set and we want to choose most suitable one for the mission
if (!g.hero)
return 0;
//assert(cb->isInTheMap(g.tile));
float turns = 0;
float distance = cb->getMovementCost(g.hero.h, g.tile);
if (!distance) //we stand on that tile
turns = 0;
else
{
if (distance < g.hero->movement) //we can move there within one turn
turns = (fl::scalar)distance / g.hero->movement;
else
turns = 1 + (fl::scalar)(distance - g.hero->movement) / g.hero->maxMovePoints(true); //bool on land?
}
float missionImportance = 0;
if (vstd::contains(ai->lockedHeroes, g.hero))
missionImportance = ai->lockedHeroes[g.hero]->priority;
float strengthRatio = 10.0f; //we are much stronger than enemy
ui64 danger = evaluateDanger (g.tile, g.hero.h);
if (danger)
strengthRatio = (fl::scalar)g.hero.h->getTotalStrength() / danger;
try
{
vt.strengthRatio->setInputValue(strengthRatio);
vt.heroStrength->setInputValue((fl::scalar)g.hero->getTotalStrength() / ai->primaryHero()->getTotalStrength());
vt.turnDistance->setInputValue(turns);
vt.missionImportance->setInputValue(missionImportance);
vt.engine.process();
//engine.process(VISIT_TILE); //TODO: Process only Visit_Tile
g.priority = vt.value->getOutputValue();
}
catch (fl::Exception & fe)
{
logAi->errorStream() << "evaluate VisitTile " << ": " << fe.getWhat();
}
assert (g.priority >= 0);
return g.priority;
}
float FuzzyHelper::evaluate (Goals::VisitHero & g)
{
auto obj = cb->getObj(ObjectInstanceID(g.objid)); //we assume for now that these goals are similar
if (!obj)
return -100; //hero died in the meantime
//TODO: consider direct copy (constructor?)
g.setpriority(Goals::VisitTile(obj->visitablePos()).sethero(g.hero).setisAbstract(g.isAbstract).accept(this));
return g.priority;
}
float FuzzyHelper::evaluate (Goals::GatherArmy & g)
{
//the more army we need, the more important goal
//the more army we lack, the less important goal
float army = g.hero->getArmyStrength();
return g.value / std::max(g.value - army, 1000.0f);
}
float FuzzyHelper::evaluate (Goals::ClearWayTo & g)
{
if (!g.hero.h)
throw cannotFulfillGoalException("ClearWayTo called without hero!");
SectorMap sm(g.hero);
int3 t = sm.firstTileToGet(g.hero, g.tile);
if (t.valid())
{
if (isSafeToVisit(g.hero, t))
{
g.setpriority(Goals::VisitTile(g.tile).sethero(g.hero).setisAbstract(g.isAbstract).accept(this));
}
else
{
g.setpriority (Goals::GatherArmy(evaluateDanger(t, g.hero.h)*SAFE_ATTACK_CONSTANT).
sethero(g.hero).setisAbstract(true).accept(this));
}
return g.priority;
}
else
return -1;
}
float FuzzyHelper::evaluate (Goals::BuildThis & g)
{
return 1;
}
float FuzzyHelper::evaluate (Goals::DigAtTile & g)
{
return 0;
}
float FuzzyHelper::evaluate (Goals::CollectRes & g)
{
return 0;
}
float FuzzyHelper::evaluate (Goals::Build & g)
{
return 0;
}
float FuzzyHelper::evaluate (Goals::Invalid & g)
{
return -1e10;
}
float FuzzyHelper::evaluate (Goals::AbstractGoal & g)
{
logAi->warnStream() << boost::format("Cannot evaluate goal %s") % g.name();
return g.priority;
}
void FuzzyHelper::setPriority (Goals::TSubgoal & g)
{
g->setpriority(g->accept(this)); //this enforces returned value is set
}
vcmi-0.98/AI/VCAI/Fuzzy.h 0000664 0000000 0000000 00000004402 12506717576 0014743 0 ustar 00root root 0000000 0000000 #pragma once
#include "fl/Headers.h"
#include "Goals.h"
/*
* Fuzzy.h, 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
*
*/
class VCAI;
class CArmedInstance;
class CBank;
class engineBase
{
public:
fl::Engine engine;
fl::RuleBlock rules;
engineBase();
void configure();
void addRule(const std::string &txt);
};
class FuzzyHelper
{
friend class VCAI;
class TacticalAdvantage : public engineBase
{
public:
fl::InputVariable * ourWalkers, * ourShooters, * ourFlyers, * enemyWalkers, * enemyShooters, * enemyFlyers;
fl::InputVariable * ourSpeed, * enemySpeed;
fl::InputVariable * bankPresent;
fl::InputVariable * castleWalls;
fl::OutputVariable * threat;
~TacticalAdvantage();
} ta;
class EvalVisitTile : public engineBase
{
public:
fl::InputVariable * strengthRatio;
fl::InputVariable * heroStrength;
fl::InputVariable * turnDistance;
fl::InputVariable * missionImportance;
fl::OutputVariable * value;
fl::RuleBlock rules;
~EvalVisitTile();
} vt;
public:
enum RuleBlocks {BANK_DANGER, TACTICAL_ADVANTAGE, VISIT_TILE};
//blocks should be initialized in this order, which may be confusing :/
FuzzyHelper();
void initTacticalAdvantage();
void initVisitTile();
float evaluate (Goals::Explore & g);
float evaluate (Goals::RecruitHero & g);
float evaluate (Goals::VisitTile & g);
float evaluate (Goals::VisitHero & g);
float evaluate (Goals::BuildThis & g);
float evaluate (Goals::DigAtTile & g);
float evaluate (Goals::CollectRes & g);
float evaluate (Goals::Build & g);
float evaluate (Goals::GatherArmy & g);
float evaluate (Goals::ClearWayTo & g);
float evaluate (Goals::Invalid & g);
float evaluate (Goals::AbstractGoal & g);
void setPriority (Goals::TSubgoal & g);
ui64 estimateBankDanger (const CBank * bank);
float getTacticalAdvantage (const CArmedInstance *we, const CArmedInstance *enemy); //returns factor how many times enemy is stronger than us
Goals::TSubgoal chooseSolution (Goals::TGoalVec vec);
//shared_ptr chooseSolution (std::vector> & vec);
};
vcmi-0.98/AI/VCAI/Goals.cpp 0000664 0000000 0000000 00000077723 12506717576 0015234 0 ustar 00root root 0000000 0000000 #include "StdInc.h"
#include "Goals.h"
#include "VCAI.h"
#include "Fuzzy.h"
#include "../../lib/mapping/CMap.h" //for victory conditions
/*
* Goals.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
*
*/
extern boost::thread_specific_ptr cb;
extern boost::thread_specific_ptr ai;
extern FuzzyHelper * fh; //TODO: this logic should be moved inside VCAI
using namespace vstd;
using namespace Goals;
TSubgoal Goals::sptr(const AbstractGoal & tmp)
{
shared_ptr ptr;
ptr.reset(tmp.clone());
return ptr;
}
std::string Goals::AbstractGoal::name() const //TODO: virtualize
{
std::string desc;
switch (goalType)
{
case INVALID:
return "INVALID";
case WIN:
return "WIN";
case DO_NOT_LOSE:
return "DO NOT LOOSE";
case CONQUER:
return "CONQUER";
case BUILD:
return "BUILD";
case EXPLORE:
desc = "EXPLORE";
break;
case GATHER_ARMY:
desc = "GATHER ARMY";
break;
case BOOST_HERO:
desc = "BOOST_HERO (unsupported)";
break;
case RECRUIT_HERO:
return "RECRUIT HERO";
case BUILD_STRUCTURE:
return "BUILD STRUCTURE";
case COLLECT_RES:
desc = "COLLECT RESOURCE";
break;
case GATHER_TROOPS:
desc = "GATHER TROOPS";
break;
case GET_OBJ:
{
auto obj = cb->getObjInstance(ObjectInstanceID(objid));
if (obj)
desc = "GET OBJ " + obj->getObjectName();
}
case FIND_OBJ:
desc = "FIND OBJ " + boost::lexical_cast(objid);
break;
case VISIT_HERO:
{
auto obj = cb->getObjInstance(ObjectInstanceID(objid));
if (obj)
desc = "VISIT HERO " + obj->getObjectName();
}
break;
case GET_ART_TYPE:
desc = "GET ARTIFACT OF TYPE " + VLC->arth->artifacts[aid]->Name();
break;
case ISSUE_COMMAND:
return "ISSUE COMMAND (unsupported)";
case VISIT_TILE:
desc = "VISIT TILE " + tile();
break;
case CLEAR_WAY_TO:
desc = "CLEAR WAY TO " + tile();
break;
case DIG_AT_TILE:
desc = "DIG AT TILE " + tile();
break;
default:
return boost::lexical_cast(goalType);
}
if (hero.get(true)) //FIXME: used to crash when we lost hero and failed goal
desc += " (" + hero->name + ")";
return desc;
}
//TODO: virtualize if code gets complex?
bool Goals::AbstractGoal::operator== (AbstractGoal &g)
{
if (g.goalType != goalType)
return false;
if (g.isElementar != isElementar) //elementar goals fulfill long term non-elementar goals (VisitTile)
return false;
switch (goalType)
{
//no parameters
case INVALID:
case WIN:
case DO_NOT_LOSE:
case RECRUIT_HERO: //recruit any hero, as yet
return true;
break;
//assigned to hero, no parameters
case CONQUER:
case EXPLORE:
case GATHER_ARMY: //actual value is indifferent
case BOOST_HERO:
return g.hero.h == hero.h; //how comes HeroPtrs are equal for different heroes?
break;
//assigned hero and tile
case VISIT_TILE:
case CLEAR_WAY_TO:
return (g.hero.h == hero.h && g.tile == tile);
break;
//assigned hero and object
case GET_OBJ:
case FIND_OBJ: //TODO: use subtype?
case VISIT_HERO:
case GET_ART_TYPE:
case DIG_AT_TILE:
return (g.hero.h == hero.h && g.objid == objid);
break;
//no check atm
case COLLECT_RES:
case GATHER_TROOPS:
case ISSUE_COMMAND:
case BUILD: //TODO: should be decomposed to build specific structures
case BUILD_STRUCTURE:
default:
return false;
}
}
//TODO: find out why the following are not generated automatically on MVS?
namespace Goals
{
template <>
void CGoal::accept (VCAI * ai)
{
ai->tryRealize(static_cast(*this));
}
template <>
void CGoal::accept (VCAI * ai)
{
ai->tryRealize(static_cast(*this));
}
template <>
float CGoal::accept (FuzzyHelper * f)
{
return f->evaluate(static_cast(*this));
}
template <>
float CGoal::accept (FuzzyHelper * f)
{
return f->evaluate(static_cast(*this));
}
}
//TSubgoal AbstractGoal::whatToDoToAchieve()
//{
// logAi->debugStream() << boost::format("Decomposing goal of type %s") % name();
// return sptr (Goals::Explore());
//}
TSubgoal Win::whatToDoToAchieve()
{
auto toBool = [=](const EventCondition &)
{
// TODO: proper implementation
// Right now even already fulfilled goals will be included into generated list
// Proper check should test if event condition is already fulfilled
// Easiest way to do this is to call CGameState::checkForVictory but this function should not be
// used on client side or in AI code
return false;
};
std::vector goals;
for (const TriggeredEvent & event : cb->getMapHeader()->triggeredEvents)
{
//TODO: try to eliminate human player(s) using loss conditions that have isHuman element
if (event.effect.type == EventEffect::VICTORY)
{
boost::range::copy(event.trigger.getFulfillmentCandidates(toBool), std::back_inserter(goals));
}
}
//TODO: instead of returning first encountered goal AI should generate list of possible subgoals
for (const EventCondition & goal : goals)
{
switch(goal.condition)
{
case EventCondition::HAVE_ARTIFACT:
return sptr (Goals::GetArtOfType(goal.objectType));
case EventCondition::DESTROY:
{
if (goal.object)
{
return sptr (Goals::GetObj(goal.object->id.getNum()));
}
else
{
// TODO: destroy all objects of type goal.objectType
// This situation represents "kill all creatures" condition from H3
break;
}
}
case EventCondition::HAVE_BUILDING:
{
// TODO build other buildings apart from Grail
// goal.objectType = buidingID to build
// goal.object = optional, town in which building should be built
// Represents "Improve town" condition from H3 (but unlike H3 it consists from 2 separate conditions)
if (goal.objectType == BuildingID::GRAIL)
{
if(auto h = ai->getHeroWithGrail())
{
//hero is in a town that can host Grail
if(h->visitedTown && !vstd::contains(h->visitedTown->forbiddenBuildings, BuildingID::GRAIL))
{
const CGTownInstance *t = h->visitedTown;
return sptr (Goals::BuildThis(BuildingID::GRAIL, t));
}
else
{
auto towns = cb->getTownsInfo();
towns.erase(boost::remove_if(towns,
[](const CGTownInstance *t) -> bool
{
return vstd::contains(t->forbiddenBuildings, BuildingID::GRAIL);
}),
towns.end());
boost::sort(towns, CDistanceSorter(h.get()));
if(towns.size())
{
return sptr (Goals::VisitTile(towns.front()->visitablePos()).sethero(h));
}
}
}
double ratio = 0;
// maybe make this check a bit more complex? For example:
// 0.75 -> dig randomly within 3 tiles radius
// 0.85 -> radius now 2 tiles
// 0.95 -> 1 tile radius, position is fully known
// AFAIK H3 AI does something like this
int3 grailPos = cb->getGrailPos(ratio);
if(ratio > 0.99)
{
return sptr (Goals::DigAtTile(grailPos));
} //TODO: use FIND_OBJ
else if(const CGObjectInstance * obj = ai->getUnvisitedObj(objWithID)) //there are unvisited Obelisks
return sptr (Goals::GetObj(obj->id.getNum()));
else
return sptr (Goals::Explore());
}
break;
}
case EventCondition::CONTROL:
{
if (goal.object)
{
return sptr (Goals::GetObj(goal.object->id.getNum()));
}
else
{
//TODO: control all objects of type "goal.objectType"
// Represents H3 condition "Flag all mines"
break;
}
}
case EventCondition::HAVE_RESOURCES:
//TODO mines? piles? marketplace?
//save?
return sptr (Goals::CollectRes(static_cast(goal.objectType), goal.value));
case EventCondition::HAVE_CREATURES:
return sptr (Goals::GatherTroops(goal.objectType, goal.value));
case EventCondition::TRANSPORT:
{
//TODO. merge with bring Grail to town? So AI will first dig grail, then transport it using this goal and builds it
// Represents "transport artifact" condition:
// goal.objectType = type of artifact
// goal.object = destination-town where artifact should be transported
break;
}
case EventCondition::STANDARD_WIN:
return sptr (Goals::Conquer());
// Conditions that likely don't need any implementation
case EventCondition::DAYS_PASSED:
break; // goal.value = number of days for condition to trigger
case EventCondition::DAYS_WITHOUT_TOWN:
break; // goal.value = number of days to trigger this
case EventCondition::IS_HUMAN:
break; // Should be only used in calculation of candidates (see toBool lambda)
case EventCondition::CONST_VALUE:
break;
default:
assert(0);
}
}
return sptr (Goals::Invalid());
}
TSubgoal FindObj::whatToDoToAchieve()
{
const CGObjectInstance * o = nullptr;
if (resID > -1) //specified
{
for(const CGObjectInstance *obj : ai->visitableObjs)
{
if(obj->ID == objid && obj->subID == resID)
{
o = obj;
break; //TODO: consider multiple objects and choose best
}
}
}
else
{
for(const CGObjectInstance *obj : ai->visitableObjs)
{
if(obj->ID == objid)
{
o = obj;
break; //TODO: consider multiple objects and choose best
}
}
}
if (o && ai->isAccessible(o->pos)) //we don't use isAccessibleForHero as we don't know which hero it is
return sptr (Goals::GetObj(o->id.getNum()));
else
return sptr (Goals::Explore());
}
std::string GetObj::completeMessage() const
{
return "hero " + hero.get()->name + " captured Object ID = " + boost::lexical_cast(objid);
}
TSubgoal GetObj::whatToDoToAchieve()
{
const CGObjectInstance * obj = cb->getObj(ObjectInstanceID(objid));
if(!obj)
return sptr (Goals::Explore());
if (obj->tempOwner == ai->playerID) //we can't capture our own object -> move to Win codition
throw cannotFulfillGoalException("Cannot capture my own object " + obj->getObjectName());
int3 pos = obj->visitablePos();
if (hero)
{
if (ai->isAccessibleForHero(pos, hero))
return sptr (Goals::VisitTile(pos).sethero(hero));
}
else
{
for (auto h : cb->getHeroesInfo())
{
if (ai->isAccessibleForHero(pos, h))
return sptr(Goals::VisitTile(pos).sethero(h)); //we must visit object with same hero, if any
}
}
return sptr (Goals::ClearWayTo(pos).sethero(hero));
}
bool GetObj::fulfillsMe (TSubgoal goal)
{
if (goal->goalType == Goals::VISIT_TILE)
{
auto obj = cb->getObj(ObjectInstanceID(objid));
if (obj && obj->visitablePos() == goal->tile) //object could be removed
return true;
}
return false;
}
std::string VisitHero::completeMessage() const
{
return "hero " + hero.get()->name + " visited hero " + boost::lexical_cast(objid);
}
TSubgoal VisitHero::whatToDoToAchieve()
{
const CGObjectInstance * obj = cb->getObj(ObjectInstanceID(objid));
if(!obj)
return sptr (Goals::Explore());
int3 pos = obj->visitablePos();
if (hero && ai->isAccessibleForHero(pos, hero, true) && isSafeToVisit(hero, pos)) //enemy heroes can get reinforcements
{
if (hero->pos == pos)
logAi->errorStream() << "Hero " << hero.name << " tries to visit himself.";
else
{
//can't use VISIT_TILE here as tile appears blocked by target hero
//FIXME: elementar goal should not be abstract
return sptr (Goals::VisitHero(objid).sethero(hero).settile(pos).setisElementar(true));
}
}
return sptr (Goals::Invalid());
}
bool VisitHero::fulfillsMe (TSubgoal goal)
{
if (goal->goalType == Goals::VISIT_TILE && cb->getObj(ObjectInstanceID(objid))->visitablePos() == goal->tile)
return true;
else
return false;
}
TSubgoal GetArtOfType::whatToDoToAchieve()
{
TSubgoal alternativeWay = CGoal::lookForArtSmart(aid); //TODO: use
if(alternativeWay->invalid())
return sptr (Goals::FindObj(Obj::ARTIFACT, aid));
return sptr (Goals::Invalid());
}
TSubgoal ClearWayTo::whatToDoToAchieve()
{
assert(cb->isInTheMap(tile)); //set tile
if(!cb->isVisible(tile))
{
logAi->errorStream() << "Clear way should be used with visible tiles!";
return sptr (Goals::Explore());
}
return (fh->chooseSolution(getAllPossibleSubgoals()));
}
TGoalVec ClearWayTo::getAllPossibleSubgoals()
{
TGoalVec ret;
std::vector heroes;
if (hero)
heroes.push_back(hero.h);
else
{
heroes = cb->getHeroesInfo();
}
for (auto h : heroes)
{
//TODO: handle clearing way to allied heroes that are blocked
//if ((hero && hero->visitablePos() == tile && hero == *h) || //we can't free the way ourselves
// h->visitablePos() == tile) //we are already on that tile! what does it mean?
// continue;
//if our hero is trapped, make sure we request clearing the way from OUR perspective
SectorMap sm(h);
int3 tileToHit = sm.firstTileToGet(h, tile);
if (!tileToHit.valid())
continue;
if (isBlockedBorderGate(tileToHit))
{ //FIXME: this way we'll not visit gate and activate quest :?
ret.push_back (sptr (Goals::FindObj (Obj::KEYMASTER, cb->getTile(tileToHit)->visitableObjects.back()->subID)));
}
auto topObj = cb->getTopObj(tileToHit);
if (topObj)
{
if (vstd::contains(ai->reservedObjs, topObj) && !vstd::contains(ai->reservedHeroesMap[h], topObj))
{
throw goalFulfilledException (sptr(Goals::ClearWayTo(tile, h)));
continue; //do not capure object reserved by other hero
}
if (topObj->ID == Obj::HERO && cb->getPlayerRelations(h->tempOwner, topObj->tempOwner) != PlayerRelations::ENEMIES)
if (topObj != hero.get(true)) //the hero we want to free
logAi->errorStream() << boost::format("%s stands in the way of %s") % topObj->getObjectName() % h->getObjectName();
if (topObj->ID == Obj::QUEST_GUARD || topObj->ID == Obj::BORDERGUARD)
{
if (shouldVisit(h, topObj))
{
//do NOT use VISIT_TILE, as tile with quets guard can't be visited
ret.push_back (sptr (Goals::GetObj(topObj->id.getNum()).sethero(h)));
continue; //do not try to visit tile or gather army
}
else
{
//TODO: we should be able to return apriopriate quest here (VCAI::striveToQuest)
logAi->debugStream() << "Quest guard blocks the way to " + tile();
}
}
}
if (isSafeToVisit(h, tileToHit)) //this makes sense only if tile is guarded, but there i no quest object
{
ret.push_back (sptr (Goals::VisitTile(tileToHit).sethero(h)));
}
else
{
ret.push_back (sptr (Goals::GatherArmy(evaluateDanger(tileToHit, h)*SAFE_ATTACK_CONSTANT).
sethero(h).setisAbstract(true)));
}
}
if (ai->canRecruitAnyHero())
ret.push_back (sptr (Goals::RecruitHero()));
if (ret.empty())
{
logAi->warnStream() << "There is no known way to clear the way to tile " + tile();
throw goalFulfilledException (sptr(Goals::ClearWayTo(tile))); //make sure asigned hero gets unlocked
}
return ret;
}
std::string Explore::completeMessage() const
{
return "Hero " + hero.get()->name + " completed exploration";
}
TSubgoal Explore::whatToDoToAchieve()
{
auto ret = fh->chooseSolution(getAllPossibleSubgoals());
if (hero) //use best step for this hero
return ret;
else
{
if (ret->hero.get(true))
return sptr (sethero(ret->hero.h).setisAbstract(true)); //choose this hero and then continue with him
else
return ret; //other solutions, like buying hero from tavern
}
}
TGoalVec Explore::getAllPossibleSubgoals()
{
TGoalVec ret;
std::vector heroes;
if (hero)
heroes.push_back(hero.h);
else
{
//heroes = ai->getUnblockedHeroes();
heroes = cb->getHeroesInfo();
erase_if (heroes, [](const HeroPtr h)
{
if (ai->getGoal(h)->goalType == Goals::EXPLORE) //do not reassign hero who is already explorer
return true;
if (!ai->isAbleToExplore(h))
return true;
return !h->movement; //saves time, immobile heroes are useless anyway
});
}
//try to use buildings that uncover map
std::vector objs;
for (auto obj : ai->visitableObjs)
{
if (!vstd::contains(ai->alreadyVisited, obj))
{
switch (obj->ID.num)
{
case Obj::REDWOOD_OBSERVATORY:
case Obj::PILLAR_OF_FIRE:
case Obj::CARTOGRAPHER:
objs.push_back (obj);
break;
case Obj::MONOLITH_ONE_WAY_ENTRANCE:
case Obj::MONOLITH_TWO_WAY:
case Obj::SUBTERRANEAN_GATE:
auto tObj = dynamic_cast(obj);
assert(ai->knownTeleportChannels.find(tObj->channel) != ai->knownTeleportChannels.end());
if(TeleportChannel::IMPASSABLE != ai->knownTeleportChannels[tObj->channel]->passability)
objs.push_back (obj);
break;
}
}
else
{
switch (obj->ID.num)
{
case Obj::MONOLITH_TWO_WAY:
case Obj::SUBTERRANEAN_GATE:
auto tObj = dynamic_cast(obj);
if(TeleportChannel::IMPASSABLE == ai->knownTeleportChannels[tObj->channel]->passability)
break;
for(auto exit : ai->knownTeleportChannels[tObj->channel]->exits)
{
if(!cb->getObj(exit))
{ // Always attempt to visit two-way teleports if one of channel exits is not visible
objs.push_back(obj);
break;
}
}
break;
}
}
}
for (auto h : heroes)
{
SectorMap sm(h);
for (auto obj : objs) //double loop, performance risk?
{
auto t = sm.firstTileToGet(h, obj->visitablePos()); //we assume that no more than one tile on the way is guarded
if (ai->canReachTile(h, t))
ret.push_back (sptr(Goals::ClearWayTo(obj->visitablePos(), h).setisAbstract(true)));
}
int3 t = whereToExplore(h);
if (t.valid())
{
ret.push_back (sptr (Goals::VisitTile(t).sethero(h)));
}
else
{
ai->markHeroUnableToExplore (h); //there is no freely accessible tile, do not poll this hero anymore
//possible issues when gathering army to break
if (hero.h == h || (!hero && h == ai->primaryHero().h)) //check this only ONCE, high cost
{
t = ai->explorationDesperate(h);
if (t.valid()) //don't waste time if we are completely blocked
ret.push_back (sptr(Goals::ClearWayTo(t, h).setisAbstract(true)));
}
}
}
//we either don't have hero yet or none of heroes can explore
if ((!hero || ret.empty()) && ai->canRecruitAnyHero())
ret.push_back (sptr(Goals::RecruitHero()));
if (ret.empty())
{
throw goalFulfilledException (sptr(Goals::Explore().sethero(hero)));
}
//throw cannotFulfillGoalException("Cannot explore - no possible ways found!");
return ret;
}
bool Explore::fulfillsMe (TSubgoal goal)
{
if (goal->goalType == Goals::EXPLORE)
{
if (goal->hero)
return hero == goal->hero;
else
return true; //cancel ALL exploration
}
return false;
}
TSubgoal RecruitHero::whatToDoToAchieve()
{
const CGTownInstance *t = ai->findTownWithTavern();
if(!t)
return sptr (Goals::BuildThis(BuildingID::TAVERN));
if(cb->getResourceAmount(Res::GOLD) < HERO_GOLD_COST)
return sptr (Goals::CollectRes(Res::GOLD, HERO_GOLD_COST));
return iAmElementar();
}
std::string VisitTile::completeMessage() const
{
return "Hero " + hero.get()->name + " visited tile " + tile();
}
TSubgoal VisitTile::whatToDoToAchieve()
{
auto ret = fh->chooseSolution(getAllPossibleSubgoals());
if (ret->hero)
{
if (isSafeToVisit(ret->hero, tile) && ai->isAccessibleForHero(tile, ret->hero))
{
ret->setisElementar(true);
return ret;
}
else
{
return sptr (Goals::GatherArmy(evaluateDanger(tile, *ret->hero) * SAFE_ATTACK_CONSTANT)
.sethero(ret->hero).setisAbstract(true));
}
}
return ret;
}
TGoalVec VisitTile::getAllPossibleSubgoals()
{
assert(cb->isInTheMap(tile));
TGoalVec ret;
if (!cb->isVisible(tile))
ret.push_back (sptr(Goals::Explore())); //what sense does it make?
else
{
std::vector heroes;
if (hero)
heroes.push_back(hero.h); //use assigned hero if any
else
heroes = cb->getHeroesInfo(); //use most convenient hero
for (auto h : heroes)
{
if (ai->isAccessibleForHero(tile, h))
ret.push_back (sptr(Goals::VisitTile(tile).sethero(h)));
}
if (ai->canRecruitAnyHero())
ret.push_back (sptr(Goals::RecruitHero()));
}
if (ret.empty())
{
auto obj = frontOrNull(cb->getVisitableObjs(tile));
if (obj && obj->ID == Obj::HERO && obj->tempOwner == ai->playerID) //our own hero stands on that tile
{
if (hero.get(true) && hero->id == obj->id) //if it's assigned hero, visit tile. If it's different hero, we can't visit tile now
ret.push_back(sptr(Goals::VisitTile(tile).sethero(dynamic_cast(obj)).setisElementar(true)));
else
throw cannotFulfillGoalException("Tile is already occupied by another hero "); //FIXME: we should give up this tile earlier
}
else
ret.push_back (sptr(Goals::ClearWayTo(tile)));
}
//important - at least one sub-goal must handle case which is impossible to fulfill (unreachable tile)
return ret;
}
TSubgoal DigAtTile::whatToDoToAchieve()
{
const CGObjectInstance *firstObj = frontOrNull(cb->getVisitableObjs(tile));
if(firstObj && firstObj->ID == Obj::HERO && firstObj->tempOwner == ai->playerID) //we have hero at dest
{
const CGHeroInstance *h = dynamic_cast(firstObj);
sethero(h).setisElementar(true);
return sptr (*this);
}
return sptr (Goals::VisitTile(tile));
}
TSubgoal BuildThis::whatToDoToAchieve()
{
//TODO check res
//look for town
//prerequisites?
return iAmElementar();
}
TSubgoal CollectRes::whatToDoToAchieve()
{
std::vector markets;
std::vector visObjs;
ai->retreiveVisitableObjs(visObjs, true);
for(const CGObjectInstance *obj : visObjs)
{
if(const IMarket *m = IMarket::castFrom(obj, false))
{
if(obj->ID == Obj::TOWN && obj->tempOwner == ai->playerID && m->allowsTrade(EMarketMode::RESOURCE_RESOURCE))
markets.push_back(m);
else if(obj->ID == Obj::TRADING_POST) //TODO a moze po prostu test na pozwalanie handlu?
markets.push_back(m);
}
}
boost::sort(markets, [](const IMarket *m1, const IMarket *m2) -> bool
{
return m1->getMarketEfficiency() < m2->getMarketEfficiency();
});
markets.erase(boost::remove_if(markets, [](const IMarket *market) -> bool
{
return !(market->o->ID == Obj::TOWN && market->o->tempOwner == ai->playerID)
&& !ai->isAccessible(market->o->visitablePos());
}),markets.end());
if(!markets.size())
{
for(const CGTownInstance *t : cb->getTownsInfo())
{
if(cb->canBuildStructure(t, BuildingID::MARKETPLACE) == EBuildingState::ALLOWED)
return sptr (Goals::BuildThis(BuildingID::MARKETPLACE, t));
}
}
else
{
const IMarket *m = markets.back();
//attempt trade at back (best prices)
int howManyCanWeBuy = 0;
for(Res::ERes i = Res::WOOD; i <= Res::GOLD; vstd::advance(i, 1))
{
if(i == resID) continue;
int toGive = -1, toReceive = -1;
m->getOffer(i, resID, toGive, toReceive, EMarketMode::RESOURCE_RESOURCE);
assert(toGive > 0 && toReceive > 0);
howManyCanWeBuy += toReceive * (cb->getResourceAmount(i) / toGive);
}
if(howManyCanWeBuy + cb->getResourceAmount(static_cast(resID)) >= value)
{
auto backObj = cb->getTopObj(m->o->visitablePos()); //it'll be a hero if we have one there; otherwise marketplace
assert(backObj);
if (backObj->tempOwner != ai->playerID)
{
return sptr (Goals::GetObj(m->o->id.getNum()));
}
else
{
return sptr (Goals::GetObj(m->o->id.getNum()).setisElementar(true));
}
}
}
return sptr (setisElementar(true)); //all the conditions for trade are met
}
TSubgoal GatherTroops::whatToDoToAchieve()
{
std::vector dwellings;
for(const CGTownInstance *t : cb->getTownsInfo())
{
auto creature = VLC->creh->creatures[objid];
if (t->subID == creature->faction) //TODO: how to force AI to build unupgraded creatures? :O
{
auto creatures = vstd::tryAt(t->town->creatures, creature->level - 1);
if(!creatures)
continue;
int upgradeNumber = vstd::find_pos(*creatures, creature->idNumber);
if(upgradeNumber < 0)
continue;
BuildingID bid(BuildingID::DWELL_FIRST + creature->level - 1 + upgradeNumber * GameConstants::CREATURES_PER_TOWN);
if (t->hasBuilt(bid)) //this assumes only creatures with dwellings are assigned to faction
{
dwellings.push_back(t);
}
else
{
return sptr (Goals::BuildThis(bid, t));
}
}
}
for (auto obj : ai->visitableObjs)
{
if (obj->ID != Obj::CREATURE_GENERATOR1) //TODO: what with other creature generators?
continue;
auto d = dynamic_cast(obj);
for (auto creature : d->creatures)
{
if (creature.first) //there are more than 0 creatures avaliabe
{
for (auto type : creature.second)
{
if (type == objid && ai->freeResources().canAfford(VLC->creh->creatures[type]->cost))
dwellings.push_back(d);
}
}
}
}
if (dwellings.size())
{
typedef std::map TDwellMap;
// sorted helper
auto comparator = [](const TDwellMap::value_type & a, const TDwellMap::value_type & b) -> bool
{
const CGPathNode *ln = ai->myCb->getPathsInfo(a.first)->getPathInfo(a.second->visitablePos()),
*rn = ai->myCb->getPathsInfo(b.first)->getPathInfo(b.second->visitablePos());
if(ln->turns != rn->turns)
return ln->turns < rn->turns;
return (ln->moveRemains > rn->moveRemains);
};
// for all owned heroes generate map nearest dwelling>
TDwellMap nearestDwellings;
for (const CGHeroInstance * hero : cb->getHeroesInfo(true))
{
nearestDwellings[hero] = *boost::range::min_element(dwellings, CDistanceSorter(hero));
}
// find hero who is nearest to a dwelling
const CGDwelling * nearest = boost::range::min_element(nearestDwellings, comparator)->second;
return sptr (Goals::GetObj(nearest->id.getNum()));
}
else
return sptr (Goals::Explore());
//TODO: exchange troops between heroes
}
TSubgoal Conquer::whatToDoToAchieve()
{
return fh->chooseSolution (getAllPossibleSubgoals());
}
TGoalVec Conquer::getAllPossibleSubgoals()
{
TGoalVec ret;
auto conquerable = [](const CGObjectInstance * obj) -> bool
{
if (cb->getPlayerRelations(ai->playerID, obj->tempOwner) == PlayerRelations::ENEMIES)
{
switch (obj->ID.num)
{
case Obj::TOWN:
case Obj::HERO:
case Obj::CREATURE_GENERATOR1:
case Obj::MINE: //TODO: check ai->knownSubterraneanGates
return true;
}
}
return false;
};
std::vector objs;
for (auto obj : ai->visitableObjs)
{
if (conquerable(obj))
objs.push_back (obj);
}
for (auto h : cb->getHeroesInfo())
{
SectorMap sm(h);
std::vector ourObjs(objs); //copy common objects
for (auto obj : ai->reservedHeroesMap[h]) //add objects reserved by this hero
{
if (conquerable(obj))
ourObjs.push_back(obj);
}
for (auto obj : ourObjs) //double loop, performance risk?
{
auto t = sm.firstTileToGet(h, obj->visitablePos()); //we assume that no more than one tile on the way is guarded
if (ai->canReachTile(h, t))
ret.push_back (sptr(Goals::ClearWayTo(obj->visitablePos(), h).setisAbstract(true)));
}
}
if (!objs.empty() && ai->canRecruitAnyHero()) //probably no point to recruit hero if we see no objects to capture
ret.push_back (sptr(Goals::RecruitHero()));
if (ret.empty())
ret.push_back (sptr(Goals::Explore())); //we need to find an enemy
return ret;
}
TSubgoal Build::whatToDoToAchieve()
{
return iAmElementar();
}
TSubgoal Invalid::whatToDoToAchieve()
{
return iAmElementar();
}
std::string GatherArmy::completeMessage() const
{
return "Hero " + hero.get()->name + " gathered army of value " + boost::lexical_cast(value);
}
TSubgoal GatherArmy::whatToDoToAchieve()
{
//TODO: find hero if none set
assert(hero.h);
return fh->chooseSolution (getAllPossibleSubgoals()); //find dwelling. use current hero to prevent him from doing nothing.
}
TGoalVec GatherArmy::getAllPossibleSubgoals()
{
//get all possible towns, heroes and dwellings we may use
TGoalVec ret;
//TODO: include evaluation of monsters gather in calculation
for (auto t : cb->getTownsInfo())
{
auto pos = t->visitablePos();
if (ai->isAccessibleForHero(pos, hero))
{
if(!t->visitingHero && howManyReinforcementsCanGet(hero,t))
{
if (!vstd::contains (ai->townVisitsThisWeek[hero], t))
ret.push_back (sptr (Goals::VisitTile(pos).sethero(hero)));
}
auto bid = ai->canBuildAnyStructure(t, std::vector
(unitsSource, unitsSource + ARRAY_COUNT(unitsSource)), 8 - cb->getDate(Date::DAY_OF_WEEK));
if (bid != BuildingID::NONE)
ret.push_back (sptr(BuildThis(bid, t)));
}
}
auto otherHeroes = cb->getHeroesInfo();
auto heroDummy = hero;
erase_if(otherHeroes, [heroDummy](const CGHeroInstance * h)
{
return (h == heroDummy.h || !ai->isAccessibleForHero(heroDummy->visitablePos(), h, true)
|| !ai->canGetArmy(heroDummy.h, h) || ai->getGoal(h)->goalType == Goals::GATHER_ARMY);
});
for (auto h : otherHeroes)
{
ret.push_back (sptr (Goals::VisitHero(h->id.getNum()).setisAbstract(true).sethero(hero)));
//go to the other hero if we are faster
ret.push_back (sptr (Goals::VisitHero(hero->id.getNum()).setisAbstract(true).sethero(h)));
//let the other hero come to us
}
std::vector objs;
for (auto obj : ai->visitableObjs)
{
if(obj->ID == Obj::CREATURE_GENERATOR1)
{
auto relationToOwner = cb->getPlayerRelations(obj->getOwner(), ai->playerID);
//Use flagged dwellings only when there are available creatures that we can afford
if(relationToOwner == PlayerRelations::SAME_PLAYER)
{
auto dwelling = dynamic_cast(obj);
for(auto & creLevel : dwelling->creatures)
{
if(creLevel.first)
{
for(auto & creatureID : creLevel.second)
{
auto creature = VLC->creh->creatures[creatureID];
if (ai->freeResources().canAfford(creature->cost))
objs.push_back(obj);
}
}
}
}
}
}
for(auto h : cb->getHeroesInfo())
{
SectorMap sm(h);
for (auto obj : objs)
{ //find safe dwelling
auto pos = obj->visitablePos();
if (ai->isGoodForVisit(obj, h, sm))
ret.push_back (sptr (Goals::VisitTile(pos).sethero(h)));
}
}
if (ai->canRecruitAnyHero()) //this is not stupid in early phase of game
ret.push_back (sptr(Goals::RecruitHero()));
if (ret.empty())
{
if (hero == ai->primaryHero() || value >= 1.1f)
ret.push_back (sptr(Goals::Explore()));
else //workaround to break loop - seemingly there are no ways to explore left
throw goalFulfilledException (sptr(Goals::GatherArmy(0).sethero(hero)));
}
return ret;
}
//TSubgoal AbstractGoal::whatToDoToAchieve()
//{
// logAi->debugStream() << boost::format("Decomposing goal of type %s") % name();
// return sptr (Goals::Explore());
//}
TSubgoal AbstractGoal::goVisitOrLookFor(const CGObjectInstance *obj)
{
if(obj)
return sptr (Goals::GetObj(obj->id.getNum()));
else
return sptr (Goals::Explore());
}
TSubgoal AbstractGoal::lookForArtSmart(int aid)
{
return sptr (Goals::Invalid());
}
bool AbstractGoal::invalid() const
{
return goalType == INVALID;
}
void AbstractGoal::accept (VCAI * ai)
{
ai->tryRealize(*this);
}
template
void CGoal::accept (VCAI * ai)
{
ai->tryRealize(static_cast(*this)); //casting enforces template instantiation
}
float AbstractGoal::accept (FuzzyHelper * f)
{
return f->evaluate(*this);
}
template
float CGoal::accept (FuzzyHelper * f)
{
return f->evaluate(static_cast(*this)); //casting enforces template instantiation
}
vcmi-0.98/AI/VCAI/Goals.h 0000664 0000000 0000000 00000026550 12506717576 0014671 0 ustar 00root root 0000000 0000000 #pragma once
#include "../../lib/VCMI_Lib.h"
#include "../../lib/CBuildingHandler.h"
#include "../../lib/CCreatureHandler.h"
#include "../../lib/CTownHandler.h"
#include "AIUtility.h"
/*
* Goals.h, 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
*
*/
struct HeroPtr;
class VCAI;
class FuzzyHelper;
namespace Goals
{
struct AbstractGoal;
class VisitTile;
typedef std::shared_ptr TSubgoal;
typedef std::vector TGoalVec;
enum EGoals
{
INVALID = -1,
WIN, DO_NOT_LOSE, CONQUER, BUILD, //build needs to get a real reasoning
EXPLORE, GATHER_ARMY, BOOST_HERO,
RECRUIT_HERO,
BUILD_STRUCTURE, //if hero set, then in visited town
COLLECT_RES,
GATHER_TROOPS, // val of creatures with objid
OBJECT_GOALS_BEGIN,
GET_OBJ, //visit or defeat or collect the object
FIND_OBJ, //find and visit any obj with objid + resid //TODO: consider universal subid for various types (aid, bid)
VISIT_HERO, //heroes can move around - set goal abstract and track hero every turn
GET_ART_TYPE,
//BUILD_STRUCTURE,
ISSUE_COMMAND,
VISIT_TILE, //tile, in conjunction with hero elementar; assumes tile is reachable
CLEAR_WAY_TO,
DIG_AT_TILE //elementar with hero on tile
};
//method chaining + clone pattern
#define VSETTER(type, field) virtual AbstractGoal & set ## field(const type &rhs) {field = rhs; return *this;};
#define OSETTER(type, field) CGoal & set ## field(const type &rhs) override { field = rhs; return *this; };
#if 0
#define SETTER
#endif // _DEBUG
enum {LOW_PR = -1};
TSubgoal sptr(const AbstractGoal & tmp);
class AbstractGoal
{
public:
bool isElementar; VSETTER(bool, isElementar)
bool isAbstract; VSETTER(bool, isAbstract)
float priority; VSETTER(float, priority)
int value; VSETTER(int, value)
int resID; VSETTER(int, resID)
int objid; VSETTER(int, objid)
int aid; VSETTER(int, aid)
int3 tile; VSETTER(int3, tile)
HeroPtr hero; VSETTER(HeroPtr, hero)
const CGTownInstance *town; VSETTER(CGTownInstance *, town)
int bid; VSETTER(int, bid)
AbstractGoal (EGoals goal = INVALID) : goalType (goal)
{
priority = 0;
isElementar = false;
isAbstract = false;
value = 0;
aid = -1;
resID = -1;
tile = int3(-1, -1, -1);
town = nullptr;
}
virtual ~AbstractGoal(){};
//FIXME: abstract goal should be abstract, but serializer fails to instantiate subgoals in such case
virtual AbstractGoal * clone() const {return const_cast(this);};
virtual TGoalVec getAllPossibleSubgoals() {TGoalVec vec; return vec;};
virtual TSubgoal whatToDoToAchieve() {return sptr(AbstractGoal());};
EGoals goalType;
std::string name() const;
virtual std::string completeMessage() const {return "This goal is unspecified!";};
bool invalid() const;
static TSubgoal goVisitOrLookFor(const CGObjectInstance *obj); //if obj is nullptr, then we'll explore
static TSubgoal lookForArtSmart(int aid); //checks non-standard ways of obtaining art (merchants, quests, etc.)
static TSubgoal tryRecruitHero();
///Visitor pattern
//TODO: make accept work for shared_ptr... somehow
virtual void accept (VCAI * ai); //unhandled goal will report standard error
virtual float accept (FuzzyHelper * f);
virtual bool operator== (AbstractGoal &g);
virtual bool fulfillsMe (Goals::TSubgoal goal) //TODO: multimethod instead of type check
{
return false;
}
template void serialize(Handler &h, const int version)
{
h & goalType & isElementar & isAbstract & priority;
h & value & resID & objid & aid & tile & hero & town & bid;
}
};
template class CGoal : public AbstractGoal
{
public:
CGoal (EGoals goal = INVALID) : AbstractGoal (goal)
{
priority = 0;
isElementar = false;
isAbstract = false;
value = 0;
aid = -1;
resID = -1;
tile = int3(-1, -1, -1);
town = nullptr;
}
OSETTER(bool, isElementar)
OSETTER(bool, isAbstract)
OSETTER(float, priority)
OSETTER(int, value)
OSETTER(int, resID)
OSETTER(int, objid)
OSETTER(int, aid)
OSETTER(int3, tile)
OSETTER(HeroPtr, hero)
OSETTER(CGTownInstance *, town)
OSETTER(int, bid)
void accept (VCAI * ai) override;
float accept (FuzzyHelper * f) override;
CGoal * clone() const override
{
return new T(static_cast(*this)); //casting enforces template instantiation
}
TSubgoal iAmElementar()
{
setisElementar(true);
shared_ptr ptr;
ptr.reset(clone());
return ptr;
}
template void serialize(Handler &h, const int version)
{
h & static_cast (*this);
//h & goalType & isElementar & isAbstract & priority;
//h & value & resID & objid & aid & tile & hero & town & bid;
}
};
class Invalid : public CGoal
{
public:
Invalid() : CGoal (Goals::INVALID) {priority = -1e10;};
TGoalVec getAllPossibleSubgoals() override {return TGoalVec();};
TSubgoal whatToDoToAchieve() override;
};
class Win : public CGoal
{
public:
Win() : CGoal (Goals::WIN) {priority = 100;};
TGoalVec getAllPossibleSubgoals() override {return TGoalVec();};
TSubgoal whatToDoToAchieve() override;
};
class NotLose : public CGoal
{
public:
NotLose() : CGoal (Goals::DO_NOT_LOSE) {priority = 100;};
TGoalVec getAllPossibleSubgoals() override {return TGoalVec();};
//TSubgoal whatToDoToAchieve() override;
};
class Conquer : public CGoal
{
public:
Conquer() : CGoal (Goals::CONQUER) {priority = 10;};
TGoalVec getAllPossibleSubgoals() override;
TSubgoal whatToDoToAchieve() override;
};
class Build : public CGoal
{
public:
Build() : CGoal (Goals::BUILD) {priority = 1;};
TGoalVec getAllPossibleSubgoals() override {return TGoalVec();};
TSubgoal whatToDoToAchieve() override;
};
class Explore : public CGoal
{
public:
Explore() : CGoal (Goals::EXPLORE){priority = 1;};
Explore(HeroPtr h) : CGoal (Goals::EXPLORE){hero = h; priority = 1;};
TGoalVec getAllPossibleSubgoals() override;
TSubgoal whatToDoToAchieve() override;
std::string completeMessage() const override;
bool fulfillsMe (TSubgoal goal) override;
};
class GatherArmy : public CGoal
{
public:
GatherArmy() : CGoal (Goals::GATHER_ARMY){};
GatherArmy(int val) : CGoal (Goals::GATHER_ARMY){value = val; priority = 2.5;};
TGoalVec getAllPossibleSubgoals() override;
TSubgoal whatToDoToAchieve() override;
std::string completeMessage() const override;
};
class BoostHero : public CGoal
{
public:
BoostHero() : CGoal (Goals::INVALID){priority = -1e10;}; //TODO
TGoalVec getAllPossibleSubgoals() override {return TGoalVec();};
//TSubgoal whatToDoToAchieve() override {return sptr(Invalid());};
};
class RecruitHero : public CGoal
{
public:
RecruitHero() : CGoal (Goals::RECRUIT_HERO){priority = 1;};
TGoalVec getAllPossibleSubgoals() override {return TGoalVec();};
TSubgoal whatToDoToAchieve() override;
};
class BuildThis : public CGoal
{
public:
BuildThis() : CGoal (Goals::BUILD_STRUCTURE){}; //FIXME: should be not allowed (private)
BuildThis(BuildingID Bid, const CGTownInstance *tid) : CGoal (Goals::BUILD_STRUCTURE) {bid = Bid; town = tid; priority = 5;};
BuildThis(BuildingID Bid) : CGoal (Goals::BUILD_STRUCTURE) {bid = Bid; priority = 5;};
TGoalVec getAllPossibleSubgoals() override {return TGoalVec();};
TSubgoal whatToDoToAchieve() override;
};
class CollectRes : public CGoal
{
public:
CollectRes() : CGoal (Goals::COLLECT_RES){};
CollectRes(int rid, int val) : CGoal (Goals::COLLECT_RES) {resID = rid; value = val; priority = 2;};
TGoalVec getAllPossibleSubgoals() override {return TGoalVec();};
TSubgoal whatToDoToAchieve() override;
};
class GatherTroops : public CGoal
{
public:
GatherTroops() : CGoal (Goals::GATHER_TROOPS){priority = 2;};
GatherTroops(int type, int val) : CGoal (Goals::GATHER_TROOPS){objid = type; value = val; priority = 2;};
TGoalVec getAllPossibleSubgoals() override {return TGoalVec();};
TSubgoal whatToDoToAchieve() override;
};
class GetObj : public CGoal
{
public:
GetObj() {}; // empty constructor not allowed
GetObj(int Objid) : CGoal(Goals::GET_OBJ) {objid = Objid; priority = 3;};
TGoalVec getAllPossibleSubgoals() override {return TGoalVec();};
TSubgoal whatToDoToAchieve() override;
bool operator== (GetObj &g) {return g.objid == objid;}
bool fulfillsMe (TSubgoal goal) override;
std::string completeMessage() const override;
};
class FindObj : public CGoal
{
public:
FindObj() {}; // empty constructor not allowed
FindObj(int ID) : CGoal(Goals::FIND_OBJ) {objid = ID; priority = 1;};
FindObj(int ID, int subID) : CGoal(Goals::FIND_OBJ) {objid = ID; resID = subID; priority = 1;};
TGoalVec getAllPossibleSubgoals() override {return TGoalVec();};
TSubgoal whatToDoToAchieve() override;
};
class VisitHero : public CGoal
{
public:
VisitHero() : CGoal (Goals::VISIT_HERO){};
VisitHero(int hid) : CGoal (Goals::VISIT_HERO){objid = hid; priority = 4;};
TGoalVec getAllPossibleSubgoals() override {return TGoalVec();};
TSubgoal whatToDoToAchieve() override;
//bool operator== (VisitHero &g) {return g.objid == objid;}
bool fulfillsMe (TSubgoal goal) override;
std::string completeMessage() const override;
};
class GetArtOfType : public CGoal
{
public:
GetArtOfType() : CGoal (Goals::GET_ART_TYPE){};
GetArtOfType(int type) : CGoal (Goals::GET_ART_TYPE){aid = type; priority = 2;};
TGoalVec getAllPossibleSubgoals() override {return TGoalVec();};
TSubgoal whatToDoToAchieve() override;
};
class VisitTile : public CGoal
//tile, in conjunction with hero elementar; assumes tile is reachable
{
public:
VisitTile() {}; // empty constructor not allowed
VisitTile(int3 Tile) : CGoal (Goals::VISIT_TILE) {tile = Tile; priority = 5;};
TGoalVec getAllPossibleSubgoals() override;
TSubgoal whatToDoToAchieve() override;
//bool operator== (VisitTile &g) {return g.tile == tile;}
std::string completeMessage() const override;
};
class ClearWayTo : public CGoal
{
public:
ClearWayTo() : CGoal (Goals::CLEAR_WAY_TO){};
ClearWayTo(int3 Tile) : CGoal (Goals::CLEAR_WAY_TO) {tile = Tile; priority = 5;};
ClearWayTo(int3 Tile, HeroPtr h) : CGoal (Goals::CLEAR_WAY_TO) {tile = Tile; hero = h; priority = 5;};
TGoalVec getAllPossibleSubgoals() override;
TSubgoal whatToDoToAchieve() override;
bool operator== (ClearWayTo &g) {return g.tile == tile;}
};
class DigAtTile : public CGoal
//elementar with hero on tile
{
public:
DigAtTile() : CGoal (Goals::DIG_AT_TILE){};
DigAtTile(int3 Tile) : CGoal (Goals::DIG_AT_TILE) {tile = Tile; priority = 20;};
TGoalVec getAllPossibleSubgoals() override {return TGoalVec();};
TSubgoal whatToDoToAchieve() override;
bool operator== (DigAtTile &g) {return g.tile == tile;}
};
class CIssueCommand : public CGoal
{
std::function command;
public:
CIssueCommand(): CGoal(ISSUE_COMMAND){};
CIssueCommand(std::function _command): CGoal(ISSUE_COMMAND), command(_command) {priority = 1e10;};
TGoalVec getAllPossibleSubgoals() override {return TGoalVec();};
//TSubgoal whatToDoToAchieve() override {return sptr(Invalid());};
};
}
vcmi-0.98/AI/VCAI/StdInc.cpp 0000664 0000000 0000000 00000000025 12506717576 0015330 0 ustar 00root root 0000000 0000000 #include "StdInc.h"
vcmi-0.98/AI/VCAI/StdInc.h 0000664 0000000 0000000 00000000052 12506717576 0014775 0 ustar 00root root 0000000 0000000 #pragma once
#include "../../Global.h"
vcmi-0.98/AI/VCAI/VCAI.cbp 0000664 0000000 0000000 00000007302 12506717576 0014655 0 ustar 00root root 0000000 0000000
vcmi-0.98/AI/VCAI/VCAI.cpp 0000664 0000000 0000000 00000271155 12506717576 0014704 0 ustar 00root root 0000000 0000000 #include "StdInc.h"
#include "VCAI.h"
#include "Goals.h"
#include "Fuzzy.h"
#include "../../lib/UnlockGuard.h"
#include "../../lib/mapObjects/MapObjects.h"
#include "../../lib/CConfigHandler.h"
#include "../../lib/CHeroHandler.h"
#include "../../lib/CModHandler.h"
/*
* CCreatureHandler.h, 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
*
*/
extern FuzzyHelper *fh;
class CGVisitableOPW;
const double SAFE_ATTACK_CONSTANT = 1.5;
const int GOLD_RESERVE = 10000; //when buying creatures we want to keep at least this much gold (10000 so at least we'll be able to reach capitol)
using namespace vstd;
//one thread may be turn of AI and another will be handling a side effect for AI2
boost::thread_specific_ptr cb;
boost::thread_specific_ptr ai;
//std::map > HeroView::infosCount;
//helper RAII to manage global ai/cb ptrs
struct SetGlobalState
{
SetGlobalState(VCAI * AI)
{
assert(!ai.get());
assert(!cb.get());
ai.reset(AI);
cb.reset(AI->myCb.get());
}
~SetGlobalState()
{
ai.release();
cb.release();
}
};
#define SET_GLOBAL_STATE(ai) SetGlobalState _hlpSetState(ai);
#define NET_EVENT_HANDLER SET_GLOBAL_STATE(this)
#define MAKING_TURN SET_GLOBAL_STATE(this)
unsigned char &retreiveTileN(std::vector< std::vector< std::vector > > &vectors, const int3 &pos)
{
return vectors[pos.x][pos.y][pos.z];
}
const unsigned char &retreiveTileN(const std::vector< std::vector< std::vector > > &vectors, const int3 &pos)
{
return vectors[pos.x][pos.y][pos.z];
}
void foreach_tile(std::vector< std::vector< std::vector > > &vectors, std::function foo)
{
for(auto & vector : vectors)
for(auto j = vector.begin(); j != vector.end(); j++)
for(auto & elem : *j)
foo(elem);
}
struct ObjInfo
{
int3 pos;
std::string name;
ObjInfo(){}
ObjInfo(const CGObjectInstance *obj):
pos(obj->pos),
name(obj->getObjectName())
{
}
};
std::map helperObjInfo;
VCAI::VCAI(void)
{
LOG_TRACE(logAi);
makingTurn = nullptr;
destinationTeleport = ObjectInstanceID();
}
VCAI::~VCAI(void)
{
LOG_TRACE(logAi);
}
void VCAI::availableCreaturesChanged(const CGDwelling *town)
{
LOG_TRACE(logAi);
NET_EVENT_HANDLER;
}
void VCAI::heroMoved(const TryMoveHero & details)
{
LOG_TRACE(logAi);
NET_EVENT_HANDLER;
validateObject(details.id); //enemy hero may have left visible area
if(details.result == TryMoveHero::TELEPORTATION)
{
const int3 from = CGHeroInstance::convertPosition(details.start, false),
to = CGHeroInstance::convertPosition(details.end, false);
const CGObjectInstance *o1 = frontOrNull(cb->getVisitableObjs(from)),
*o2 = frontOrNull(cb->getVisitableObjs(to));
auto t1 = dynamic_cast(o1);
auto t2 = dynamic_cast(o2);
if(t1 && t2)
{
if(cb->isTeleportChannelBidirectional(t1->channel))
{
if(o1->ID == Obj::SUBTERRANEAN_GATE && o1->ID == o2->ID) // We need to only add subterranean gates in knownSubterraneanGates. Used for features not yet ported to use teleport channels
{
knownSubterraneanGates[o1] = o2;
knownSubterraneanGates[o2] = o1;
logAi->debugStream() << boost::format("Found a pair of subterranean gates between %s and %s!") % from % to;
}
}
}
}
}
void VCAI::stackChagedCount(const StackLocation &location, const TQuantity &change, bool isAbsolute)
{
LOG_TRACE_PARAMS(logAi, "isAbsolute '%i'", isAbsolute);
NET_EVENT_HANDLER;
}
void VCAI::heroInGarrisonChange(const CGTownInstance *town)
{
LOG_TRACE(logAi);
NET_EVENT_HANDLER;
}
void VCAI::centerView(int3 pos, int focusTime)
{
LOG_TRACE_PARAMS(logAi, "focusTime '%i'", focusTime);
NET_EVENT_HANDLER;
}
void VCAI::artifactMoved(const ArtifactLocation &src, const ArtifactLocation &dst)
{
LOG_TRACE(logAi);
NET_EVENT_HANDLER;
}
void VCAI::artifactAssembled(const ArtifactLocation &al)
{
LOG_TRACE(logAi);
NET_EVENT_HANDLER;
}
void VCAI::showTavernWindow(const CGObjectInstance *townOrTavern)
{
LOG_TRACE(logAi);
NET_EVENT_HANDLER;
}
void VCAI::showThievesGuildWindow (const CGObjectInstance * obj)
{
LOG_TRACE(logAi);
NET_EVENT_HANDLER;
}
void VCAI::playerBlocked(int reason, bool start)
{
LOG_TRACE_PARAMS(logAi, "reason '%i', start '%i'", reason % start);
NET_EVENT_HANDLER;
if (start && reason == PlayerBlocked::UPCOMING_BATTLE)
status.setBattle(UPCOMING_BATTLE);
if(reason == PlayerBlocked::ONGOING_MOVEMENT)
status.setMove(start);
}
void VCAI::showPuzzleMap()
{
LOG_TRACE(logAi);
NET_EVENT_HANDLER;
}
void VCAI::showShipyardDialog(const IShipyard *obj)
{
LOG_TRACE(logAi);
NET_EVENT_HANDLER;
}
void VCAI::gameOver(PlayerColor player, const EVictoryLossCheckResult & victoryLossCheckResult)
{
LOG_TRACE_PARAMS(logAi, "victoryLossCheckResult '%s'", victoryLossCheckResult.messageToSelf);
NET_EVENT_HANDLER;
logAi->debugStream() << boost::format("Player %d: I heard that player %d %s.") % playerID % player.getNum() % (victoryLossCheckResult.victory() ? "won" : "lost");
if(player == playerID)
{
if(victoryLossCheckResult.victory())
{
logAi->debugStream() << "VCAI: I won! Incredible!";
logAi->debugStream() << "Turn nr " << myCb->getDate();
}
else
{
logAi->debugStream() << "VCAI: Player " << player << " lost. It's me. What a disappointment! :(";
}
finish();
}
}
void VCAI::artifactPut(const ArtifactLocation &al)
{
LOG_TRACE(logAi);
NET_EVENT_HANDLER;
}
void VCAI::artifactRemoved(const ArtifactLocation &al)
{
LOG_TRACE(logAi);
NET_EVENT_HANDLER;
}
void VCAI::stacksErased(const StackLocation &location)
{
LOG_TRACE(logAi);
NET_EVENT_HANDLER;
}
void VCAI::artifactDisassembled(const ArtifactLocation &al)
{
LOG_TRACE(logAi);
NET_EVENT_HANDLER;
}
void VCAI::heroVisit(const CGHeroInstance *visitor, const CGObjectInstance *visitedObj, bool start)
{
LOG_TRACE_PARAMS(logAi, "start '%i'; obj '%s'", start % (visitedObj ? visitedObj->getObjectName() : std::string("n/a")));
NET_EVENT_HANDLER;
if(start)
{
markObjectVisited (visitedObj);
unreserveObject(visitor, visitedObj);
completeGoal (sptr(Goals::GetObj(visitedObj->id.getNum()).sethero(visitor))); //we don't need to visit it anymore
//TODO: what if we visited one-time visitable object that was reserved by another hero (shouldn't, but..)
}
status.heroVisit(visitedObj, start);
}
void VCAI::availableArtifactsChanged(const CGBlackMarket *bm /*= nullptr*/)
{
LOG_TRACE(logAi);
NET_EVENT_HANDLER;
}
void VCAI::heroVisitsTown(const CGHeroInstance* hero, const CGTownInstance * town)
{
LOG_TRACE(logAi);
NET_EVENT_HANDLER;
//buildArmyIn(town);
//moveCreaturesToHero(town);
}
void VCAI::tileHidden(const std::unordered_set &pos)
{
LOG_TRACE(logAi);
NET_EVENT_HANDLER;
validateVisitableObjs();
}
void VCAI::tileRevealed(const std::unordered_set &pos)
{
LOG_TRACE(logAi);
NET_EVENT_HANDLER;
for(int3 tile : pos)
for(const CGObjectInstance *obj : myCb->getVisitableObjs(tile))
addVisitableObj(obj);
clearHeroesUnableToExplore();
}
void VCAI::heroExchangeStarted(ObjectInstanceID hero1, ObjectInstanceID hero2, QueryID query)
{
LOG_TRACE(logAi);
NET_EVENT_HANDLER;
auto firstHero = cb->getHero(hero1);
auto secondHero = cb->getHero(hero2);
status.addQuery(query, boost::str(boost::format("Exchange between heroes %s and %s") % firstHero->name % secondHero->name));
requestActionASAP([=]()
{
float goalpriority1 = 0, goalpriority2 = 0;
auto firstGoal = getGoal(firstHero);
if (firstGoal->goalType == Goals::GATHER_ARMY)
goalpriority1 = firstGoal->priority;
auto secondGoal = getGoal(secondHero);
if (secondGoal->goalType == Goals::GATHER_ARMY)
goalpriority2 = secondGoal->priority;
if (goalpriority1 > goalpriority2)
pickBestCreatures (firstHero, secondHero);
else if (goalpriority1 < goalpriority2)
pickBestCreatures (secondHero, firstHero);
else //regular criteria
{
if (firstHero->getFightingStrength() > secondHero->getFightingStrength() && canGetArmy (firstHero, secondHero))
pickBestCreatures (firstHero, secondHero);
else if (canGetArmy (secondHero, firstHero))
pickBestCreatures (secondHero, firstHero);
completeGoal(sptr(Goals::VisitHero(firstHero->id.getNum()))); //TODO: what if we were visited by other hero in the meantime?
completeGoal(sptr(Goals::VisitHero(secondHero->id.getNum())));
//TODO: exchange artifacts
}
answerQuery(query, 0);
});
}
void VCAI::heroPrimarySkillChanged(const CGHeroInstance * hero, int which, si64 val)
{
LOG_TRACE_PARAMS(logAi, "which '%i', val '%i'", which % val);
NET_EVENT_HANDLER;
}
void VCAI::showRecruitmentDialog(const CGDwelling *dwelling, const CArmedInstance *dst, int level)
{
LOG_TRACE_PARAMS(logAi, "level '%i'", level);
NET_EVENT_HANDLER;
}
void VCAI::heroMovePointsChanged(const CGHeroInstance * hero)
{
LOG_TRACE(logAi);
NET_EVENT_HANDLER;
}
void VCAI::stackChangedType(const StackLocation &location, const CCreature &newType)
{
LOG_TRACE(logAi);
NET_EVENT_HANDLER;
}
void VCAI::stacksRebalanced(const StackLocation &src, const StackLocation &dst, TQuantity count)
{
LOG_TRACE(logAi);
NET_EVENT_HANDLER;
}
void VCAI::newObject(const CGObjectInstance * obj)
{
LOG_TRACE(logAi);
NET_EVENT_HANDLER;
if(obj->isVisitable())
addVisitableObj(obj);
clearHeroesUnableToExplore();
}
void VCAI::objectRemoved(const CGObjectInstance *obj)
{
LOG_TRACE(logAi);
NET_EVENT_HANDLER;
erase_if_present(visitableObjs, obj);
erase_if_present(alreadyVisited, obj);
for (auto h : cb->getHeroesInfo())
unreserveObject(h, obj);
//TODO
//there are other places where CGObjectinstance ptrs are stored...
//
if(obj->ID == Obj::HERO && obj->tempOwner == playerID)
{
lostHero(cb->getHero(obj->id)); //we can promote, since objectRemoved is called just before actual deletion
}
}
void VCAI::showHillFortWindow(const CGObjectInstance *object, const CGHeroInstance *visitor)
{
LOG_TRACE(logAi);
NET_EVENT_HANDLER;
requestActionASAP([=]()
{
makePossibleUpgrades(visitor);
});
}
void VCAI::playerBonusChanged(const Bonus &bonus, bool gain)
{
LOG_TRACE_PARAMS(logAi, "gain '%i'", gain);
NET_EVENT_HANDLER;
}
void VCAI::newStackInserted(const StackLocation &location, const CStackInstance &stack)
{
LOG_TRACE(logAi);
NET_EVENT_HANDLER;
}
void VCAI::heroCreated(const CGHeroInstance* h)
{
LOG_TRACE(logAi);
if (h->visitedTown)
townVisitsThisWeek[HeroPtr(h)].insert(h->visitedTown);
NET_EVENT_HANDLER;
}
void VCAI::advmapSpellCast(const CGHeroInstance * caster, int spellID)
{
LOG_TRACE_PARAMS(logAi, "spellID '%i", spellID);
NET_EVENT_HANDLER;
}
void VCAI::showInfoDialog(const std::string &text, const std::vector &components, int soundID)
{
LOG_TRACE_PARAMS(logAi, "soundID '%i'", soundID);
NET_EVENT_HANDLER;
}
void VCAI::requestRealized(PackageApplied *pa)
{
LOG_TRACE(logAi);
NET_EVENT_HANDLER;
if(status.haveTurn())
{
if(pa->packType == typeList.getTypeID())
if(pa->result)
status.madeTurn();
}
if(pa->packType == typeList.getTypeID())
{
status.receivedAnswerConfirmation(pa->requestID, pa->result);
}
}
void VCAI::receivedResource(int type, int val)
{
LOG_TRACE_PARAMS(logAi, "type '%i', val '%i'", type % val);
NET_EVENT_HANDLER;
}
void VCAI::stacksSwapped(const StackLocation &loc1, const StackLocation &loc2)
{
LOG_TRACE(logAi);
NET_EVENT_HANDLER;
}
void VCAI::showUniversityWindow(const IMarket *market, const CGHeroInstance *visitor)
{
LOG_TRACE(logAi);
NET_EVENT_HANDLER;
}
void VCAI::heroManaPointsChanged(const CGHeroInstance * hero)
{
LOG_TRACE(logAi);
NET_EVENT_HANDLER;
}
void VCAI::heroSecondarySkillChanged(const CGHeroInstance * hero, int which, int val)
{
LOG_TRACE_PARAMS(logAi, "which '%d', val '%d'", which % val);
NET_EVENT_HANDLER;
}
void VCAI::battleResultsApplied()
{
LOG_TRACE(logAi);
NET_EVENT_HANDLER;
assert(status.getBattle() == ENDING_BATTLE);
status.setBattle(NO_BATTLE);
}
void VCAI::objectPropertyChanged(const SetObjectProperty * sop)
{
LOG_TRACE(logAi);
NET_EVENT_HANDLER;
if(sop->what == ObjProperty::OWNER)
{
//we don't want to visit know object twice (do we really?)
if(sop->val == playerID.getNum())
erase_if_present(visitableObjs, myCb->getObj(sop->id));
else if (myCb->getPlayerRelations(playerID, (PlayerColor)sop->val) == PlayerRelations::ENEMIES)
{
//we want to visit objects owned by oppponents
auto obj = myCb->getObj(sop->id, false);
if (obj)
{
addVisitableObj(obj);
erase_if_present(alreadyVisited, obj);
}
}
}
}
void VCAI::buildChanged(const CGTownInstance *town, BuildingID buildingID, int what)
{
LOG_TRACE_PARAMS(logAi, "what '%i'", what);
NET_EVENT_HANDLER;
}
void VCAI::heroBonusChanged(const CGHeroInstance *hero, const Bonus &bonus, bool gain)
{
LOG_TRACE_PARAMS(logAi, "gain '%i'", gain);
NET_EVENT_HANDLER;
}
void VCAI::showMarketWindow(const IMarket *market, const CGHeroInstance *visitor)
{
LOG_TRACE(logAi);
NET_EVENT_HANDLER;
}
void VCAI::showWorldViewEx(const std::vector & objectPositions)
{
//TODO: AI support for ViewXXX spell
LOG_TRACE(logAi);
NET_EVENT_HANDLER;
}
void VCAI::init(shared_ptr CB)
{
LOG_TRACE(logAi);
myCb = CB;
cbc = CB;
NET_EVENT_HANDLER;
playerID = *myCb->getMyColor();
myCb->waitTillRealize = true;
myCb->unlockGsWhenWaiting = true;
if(!fh)
fh = new FuzzyHelper();
retreiveVisitableObjs();
}
void VCAI::yourTurn()
{
LOG_TRACE(logAi);
NET_EVENT_HANDLER;
status.startedTurn();
makingTurn = make_unique(&VCAI::makeTurn, this);
}
void VCAI::heroGotLevel(const CGHeroInstance *hero, PrimarySkill::PrimarySkill pskill, std::vector &skills, QueryID queryID)
{
LOG_TRACE_PARAMS(logAi, "queryID '%i'", queryID);
NET_EVENT_HANDLER;
status.addQuery(queryID, boost::str(boost::format("Hero %s got level %d") % hero->name % hero->level));
requestActionASAP([=]{ answerQuery(queryID, 0); });
}
void VCAI::commanderGotLevel (const CCommanderInstance * commander, std::vector skills, QueryID queryID)
{
LOG_TRACE_PARAMS(logAi, "queryID '%i'", queryID);
NET_EVENT_HANDLER;
status.addQuery(queryID, boost::str(boost::format("Commander %s of %s got level %d") % commander->name % commander->armyObj->nodeName() % (int)commander->level));
requestActionASAP([=]{ answerQuery(queryID, 0); });
}
void VCAI::showBlockingDialog(const std::string &text, const std::vector &components, QueryID askID, const int soundID, bool selection, bool cancel)
{
LOG_TRACE_PARAMS(logAi, "text '%s', askID '%i', soundID '%i', selection '%i', cancel '%i'", text % askID % soundID % selection % cancel);
NET_EVENT_HANDLER;
int sel = 0;
status.addQuery(askID, boost::str(boost::format("Blocking dialog query with %d components - %s")
% components.size() % text));
if(selection) //select from multiple components -> take the last one (they're indexed [1-size])
sel = components.size();
if(!selection && cancel) //yes&no -> always answer yes, we are a brave AI :)
sel = 1;
requestActionASAP([=]()
{
answerQuery(askID, sel);
});
}
void VCAI::showTeleportDialog(TeleportChannelID channel, std::vector exits, bool impassable, QueryID askID)
{
LOG_TRACE_PARAMS(logAi, "askID '%i', exits '%s'", askID % exits);
NET_EVENT_HANDLER;
status.addQuery(askID, boost::str(boost::format("Teleport dialog query with %d exits")
% exits.size()));
ObjectInstanceID choosenExit;
if(impassable)
knownTeleportChannels[channel]->passability = TeleportChannel::IMPASSABLE;
else
{
if(destinationTeleport != ObjectInstanceID() && vstd::contains(exits, destinationTeleport))
choosenExit = destinationTeleport;
if(!status.channelProbing())
{
vstd::copy_if(exits, vstd::set_inserter(teleportChannelProbingList), [&](ObjectInstanceID id) -> bool
{
return !(vstd::contains(visitableObjs, cb->getObj(id)) || id == choosenExit);
});
}
}
requestActionASAP([=]()
{
answerQuery(askID, choosenExit.getNum());
});
}
void VCAI::showGarrisonDialog(const CArmedInstance *up, const CGHeroInstance *down, bool removableUnits, QueryID queryID)
{
LOG_TRACE_PARAMS(logAi, "removableUnits '%i', queryID '%i'", removableUnits % queryID);
NET_EVENT_HANDLER;
std::string s1 = up ? up->nodeName() : "NONE";
std::string s2 = down ? down->nodeName() : "NONE";
status.addQuery(queryID, boost::str(boost::format("Garrison dialog with %s and %s") % s1 % s2));
//you can't request action from action-response thread
requestActionASAP([=]()
{
pickBestCreatures (down, up);
answerQuery(queryID, 0);
});
}
void VCAI::saveGame(COSer & h, const int version)
{
LOG_TRACE_PARAMS(logAi, "version '%i'", version);
NET_EVENT_HANDLER;
validateVisitableObjs();
registerGoals(h);
CAdventureAI::saveGame(h, version);
serializeInternal(h, version);
}
void VCAI::loadGame(CISer & h, const int version)
{
LOG_TRACE_PARAMS(logAi, "version '%i'", version);
NET_EVENT_HANDLER;
registerGoals(h);
CAdventureAI::loadGame(h, version);
serializeInternal(h, version);
}
void makePossibleUpgrades(const CArmedInstance *obj)
{
if(!obj)
return;
for(int i = 0; i < GameConstants::ARMY_SIZE; i++)
{
if(const CStackInstance *s = obj->getStackPtr(SlotID(i)))
{
UpgradeInfo ui;
cb->getUpgradeInfo(obj, SlotID(i), ui);
if(ui.oldID >= 0 && cb->getResourceAmount().canAfford(ui.cost[0] * s->count))
{
cb->upgradeCreature(obj, SlotID(i), ui.newID[0]);
}
}
}
}
void VCAI::makeTurn()
{
MAKING_TURN;
boost::shared_lock gsLock(cb->getGsMutex());
setThreadName("VCAI::makeTurn");
logGlobal->infoStream() << boost::format("Player %d starting turn") % static_cast(playerID.getNum());
switch(cb->getDate(Date::DAY_OF_WEEK))
{
case 1:
{
townVisitsThisWeek.clear();
std::vector objs;
retreiveVisitableObjs(objs, true);
for(const CGObjectInstance *obj : objs)
{
if (isWeeklyRevisitable(obj))
{
addVisitableObj(obj);
erase_if_present (alreadyVisited, obj);
}
}
}
break;
}
markHeroAbleToExplore (primaryHero());
makeTurnInternal();
makingTurn.reset();
return;
}
void VCAI::makeTurnInternal()
{
saving = 0;
//it looks messy here, but it's better to have armed heroes before attempting realizing goals
for(const CGTownInstance *t : cb->getTownsInfo())
moveCreaturesToHero(t);
try
{
//Pick objects reserved in previous turn - we expect only nerby objects there
auto reservedHeroesCopy = reservedHeroesMap; //work on copy => the map may be changed while iterating (eg because hero died when attempting a goal)
for (auto hero : reservedHeroesCopy)
{
if(reservedHeroesMap.count(hero.first))
continue; //hero might have been removed while we were in this loop
if(!hero.first.validAndSet())
{
logAi->errorStream() << "Hero " << hero.first.name << " present on reserved map. Shouldn't be. ";
continue;
}
std::vector vec(hero.second.begin(), hero.second.end());
boost::sort (vec, CDistanceSorter(hero.first.get()));
for (auto obj : vec)
{
if(!obj || !cb->getObj(obj->id))
{
logAi->errorStream() << "Error: there is wrong object on list for hero " << hero.first->name;
continue;
}
striveToGoal (sptr(Goals::VisitTile(obj->visitablePos()).sethero(hero.first)));
}
}
//now try to win
striveToGoal(sptr(Goals::Win()));
//finally, continue our abstract long-term goals
int oldMovement = 0;
int newMovement = 0;
while (true)
{
oldMovement = newMovement; //remember old value
newMovement = 0;
std::vector > safeCopy;
for (auto mission : lockedHeroes)
{
fh->setPriority (mission.second); //re-evaluate
if (canAct(mission.first))
{
newMovement += mission.first->movement;
safeCopy.push_back (mission);
}
}
if (newMovement == oldMovement) //means our heroes didn't move or didn't re-assign their goals
{
logAi->warnStream() << "Our heroes don't move anymore, exhaustive decomposition failed";
break;
}
if (safeCopy.empty())
break; //all heroes exhausted their locked goals
else
{
typedef std::pair TItrType;
auto lockedHeroesSorter = [](TItrType m1, TItrType m2) -> bool
{
return m1.second->priority < m2.second->priority;
};
boost::sort(safeCopy, lockedHeroesSorter);
striveToGoal (safeCopy.back().second);
}
}
auto quests = myCb->getMyQuests();
for (auto quest : quests)
{
striveToQuest (quest);
}
striveToGoal(sptr(Goals::Build())); //TODO: smarter building management
performTypicalActions();
//for debug purpose
for (auto h : cb->getHeroesInfo())
{
if (h->movement)
logAi->warnStream() << boost::format("hero %s has %d MP left") % h->name % h->movement;
}
}
catch(boost::thread_interrupted &e)
{
logAi->debugStream() << "Making turn thread has been interrupted. We'll end without calling endTurn.";
return;
}
catch(std::exception &e)
{
logAi->debugStream() << "Making turn thread has caught an exception: " << e.what();
}
endTurn();
}
bool VCAI::goVisitObj(const CGObjectInstance * obj, HeroPtr h)
{
int3 dst = obj->visitablePos();
logAi->debugStream() << boost::format("%s will try to visit %s at (%s)") % h->name % obj->getObjectName() % strFromInt3(dst);
return moveHeroToTile(dst, h);
}
void VCAI::performObjectInteraction(const CGObjectInstance * obj, HeroPtr h)
{
LOG_TRACE_PARAMS(logAi, "Hero %s and object %s at %s", h->name % obj->getObjectName() % obj->pos);
switch (obj->ID)
{
case Obj::CREATURE_GENERATOR1:
recruitCreatures (dynamic_cast(obj), h.get());
checkHeroArmy (h);
break;
case Obj::TOWN:
moveCreaturesToHero (dynamic_cast(obj));
if (h->visitedTown) //we are inside, not just attacking
{
townVisitsThisWeek[h].insert(h->visitedTown);
if (!h->hasSpellbook() && cb->getResourceAmount(Res::GOLD) >= GameConstants::SPELLBOOK_GOLD_COST + saving[Res::GOLD] &&
h->visitedTown->hasBuilt (BuildingID::MAGES_GUILD_1))
cb->buyArtifact(h.get(), ArtifactID::SPELLBOOK);
}
break;
}
completeGoal (sptr(Goals::GetObj(obj->id.getNum()).sethero(h)));
}
void VCAI::moveCreaturesToHero(const CGTownInstance * t)
{
if(t->visitingHero && t->armedGarrison() && t->visitingHero->tempOwner == t->tempOwner)
{
pickBestCreatures (t->visitingHero, t);
}
}
bool VCAI::canGetArmy (const CGHeroInstance * army, const CGHeroInstance * source)
{ //TODO: merge with pickBestCreatures
//if (ai->primaryHero().h == source)
if(army->tempOwner != source->tempOwner)
{
logAi->errorStream() << "Why are we even considering exchange between heroes from different players?";
return false;
}
const CArmedInstance *armies[] = {army, source};
//we calculate total strength for each creature type available in armies
std::map creToPower;
for(auto armyPtr : armies)
for(auto &i : armyPtr->Slots())
{
//TODO: allow splitting stacks?
creToPower[i.second->type] += i.second->getPower();
}
//TODO - consider more than just power (ie morale penalty, hero specialty in certain stacks, etc)
int armySize = creToPower.size();
armySize = std::min ((source->needsLastStack() ? armySize - 1 : armySize), GameConstants::ARMY_SIZE); //can't move away last stack
std::vector bestArmy; //types that'll be in final dst army
for (int i = 0; i < armySize; i++) //pick the creatures from which we can get most power, as many as dest can fit
{
typedef const std::pair &CrePowerPair;
auto creIt = boost::max_element(creToPower, [](CrePowerPair lhs, CrePowerPair rhs)
{
return lhs.second < rhs.second;
});
bestArmy.push_back(creIt->first);
creToPower.erase(creIt);
if(creToPower.empty())
break;
}
//foreach best type -> iterate over slots in both armies and if it's the appropriate type, send it to the slot where it belongs
for (int i = 0; i < bestArmy.size(); i++) //i-th strongest creature type will go to i-th slot
{
for(auto armyPtr : armies)
for (int j = 0; j < GameConstants::ARMY_SIZE; j++)
{
if(armyPtr->getCreature(SlotID(j)) == bestArmy[i] && armyPtr != army) //it's a searched creature not in dst ARMY
{
//FIXME: line below is useless when simulating exchange between two non-singular armies
if (!(armyPtr->needsLastStack() && armyPtr->Slots().size() == 1)) //can't take away last creature
return true; //at least one exchange will be performed
else
return false; //no further exchange possible
}
}
}
return false;
}
void VCAI::pickBestCreatures(const CArmedInstance * army, const CArmedInstance * source)
{
//TODO - what if source is a hero (the last stack problem) -> it'd good to create a single stack of weakest cre
const CArmedInstance *armies[] = {army, source};
//we calculate total strength for each creature type available in armies
std::map creToPower;
for(auto armyPtr : armies)
for(auto &i : armyPtr->Slots())
{//TODO: allow splitting stacks?
creToPower[i.second->type] += i.second->getPower();
}
//TODO - consider more than just power (ie morale penalty, hero specialty in certain stacks, etc)
int armySize = creToPower.size();
armySize = std::min ((source->needsLastStack() ? armySize - 1 : armySize), GameConstants::ARMY_SIZE); //can't move away last stack
std::vector bestArmy; //types that'll be in final dst army
for (int i = 0; i < armySize; i++) //pick the creatures from which we can get most power, as many as dest can fit
{
typedef const std::pair &CrePowerPair;
auto creIt = boost::max_element(creToPower, [](CrePowerPair lhs, CrePowerPair rhs)
{
return lhs.second < rhs.second;
});
bestArmy.push_back(creIt->first);
creToPower.erase(creIt);
if(creToPower.empty())
break;
}
//foreach best type -> iterate over slots in both armies and if it's the appropriate type, send it to the slot where it belongs
for (int i = 0; i < bestArmy.size(); i++) //i-th strongest creature type will go to i-th slot
{
for(auto armyPtr : armies)
for (int j = 0; j < GameConstants::ARMY_SIZE; j++)
{
if(armyPtr->getCreature(SlotID(j)) == bestArmy[i] && (i != j || armyPtr != army)) //it's a searched creature not in dst SLOT
if (!(armyPtr->needsLastStack() && armyPtr->Slots().size() == 1)) //can't take away last creature
cb->mergeOrSwapStacks(armyPtr, army, SlotID(j), SlotID(i));
}
}
//TODO - having now strongest possible army, we may want to think about arranging stacks
auto hero = dynamic_cast(army);
if (hero)
{
checkHeroArmy (hero);
}
}
void VCAI::recruitCreatures(const CGDwelling * d, const CArmedInstance * recruiter)
{
for(int i = 0; i < d->creatures.size(); i++)
{
if(!d->creatures[i].second.size())
continue;
int count = d->creatures[i].first;
CreatureID creID = d->creatures[i].second.back();
// const CCreature *c = VLC->creh->creatures[creID];
// if(containsSavedRes(c->cost))
// continue;
amin(count, freeResources() / VLC->creh->creatures[creID]->cost);
if(count > 0)
cb->recruitCreatures(d, recruiter, creID, count, i);
}
}
bool VCAI::tryBuildStructure(const CGTownInstance * t, BuildingID building, unsigned int maxDays)
{
if (maxDays == 0)
{
logAi->warnStream() << "Request to build building " << building << " in 0 days!";
return false;
}
if (!vstd::contains(t->town->buildings, building))
return false; // no such building in town
if (t->hasBuilt(building)) //Already built? Shouldn't happen in general
return true;
const CBuilding * buildPtr = t->town->buildings.at(building);
auto toBuild = buildPtr->requirements.getFulfillmentCandidates([&](const BuildingID & buildID)
{
return t->hasBuilt(buildID);
});
toBuild.push_back(building);
for(BuildingID buildID : toBuild)
{
EBuildingState::EBuildingState canBuild = cb->canBuildStructure(t, buildID);
if (canBuild == EBuildingState::HAVE_CAPITAL
|| canBuild == EBuildingState::FORBIDDEN
|| canBuild == EBuildingState::NO_WATER)
return false; //we won't be able to build this
}
if (maxDays && toBuild.size() > maxDays)
return false;
TResources currentRes = cb->getResourceAmount();
//TODO: calculate if we have enough resources to build it in maxDays
for(const auto & buildID : toBuild)
{
const CBuilding *b = t->town->buildings.at(buildID);
EBuildingState::EBuildingState canBuild = cb->canBuildStructure(t, buildID);
if(canBuild == EBuildingState::ALLOWED)
{
if(!containsSavedRes(b->resources))
{
logAi->debugStream() << boost::format("Player %d will build %s in town of %s at %s") % playerID % b->Name() % t->name % t->pos;
cb->buildBuilding(t, buildID);
return true;
}
continue;
}
else if(canBuild == EBuildingState::NO_RESOURCES)
{
//TResources income = estimateIncome();
TResources cost = t->town->buildings.at(buildID)->resources;
for (int i = 0; i < GameConstants::RESOURCE_QUANTITY; i++)
{
//int diff = currentRes[i] - cost[i] + income[i];
int diff = currentRes[i] - cost[i];
if(diff < 0)
saving[i] = 1;
}
continue;
}
else if (canBuild == EBuildingState::PREREQUIRES)
{
// can happen when dependencies have their own missing dependencies
if (tryBuildStructure(t, buildID, maxDays - 1))
return true;
}
else if (canBuild == EBuildingState::MISSING_BASE)
{
if (tryBuildStructure(t, b->upgrade, maxDays - 1))
return true;
}
}
return false;
}
//bool VCAI::canBuildStructure(const CGTownInstance * t, BuildingID building, unsigned int maxDays=7)
//{
// if (maxDays == 0)
// {
// logAi->warnStream() << "Request to build building " << building << " in 0 days!";
// return false;
// }
//
// if (!vstd::contains(t->town->buildings, building))
// return false; // no such building in town
//
// if (t->hasBuilt(building)) //Already built? Shouldn't happen in general
// return true;
//
// const CBuilding * buildPtr = t->town->buildings.at(building);
//
// auto toBuild = buildPtr->requirements.getFulfillmentCandidates([&](const BuildingID & buildID)
// {
// return t->hasBuilt(buildID);
// });
// toBuild.push_back(building);
//
// for(BuildingID buildID : toBuild)
// {
// EBuildingState::EBuildingState canBuild = cb->canBuildStructure(t, buildID);
// if (canBuild == EBuildingState::HAVE_CAPITAL
// || canBuild == EBuildingState::FORBIDDEN
// || canBuild == EBuildingState::NO_WATER)
// return false; //we won't be able to build this
// }
//
// if (maxDays && toBuild.size() > maxDays)
// return false;
//
// TResources currentRes = cb->getResourceAmount();
// TResources income = estimateIncome();
// //TODO: calculate if we have enough resources to build it in maxDays
//
// for(const auto & buildID : toBuild)
// {
// const CBuilding *b = t->town->buildings.at(buildID);
//
// EBuildingState::EBuildingState canBuild = cb->canBuildStructure(t, buildID);
// if(canBuild == EBuildingState::ALLOWED)
// {
// if(!containsSavedRes(b->resources))
// {
// logAi->debugStream() << boost::format("Player %d will build %s in town of %s at %s") % playerID % b->Name() % t->name % t->pos;
// return true;
// }
// continue;
// }
// else if(canBuild == EBuildingState::NO_RESOURCES)
// {
// TResources cost = t->town->buildings.at(buildID)->resources;
// for (int i = 0; i < GameConstants::RESOURCE_QUANTITY; i++)
// {
// int diff = currentRes[i] - cost[i] + income[i];
// if(diff < 0)
// saving[i] = 1;
// }
// continue;
// }
// else if (canBuild == EBuildingState::PREREQUIRES)
// {
// // can happen when dependencies have their own missing dependencies
// if (canBuildStructure(t, buildID, maxDays - 1))
// return true;
// }
// else if (canBuild == EBuildingState::MISSING_BASE)
// {
// if (canBuildStructure(t, b->upgrade, maxDays - 1))
// return true;
// }
// }
// return false;
//}
bool VCAI::tryBuildAnyStructure(const CGTownInstance * t, std::vector buildList, unsigned int maxDays)
{
for(const auto & building : buildList)
{
if(t->hasBuilt(building))
continue;
if (tryBuildStructure(t, building, maxDays))
return true;
}
return false; //Can't build anything
}
BuildingID VCAI::canBuildAnyStructure(const CGTownInstance * t, std::vector buildList, unsigned int maxDays)
{
for(const auto & building : buildList)
{
if(t->hasBuilt(building))
continue;
if (cb->canBuildStructure(t, building))
return building;
}
return BuildingID::NONE; //Can't build anything
}
bool VCAI::tryBuildNextStructure(const CGTownInstance * t, std::vector buildList, unsigned int maxDays)
{
for(const auto & building : buildList)
{
if(t->hasBuilt(building))
continue;
return tryBuildStructure(t, building, maxDays);
}
return false;//Nothing to build
}
void VCAI::buildStructure(const CGTownInstance * t)
{
//TODO make *real* town development system
//TODO: faction-specific development: use special buildings, build dwellings in better order, etc
//TODO: build resource silo, defences when needed
//Possible - allow "locking" on specific building (build prerequisites and then building itself)
TResources currentRes = cb->getResourceAmount();
TResources currentIncome = t->dailyIncome();
int townIncome = currentIncome[Res::GOLD];
if (tryBuildAnyStructure(t, std::vector(essential, essential + ARRAY_COUNT(essential))))
return;
//we're running out of gold - try to build something gold-producing. Multiplier can be tweaked, 6 is minimum due to buildings costs
if (currentRes[Res::GOLD] < townIncome * 6)
if (tryBuildNextStructure(t, std::vector(goldSource, goldSource + ARRAY_COUNT(goldSource))))
return;
if (cb->getDate(Date::DAY_OF_WEEK) > 6)// last 2 days of week - try to focus on growth
{
if (tryBuildNextStructure(t, std::vector(unitGrowth, unitGrowth + ARRAY_COUNT(unitGrowth)), 2))
return;
}
// first in-game week or second half of any week: try build dwellings
if (cb->getDate(Date::DAY) < 7 || cb->getDate(Date::DAY_OF_WEEK) > 3)
if (tryBuildAnyStructure(t, std::vector(unitsSource, unitsSource + ARRAY_COUNT(unitsSource)), 8 - cb->getDate(Date::DAY_OF_WEEK)))
return;
//try to upgrade dwelling
for(int i = 0; i < ARRAY_COUNT(unitsUpgrade); i++)
{
if (t->hasBuilt(unitsSource[i]) && !t->hasBuilt(unitsUpgrade[i]))
{
if (tryBuildStructure(t, unitsUpgrade[i]))
return;
}
}
//remaining tasks
if (tryBuildNextStructure(t, std::vector(goldSource, goldSource + ARRAY_COUNT(goldSource))))
return;
if (tryBuildNextStructure(t, std::vector(spells, spells + ARRAY_COUNT(spells))))
return;
if (tryBuildAnyStructure(t, std::vector(extra, extra + ARRAY_COUNT(extra))))
return;
}
bool VCAI::isGoodForVisit(const CGObjectInstance *obj, HeroPtr h, SectorMap &sm)
{
const int3 pos = obj->visitablePos();
if (canReachTile(h.get(), sm.firstTileToGet(h, obj->visitablePos())) &&
!obj->wasVisited(playerID) &&
(cb->getPlayerRelations(ai->playerID, obj->tempOwner) == PlayerRelations::ENEMIES || isWeeklyRevisitable(obj)) && //flag or get weekly resources / creatures
isSafeToVisit(h, pos) &&
shouldVisit(h, obj) &&
!vstd::contains(alreadyVisited, obj) &&
!vstd::contains(reservedObjs, obj))
{
const CGObjectInstance *topObj = cb->getVisitableObjs(obj->visitablePos()).back(); //it may be hero visiting this obj
//we don't try visiting object on which allied or owned hero stands
// -> it will just trigger exchange windows and AI will be confused that obj behind doesn't get visited
if (topObj->ID == Obj::HERO && cb->getPlayerRelations(h->tempOwner, topObj->tempOwner) != PlayerRelations::ENEMIES)
return false;
else
return true; //all of the following is met
}
return false;
}
std::vector VCAI::getPossibleDestinations(HeroPtr h)
{
validateVisitableObjs();
std::vector possibleDestinations;
SectorMap sm(h);
for(const CGObjectInstance *obj : visitableObjs)
{
if (isGoodForVisit(obj, h, sm))
{
possibleDestinations.push_back(obj);
}
}
boost::sort(possibleDestinations, CDistanceSorter(h.get()));
return possibleDestinations;
}
bool VCAI::canReachTile (const CGHeroInstance * h, int3 t)
{
if (t.valid())
{
auto obj = cb->getTopObj(t);
if (obj && vstd::contains(ai->reservedObjs, obj) && !vstd::contains(reservedHeroesMap[h], obj))
return false; //do not capture object reserved by another hero
else
return true;
}
else
return false;
}
bool VCAI::canRecruitAnyHero (const CGTownInstance * t) const
{
//TODO: make gathering gold, building tavern or conquering town (?) possible subgoals
if (!t)
t = findTownWithTavern();
if (t)
return cb->getResourceAmount(Res::GOLD) >= HERO_GOLD_COST &&
cb->getHeroesInfo().size() < ALLOWED_ROAMING_HEROES &&
cb->getAvailableHeroes(t).size();
else
return false;
}
void VCAI::wander(HeroPtr h)
{
//unclaim objects that are now dangerous for us
auto reservedObjsSetCopy = reservedHeroesMap[h];
for (auto obj : reservedObjsSetCopy)
{
if (!isSafeToVisit(h, obj->visitablePos()))
unreserveObject(h, obj);
}
TimeCheck tc("looking for wander destination");
while (h->movement)
{
validateVisitableObjs();
std::vector dests, tmp;
range::copy(reservedHeroesMap[h], std::back_inserter(tmp)); //also visit our reserved objects - but they are not prioritized to avoid running back and forth
for (auto obj : tmp)
{
if (isAccessibleForHero (obj->visitablePos(), h)) //even nearby objects could be blocked by other heroes :(
dests.push_back(obj); //can't use lambda for member function :(
}
range::copy(getPossibleDestinations(h), std::back_inserter(dests));
if(!dests.size())
{
if (cb->getVisitableObjs(h->visitablePos()).size() > 1)
moveHeroToTile(h->visitablePos(), h); //just in case we're standing on blocked subterranean gate
auto compareReinforcements = [h](const CGTownInstance *lhs, const CGTownInstance *rhs) -> bool
{
return howManyReinforcementsCanGet(h, lhs) < howManyReinforcementsCanGet(h, rhs);
};
std::vector townsReachable;
std::vector townsNotReachable;
for(const CGTownInstance *t : cb->getTownsInfo())
{
if(!t->visitingHero && howManyReinforcementsCanGet(h,t) && !vstd::contains(townVisitsThisWeek[h], t))
{
if (isAccessibleForHero (t->visitablePos(), h))
townsReachable.push_back(t);
else
townsNotReachable.push_back(t);
}
}
if(townsReachable.size())
{
boost::sort(townsReachable, compareReinforcements);
dests.push_back(townsReachable.back());
}
else if(townsNotReachable.size())
{
boost::sort(townsNotReachable, compareReinforcements);
//TODO pick the truly best
const CGTownInstance *t = townsNotReachable.back();
logAi->debugStream() << boost::format("%s can't reach any town, we'll try to make our way to %s at %s") % h->name % t->name % t->visitablePos();
int3 pos1 = h->pos;
striveToGoal(sptr(Goals::ClearWayTo(t->visitablePos()).sethero(h)));
//if out hero is stuck, we may need to request another hero to clear the way we see
if (pos1 == h->pos && h == primaryHero()) //hero can't move
{
if (canRecruitAnyHero(t))
recruitHero(t);
}
break;
}
else if(cb->getResourceAmount(Res::GOLD) >= HERO_GOLD_COST)
{
std::vector