games/vcmi
1
0
Fork 0
mirror of https://github.com/vcmi/vcmi.git synced 2024-12-28 23:06:24 +02:00
Code Issues Releases Activity
416c08260a
vcmi/AI/VCAI/VCAI.cpp
DjWarmonger b597171f91 - EXPLORE goal can now be complete soAI won't get stuck 
- AI won't try to visit tiles occupied by allied heroes by default
2012-05-09 07:56:39 +00:00

3104 lines
79 KiB
C++
Raw Blame History

#include "StdInc.h"
#include "VCAI.h"
#include "../../lib/UnlockGuard.h"
#include "Fuzzy.h"
#include "../../lib/CObjectHandler.h"
#define I_AM_ELEMENTAR return CGoal(*this).setisElementar(true)
CLogger &aiLogger = tlog6;
extern FuzzyHelper *fh;
class CGVisitableOPW;
const int ACTUAL_RESOURCE_COUNT = 7;
const double SAFE_ATTACK_CONSTANT = 1.5;
using namespace vstd;
//one thread may be turn of AI and another will be handling a side effect for AI2
boost::thread_specific_ptr<CCallback> cb;
boost::thread_specific_ptr<VCAI> ai;
// CCallback *cb;
// VCAI *ai;
//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);
}
~SetGlobalState()
{
ai.release();
cb.release();
}
};
template <typename Container>
typename Container::value_type backOrNull(const Container &c) //returns last element of container or NULL if it is empty (to be used with containers of pointers)
{
if(c.size())
return c.back();
else
return NULL;
}
template <typename Container>
typename Container::value_type frontOrNull(const Container &c) //returns first element of container or NULL if it is empty (to be used with containers of pointers)
{
if(c.size())
return c.front();
else
return NULL;
}
#define SET_GLOBAL_STATE(ai) SetGlobalState _hlpSetState(ai);
#define NET_EVENT_HANDLER SET_GLOBAL_STATE(this)
#define MAKING_TURN SET_GLOBAL_STATE(this)
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)
const int HERO_GOLD_COST = 2500;
const int ALLOWED_ROAMING_HEROES = 8;
const int GOLD_MINE_PRODUCTION = 1000, WOOD_ORE_MINE_PRODUCTION = 2, RESOURCE_MINE_PRODUCTION = 1;
std::string goalName(EGoals goalType)
{
switch (goalType)
{
case INVALID:
return "INVALID";
case WIN:
return "WIN";
case CONQUER:
return "CONQUER";
case BUILD:
return "BUILD";
case EXPLORE:
return "EXPLORE";
case GATHER_ARMY:
return "GATHER ARMY";
case VISIT_TILE:
return "VISIT TILE";
case CLEAR_WAY_TO:
return "CLEAR WAY TO";
default:
return boost::lexical_cast<std::string>(goalType);
}
}
bool compareHeroStrength(const CGHeroInstance *h1, const CGHeroInstance *h2)
{
return h1->getTotalStrength() < h2->getTotalStrength();
}
bool compareArmyStrength(const CArmedInstance *a1, const CArmedInstance *a2)
{
return a1->getArmyStrength() < a2->getArmyStrength();
}
static const int3 dirs[] = { int3(0,1,0),int3(0,-1,0),int3(-1,0,0),int3(+1,0,0),
int3(1,1,0),int3(-1,1,0),int3(1,-1,0),int3(-1,-1,0) };
struct AILogger
{
AILogger()
{
lvl = 0;
}
int lvl;
struct Tab
{
Tab();
~Tab();
};
} logger;
AILogger::Tab::Tab()
{
logger.lvl++;
}
AILogger::Tab::~Tab()
{
logger.lvl--;
}
struct TimeCheck
{
CStopWatch time;
std::string txt;
TimeCheck(crstring TXT) : txt(TXT)
{
}
~TimeCheck()
{
BNLOG("Time of %s was %d ms.", txt % time.getDiff());
}
};
template<typename T>
void removeDuplicates(std::vector<T> &vec)
{
boost::sort(vec);
vec.erase(std::unique(vec.begin(), vec.end()), vec.end());
}
template<typename Range, typename Predicate>
void erase_if(Range &vec, Predicate pred)
{
vec.erase(boost::remove_if(vec, pred),vec.end());
}
struct AtScopeExit
{
boost::function<void()> foo;
AtScopeExit(const boost::function<void()> &FOO) : foo(FOO)
{}
~AtScopeExit()
{
foo();
}
};
void foreach_tile_pos(boost::function<void(const int3& pos)> foo)
{
for(int i = 0; i < cb->getMapSize().x; i++)
for(int j = 0; j < cb->getMapSize().y; j++)
for(int k = 0; k < cb->getMapSize().z; k++)
foo(int3(i,j,k));
}
void foreach_neighbour(const int3 &pos, boost::function<void(const int3& pos)> foo)
{
BOOST_FOREACH(const int3 &dir, dirs)
{
const int3 n = pos + dir;
if(cb->isInTheMap(n))
foo(pos+dir);
}
}
unsigned char &retreiveTileN(std::vector< std::vector< std::vector<unsigned char> > > &vectors, const int3 &pos)
{
return vectors[pos.x][pos.y][pos.z];
}
const unsigned char &retreiveTileN(const std::vector< std::vector< std::vector<unsigned char> > > &vectors, const int3 &pos)
{
return vectors[pos.x][pos.y][pos.z];
}
void foreach_tile(std::vector< std::vector< std::vector<unsigned char> > > &vectors, boost::function<void(unsigned char &in)> foo)
{
for(auto i = vectors.begin(); i != vectors.end(); i++)
for(auto j = i->begin(); j != i->end(); j++)
for(auto z = j->begin(); z != j->end(); z++)
foo(*z);
}
struct ObjInfo
{
int3 pos;
std::string name;
ObjInfo(){}
ObjInfo(const CGObjectInstance *obj)
{
pos = obj->pos;
name = obj->getHoverText();
}
};
std::map<const CGObjectInstance *, ObjInfo> helperObjInfo;
template <typename Container, typename Item>
bool remove_if_present(Container &c, const Item &item)
{
auto i = std::find(c.begin(), c.end(), item);
if (i != c.end())
{
c.erase(i);
return true;
}
return false;
}
template <typename V, typename Item, typename Item2>
bool remove_if_present(std::map<Item,V> & c, const Item2 &item)
{
auto i = c.find(item);
if (i != c.end())
{
c.erase(i);
return true;
}
return false;
}
template <typename Container, typename Pred>
void erase(Container &c, Pred pred)
{
c.erase(boost::remove_if(c, pred), c.end());
}
bool isReachable(const CGObjectInstance *obj)
{
return cb->getPathInfo(obj->visitablePos())->turns < 255;
}
ui64 howManyReinforcementsCanGet(const CGHeroInstance *h, const CGTownInstance *t)
{
ui64 ret = 0;
int freeHeroSlots = GameConstants::ARMY_SIZE - h->stacksCount();
std::vector<const CStackInstance *> toMove;
BOOST_FOREACH(auto const slot, t->Slots())
{
//can be merged woth another stack?
TSlot 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();
});
BOOST_REVERSE_FOREACH(const CStackInstance *stack, toMove)
{
if(freeHeroSlots)
{
ret += stack->getPower();
freeHeroSlots--;
}
else
break;
}
return ret;
}
std::string strFromInt3(int3 pos)
{
std::ostringstream oss;
oss << pos;
return oss.str();
}
bool isCloser(const CGObjectInstance *lhs, const CGObjectInstance *rhs)
{
const CGPathNode *ln = cb->getPathInfo(lhs->visitablePos()), *rn = cb->getPathInfo(rhs->visitablePos());
if(ln->turns != rn->turns)
return ln->turns < rn->turns;
return (ln->moveRemains > rn->moveRemains);
};
bool compareMovement(const CGHeroInstance *lhs, const CGHeroInstance *rhs)
{
return lhs->movement > rhs->movement;
};
ui64 evaluateDanger(const CGObjectInstance *obj);
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->guardingCreaturePosition(tile);
if(guardPos.x >= 0 && guardPos != tile)
guardDanger = evaluateDanger(guardPos);
//TODO mozna odwiedzic blockvis nie ruszajac straznika
return std::max(objectDanger, guardDanger);
return 0;
}
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;
if(const CGObjectInstance * dangerousObject = backOrNull(cb->getVisitableObjs(tile)))
{
objectDanger = evaluateDanger(dangerousObject); //unguarded objects can also be dangerous or unhandled
if (dangerousObject)
{
//TODO: don't downcast objects AI shouldnt know about!
auto armedObj = dynamic_cast<const CArmedInstance*>(dangerousObject);
if(armedObj)
objectDanger *= fh->getTacticalAdvantage(visitor, armedObj);
}
}
int3 guardPos = cb->guardingCreaturePosition(tile);
if(guardPos.x >= 0 && guardPos != tile)
guardDanger = evaluateDanger(guardPos, visitor);
//TODO mozna odwiedzic blockvis nie ruszajac straznika
return std::max(objectDanger, guardDanger);
return 0;
}
ui64 evaluateDanger(const CGObjectInstance *obj)
{
if(obj->tempOwner < GameConstants::PLAYER_LIMIT && cb->getPlayerRelations(obj->tempOwner, ai->playerID)) //owned or allied objects don't pose any threat
return 0;
switch(obj->ID)
{
case GameConstants::HEROI_TYPE:
{
InfoAboutHero iah;
cb->getHeroInfo(obj, iah);
return iah.army.getStrength();
}
case GameConstants::TOWNI_TYPE:
case Obj::GARRISON: case Obj::GARRISON2: //garrison
{
InfoAboutTown iat;
cb->getTownInfo(obj, iat);
return iat.army.getStrength();
}
case GameConstants::CREI_TYPE:
{
//TODO!!!!!!!!
const CGCreature *cre = dynamic_cast<const CGCreature*>(obj);
return cre->getArmyStrength();
}
case Obj::CREATURE_GENERATOR1:
{
const CGDwelling *d = dynamic_cast<const CGDwelling*>(obj);
return d->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 (VLC->objh->bankObjToIndex(obj));
default:
return 0;
}
}
bool compareDanger(const CGObjectInstance *lhs, const CGObjectInstance *rhs)
{
return evaluateDanger(lhs) < evaluateDanger(rhs);
}
VCAI::VCAI(void)
{
LOG_ENTRY;
myCb = NULL;
battleAIName = "StupidAI";
makingTurn = NULL;
}
VCAI::~VCAI(void)
{
LOG_ENTRY;
}
void VCAI::availableCreaturesChanged(const CGDwelling *town)
{
NET_EVENT_HANDLER;
LOG_ENTRY;
}
void VCAI::heroMoved(const TryMoveHero & details)
{
NET_EVENT_HANDLER;
LOG_ENTRY;
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));
if(o1 && o2 && o1->ID == Obj::SUBTERRANEAN_GATE && o2->ID == Obj::SUBTERRANEAN_GATE)
{
knownSubterraneanGates[o1] = o2;
knownSubterraneanGates[o2] = o1;
BNLOG("Found a pair of subterranean gates between %s and %s!", from % to);
}
}
}
void VCAI::stackChagedCount(const StackLocation &location, const TQuantity &change, bool isAbsolute)
{
NET_EVENT_HANDLER;
LOG_ENTRY;
}
void VCAI::heroInGarrisonChange(const CGTownInstance *town)
{
NET_EVENT_HANDLER;
LOG_ENTRY;
}
void VCAI::centerView(int3 pos, int focusTime)
{
NET_EVENT_HANDLER;
LOG_ENTRY;
}
void VCAI::artifactMoved(const ArtifactLocation &src, const ArtifactLocation &dst)
{
NET_EVENT_HANDLER;
LOG_ENTRY;
}
void VCAI::artifactAssembled(const ArtifactLocation &al)
{
NET_EVENT_HANDLER;
LOG_ENTRY;
}
void VCAI::showTavernWindow(const CGObjectInstance *townOrTavern)
{
NET_EVENT_HANDLER;
LOG_ENTRY;
}
void VCAI::showThievesGuildWindow (const CGObjectInstance * obj)
{
NET_EVENT_HANDLER;
LOG_ENTRY;
}
void VCAI::playerBlocked(int reason)
{
NET_EVENT_HANDLER;
LOG_ENTRY;
if (reason == PlayerBlocked::UPCOMING_BATTLE)
status.setBattle(UPCOMING_BATTLE);
}
void VCAI::showPuzzleMap()
{
NET_EVENT_HANDLER;
LOG_ENTRY;
}
void VCAI::showShipyardDialog(const IShipyard *obj)
{
NET_EVENT_HANDLER;
LOG_ENTRY;
}
void VCAI::gameOver(ui8 player, bool victory)
{
NET_EVENT_HANDLER;
LOG_ENTRY;
BNLOG("Player %d: I heard that player %d %s.", playerID % (int)player % (victory ? "won" : "lost"));
if(player == playerID)
{
if(victory)
{
tlog0 << "VCAI: I won! Incredible!\n";
tlog0 << "Turn nr " << myCb->getDate() << std::endl;
}
else
{
tlog0 << "VCAI: Player " << (int)player << " lost. It's me. What a disappointment! :(\n";
}
// //let's make Impossible difficulty finally standing to its name :>
// if(myCb->getStartInfo()->difficulty == 4 && !victory)
// {
// //play dirty: crash the whole engine to avoid lose
// //that way AI is unbeatable!
// *(int*)NULL = 666;
// }
// TODO - at least write some insults on stdout
finish();
}
}
void VCAI::artifactPut(const ArtifactLocation &al)
{
NET_EVENT_HANDLER;
LOG_ENTRY;
}
void VCAI::artifactRemoved(const ArtifactLocation &al)
{
NET_EVENT_HANDLER;
LOG_ENTRY;
}
void VCAI::stacksErased(const StackLocation &location)
{
NET_EVENT_HANDLER;
LOG_ENTRY;
}
void VCAI::artifactDisassembled(const ArtifactLocation &al)
{
NET_EVENT_HANDLER;
LOG_ENTRY;
}
void VCAI::heroVisit(const CGHeroInstance *visitor, const CGObjectInstance *visitedObj, bool start)
{
NET_EVENT_HANDLER;
LOG_ENTRY;
if (start)
{
visitedObject = const_cast<CGObjectInstance *>(visitedObj); // remember the object and wait for return
markObjectVisited (visitedObj);
remove_if_present(reservedObjs, visitedObj); //unreserve objects
remove_if_present(reservedHeroesMap[visitor], visitedObj);
}
}
void VCAI::availableArtifactsChanged(const CGBlackMarket *bm /*= NULL*/)
{
NET_EVENT_HANDLER;
LOG_ENTRY;
}
void VCAI::heroVisitsTown(const CGHeroInstance* hero, const CGTownInstance * town)
{
NET_EVENT_HANDLER;
LOG_ENTRY;
//buildArmyIn(town);
//moveCreaturesToHero(town);
}
void VCAI::tileHidden(const boost::unordered_set<int3, ShashInt3> &pos)
{
NET_EVENT_HANDLER;
LOG_ENTRY;
// BOOST_FOREACH(int3 tile, pos)
// BOOST_FOREACH(const CGObjectInstance *obj, cb->getVisitableObjs(tile))
// remove_if_present(visitableObjs, obj);
visitableObjs.erase(boost::remove_if(visitableObjs, [&](const CGObjectInstance *obj){return !myCb->getObj(obj->id);}), visitableObjs.end());
}
void VCAI::tileRevealed(const boost::unordered_set<int3, ShashInt3> &pos)
{
NET_EVENT_HANDLER;
LOG_ENTRY;
BOOST_FOREACH(int3 tile, pos)
BOOST_FOREACH(const CGObjectInstance *obj, myCb->getVisitableObjs(tile))
addVisitableObj(obj);
}
void VCAI::heroExchangeStarted(si32 hero1, si32 hero2)
{
NET_EVENT_HANDLER;
LOG_ENTRY;
}
void VCAI::heroPrimarySkillChanged(const CGHeroInstance * hero, int which, si64 val)
{
NET_EVENT_HANDLER;
LOG_ENTRY;
}
void VCAI::showRecruitmentDialog(const CGDwelling *dwelling, const CArmedInstance *dst, int level)
{
NET_EVENT_HANDLER;
LOG_ENTRY;
}
void VCAI::heroMovePointsChanged(const CGHeroInstance * hero)
{
NET_EVENT_HANDLER;
LOG_ENTRY;
}
void VCAI::stackChangedType(const StackLocation &location, const CCreature &newType)
{
NET_EVENT_HANDLER;
LOG_ENTRY;
}
void VCAI::stacksRebalanced(const StackLocation &src, const StackLocation &dst, TQuantity count)
{
NET_EVENT_HANDLER;
LOG_ENTRY;
}
void VCAI::newObject(const CGObjectInstance * obj)
{
NET_EVENT_HANDLER;
LOG_ENTRY;
if(obj->isVisitable())
addVisitableObj(obj);
}
void VCAI::objectRemoved(const CGObjectInstance *obj)
{
NET_EVENT_HANDLER;
LOG_ENTRY;
if(remove_if_present(visitableObjs, obj))
assert(obj->isVisitable());
BOOST_FOREACH(auto &p, reservedHeroesMap)
remove_if_present(p.second, obj);
//TODO
//there are other places where CGObjectinstance ptrs are stored...
}
void VCAI::showHillFortWindow(const CGObjectInstance *object, const CGHeroInstance *visitor)
{
NET_EVENT_HANDLER;
LOG_ENTRY;
}
void VCAI::playerBonusChanged(const Bonus &bonus, bool gain)
{
NET_EVENT_HANDLER;
LOG_ENTRY;
}
void VCAI::newStackInserted(const StackLocation &location, const CStackInstance &stack)
{
NET_EVENT_HANDLER;
LOG_ENTRY;
}
void VCAI::heroCreated(const CGHeroInstance*)
{
NET_EVENT_HANDLER;
LOG_ENTRY;
}
void VCAI::advmapSpellCast(const CGHeroInstance * caster, int spellID)
{
NET_EVENT_HANDLER;
LOG_ENTRY;
}
void VCAI::showInfoDialog(const std::string &text, const std::vector<Component*> &components, int soundID)
{
NET_EVENT_HANDLER;
LOG_ENTRY;
}
void VCAI::requestRealized(PackageApplied *pa)
{
NET_EVENT_HANDLER;
LOG_ENTRY;
if(status.haveTurn())
{
if(pa->packType == typeList.getTypeID<EndTurn>())
if(pa->result)
status.madeTurn();
}
if(pa->packType == typeList.getTypeID<QueryReply>())
{
status.removeQuery();
}
}
void VCAI::receivedResource(int type, int val)
{
NET_EVENT_HANDLER;
LOG_ENTRY;
}
void VCAI::stacksSwapped(const StackLocation &loc1, const StackLocation &loc2)
{
NET_EVENT_HANDLER;
LOG_ENTRY;
}
void VCAI::showUniversityWindow(const IMarket *market, const CGHeroInstance *visitor)
{
NET_EVENT_HANDLER;
LOG_ENTRY;
}
void VCAI::heroManaPointsChanged(const CGHeroInstance * hero)
{
NET_EVENT_HANDLER;
LOG_ENTRY;
}
void VCAI::heroSecondarySkillChanged(const CGHeroInstance * hero, int which, int val)
{
NET_EVENT_HANDLER;
LOG_ENTRY;
}
void VCAI::battleResultsApplied()
{
NET_EVENT_HANDLER;
LOG_ENTRY;
assert(status.getBattle() == ENDING_BATTLE);
status.setBattle(NO_BATTLE);
}
void VCAI::objectPropertyChanged(const SetObjectProperty * sop)
{
NET_EVENT_HANDLER;
LOG_ENTRY;
if(sop->what == ObjProperty::OWNER)
{
if(sop->val == playerID)
remove_if_present(visitableObjs, myCb->getObj(sop->id));
//TODO restore lost obj
}
}
void VCAI::buildChanged(const CGTownInstance *town, int buildingID, int what)
{
NET_EVENT_HANDLER;
LOG_ENTRY;
}
void VCAI::heroBonusChanged(const CGHeroInstance *hero, const Bonus &bonus, bool gain)
{
NET_EVENT_HANDLER;
LOG_ENTRY;
}
void VCAI::showMarketWindow(const IMarket *market, const CGHeroInstance *visitor)
{
NET_EVENT_HANDLER;
LOG_ENTRY;
}
void VCAI::init(CCallback * CB)
{
myCb = CB;
cbc = CB;
NET_EVENT_HANDLER;
LOG_ENTRY;
playerID = myCb->getMyColor();
myCb->waitTillRealize = true;
myCb->unlockGsWhenWaiting = true;
if(!fh)
fh = new FuzzyHelper();
retreiveVisitableObjs(visitableObjs);
}
void VCAI::yourTurn()
{
NET_EVENT_HANDLER;
LOG_ENTRY;
status.startedTurn();
makingTurn = new boost::thread(&VCAI::makeTurn, this);
}
void VCAI::heroGotLevel(const CGHeroInstance *hero, int pskill, std::vector<ui16> &skills, boost::function<void(ui32)> &callback)
{
NET_EVENT_HANDLER;
LOG_ENTRY;
status.addQuery();
requestActionASAP(boost::bind(callback, 0));
}
void VCAI::showBlockingDialog(const std::string &text, const std::vector<Component> &components, ui32 askID, const int soundID, bool selection, bool cancel)
{
NET_EVENT_HANDLER;
LOG_ENTRY;
int sel = 0;
status.addQuery();
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([=]()
{
cb->selectionMade(sel, askID);
});
}
void VCAI::showGarrisonDialog(const CArmedInstance *up, const CGHeroInstance *down, bool removableUnits, boost::function<void()> &onEnd)
{
NET_EVENT_HANDLER;
LOG_ENTRY;
status.addQuery();
//you can't request action from action-response thread
requestActionASAP([=]()
{
pickBestCreatures (down, up);
onEnd();
});
}
void VCAI::serialize(COSer<CSaveFile> &h, const int version)
{
NET_EVENT_HANDLER;
LOG_ENTRY;
}
void VCAI::serialize(CISer<CLoadFile> &h, const int version)
{
NET_EVENT_HANDLER;
LOG_ENTRY;
}
void makePossibleUpgrades(const CArmedInstance *obj)
{
if(!obj)
return;
for(int i = 0; i < GameConstants::ARMY_SIZE; i++)
{
if(const CStackInstance *s = obj->getStackPtr(i))
{
UpgradeInfo ui;
cb->getUpgradeInfo(obj, i, ui);
if(ui.oldID >= 0 && cb->getResourceAmount().canAfford(ui.cost[0] * s->count))
{
cb->upgradeCreature(obj, i, ui.newID[0]);
}
}
}
}
void VCAI::makeTurn()
{
MAKING_TURN;
boost::shared_lock<boost::shared_mutex> gsLock(cb->getGsMutex());
setThreadName(-1, "VCAI::makeTurn");
BNLOG("Player %d starting turn", playerID);
INDENT;
switch(cb->getDate(1))
{
case 1:
{
townVisitsThisWeek.clear();
std::vector<const CGObjectInstance *> objs;
retreiveVisitableObjs(objs, true);
BOOST_FOREACH(const CGObjectInstance *obj, objs)
{
if (isWeeklyRevisitable(obj))
{
if (!vstd::contains(visitableObjs, obj))
visitableObjs.push_back(obj);
auto o = std::find (alreadyVisited.begin(), alreadyVisited.end(), obj);
if (o != alreadyVisited.end())
alreadyVisited.erase(o);
}
}
}
break;
case 7: //reconsider strategy
{
const CGHeroInstance * h = primaryHero();
if (h) //check if our primary hero can handle danger
{
ui64 totalDanger = 0;
int dangerousObjects = 0;
std::vector<const CGObjectInstance *> objs;
retreiveVisitableObjs(objs, false);
BOOST_FOREACH (auto obj, objs)
{
if (evaluateDanger(obj)) //potentilaly dnagerous
{
totalDanger += evaluateDanger (obj->visitablePos(), h);
++dangerousObjects;
}
}
if (dangerousObjects && totalDanger / dangerousObjects > h->getHeroStrength())
{
setGoal (h, CGoal(GATHER_ARMY).sethero(h));
}
}
}
break;
}
if(cb->getSelectedHero())
cb->recalculatePaths();
makeTurnInternal();
vstd::clear_pointer(makingTurn);
return;
}
void VCAI::makeTurnInternal()
{
saving = 0;
//it looks messy here, but it's better to have armed heroes before attempting realizing goals
BOOST_FOREACH(const CGTownInstance *t, cb->getTownsInfo())
moveCreaturesToHero(t);
try
{
//Pick objects reserved in previous turn - we expect only nerby objects there
BOOST_FOREACH (auto hero, reservedHeroesMap)
{
cb->setSelection(hero.first);
boost::sort (hero.second, isCloser);
BOOST_FOREACH (auto obj, hero.second)
{
const CGHeroInstance * h = hero.first;
striveToGoal (CGoal(VISIT_TILE).sethero(h).settile(obj->visitablePos()));
}
}
//now try to win
striveToGoal(CGoal(WIN));
//finally, continue our abstract long-temr goals
std::vector<std::pair<const CGHeroInstance *, CGoal> > safeCopy; //heroes tend to die in the process and loose their goals, unsafe to iterate it
BOOST_FOREACH (auto h, lockedHeroes)
{
safeCopy.push_back(h);
}
auto lockedHeroesSorter = [](std::pair<const CGHeroInstance *, CGoal> h1, std::pair<const CGHeroInstance *, CGoal> h2) -> bool
{
return compareMovement (h1.first, h2.first);
};
boost::sort(safeCopy, lockedHeroesSorter);
while (safeCopy.size()) //continue our goals
{
auto it = safeCopy.begin();
if (it->first && it->first->tempOwner == playerID && vstd::contains(lockedHeroes, it->first)) //make sure hero still has his goal
{
cb->setSelection(it->first);
striveToGoal (it->second);
}
safeCopy.erase(it);
}
striveToGoal(CGoal(BUILD)); //TODO: smarter building management
}
catch(boost::thread_interrupted &e)
{
tlog0 << "Making turn thread has been interrupted. We'll end without calling endTurn.\n";
return;
}
catch(std::exception &e)
{
tlog0 << "Making turn thread has caught an exception: " << e.what() << "\n";
}
endTurn();
}
bool VCAI::goVisitObj(const CGObjectInstance * obj, const CGHeroInstance * h)
{
int3 dst = obj->visitablePos();
BNLOG("%s will try to visit %s at (%s)", h->name % obj->hoverName % strFromInt3(dst));
return moveHeroToTile(dst, h);
}
void VCAI::performObjectInteraction(const CGObjectInstance * obj, const CGHeroInstance * h)
{
switch (obj->ID)
{
case Obj::CREATURE_GENERATOR1:
recruitCreatures(dynamic_cast<const CGDwelling *>(obj));
break;
}
}
void VCAI::moveCreaturesToHero(const CGTownInstance * t)
{
if(t->visitingHero && t->armedGarrison())
{
pickBestCreatures (t->visitingHero, t);
}
}
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<const CCreature*, int> creToPower;
BOOST_FOREACH(auto armyPtr, armies)
BOOST_FOREACH(auto &i, armyPtr->Slots())
creToPower[i.second->type] += i.second->getPower();
//TODO - consider more than just power (ie morale penalty, hero specialty in certain stacks, etc)
std::vector<const CCreature *> bestArmy; //types that'll be in final dst army
for (int i = 0; i < GameConstants::ARMY_SIZE; i++) //pick the creatures from which we can get most power, as many as dest can fit
{
typedef const std::pair<const CCreature*, int> &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
BOOST_FOREACH(auto armyPtr, armies)
for (int j = 0; j < GameConstants::ARMY_SIZE; j++)
if(armyPtr->getCreature(j) == bestArmy[i] && (i != j || armyPtr != army)) //it's a searched creature not in dst slot
cb->mergeOrSwapStacks(armyPtr, army, j, i);
//TODO - having now strongest possible army, we may want to think about arranging stacks
}
void VCAI::recruitCreatures(const CGDwelling * d)
{
for(int i = 0; i < d->creatures.size(); i++)
{
if(!d->creatures[i].second.size())
continue;
int count = d->creatures[i].first;
int creID = d->creatures[i].second.back();
// const CCreature *c = VLC->creh->creatures[creID];
// if(containsSavedRes(c->cost))
// continue;
TResources myRes = cb->getResourceAmount();
myRes[Res::GOLD] -= GOLD_RESERVE;
amin(count, myRes / VLC->creh->creatures[creID]->cost);
if(count > 0)
cb->recruitCreatures(d, creID, count, i);
}
}
void VCAI::buildStructure(const CGTownInstance * t)
{
//TODO make *real* town development system
const int buildings[] = {5, 11, 14, 16, 0, 12, 7, 8, 9, 13, 30, 31, 32, 33, 34, 35, 36, 37, 38,
39, 40, 41, 42, 43, 1, 2, 3, 4, 17, 18, 19, 21, 22, 23};
for(int i = 0; i < ARRAY_COUNT(buildings); i++)
{
if(t->hasBuilt(buildings[i]))
continue;
const CBuilding *b = VLC->buildh->buildings[t->subID][buildings[i]];
int canBuild = cb->canBuildStructure(t, buildings[i]);
if(canBuild == EBuildingState::ALLOWED)
{
if(!containsSavedRes(b->resources))
{
BNLOG("Player %d will build %s in town of %s at %s", playerID % b->Name() % t->name % t->pos);
cb->buildBuilding(t, buildings[i]);
}
break;
}
else if(canBuild == EBuildingState::NO_RESOURCES)
{
TResources mine = cb->getResourceAmount(), cost = VLC->buildh->buildings[t->subID][buildings[i]]->resources,
income = estimateIncome();
for (int i = 0; i < GameConstants::RESOURCE_QUANTITY; i++)
{
int diff = mine[i] - cost[i] + income[i];
if(diff < 0)
saving[i] = 1;
}
continue;
}
}
}
bool isSafeToVisit(const CGHeroInstance *h, crint3 tile)
{
const ui64 heroStrength = h->getTotalStrength(),
dangerStrength = evaluateDanger(tile, h);
if(dangerStrength)
{
if(heroStrength / SAFE_ATTACK_CONSTANT > dangerStrength)
{
BNLOG("It's, safe for %s to visit tile %s", h->name % tile);
return true;
}
else
return false;
}
return true; //there's no danger
}
std::vector<const CGObjectInstance *> VCAI::getPossibleDestinations(const CGHeroInstance *h)
{
validateVisitableObjs();
std::vector<const CGObjectInstance *> possibleDestinations;
BOOST_FOREACH(const CGObjectInstance *obj, visitableObjs)
{
if(cb->getPathInfo(obj->visitablePos())->reachable() && !obj->wasVisited(playerID) &&
(obj->tempOwner != playerID || isWeeklyRevisitable(obj))) //flag or get weekly resources / creatures
possibleDestinations.push_back(obj);
}
boost::sort(possibleDestinations, isCloser);
possibleDestinations.erase(boost::remove_if(possibleDestinations, [&](const CGObjectInstance *obj) -> bool
{
if(vstd::contains(alreadyVisited, obj))
return true;
if(!isSafeToVisit(h, obj->visitablePos()))
return true;
if (!shouldVisit(h, obj))
return true;
if (vstd::contains(reservedObjs, obj)) //does checking for our own reserved objects make sense? here?
return true;
return false;
}),possibleDestinations.end());
return possibleDestinations;
}
void VCAI::wander(const CGHeroInstance * h)
{
while(1)
{
std::vector <ObjectIdRef> dests;
range::copy(reservedHeroesMap[h], std::back_inserter(dests));
if (!dests.size())
range::copy(getPossibleDestinations(h), std::back_inserter(dests));
if(!dests.size())
{
auto compareReinforcements = [h](const CGTownInstance *lhs, const CGTownInstance *rhs) -> bool
{
return howManyReinforcementsCanGet(h, lhs) < howManyReinforcementsCanGet(h, rhs);
};
std::vector<const CGTownInstance *> townsReachable;
std::vector<const CGTownInstance *> townsNotReachable;
BOOST_FOREACH(const CGTownInstance *t, cb->getTownsInfo())
{
if(!t->visitingHero && howManyReinforcementsCanGet(h,t) && !vstd::contains(townVisitsThisWeek[h], t))
{
if(isReachable(t))
townsReachable.push_back(t);
else
townsNotReachable.push_back(t);
}
}
if(townsReachable.size())
{
boost::sort(townsReachable, compareReinforcements);
dests.emplace_back(townsReachable.back());
}
else if(townsNotReachable.size())
{
boost::sort(townsNotReachable, compareReinforcements);
//TODO pick the truly best
const CGTownInstance *t = townsNotReachable.back();
BNLOG("%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(CGoal(CLEAR_WAY_TO).settile(t->visitablePos()).sethero(h));
if (pos1 == h->pos && h == primaryHero()) //hero can't move
{
if(cb->getResourceAmount(Res::GOLD) >= HERO_GOLD_COST && cb->getHeroesInfo().size() < ALLOWED_ROAMING_HEROES && cb->getAvailableHeroes(t).size())
recruitHero(t);
}
break;
}
else if(cb->getResourceAmount(Res::GOLD) >= HERO_GOLD_COST)
{
std::vector<const CGTownInstance *> towns = cb->getTownsInfo();
erase_if(towns, [](const CGTownInstance *t) -> bool
{
BOOST_FOREACH(const CGHeroInstance *h, cb->getHeroesInfo())
if(!t->getArmyStrength() || howManyReinforcementsCanGet(h, t))
return true;
return false;
});
boost::sort(towns, compareArmyStrength);
if(towns.size())
recruitHero(towns.back());
break;
}
else
{
PNLOG("Nowhere more to go...\n");
break;
}
}
const ObjectIdRef&dest = dests.front();
if(!goVisitObj(dest, h))
{
if(!dest)
{
BNLOG("Visit attempt made the object (id=%d) gone...", dest.id);
}
else
{
BNLOG("Hero %s apparently used all MPs (%d left)\n", h->name % h->movement);
reserveObject(h, dest); //reserve that object - we predict it will be reached soon
//removed - do not forget abstract goal so easily
//setGoal(h, CGoal(VISIT_TILE).sethero(h).settile(dest->visitablePos()));
}
break;
}
if(h->visitedTown)
{
townVisitsThisWeek[h].push_back(h->visitedTown);
buildArmyIn(h->visitedTown);
break;
}
}
}
void VCAI::setGoal (const CGHeroInstance *h, const CGoal goal)
{ //TODO: check for presence?
if (goal.goalType == EGoals::INVALID)
remove_if_present(lockedHeroes, h);
else
lockedHeroes[h] = CGoal(goal).setisElementar(false); //always evaluate goals before realizing
}
void VCAI::setGoal (const CGHeroInstance *h, EGoals goalType)
{
if (goalType == EGoals::INVALID)
remove_if_present(lockedHeroes, h);
else
lockedHeroes[h] = CGoal(goalType).setisElementar(false); //always evaluate goals before realizing;
}
void VCAI::completeGoal (const CGoal goal)
{
if (const CGHeroInstance * h = goal.hero)
{
auto it = lockedHeroes.find(h);
if (it != lockedHeroes.end())
if (it->second.goalType == goal.goalType)
lockedHeroes.erase(it); //goal fulfilled, free hero
}
}
void VCAI::battleStart(const CCreatureSet *army1, const CCreatureSet *army2, int3 tile, const CGHeroInstance *hero1, const CGHeroInstance *hero2, bool side)
{
NET_EVENT_HANDLER;
assert(playerID > GameConstants::PLAYER_LIMIT || status.getBattle() == UPCOMING_BATTLE);
status.setBattle(ONGOING_BATTLE);
const CGObjectInstance *presumedEnemy = backOrNull(cb->getVisitableObjs(tile)); //may be NULL in some very are cases -> eg. visited monolith and fighting with an enemy at the FoW covered exit
battlename = boost::str(boost::format("Starting battle of %s attacking %s at %s") % (hero1 ? hero1->name : "a army") % (presumedEnemy ? presumedEnemy->hoverName : "unknown enemy") % tile);
CAdventureAI::battleStart(army1, army2, tile, hero1, hero2, side);
}
void VCAI::battleEnd(const BattleResult *br)
{
NET_EVENT_HANDLER;
assert(status.getBattle() == ONGOING_BATTLE);
status.setBattle(ENDING_BATTLE);
bool won = br->winner == myCb->battleGetMySide();
BNLOG("Player %d: I %s the %s!", playerID % (won ? "won" : "lost") % battlename);
battlename.clear();
CAdventureAI::battleEnd(br);
}
void VCAI::waitTillFree()
{
auto unlock = vstd::makeUnlockSharedGuard(cb->getGsMutex());
status.waitTillFree();
}
void VCAI::markObjectVisited (const CGObjectInstance *obj)
{
if(dynamic_cast<const CGVisitableOPH *>(obj) || //we may want to wisit it with another hero
dynamic_cast<const CGBonusingObject *>(obj) || //or another time
(obj->ID == Obj::MONSTER))
return;
alreadyVisited.push_back(obj);
}
void VCAI::reserveObject (const CGHeroInstance * h, const CGObjectInstance *obj)
{
reservedObjs.push_back(obj);
reservedHeroesMap[h].push_back(obj);
}
void VCAI::validateVisitableObjs()
{
std::vector<const CGObjectInstance *> hlp;
retreiveVisitableObjs(hlp, true);
start:
BOOST_FOREACH(const CGObjectInstance *obj, visitableObjs)
if(!vstd::contains(hlp, obj))
{
tlog1 << helperObjInfo[obj].name << " at " << helperObjInfo[obj].pos << " shouldn't be on list!\n";
remove_if_present(visitableObjs, obj);
goto start;
}
}
void VCAI::retreiveVisitableObjs(std::vector<const CGObjectInstance *> &out, bool includeOwned /*= false*/) const
{
foreach_tile_pos([&](const int3 &pos)
{
BOOST_FOREACH(const CGObjectInstance *obj, cb->getVisitableObjs(pos, false))
{
if(includeOwned || obj->tempOwner != playerID)
out.push_back(obj);
}
});
}
std::vector<const CGObjectInstance *> VCAI::getFlaggedObjects() const
{
std::vector<const CGObjectInstance *> ret;
retreiveVisitableObjs(ret, true);
erase_if(ret, [](const CGObjectInstance *obj)
{
return obj->tempOwner != ai->playerID;
});
return ret;
}
void VCAI::addVisitableObj(const CGObjectInstance *obj)
{
visitableObjs.push_back(obj);
helperObjInfo[obj] = ObjInfo(obj);
}
const CGObjectInstance * VCAI::lookForArt(int aid) const
{
BOOST_FOREACH(const CGObjectInstance *obj, ai->visitableObjs)
{
if(obj->ID == 5 && obj->subID == aid)
return obj;
}
return NULL;
//TODO what if more than one artifact is available? return them all or some slection criteria
}
bool VCAI::isAccessible(const int3 &pos)
{
//TODO precalculate for speed
BOOST_FOREACH(const CGHeroInstance *h, cb->getHeroesInfo())
{
if(isAccessibleForHero(pos, h))
return true;
}
return false;
}
const CGHeroInstance * VCAI::getHeroWithGrail() const
{
BOOST_FOREACH(const CGHeroInstance *h, cb->getHeroesInfo())
if(h->hasArt(2)) //grail
return h;
return NULL;
}
const CGObjectInstance * VCAI::getUnvisitedObj(const boost::function<bool(const CGObjectInstance *)> &predicate)
{
//TODO smarter definition of unvisited
BOOST_FOREACH(const CGObjectInstance *obj, visitableObjs)
if(predicate(obj) && !vstd::contains(alreadyVisited, obj))
return obj;
return NULL;
}
bool VCAI::isAccessibleForHero(const int3 & pos, const CGHeroInstance * h, bool includeAllies) const
{
cb->setSelection(h);
if (!includeAllies)
{ //don't visit tile occupied by allied hero
BOOST_FOREACH (auto obj, cb->getVisitableObjs(pos))
{
if (obj->ID == GameConstants::HEROI_TYPE && obj->tempOwner == h->tempOwner && obj != h)
return false;
}
}
return cb->getPathInfo(pos)->reachable();
}
class cannotFulfillGoalException : public std::exception
{
std::string msg;
public:
explicit cannotFulfillGoalException(crstring _Message) : msg(_Message)
{
}
virtual ~cannotFulfillGoalException() throw ()
{
};
const char *what() const throw () OVERRIDE
{
return msg.c_str();
}
};
class goalFulfilledException : public std::exception
{
std::string msg;
public:
explicit goalFulfilledException(crstring _Message) : msg(_Message)
{
}
virtual ~goalFulfilledException() throw ()
{
};
const char *what() const throw () OVERRIDE
{
return msg.c_str();
}
};
bool VCAI::moveHeroToTile(int3 dst, const CGHeroInstance * h)
{
visitedObject = NULL;
int3 startHpos = h->visitablePos();
bool ret = false;
if(startHpos == dst)
{
assert(cb->getVisitableObjs(dst).size() > 1); //there's no point in revisiting tile where there is no visitable object
cb->moveHero(h,CGHeroInstance::convertPosition(dst, true));
waitTillFree(); //movement may cause battle or blocking dialog
ret = true;
}
else
{
CGPath path;
cb->getPath2(dst, path);
if(path.nodes.empty())
{
tlog1 << "Hero " << h->name << " cannot reach " << dst << std::endl;
//setGoal(h, INVALID);
completeGoal (CGoal(VISIT_TILE).sethero(h));
cb->recalculatePaths();
throw std::runtime_error("Wrong move order!");
}
int i=path.nodes.size()-1;
for(; i>0; i--)
{
//stop sending move requests if the next node can't be reached at the current turn (hero exhausted his move points)
if(path.nodes[i-1].turns)
{
//blockedHeroes.insert(h); //to avoid attempts of moving heroes with very little MPs
break;
}
int3 endpos = path.nodes[i-1].coord;
if(endpos == h->visitablePos())
//if (endpos == h->pos)
continue;
// if(i > 1)
// {
// int3 afterEndPos = path.nodes[i-2].coord;
// if(afterEndPos.z != endpos.z)
//
// }
//tlog0 << "Moving " << h->name << " from " << h->getPosition() << " to " << endpos << std::endl;
cb->moveHero(h,CGHeroInstance::convertPosition(endpos, true));
waitTillFree(); //movement may cause battle or blocking dialog
boost::this_thread::interruption_point();
if(h->tempOwner != playerID) //we lost hero - remove all tasks assigned to him/her
{
remove_if_present(lockedHeroes, h);
BOOST_FOREACH (auto obj, reservedHeroesMap[h])
{
remove_if_present(reservedObjs, obj); //unreserve all objects for that hero
}
remove_if_present(reservedHeroesMap, h);
throw std::runtime_error("Hero was lost!"); //we need to throw, otherwise hero will be assigned to sth again
break;
}
}
ret = !i;
}
if (visitedObject) //we step into something interesting
{
performObjectInteraction (visitedObject, h);
}
if(h->tempOwner == playerID) //we could have lost hero after last move
{
cb->recalculatePaths();
if (startHpos == h->visitablePos() && !ret) //we didn't move and didn't reach the target
{
throw cannotFulfillGoalException("Invalid path found!");
}
}
BNLOG("Hero %s moved from %s to %s", h->name % startHpos % h->visitablePos());
return ret;
}
int howManyTilesWillBeDiscovered(const int3 &pos, int radious)
{
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(cb->isInTheMap(npos) && pos.dist2d(npos) - 0.5 < radious && !cb->isVisible(npos))
{
ret++;
}
}
}
return ret;
}
int howManyTilesWillBeDiscovered(int radious, int3 pos, crint3 dir)
{
return howManyTilesWillBeDiscovered(pos + dir, radious);
}
void getVisibleNeighbours(const std::vector<int3> &tiles, std::vector<int3> &out)
{
BOOST_FOREACH(const int3 &tile, tiles)
{
foreach_neighbour(tile, [&](int3 neighbour)
{
if(cb->isVisible(neighbour))
out.push_back(neighbour);
});
}
}
void VCAI::tryRealize(CGoal g)
{
BNLOG("Attempting realizing goal with code %s", goalName(g.goalType));
switch(g.goalType)
{
case EXPLORE:
{
assert(0); //this goal is not elementar!
}
break;
case RECRUIT_HERO:
{
if(const CGTownInstance *t = findTownWithTavern())
{
//TODO co jesli nie ma dostepnego bohatera?
//TODO jezeli miasto jest zablokowane, sprobowac oczyscic wejscie
cb->recruitHero(t, cb->getAvailableHeroes(t)[0]);
}
//TODO karkolomna alternatywa - tawerna na mapie przygod lub wiezienie (nie wiem, czy warto?)
}
break;
case VISIT_TILE:
{
//cb->recalculatePaths();
if(!g.hero->movement)
throw cannotFulfillGoalException("Cannot visit tile: hero is out of MPs!");
if(!g.isBlockedBorderGate(g.tile))
{
if (ai->moveHeroToTile(g.tile, g.hero))
{
throw goalFulfilledException("");
}
}
else
throw cannotFulfillGoalException("There's a blocked gate!");
}
break;
case BUILD_STRUCTURE:
{
const CGTownInstance *t = g.town;
if(!t && g.hero)
t = g.hero->visitedTown;
if(!t)
{
BOOST_FOREACH(const CGTownInstance *t, cb->getTownsInfo())
{
switch(cb->canBuildStructure(t, g.bid))
{
case EBuildingState::ALLOWED:
cb->buildBuilding(t, g.bid);
return;
default:
break;
}
}
}
else if(cb->canBuildStructure(t, g.bid) == EBuildingState::ALLOWED)
{
cb->buildBuilding(t, g.bid);
return;
}
throw cannotFulfillGoalException("Cannot build a given structure!");
}
break;
case DIG_AT_TILE:
{
assert(g.hero->visitablePos() == g.tile);
if (g.hero->diggingStatus() == CGHeroInstance::CAN_DIG)
{
cb->dig (g.hero);
setGoal (g.hero, INVALID); // finished digging
}
else
{
ai->lockedHeroes[g.hero] = g; //hero who tries to dig shouldn't do anything else
throw cannotFulfillGoalException("A hero can't dig!\n");
}
}
break;
case COLLECT_RES:
if(const CGObjectInstance *obj = cb->getObj(g.objid, false))
{
if(const IMarket *m = IMarket::castFrom(obj, false))
{
for (int i = 0; i < ACTUAL_RESOURCE_COUNT; i++)
{
if(i == g.resID) continue;
int toGive, toGet;
m->getOffer(i, g.resID, toGive, toGet, EMarketMode::RESOURCE_RESOURCE);
toGive = toGive * (cb->getResourceAmount(i) / toGive);
cb->trade(obj, EMarketMode::RESOURCE_RESOURCE, i, g.resID, toGive);
if(cb->getResourceAmount(g.resID) >= g.value)
return;
}
}
else
{
throw cannotFulfillGoalException("I don't know how to use this object to raise resources!");
}
}
else
{
saving[g.resID] = 1;
throw cannotFulfillGoalException("No object that could be used to raise resources!");
}
case CONQUER:
case GATHER_ARMY:
case BOOST_HERO:
// TODO: conquer??
throw cannotFulfillGoalException("I don't know how to fulfill this!");
case BUILD:
performTypicalActions();
throw cannotFulfillGoalException("BUILD has been realized as much as possible.");
case INVALID:
throw cannotFulfillGoalException("I don't know how to fulfill this!");
default:
throw cannotFulfillGoalException("Unknown type of goal !");
}
}
const CGTownInstance * VCAI::findTownWithTavern() const
{
BOOST_FOREACH(const CGTownInstance *t, cb->getTownsInfo())
if(vstd::contains(t->builtBuildings, EBuilding::TAVERN) && !t->visitingHero)
return t;
return NULL;
}
std::vector<const CGHeroInstance *> VCAI::getUnblockedHeroes() const
{
std::vector<const CGHeroInstance *> ret = cb->getHeroesInfo();
BOOST_FOREACH(auto h, lockedHeroes)
{
if (!h.second.invalid()) //we can use heroes without valid goal
remove_if_present(ret, h.first);
}
return ret;
}
const CGHeroInstance * VCAI::primaryHero() const
{
auto hs = cb->getHeroesInfo();
boost::sort(hs, compareHeroStrength);
if(hs.empty())
return NULL;
return hs.back();
}
void VCAI::endTurn()
{
tlog4 << "Player " << playerID << " ends turn\n";
if(!status.haveTurn())
{
tlog1 << "Not having turn at the end of turn???\n";
}
do
{
cb->endTurn();
} while(status.haveTurn()); //for some reasons, our request may fail -> stop requesting end of turn only after we've received a confirmation that it's over
tlog4 << "Player " << playerID << " ended turn\n";
}
void VCAI::striveToGoal(const CGoal &ultimateGoal)
{
if (ultimateGoal.invalid())
return;
CGoal abstractGoal;
while(1)
{
CGoal goal = ultimateGoal;
BNLOG("Striving to goal of type %s", goalName(ultimateGoal.goalType));
int maxGoals = 100; //preventing deadlock for mutually dependent goals
while(!goal.isElementar && !goal.isAbstract && maxGoals)
{
INDENT;
BNLOG("Considering goal %s", goalName(goal.goalType));
try
{
boost::this_thread::interruption_point();
goal = goal.whatToDoToAchieve();
--maxGoals;
}
catch(std::exception &e)
{
BNLOG("Goal %s decomposition failed: %s", goalName(goal.goalType) % e.what());
return;
}
}
try
{
boost::this_thread::interruption_point();
if (goal.hero) //lock this hero to fulfill ultimate goal
{
if (maxGoals)
{
setGoal (goal.hero, goal);
}
else
{
setGoal (goal.hero, INVALID); // we seemingly don't know what to do with hero
}
}
if (goal.isAbstract)
{
abstractGoal = goal; //allow only one abstract goal per call
BNLOG("Choosing abstract goal %s", goalName(goal.goalType));
break;
}
else
tryRealize(goal);
boost::this_thread::interruption_point();
}
catch(boost::thread_interrupted &e)
{
BNLOG("Player %d: Making turn thread received an interruption!", playerID);
throw; //rethrow, we want to truly end this thread
}
catch(goalFulfilledException &e)
{
completeGoal (goal);
if (maxGoals > 98) //completed goal was main goal
//TODO: find better condition
return;
}
catch(std::exception &e)
{
BNLOG("Failed to realize subgoal of type %s (greater goal type was %s), I will stop.", goalName(goal.goalType) % goalName(ultimateGoal.goalType));
BNLOG("The error message was: %s", e.what());
break;
}
}
//TODO: save abstract goals not related to hero
if (!abstractGoal.invalid()) //try to realize our one goal
{
while (1)
{
CGoal goal = CGoal(abstractGoal).setisAbstract(false);
int maxGoals = 50;
while (!goal.isElementar && maxGoals) //find elementar goal and fulfill it
{
try
{
boost::this_thread::interruption_point();
goal = goal.whatToDoToAchieve();
--maxGoals;
}
catch(std::exception &e)
{
BNLOG("Goal %s decomposition failed: %s", goalName(goal.goalType) % e.what());
return;
}
}
try
{
boost::this_thread::interruption_point();
tryRealize(goal);
boost::this_thread::interruption_point();
}
catch(boost::thread_interrupted &e)
{
BNLOG("Player %d: Making turn thread received an interruption!", playerID);
throw; //rethrow, we want to truly end this thread
}
catch(goalFulfilledException &e)
{
completeGoal (goal);
if (maxGoals > 98) //completed goal was main goal
//TODO: find better condition
return;
}
catch(std::exception &e)
{
BNLOG("Failed to realize subgoal of type %s (greater goal type was %s), I will stop.", goalName(goal.goalType) % goalName(ultimateGoal.goalType));
BNLOG("The error message was: %s", e.what());
break;
}
}
}
}
void VCAI::performTypicalActions()
{
BOOST_FOREACH(const CGTownInstance *t, cb->getTownsInfo())
{
BNLOG("Looking into %s", t->name);
buildStructure(t);
buildArmyIn(t);
if(!ai->primaryHero() ||
(t->getArmyStrength() > ai->primaryHero()->getArmyStrength() * 2 && !isAccessibleForHero(t->visitablePos(), ai->primaryHero())))
{
recruitHero(t);
buildArmyIn(t);
}
}
BOOST_FOREACH(const CGHeroInstance *h, getUnblockedHeroes())
{
BNLOG("Looking into %s, MP=%d", h->name.c_str() % h->movement);
INDENT;
makePossibleUpgrades(h);
cb->setSelection(h);
try
{
wander(h);
}
catch(std::exception &e)
{
BNLOG("Cannot use this hero anymore, received exception: %s", e.what());
continue;
}
}
}
void VCAI::buildArmyIn(const CGTownInstance * t)
{
makePossibleUpgrades(t->visitingHero);
makePossibleUpgrades(t);
recruitCreatures(t);
moveCreaturesToHero(t);
}
int3 VCAI::explorationBestNeighbour(int3 hpos, int radius, const CGHeroInstance * h)
{
TimeCheck tc("looking for best exploration neighbour");
std::map<int3, int> dstToRevealedTiles;
BOOST_FOREACH(crint3 dir, dirs)
if(cb->isInTheMap(hpos+dir))
dstToRevealedTiles[hpos + dir] = howManyTilesWillBeDiscovered(radius, hpos, dir) * isSafeToVisit(h, hpos + dir);
auto best = dstToRevealedTiles.begin();
best->second *= cb->getPathInfo(best->first)->reachable();
best->second *= cb->getPathInfo(best->first)->accessible == CGPathNode::ACCESSIBLE;
for(auto i = dstToRevealedTiles.begin(); i != dstToRevealedTiles.end(); i++)
{
const CGPathNode *pn = cb->getPathInfo(i->first);
//const TerrainTile *t = cb->getTile(i->first);
if(best->second < i->second && i->second && pn->reachable() && pn->accessible == CGPathNode::ACCESSIBLE)
best = i;
}
if(best->second)
return best->first;
throw cannotFulfillGoalException("No neighbour will bring new discoveries!");
}
int3 VCAI::explorationNewPoint(int radius, const CGHeroInstance * h, std::vector<std::vector<int3> > &tiles)
{
TimeCheck tc("looking for new exploration point");
tlog0 << "Looking for an another place for exploration...\n";
tiles.resize(radius);
foreach_tile_pos([&](const int3 &pos)
{
if(!cb->isVisible(pos))
tiles[0].push_back(pos);
});
for (int i = 1; i < radius; i++)
{
getVisibleNeighbours(tiles[i-1], tiles[i]);
removeDuplicates(tiles[i]);
BOOST_FOREACH(const int3 &tile, tiles[i])
{
if(cb->getPathInfo(tile)->reachable() && isSafeToVisit(h, tile) && howManyTilesWillBeDiscovered(tile, radius))
{
return tile;
}
}
}
throw cannotFulfillGoalException("No accessible tile will bring discoveries!");
}
TResources VCAI::estimateIncome() const
{
TResources ret;
BOOST_FOREACH(const CGTownInstance *t, cb->getTownsInfo())
{
ret[Res::GOLD] += t->dailyIncome();
//TODO duplikuje newturn
if(t->hasBuilt(EBuilding::RESOURCE_SILO)) //there is resource silo
{
if(t->town->primaryRes == 127) //we'll give wood and ore
{
ret[Res::WOOD] ++;
ret[Res::ORE] ++;
}
else
{
ret[t->town->primaryRes] ++;
}
}
}
BOOST_FOREACH(const CGObjectInstance *obj, getFlaggedObjects())
{
if(obj->ID == Obj::MINE)
{
switch(obj->subID)
{
case Res::WOOD:
case Res::ORE:
ret[obj->subID] += WOOD_ORE_MINE_PRODUCTION;
break;
case Res::GOLD:
case 7: //abandoned mine -> also gold
ret[Res::GOLD] += GOLD_MINE_PRODUCTION;
break;
default:
ret[obj->subID] += RESOURCE_MINE_PRODUCTION;
break;
}
}
}
return ret;
}
bool VCAI::containsSavedRes(const TResources &cost) const
{
for (int i = 0; i < GameConstants::RESOURCE_QUANTITY; i++)
{
if(saving[i] && cost[i])
return true;
}
return false;
}
void VCAI::recruitHero(const CGTownInstance * t)
{
BNLOG("Trying to recruit a hero in %s at %s", t->name % t->visitablePos())
cb->recruitHero(t, cb->getAvailableHeroes(t).front());
}
void VCAI::finish()
{
if(makingTurn)
makingTurn->interrupt();
}
void VCAI::requestActionASAP(boost::function<void()> whatToDo)
{
boost::barrier b(2);
boost::thread newThread([&b,this,whatToDo]()
{
setThreadName(-1, "VCAI::requestActionASAP::helper");
SET_GLOBAL_STATE(this);
boost::shared_lock<boost::shared_mutex> gsLock(cb->getGsMutex());
b.wait();
whatToDo();
});
b.wait();
}
AIStatus::AIStatus()
{
battle = NO_BATTLE;
remainingQueries = 0;
havingTurn = false;
}
AIStatus::~AIStatus()
{
}
void AIStatus::setBattle(BattleState BS)
{
boost::unique_lock<boost::mutex> lock(mx);
battle = BS;
cv.notify_all();
}
BattleState AIStatus::getBattle()
{
boost::unique_lock<boost::mutex> lock(mx);
return battle;
}
void AIStatus::addQueries(int val)
{
boost::unique_lock<boost::mutex> lock(mx);
remainingQueries += val;
BNLOG("Changing count of queries by %d, to a total of %d", val % remainingQueries);
assert(remainingQueries >= 0);
cv.notify_all();
}
void AIStatus::addQuery()
{
addQueries(1);
}
void AIStatus::removeQuery()
{
addQueries(-1);
}
int AIStatus::getQueriesCount()
{
boost::unique_lock<boost::mutex> lock(mx);
return remainingQueries;
}
void AIStatus::startedTurn()
{
boost::unique_lock<boost::mutex> lock(mx);
havingTurn = true;
cv.notify_all();
}
void AIStatus::madeTurn()
{
boost::unique_lock<boost::mutex> lock(mx);
havingTurn = false;
cv.notify_all();
}
void AIStatus::waitTillFree()
{
boost::unique_lock<boost::mutex> lock(mx);
while(battle != NO_BATTLE || remainingQueries)
cv.wait(lock);
}
bool AIStatus::haveTurn()
{
boost::unique_lock<boost::mutex> lock(mx);
return havingTurn;
}
int3 whereToExplore(const CGHeroInstance *h)
{
//TODO it's stupid and ineffective, write sth better
cb->setSelection(h);
int radius = h->getSightRadious();
int3 hpos = h->visitablePos();
//look for nearby objs -> visit them if they're close enouh
const int DIST_LIMIT = 3;
std::vector<const CGObjectInstance *> nearbyVisitableObjs;
BOOST_FOREACH(const CGObjectInstance *obj, ai->getPossibleDestinations(h))
{
int3 op = obj->visitablePos();
CGPath p;
cb->getPath2(op, p);
if(p.nodes.size() && p.endPos() == op && p.nodes.size() <= DIST_LIMIT)
nearbyVisitableObjs.push_back(obj);
}
boost::sort(nearbyVisitableObjs, isCloser);
if(nearbyVisitableObjs.size())
return nearbyVisitableObjs.back()->visitablePos();
try
{
return ai->explorationBestNeighbour(hpos, radius, h);
}
catch(cannotFulfillGoalException &e)
{
std::vector<std::vector<int3> > tiles; //tiles[distance_to_fow], metryka taksówkowa
try
{
return ai->explorationNewPoint(radius, h, tiles);
}
catch(cannotFulfillGoalException &e)
{
std::map<int, std::vector<int3> > profits;
{
TimeCheck tc("Evaluating exploration possibilities");
tiles[0].clear(); //we can't reach FoW anyway
BOOST_FOREACH(auto &vt, tiles)
BOOST_FOREACH(auto &tile, vt)
profits[howManyTilesWillBeDiscovered(tile, radius)].push_back(tile);
}
if(profits.empty())
throw cannotFulfillGoalException("Cannot explore - no possible ways found!");
auto bestDest = profits.end();
bestDest--;
return bestDest->second.front(); //TODO which is the real best tile?
}
}
}
TSubgoal CGoal::whatToDoToAchieve()
{
switch(goalType)
{
case WIN:
{
const CVictoryCondition &vc = cb->getMapHeader()->victoryCondition;
EVictoryConditionType::EVictoryConditionType cond = vc.condition;
if(!vc.appliesToAI)
{
//TODO deduce victory from human loss condition
cond = EVictoryConditionType::WINSTANDARD;
}
switch(cond)
{
case EVictoryConditionType::ARTIFACT:
return CGoal(GET_ART_TYPE).setaid(vc.ID);
case EVictoryConditionType::BEATHERO:
return CGoal(GET_OBJ).setobjid(vc.ID);
case EVictoryConditionType::BEATMONSTER:
return CGoal(GET_OBJ).setobjid(vc.ID);
case EVictoryConditionType::BUILDCITY:
//TODO build castle/capitol
break;
case EVictoryConditionType::BUILDGRAIL:
{
if(const CGHeroInstance *h = ai->getHeroWithGrail())
{
//hero is in a town that can host Grail
if(h->visitedTown && !vstd::contains(h->visitedTown->forbiddenBuildings, EBuilding::GRAIL))
{
const CGTownInstance *t = h->visitedTown;
return CGoal(BUILD_STRUCTURE).setbid(EBuilding::GRAIL).settown(t);
}
else
{
auto towns = cb->getTownsInfo();
towns.erase(boost::remove_if(towns,
[](const CGTownInstance *t) -> bool
{
return vstd::contains(t->forbiddenBuildings, EBuilding::GRAIL);
}),
towns.end());
boost::sort(towns, isCloser);
if(towns.size())
{
return CGoal(VISIT_TILE).sethero(h).settile(towns.front()->visitablePos());
}
}
}
double ratio = 0;
int3 grailPos = cb->getGrailPos(ratio);
if(ratio > 0.99)
{
return CGoal(DIG_AT_TILE).settile(grailPos);
}
else if(const CGObjectInstance * obj = ai->getUnvisitedObj(objWithID<Obj::OBELISK>)) //there are unvisited Obelisks
{
return CGoal(GET_OBJ).setobjid(obj->id);
}
else
return CGoal(EXPLORE);
}
break;
case EVictoryConditionType::CAPTURECITY:
return CGoal(GET_OBJ).setobjid(vc.ID);
case EVictoryConditionType::GATHERRESOURCE:
return CGoal(COLLECT_RES).setresID(vc.ID).setvalue(vc.count);
//TODO mines? piles? marketplace?
//save?
break;
case EVictoryConditionType::GATHERTROOP:
break;
case EVictoryConditionType::TAKEDWELLINGS:
break;
case EVictoryConditionType::TAKEMINES:
break;
case EVictoryConditionType::TRANSPORTITEM:
break;
case EVictoryConditionType::WINSTANDARD:
return CGoal(CONQUER);
default:
assert(0);
}
}
break;
case GET_OBJ:
{
const CGObjectInstance * obj = cb->getObj(objid);
if(!obj)
return CGoal(EXPLORE);
int3 pos = cb->getObj(objid)->visitablePos();
return CGoal(VISIT_TILE).settile(pos);
}
break;
case GET_ART_TYPE:
{
const CGObjectInstance *artInst = ai->lookForArt(aid);
if(!artInst)
{
TSubgoal alternativeWay = CGoal::lookForArtSmart(aid);
if(alternativeWay.invalid())
return CGoal(EXPLORE);
else
return alternativeWay;
}
else
return CGoal(GET_OBJ).setobjid(artInst->id);
}
break;
case CLEAR_WAY_TO:
{
assert(tile.x >= 0); //set tile
if(!cb->isVisible(tile))
{
tlog1 << "Clear way should be used with visible tiles!\n";
return CGoal(EXPLORE);
}
const CGHeroInstance *h = hero ? hero : ai->primaryHero();
if(!h)
return CGoal(RECRUIT_HERO);
cb->setSelection(h);
SectorMap sm;
bool dropToFile = false;
if(dropToFile) //for debug purposes
sm.write("test.txt");
int3 tileToHit = sm.firstTileToGet(h, tile);
//if(isSafeToVisit(h, tileToHit))
if(isBlockedBorderGate(tileToHit))
throw cannotFulfillGoalException("There's blocked border gate!");
if(tileToHit == tile)
{
tlog1 << boost::format("Very strange, tile to hit is %s and tile is also %s, while hero %s is at %s\n")
% tileToHit % tile % h->name % h->visitablePos();
throw cannotFulfillGoalException("Retreiving first tile to hit failed (probably)!");
}
return CGoal(VISIT_TILE).settile(tileToHit).sethero(h);
//TODO czy istnieje lepsza droga?
}
throw cannotFulfillGoalException("Cannot reach given tile!");
//return CGoal(EXPLORE); // TODO improve
case EXPLORE:
{
if (hero)
{
return CGoal(VISIT_TILE).settile(whereToExplore(hero)).sethero(hero);
}
auto hs = cb->getHeroesInfo();
int howManyHeroes = hs.size();
erase(hs, [](const CGHeroInstance *h)
{
return contains(ai->lockedHeroes, h);
});
if(hs.empty()) //all heroes are busy. buy new one
{
if (howManyHeroes < 3 && ai->findTownWithTavern()) //we may want to recruit second hero. TODO: make it smart finally
return CGoal(RECRUIT_HERO);
else //find mobile hero with weakest army
{
hs = cb->getHeroesInfo();
erase_if(hs, [](const CGHeroInstance *h)
{
return !h->movement; //only hero with movement are of interest for us
});
if (hs.empty())
{
if (howManyHeroes < GameConstants::MAX_HEROES_PER_PLAYER)
return CGoal(RECRUIT_HERO);
else
throw cannotFulfillGoalException("No heroes with remaining MPs for exploring!\n");
}
boost::sort(hs, compareMovement); //closer to what?
}
}
const CGHeroInstance *h = hs.front();
return (*this).sethero(h).setisAbstract(true);
}
I_AM_ELEMENTAR;
case RECRUIT_HERO:
{
const CGTownInstance *t = ai->findTownWithTavern();
if(!t)
return CGoal(BUILD_STRUCTURE).setbid(EBuilding::TAVERN);
if(cb->getResourceAmount(Res::GOLD) < HERO_GOLD_COST)
return CGoal(COLLECT_RES).setresID(Res::GOLD).setvalue(HERO_GOLD_COST);
I_AM_ELEMENTAR;
}
break;
case VISIT_TILE:
{
if(!cb->isVisible(tile))
return CGoal(EXPLORE);
if(hero && !ai->isAccessibleForHero(tile, hero))
hero = NULL;
if(!hero)
{
if(cb->getHeroesInfo().empty())
{
return CGoal(RECRUIT_HERO);
}
BOOST_FOREACH(const CGHeroInstance *h, cb->getHeroesInfo())
{
if(ai->isAccessibleForHero(tile, h))
{
hero = h;
break;
}
}
}
if(hero)
{
if(isSafeToVisit(hero, tile))
return CGoal(*this).setisElementar(true);
else
{
return CGoal(GATHER_ARMY).sethero(hero);
}
}
else //inaccessible for all heroes
{
return CGoal(CLEAR_WAY_TO).settile(tile);
}
}
break;
case DIG_AT_TILE:
{
const CGObjectInstance *firstObj = frontOrNull(cb->getVisitableObjs(tile));
if(firstObj && firstObj->ID == GameConstants::HEROI_TYPE && firstObj->tempOwner == ai->playerID) //we have hero at dest
{
const CGHeroInstance *h = dynamic_cast<const CGHeroInstance *>(firstObj);
return CGoal(*this).sethero(h).setisElementar(true);
}
return CGoal(VISIT_TILE).settile(tile);
}
break;
case BUILD_STRUCTURE:
//TODO check res
//look for town
//prerequisites?
I_AM_ELEMENTAR;
case COLLECT_RES:
{
std::vector<const IMarket*> markets;
std::vector<const CGObjectInstance*> visObjs;
ai->retreiveVisitableObjs(visObjs, true);
BOOST_FOREACH(const CGObjectInstance *obj, visObjs)
{
if(const IMarket *m = IMarket::castFrom(obj, false))
{
if(obj->ID == GameConstants::TOWNI_TYPE && 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 == GameConstants::TOWNI_TYPE && market->o->tempOwner == ai->playerID)
&& !ai->isAccessible(market->o->visitablePos());
}),markets.end());
if(!markets.size())
{
BOOST_FOREACH(const CGTownInstance *t, cb->getTownsInfo())
{
if(cb->canBuildStructure(t, EBuilding::MARKETPLACE) == EBuildingState::ALLOWED)
return CGoal(BUILD_STRUCTURE).settown(t).setbid(EBuilding::MARKETPLACE);
}
}
else
{
const IMarket *m = markets.back();
//attempt trade at back (best prices)
int howManyCanWeBuy = 0;
for(int i = 0; i < ACTUAL_RESOURCE_COUNT; i++)
{
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(resID) >= value)
{
auto backObj = backOrNull(cb->getVisitableObjs(m->o->visitablePos())); //it'll be a hero if we have one there; otherwise marketplace
assert(backObj);
if(backObj->tempOwner != ai->playerID)
return CGoal(GET_OBJ).setobjid(m->o->id);
return setobjid(m->o->id).setisElementar(true);
}
}
}
return CGoal(INVALID);
case CONQUER: //TODO: put it into a function?
{
auto hs = cb->getHeroesInfo();
int howManyHeroes = hs.size();
erase(hs, [](const CGHeroInstance *h)
{
return contains(ai->lockedHeroes, h);
});
if(hs.empty()) //all heroes are busy. buy new one
{
if (howManyHeroes < 3 && ai->findTownWithTavern()) //we may want to recruit second hero. TODO: make it smart finally
return CGoal(RECRUIT_HERO);
else //find mobile hero with weakest army
{
hs = cb->getHeroesInfo();
erase_if(hs, [](const CGHeroInstance *h)
{
return !h->movement; //only hero with movement are of interest for us
});
if (hs.empty())
{
if (howManyHeroes < GameConstants::MAX_HEROES_PER_PLAYER)
return CGoal(RECRUIT_HERO);
else
throw cannotFulfillGoalException("No heroes with remaining MPs for exploring!\n");
}
boost::sort(hs, compareHeroStrength);
}
}
const CGHeroInstance *h = hs.back();
cb->setSelection(h);
std::vector<const CGObjectInstance *> objs; //here we'll gather enemy towns and heroes
ai->retreiveVisitableObjs(objs);
erase_if(objs, [&](const CGObjectInstance *obj)
{
return (obj->ID != GameConstants::TOWNI_TYPE && obj->ID != GameConstants::HEROI_TYPE) //not town/hero
|| cb->getPlayerRelations(ai->playerID, obj->tempOwner) != 0; //not enemy
});
if(objs.empty())
return CGoal(EXPLORE); //we need to find an enemy
erase_if(objs, [&](const CGObjectInstance *obj)
{
return !isSafeToVisit(h, obj->visitablePos());
});
if(objs.empty())
I_AM_ELEMENTAR;
boost::sort(objs, isCloser);
BOOST_FOREACH(const CGObjectInstance *obj, objs)
{
if(ai->isAccessibleForHero(obj->visitablePos(), h))
return CGoal(VISIT_TILE).sethero(h).settile(obj->visitablePos());
}
return CGoal(EXPLORE); //enemy is inaccessible
}
break;
case BUILD:
I_AM_ELEMENTAR;
case INVALID:
I_AM_ELEMENTAR;
case GATHER_ARMY:
{
//TODO: find hero if none set
const CGHeroInstance *h = hero;
cb->setSelection(h);
auto compareReinforcements = [h](const CGTownInstance *lhs, const CGTownInstance *rhs) -> bool
{
return howManyReinforcementsCanGet(h, lhs) < howManyReinforcementsCanGet(h, rhs);
};
std::vector<const CGTownInstance *> townsReachable;
BOOST_FOREACH(const CGTownInstance *t, cb->getTownsInfo())
{
if(!t->visitingHero && howManyReinforcementsCanGet(h,t))
{
if(isReachable(t))
townsReachable.push_back(t);
}
}
if(townsReachable.size()) //try towns first
{
boost::sort(townsReachable, compareReinforcements);
return CGoal(VISIT_TILE).sethero(hero).settile(townsReachable.back()->visitablePos());
}
else
{
std::vector<const CGObjectInstance *> objs; //here we'll gather all dwellings
ai->retreiveVisitableObjs(objs);
erase_if(objs, [&](const CGObjectInstance *obj)
{
return (obj->ID != Obj::CREATURE_GENERATOR1); //not town/ dwelling
});
if(objs.empty()) //no possible objects, we did eveyrthing already
return CGoal(EXPLORE).sethero(hero);
//TODO: check if we can recruit any creatures there, evaluate army
boost::sort(objs, isCloser);
BOOST_FOREACH(const CGObjectInstance *obj, objs)
{ //find safe dwelling
if (isSafeToVisit(hero, obj->visitablePos())) //TODO: make use of multiple heroes
return CGoal(VISIT_TILE).sethero(hero).settile(obj->visitablePos());
}
}
return CGoal(EXPLORE); //find dwelling
}
break;
default:
assert(0);
}
return CGoal(EXPLORE);
}
TSubgoal CGoal::goVisitOrLookFor(const CGObjectInstance *obj)
{
if(obj)
return CGoal(GET_OBJ).setobjid(obj->id);
else
return CGoal(EXPLORE);
}
TSubgoal CGoal::lookForArtSmart(int aid)
{
return CGoal(INVALID);
}
bool CGoal::invalid() const
{
return goalType == INVALID;
}
bool CGoal::isBlockedBorderGate(int3 tileToHit)
{
return cb->getTile(tileToHit)->topVisitableID() == Obj::BORDER_GATE
&& cb->getPathInfo(tileToHit)->accessible != CGPathNode::ACCESSIBLE;
}
SectorMap::SectorMap()
{
// int3 sizes = cb->getMapSize();
// sector.resize(sizes.x);
// BOOST_FOREACH(auto &i, sector)
// i.resize(sizes.y);
//
// BOOST_FOREACH(auto &i, sector)
// BOOST_FOREACH(auto &j, i)
// j.resize(sizes.z, 0);
update();
}
bool markIfBlocked(ui8 &sec, crint3 pos, const TerrainTile *t)
{
if(t->blocked && !t->visitable)
{
sec = NOT_AVAILABLE;
return true;
}
return false;
}
bool markIfBlocked(ui8 &sec, crint3 pos)
{
return markIfBlocked(sec, pos, cb->getTile(pos));
}
void SectorMap::update()
{
clear();
int curSector = 3; //0 is invisible, 1 is not explored
foreach_tile_pos([&](crint3 pos)
{
if(retreiveTile(pos) == NOT_CHECKED)
{
if(!markIfBlocked(retreiveTile(pos), pos))
exploreNewSector(pos, curSector++);
}
});
valid = true;
}
void SectorMap::clear()
{
sector = cb->getVisibilityMap();
valid = false;
}
bool canBeEmbarkmentPoint(const TerrainTile *t)
{
//tile must be free of with unoccupied boat
return !t->blocked
|| (t->visitableObjects.size() == 1 && t->topVisitableID() == Obj::BOAT);
}
void SectorMap::exploreNewSector(crint3 pos, int num)
{
Sector &s = infoOnSectors[num];
s.id = num;
s.water = cb->getTile(pos)->isWater();
std::queue<int3> toVisit;
toVisit.push(pos);
while(toVisit.size())
{
int3 curPos = toVisit.front();
toVisit.pop();
ui8 &sec = retreiveTile(curPos);
if(sec == NOT_CHECKED)
{
const TerrainTile *t = cb->getTile(curPos);
if(!markIfBlocked(sec, curPos, t))
{
if(t->isWater() == s.water) //sector is only-water or only-land
{
sec = num;
s.tiles.push_back(curPos);
foreach_neighbour(curPos, [&](crint3 neighPos)
{
if(retreiveTile(neighPos) == NOT_CHECKED)
{
toVisit.push(neighPos);
//parent[neighPos] = curPos;
}
const TerrainTile *nt = cb->getTile(neighPos, false);
if(nt && nt->isWater() != s.water && canBeEmbarkmentPoint(nt))
{
s.embarkmentPoints.push_back(neighPos);
}
});
if(t->visitable && vstd::contains(ai->knownSubterraneanGates, t->visitableObjects.front()))
toVisit.push(ai->knownSubterraneanGates[t->visitableObjects.front()]->pos);
}
}
}
}
removeDuplicates(s.embarkmentPoints);
}
void SectorMap::write(crstring fname)
{
std::ofstream out(fname);
for(int k = 0; k < cb->getMapSize().z; k++)
{
for(int j = 0; j < cb->getMapSize().y; j++)
{
for(int i = 0; i < cb->getMapSize().x; i++)
{
out << (int)sector[i][j][k] << '\t';
}
out << std::endl;
}
out << std::endl;
}
}
bool isWeeklyRevisitable (const CGObjectInstance * obj)
{ //TODO: allow polling of remaining creatures in dwelling
if (dynamic_cast<const CGVisitableOPW *>(obj) || //ensures future compatibility, unlike IDs
dynamic_cast<const CGDwelling *>(obj) ||
dynamic_cast<const CBank *>(obj)) //banks tend to respawn often in mods
return true;
switch (obj->ID)
{
case Obj::STABLES: //any other potential visitable objects?
return true;
}
return false;
}
bool shouldVisit (const CGHeroInstance * h, const CGObjectInstance * obj)
{
switch (obj->ID)
{
case Obj::CREATURE_GENERATOR1:
{
if (obj->tempOwner != h->tempOwner)
return true; //flag just in case
bool canRecruitCreatures = false;
const CGDwelling * d = dynamic_cast<const CGDwelling *>(obj);
BOOST_FOREACH(auto level, d->creatures)
{
BOOST_FOREACH(auto c, level.second)
{
if (h->getSlotFor(c) != -1)
canRecruitCreatures = true;
}
}
return canRecruitCreatures;
}
case Obj::MONOLITH1:
case Obj::MONOLITH2:
case Obj::MONOLITH3:
case Obj::WHIRLPOOL:
//TODO: mehcanism for handling monoliths
return false;
case Obj::SCHOOL_OF_MAGIC:
case Obj::SCHOOL_OF_WAR:
{
TResources myRes = ai->myCb->getResourceAmount();
if (myRes[Res::GOLD] - GOLD_RESERVE < 1000)
return false;
}
break;
case Obj::LIBRARY_OF_ENLIGHTENMENT:
if (h->level < 12)
return false;
case Obj::TREE_OF_KNOWLEDGE:
{
TResources myRes = ai->myCb->getResourceAmount();
if (myRes[Res::GOLD] - GOLD_RESERVE < 2000 || myRes[Res::GEMS] < 10)
return false;
}
break;
}
if (obj->wasVisited(h))
return false;
return true;
}
int3 SectorMap::firstTileToGet(const CGHeroInstance *h, crint3 dst)
{
int sourceSector = retreiveTile(h->visitablePos()),
destinationSector = retreiveTile(dst);
if(sourceSector != destinationSector)
{
const Sector *src = &infoOnSectors[sourceSector],
*dst = &infoOnSectors[destinationSector];
std::map<const Sector*, const Sector*> preds;
std::queue<const Sector *> sq;
sq.push(src);
while(!sq.empty())
{
const Sector *s = sq.front();
sq.pop();
BOOST_FOREACH(int3 ep, s->embarkmentPoints)
{
Sector *neigh = &infoOnSectors[retreiveTile(ep)];
//preds[s].push_back(neigh);
if(!preds[neigh])
{
preds[neigh] = s;
sq.push(neigh);
}
}
//TODO consider other types of connections between sectors?
}
if(!preds[dst])
{
write("test.txt");
ai->completeGoal (CGoal(EXPLORE).sethero(h)); //if we can't find the way, seemingly all tiles were explored
//TODO: more organized way?
throw cannotFulfillGoalException(str(format("Cannot find connection between sectors %d and %d") % src->id % dst->id));
}
std::vector<const Sector*> toTraverse;
toTraverse.push_back(dst);
while(toTraverse.back() != src)
{
toTraverse.push_back(preds[toTraverse.back()]);
}
if(preds[dst])
{
const Sector *sectorToReach = toTraverse.at(toTraverse.size() - 2);
if(!src->water && sectorToReach->water) //embark
{
//embark on ship -> look for an EP with a boat
auto firstEP = boost::find_if(src->embarkmentPoints, [=](crint3 pos) -> bool
{
const TerrainTile *t = cb->getTile(pos);
return t && t->visitableObjects.size() == 1 && t->topVisitableID() == Obj::BOAT
&& retreiveTile(pos) == sectorToReach->id;
});
if(firstEP != src->embarkmentPoints.end())
{
return *firstEP;
}
else
{
//we need to find a shipyard with an access to the desired sector's EP
//TODO what about Summon Boat spell?
std::vector<const IShipyard *> shipyards;
BOOST_FOREACH(const CGTownInstance *t, cb->getTownsInfo())
{
if(t->hasBuilt(EBuilding::SHIPYARD))
shipyards.push_back(t);
}
std::vector<const CGObjectInstance*> visObjs;
ai->retreiveVisitableObjs(visObjs, true);
BOOST_FOREACH(const CGObjectInstance *obj, visObjs)
{
if(obj->ID != GameConstants::TOWNI_TYPE) //towns were handled in the previous loop
if(const IShipyard *shipyard = IShipyard::castFrom(obj))
shipyards.push_back(shipyard);
}
shipyards.erase(boost::remove_if(shipyards, [=](const IShipyard *shipyard) -> bool
{
return shipyard->state() != 0 || retreiveTile(shipyard->bestLocation()) != sectorToReach->id;
}),shipyards.end());
if(!shipyards.size())
{
//TODO consider possibility of building shipyard in a town
throw cannotFulfillGoalException("There is no known shipyard!");
}
//we have only shipyards that possibly can build ships onto the appropriate EP
auto ownedGoodShipyard = boost::find_if(shipyards, [](const IShipyard *s) -> bool
{
return s->o->tempOwner == ai->playerID;
});
if(ownedGoodShipyard != shipyards.end())
{
const IShipyard *s = *ownedGoodShipyard;
TResources shipCost;
s->getBoatCost(shipCost);
if(cb->getResourceAmount().canAfford(shipCost))
{
int3 ret = s->bestLocation();
cb->buildBoat(s);
return ret;
}
else
{
//TODO gather res
throw cannotFulfillGoalException("Not enough resources to build a boat");
}
}
else
{
//TODO pick best shipyard to take over
return shipyards.front()->o->pos;
}
}
}
else if(src->water && !sectorToReach->water)
{
//TODO
//disembark
}
else
{
//TODO
//transition between two land/water sectors. Monolith? Whirlpool? ...
throw cannotFulfillGoalException("Land-land and water-water inter-sector transitions are not implemented!");
}
}
else
{
throw cannotFulfillGoalException("Inter-sector route detection failed: not connected sectors?");
}
}
else
{
makeParentBFS(h->visitablePos());
int3 curtile = dst;
while(curtile != h->visitablePos())
{
if(cb->getPathInfo(curtile)->reachable())
{
return curtile;
}
else
{
auto i = parent.find(curtile);
if(i != parent.end())
{
assert(curtile != i->second);
curtile = i->second;
}
else
throw cannotFulfillGoalException("Unreachable tile in sector? Should not happen!");
}
}
}
throw cannotFulfillGoalException("Impossible happened.");
}
void SectorMap::makeParentBFS(crint3 source)
{
parent.clear();
int mySector = retreiveTile(source);
std::queue<int3> toVisit;
toVisit.push(source);
while(toVisit.size())
{
int3 curPos = toVisit.front();
toVisit.pop();
ui8 &sec = retreiveTile(curPos);
assert(sec == mySector); //consider only tiles from the same sector
//const TerrainTile *t = cb->getTile(curPos);
foreach_neighbour(curPos, [&](crint3 neighPos)
{
if(retreiveTile(neighPos) == mySector && !vstd::contains(parent, neighPos))
{
toVisit.push(neighPos);
parent[neighPos] = curPos;
}
});
}
}
unsigned char & SectorMap::retreiveTile(crint3 pos)
{
return retreiveTileN(sector, pos);
}
const CGObjectInstance * ObjectIdRef::operator->() const
{
return cb->getObj(id, false);
}
ObjectIdRef::operator const CGObjectInstance*() const
{
return cb->getObj(id, false);
}
ObjectIdRef::ObjectIdRef(int _id) : id(_id)
{
}
ObjectIdRef::ObjectIdRef(const CGObjectInstance *obj) : id(obj->id)
{
}
bool ObjectIdRef::operator<(const ObjectIdRef &rhs) const
{
return id < rhs.id;
}
Reference in New Issue View Git Blame Copy Permalink