/* * AINodeStorage.cpp, part of VCMI engine * * Authors: listed in file AUTHORS in main folder * * License: GNU General Public License v2.0 or later * Full text of license available in license.txt file, in main folder * */ #include "StdInc.h" #include "AINodeStorage.h" #include "Actions/TownPortalAction.h" #include "../Goals/Goals.h" #include "../AIGateway.h" #include "../Engine/Nullkiller.h" #include "../../../CCallback.h" #include "../../../lib/mapping/CMap.h" #include "../../../lib/mapObjects/MapObjects.h" #include "../../../lib/pathfinder/CPathfinder.h" #include "../../../lib/pathfinder/PathfinderUtil.h" #include "../../../lib/pathfinder/PathfinderOptions.h" #include "../../../lib/CPlayerState.h" namespace NKAI { std::shared_ptr> AISharedStorage::shared; uint64_t AISharedStorage::version = 0; boost::mutex AISharedStorage::locker; std::set commitedTiles; std::set commitedTilesInitial; const uint64_t FirstActorMask = 1; const uint64_t MIN_ARMY_STRENGTH_FOR_CHAIN = 5000; const uint64_t MIN_ARMY_STRENGTH_FOR_NEXT_ACTOR = 1000; const uint64_t CHAIN_MAX_DEPTH = 4; const bool DO_NOT_SAVE_TO_COMMITED_TILES = false; AISharedStorage::AISharedStorage(int3 sizes) { if(!shared){ shared.reset(new boost::multi_array( boost::extents[sizes.z][sizes.x][sizes.y][AIPathfinding::NUM_CHAINS])); nodes = shared; foreach_tile_pos([&](const int3 & pos) { for(auto i = 0; i < AIPathfinding::NUM_CHAINS; i++) { auto & node = get(pos)[i]; node.version = -1; node.coord = pos; } }); } else nodes = shared; } AISharedStorage::~AISharedStorage() { nodes.reset(); if(shared && shared.use_count() == 1) { shared.reset(); } } void AIPathNode::addSpecialAction(std::shared_ptr action) { if(!specialAction) { specialAction = action; } else { auto parts = specialAction->getParts(); if(parts.empty()) { parts.push_back(specialAction); } parts.push_back(action); specialAction = std::make_shared(parts); } } AINodeStorage::AINodeStorage(const Nullkiller * ai, const int3 & Sizes) : sizes(Sizes), ai(ai), cb(ai->cb.get()), nodes(Sizes) { accesibility = std::make_unique>( boost::extents[sizes.z][sizes.x][sizes.y][EPathfindingLayer::NUM_LAYERS]); dangerEvaluator.reset(new FuzzyHelper(ai)); } AINodeStorage::~AINodeStorage() = default; void AINodeStorage::initialize(const PathfinderOptions & options, const CGameState * gs) { if(heroChainPass != EHeroChainPass::INITIAL) return; AISharedStorage::version++; //TODO: fix this code duplication with NodeStorage::initialize, problem is to keep `resetTile` inline const PlayerColor fowPlayer = ai->playerID; const auto & fow = static_cast(gs)->getPlayerTeam(fowPlayer)->fogOfWarMap; const int3 sizes = gs->getMapSize(); //Each thread gets different x, but an array of y located next to each other in memory tbb::parallel_for(tbb::blocked_range(0, sizes.x), [&](const tbb::blocked_range& r) { int3 pos; for(pos.z = 0; pos.z < sizes.z; ++pos.z) { const bool useFlying = options.useFlying; const bool useWaterWalking = options.useWaterWalking; const PlayerColor player = playerID; for(pos.x = r.begin(); pos.x != r.end(); ++pos.x) { for(pos.y = 0; pos.y < sizes.y; ++pos.y) { const TerrainTile & tile = gs->map->getTile(pos); if (!tile.terType->isPassable()) continue; if (tile.terType->isWater()) { resetTile(pos, ELayer::SAIL, PathfinderUtil::evaluateAccessibility(pos, tile, fow, player, gs)); if (useFlying) resetTile(pos, ELayer::AIR, PathfinderUtil::evaluateAccessibility(pos, tile, fow, player, gs)); if (useWaterWalking) resetTile(pos, ELayer::WATER, PathfinderUtil::evaluateAccessibility(pos, tile, fow, player, gs)); } else { resetTile(pos, ELayer::LAND, PathfinderUtil::evaluateAccessibility(pos, tile, fow, player, gs)); if (useFlying) resetTile(pos, ELayer::AIR, PathfinderUtil::evaluateAccessibility(pos, tile, fow, player, gs)); } } } } }); } void AINodeStorage::clear() { actors.clear(); commitedTiles.clear(); heroChainPass = EHeroChainPass::INITIAL; heroChainTurn = 0; heroChainMaxTurns = 1; turnDistanceLimit[HeroRole::MAIN] = 255; turnDistanceLimit[HeroRole::SCOUT] = 255; } std::optional AINodeStorage::getOrCreateNode( const int3 & pos, const EPathfindingLayer layer, const ChainActor * actor) { int bucketIndex = ((uintptr_t)actor + static_cast(layer)) % AIPathfinding::BUCKET_COUNT; int bucketOffset = bucketIndex * AIPathfinding::BUCKET_SIZE; auto chains = nodes.get(pos); if(blocked(pos, layer)) { return std::nullopt; } for(auto i = AIPathfinding::BUCKET_SIZE - 1; i >= 0; i--) { AIPathNode & node = chains[i + bucketOffset]; if(node.version != AISharedStorage::version) { node.reset(layer, getAccessibility(pos, layer)); node.version = AISharedStorage::version; node.actor = actor; return &node; } if(node.actor == actor && node.layer == layer) { return &node; } } return std::nullopt; } std::vector AINodeStorage::getInitialNodes() { if(heroChainPass) { if(heroChainTurn == 0) calculateTownPortalTeleportations(heroChain); return heroChain; } std::vector initialNodes; for(auto actorPtr : actors) { ChainActor * actor = actorPtr.get(); auto allocated = getOrCreateNode(actor->initialPosition, actor->layer, actor); if(!allocated) continue; AIPathNode * initialNode = allocated.value(); initialNode->inPQ = false; initialNode->pq = nullptr; initialNode->turns = actor->initialTurn; initialNode->moveRemains = actor->initialMovement; initialNode->danger = 0; initialNode->setCost(actor->initialTurn); initialNode->action = EPathNodeAction::NORMAL; if(actor->isMovable) { initialNodes.push_back(initialNode); } else { initialNode->locked = true; } } if(heroChainTurn == 0) calculateTownPortalTeleportations(initialNodes); return initialNodes; } void AINodeStorage::commit(CDestinationNodeInfo & destination, const PathNodeInfo & source) { const AIPathNode * srcNode = getAINode(source.node); updateAINode(destination.node, [&](AIPathNode * dstNode) { commit(dstNode, srcNode, destination.action, destination.turn, destination.movementLeft, destination.cost); if(srcNode->specialAction || srcNode->chainOther) { // there is some action on source tile which should be performed before we can bypass it destination.node->theNodeBefore = source.node; } if(dstNode->specialAction && dstNode->actor) { dstNode->specialAction->applyOnDestination(dstNode->actor->hero, destination, source, dstNode, srcNode); } }); } void AINodeStorage::commit( AIPathNode * destination, const AIPathNode * source, EPathNodeAction action, int turn, int movementLeft, float cost, bool saveToCommited) const { destination->action = action; destination->setCost(cost); destination->moveRemains = movementLeft; destination->turns = turn; destination->armyLoss = source->armyLoss; destination->manaCost = source->manaCost; destination->danger = source->danger; destination->theNodeBefore = source->theNodeBefore; destination->chainOther = nullptr; #if NKAI_PATHFINDER_TRACE_LEVEL >= 2 logAi->trace( "Commited %s -> %s, layer: %d, cost: %f, turn: %s, mp: %d, hero: %s, mask: %x, army: %lld", source->coord.toString(), destination->coord.toString(), destination->layer, destination->getCost(), std::to_string(destination->turns), destination->moveRemains, destination->actor->toString(), destination->actor->chainMask, destination->actor->armyValue); #endif if(saveToCommited && destination->turns <= heroChainTurn) { commitedTiles.insert(destination->coord); } if(destination->turns == source->turns) { destination->dayFlags = source->dayFlags; } } void AINodeStorage::calculateNeighbours( std::vector & result, const PathNodeInfo & source, EPathfindingLayer layer, const PathfinderConfig * pathfinderConfig, const CPathfinderHelper * pathfinderHelper) { std::vector accessibleNeighbourTiles; result.clear(); accessibleNeighbourTiles.reserve(8); pathfinderHelper->calculateNeighbourTiles(accessibleNeighbourTiles, source); const AIPathNode * srcNode = getAINode(source.node); for(auto & neighbour : accessibleNeighbourTiles) { if(getAccessibility(neighbour, layer) == EPathAccessibility::NOT_SET) { #if NKAI_PATHFINDER_TRACE_LEVEL >= 2 logAi->trace( "Node %s rejected for %s, layer %d because of inaccessibility", neighbour.toString(), source.coord.toString(), static_cast(layer)); #endif continue; } auto nextNode = getOrCreateNode(neighbour, layer, srcNode->actor); if(!nextNode) { #if NKAI_PATHFINDER_TRACE_LEVEL >= 2 logAi->trace( "Failed to allocate node at %s[%d]", neighbour.toString(), static_cast(layer)); #endif continue; } #if NKAI_PATHFINDER_TRACE_LEVEL >= 2 logAi->trace( "Node %s added to neighbors of %s, layer %d", neighbour.toString(), source.coord.toString(), static_cast(layer)); #endif result.push_back(nextNode.value()); } } constexpr std::array phisycalLayers = {EPathfindingLayer::LAND, EPathfindingLayer::SAIL}; bool AINodeStorage::increaseHeroChainTurnLimit() { if(heroChainTurn >= heroChainMaxTurns) return false; heroChainTurn++; commitedTiles.clear(); for(auto layer : phisycalLayers) { foreach_tile_pos([&](const int3 & pos) { iterateValidNodesUntil(pos, layer, [&](AIPathNode & node) { if(node.turns <= heroChainTurn && node.action != EPathNodeAction::UNKNOWN) { commitedTiles.insert(pos); return true; } return false; }); }); } return true; } bool AINodeStorage::calculateHeroChainFinal() { heroChainPass = EHeroChainPass::FINAL; heroChain.resize(0); for(auto layer : phisycalLayers) { foreach_tile_pos([&](const int3 & pos) { iterateValidNodes(pos, layer, [&](AIPathNode & node) { if(node.turns > heroChainTurn && !node.locked && node.action != EPathNodeAction::UNKNOWN && node.actor->actorExchangeCount > 1 && !hasBetterChain(&node, node)) { heroChain.push_back(&node); } }); }); } return heroChain.size(); } struct DelayedWork { AIPathNode * carrier; AIPathNode * other; DelayedWork() { } DelayedWork(AIPathNode * carrier, AIPathNode * other) : carrier(carrier), other(other) { } }; class HeroChainCalculationTask { private: AINodeStorage & storage; std::vector existingChains; std::vector newChains; uint64_t chainMask; int heroChainTurn; std::vector heroChain; const std::vector & tiles; std::vector delayedWork; public: HeroChainCalculationTask( AINodeStorage & storage, const std::vector & tiles, uint64_t chainMask, int heroChainTurn) :existingChains(), newChains(), delayedWork(), storage(storage), chainMask(chainMask), heroChainTurn(heroChainTurn), heroChain(), tiles(tiles) { existingChains.reserve(AIPathfinding::NUM_CHAINS); newChains.reserve(AIPathfinding::NUM_CHAINS); } void execute(const tbb::blocked_range& r) { std::random_device randomDevice; std::mt19937 randomEngine(randomDevice()); for(int i = r.begin(); i != r.end(); i++) { auto & pos = tiles[i]; for(auto layer : phisycalLayers) { existingChains.clear(); storage.iterateValidNodes(pos, layer, [this](AIPathNode & node) { if(node.turns <= heroChainTurn && node.action != EPathNodeAction::UNKNOWN) existingChains.push_back(&node); }); if(existingChains.empty()) continue; newChains.clear(); std::shuffle(existingChains.begin(), existingChains.end(), randomEngine); for(AIPathNode * node : existingChains) { if(node->actor->isMovable) { calculateHeroChain(node, existingChains, newChains); } } for(auto delayed = delayedWork.begin(); delayed != delayedWork.end();) { auto newActor = delayed->carrier->actor->tryExchangeNoLock(delayed->other->actor); if(!newActor.lockAcquired) continue; if(newActor.actor) { newChains.push_back(calculateExchange(newActor.actor, delayed->carrier, delayed->other)); } delayed++; } delayedWork.clear(); cleanupInefectiveChains(newChains); addHeroChain(newChains); } } } void calculateHeroChain( AIPathNode * srcNode, const std::vector & variants, std::vector & result); void calculateHeroChain( AIPathNode * carrier, AIPathNode * other, std::vector & result); void cleanupInefectiveChains(std::vector & result) const; void addHeroChain(const std::vector & result); ExchangeCandidate calculateExchange( ChainActor * exchangeActor, AIPathNode * carrierParentNode, AIPathNode * otherParentNode) const; void flushResult(std::vector & result) { vstd::concatenate(result, heroChain); } }; bool AINodeStorage::calculateHeroChain() { std::random_device randomDevice; std::mt19937 randomEngine(randomDevice()); heroChainPass = EHeroChainPass::CHAIN; heroChain.clear(); std::vector data(commitedTiles.begin(), commitedTiles.end()); if(data.size() > 100) { boost::mutex resultMutex; std::shuffle(data.begin(), data.end(), randomEngine); tbb::parallel_for(tbb::blocked_range(0, data.size()), [&](const tbb::blocked_range& r) { //auto r = blocked_range(0, data.size()); HeroChainCalculationTask task(*this, data, chainMask, heroChainTurn); task.execute(r); { boost::lock_guard resultLock(resultMutex); task.flushResult(heroChain); } }); } else { auto r = tbb::blocked_range(0, data.size()); HeroChainCalculationTask task(*this, data, chainMask, heroChainTurn); task.execute(r); task.flushResult(heroChain); } commitedTiles.clear(); return !heroChain.empty(); } bool AINodeStorage::selectFirstActor() { if(actors.empty()) return false; auto strongest = *vstd::maxElementByFun(actors, [](std::shared_ptr actor) -> uint64_t { return actor->armyValue; }); chainMask = strongest->chainMask; commitedTilesInitial = commitedTiles; return true; } bool AINodeStorage::selectNextActor() { auto currentActor = std::find_if(actors.begin(), actors.end(), [&](std::shared_ptr actor)-> bool { return actor->chainMask == chainMask; }); auto nextActor = actors.end(); for(auto actor = actors.begin(); actor != actors.end(); actor++) { if(actor->get()->armyValue > currentActor->get()->armyValue || (actor->get()->armyValue == currentActor->get()->armyValue && actor <= currentActor)) { continue; } if(nextActor == actors.end() || actor->get()->armyValue > nextActor->get()->armyValue) { nextActor = actor; } } if(nextActor != actors.end()) { if(nextActor->get()->armyValue < MIN_ARMY_STRENGTH_FOR_NEXT_ACTOR) return false; chainMask = nextActor->get()->chainMask; commitedTiles = commitedTilesInitial; return true; } return false; } uint64_t AINodeStorage::evaluateArmyLoss(const CGHeroInstance * hero, uint64_t armyValue, uint64_t danger) const { float fightingStrength = ai->heroManager->getFightingStrengthCached(hero); double ratio = (double)danger / (armyValue * fightingStrength); return (uint64_t)(armyValue * ratio * ratio); } void HeroChainCalculationTask::cleanupInefectiveChains(std::vector & result) const { vstd::erase_if(result, [&](const ExchangeCandidate & chainInfo) -> bool { auto isNotEffective = storage.hasBetterChain(chainInfo.carrierParent, chainInfo) || storage.hasBetterChain(chainInfo.carrierParent, chainInfo, result); #if NKAI_PATHFINDER_TRACE_LEVEL >= 2 if(isNotEffective) { logAi->trace( "Skip exchange %s[%x] -> %s[%x] at %s is ineficient", chainInfo.otherParent->actor->toString(), chainInfo.otherParent->actor->chainMask, chainInfo.carrierParent->actor->toString(), chainInfo.carrierParent->actor->chainMask, chainInfo.carrierParent->coord.toString()); } #endif return isNotEffective; }); } void HeroChainCalculationTask::calculateHeroChain( AIPathNode * srcNode, const std::vector & variants, std::vector & result) { for(AIPathNode * node : variants) { if(node == srcNode || !node->actor || node->version != AISharedStorage::version) continue; if((node->actor->chainMask & chainMask) == 0 && (srcNode->actor->chainMask & chainMask) == 0) continue; if(node->actor->actorExchangeCount + srcNode->actor->actorExchangeCount > CHAIN_MAX_DEPTH) continue; if(node->action == EPathNodeAction::BATTLE || node->action == EPathNodeAction::TELEPORT_BATTLE || node->action == EPathNodeAction::TELEPORT_NORMAL || node->action == EPathNodeAction::TELEPORT_BLOCKING_VISIT) { continue; } if(node->turns > heroChainTurn || (node->action == EPathNodeAction::UNKNOWN && node->actor->hero) || (node->actor->chainMask & srcNode->actor->chainMask) != 0) { #if NKAI_PATHFINDER_TRACE_LEVEL >= 2 logAi->trace( "Skip exchange %s[%x] -> %s[%x] at %s because of %s", node->actor->toString(), node->actor->chainMask, srcNode->actor->toString(), srcNode->actor->chainMask, srcNode->coord.toString(), (node->turns > heroChainTurn ? "turn limit" : (node->action == EPathNodeAction::UNKNOWN && node->actor->hero) ? "action unknown" : "chain mask")); #endif continue; } #if NKAI_PATHFINDER_TRACE_LEVEL >= 2 logAi->trace( "Thy exchange %s[%x] -> %s[%x] at %s", node->actor->toString(), node->actor->chainMask, srcNode->actor->toString(), srcNode->actor->chainMask, srcNode->coord.toString()); #endif calculateHeroChain(srcNode, node, result); } } void HeroChainCalculationTask::calculateHeroChain( AIPathNode * carrier, AIPathNode * other, std::vector & result) { if(carrier->armyLoss < carrier->actor->armyValue && (carrier->action != EPathNodeAction::BATTLE || (carrier->actor->allowBattle && carrier->specialAction)) && carrier->action != EPathNodeAction::BLOCKING_VISIT && (other->armyLoss == 0 || other->armyLoss < other->actor->armyValue)) { #if NKAI_PATHFINDER_TRACE_LEVEL >= 2 logAi->trace( "Exchange allowed %s[%x] -> %s[%x] at %s", other->actor->toString(), other->actor->chainMask, carrier->actor->toString(), carrier->actor->chainMask, carrier->coord.toString()); #endif if(other->actor->isMovable) { bool hasLessMp = carrier->turns > other->turns || (carrier->turns == other->turns && carrier->moveRemains < other->moveRemains); bool hasLessExperience = carrier->actor->hero->exp < other->actor->hero->exp; if(hasLessMp && hasLessExperience) { #if NKAI_PATHFINDER_TRACE_LEVEL >= 2 logAi->trace("Exchange at %s is ineficient. Blocked.", carrier->coord.toString()); #endif return; } } auto newActor = carrier->actor->tryExchangeNoLock(other->actor); if(!newActor.lockAcquired) delayedWork.push_back(DelayedWork(carrier, other)); if(newActor.actor) result.push_back(calculateExchange(newActor.actor, carrier, other)); } } void HeroChainCalculationTask::addHeroChain(const std::vector & result) { for(const ExchangeCandidate & chainInfo : result) { auto carrier = chainInfo.carrierParent; auto newActor = chainInfo.actor; auto other = chainInfo.otherParent; auto chainNodeOptional = storage.getOrCreateNode(carrier->coord, carrier->layer, newActor); if(!chainNodeOptional) { #if NKAI_PATHFINDER_TRACE_LEVEL >= 2 logAi->trace("Exchange at %s can not allocate node. Blocked.", carrier->coord.toString()); #endif continue; } auto exchangeNode = chainNodeOptional.value(); if(exchangeNode->action != EPathNodeAction::UNKNOWN) { #if NKAI_PATHFINDER_TRACE_LEVEL >= 2 logAi->trace( "Skip exchange %s[%x] -> %s[%x] at %s because node is in use", other->actor->toString(), other->actor->chainMask, carrier->actor->toString(), carrier->actor->chainMask, carrier->coord.toString()); #endif continue; } if(exchangeNode->turns != 0xFF && exchangeNode->getCost() < chainInfo.getCost()) { #if NKAI_PATHFINDER_TRACE_LEVEL >= 2 logAi->trace( "Skip exchange %s[%x] -> %s[%x] at %s because not effective enough. %f < %f", other->actor->toString(), other->actor->chainMask, carrier->actor->toString(), carrier->actor->chainMask, carrier->coord.toString(), exchangeNode->getCost(), chainInfo.getCost()); #endif continue; } storage.commit( exchangeNode, carrier, carrier->action, chainInfo.turns, chainInfo.moveRemains, chainInfo.getCost(), DO_NOT_SAVE_TO_COMMITED_TILES); if(carrier->specialAction || carrier->chainOther) { // there is some action on source tile which should be performed before we can bypass it exchangeNode->theNodeBefore = carrier; } if(exchangeNode->actor->actorAction) { exchangeNode->theNodeBefore = carrier; exchangeNode->addSpecialAction(exchangeNode->actor->actorAction); } exchangeNode->chainOther = other; exchangeNode->armyLoss = chainInfo.armyLoss; #if NKAI_PATHFINDER_TRACE_LEVEL >= 2 logAi->trace( "Chain accepted at %s %s -> %s, mask %x, cost %f, turn: %s, mp: %d, army %i", exchangeNode->coord.toString(), other->actor->toString(), exchangeNode->actor->toString(), exchangeNode->actor->chainMask, exchangeNode->getCost(), std::to_string(exchangeNode->turns), exchangeNode->moveRemains, exchangeNode->actor->armyValue); #endif heroChain.push_back(exchangeNode); } } ExchangeCandidate HeroChainCalculationTask::calculateExchange( ChainActor * exchangeActor, AIPathNode * carrierParentNode, AIPathNode * otherParentNode) const { ExchangeCandidate candidate; candidate.layer = carrierParentNode->layer; candidate.coord = carrierParentNode->coord; candidate.carrierParent = carrierParentNode; candidate.otherParent = otherParentNode; candidate.actor = exchangeActor; candidate.armyLoss = carrierParentNode->armyLoss + otherParentNode->armyLoss; candidate.turns = carrierParentNode->turns; candidate.setCost(carrierParentNode->getCost() + otherParentNode->getCost() / 1000.0); candidate.moveRemains = carrierParentNode->moveRemains; candidate.danger = carrierParentNode->danger; if(carrierParentNode->turns < otherParentNode->turns) { int moveRemains = exchangeActor->maxMovePoints(carrierParentNode->layer); float waitingCost = otherParentNode->turns - carrierParentNode->turns - 1 + carrierParentNode->moveRemains / (float)moveRemains; candidate.turns = otherParentNode->turns; candidate.setCost(candidate.getCost() + waitingCost); candidate.moveRemains = moveRemains; } return candidate; } const std::set AINodeStorage::getAllHeroes() const { std::set heroes; for(auto actor : actors) { if(actor->hero) heroes.insert(actor->hero); } return heroes; } bool AINodeStorage::isDistanceLimitReached(const PathNodeInfo & source, CDestinationNodeInfo & destination) const { if(heroChainPass == EHeroChainPass::CHAIN && destination.node->turns > heroChainTurn) { return true; } auto aiNode = getAINode(destination.node); if(heroChainPass != EHeroChainPass::CHAIN && destination.node->turns > turnDistanceLimit[aiNode->actor->heroRole]) { return true; } return false; } void AINodeStorage::setHeroes(std::map heroes) { playerID = ai->playerID; for(auto & hero : heroes) { // do not allow our own heroes in garrison to act on map if(hero.first->getOwner() == ai->playerID && hero.first->inTownGarrison && (ai->isHeroLocked(hero.first) || ai->heroManager->heroCapReached())) { continue; } uint64_t mask = FirstActorMask << actors.size(); auto actor = std::make_shared(hero.first, hero.second, mask, ai); if(actor->hero->tempOwner != ai->playerID) { bool onLand = !actor->hero->boat || actor->hero->boat->layer != EPathfindingLayer::SAIL; actor->initialMovement = actor->hero->movementPointsLimit(onLand); } playerID = actor->hero->tempOwner; actors.push_back(actor); } } void AINodeStorage::setTownsAndDwellings( const std::vector & towns, const std::set & visitableObjs) { for(auto town : towns) { uint64_t mask = FirstActorMask << actors.size(); // TODO: investigate logix of second condition || ai->nullkiller->getHeroLockedReason(town->garrisonHero) != HeroLockedReason::DEFENCE // check defence imrove if(!town->garrisonHero) { actors.push_back(std::make_shared(town, mask)); } } /*auto dayOfWeek = cb->getDate(Date::DAY_OF_WEEK); auto waitForGrowth = dayOfWeek > 4;*/ for(auto obj: visitableObjs) { if(obj->ID == Obj::HILL_FORT) { uint64_t mask = FirstActorMask << actors.size(); actors.push_back(std::make_shared(obj, mask)); } /*const CGDwelling * dwelling = dynamic_cast(obj); if(dwelling) { uint64_t mask = 1 << actors.size(); auto dwellingActor = std::make_shared(dwelling, mask, false, dayOfWeek); if(dwellingActor->creatureSet->getArmyStrength()) { actors.push_back(dwellingActor); } if(waitForGrowth) { mask = 1 << actors.size(); dwellingActor = std::make_shared(dwelling, mask, waitForGrowth, dayOfWeek); if(dwellingActor->creatureSet->getArmyStrength()) { actors.push_back(dwellingActor); } } }*/ } } std::vector AINodeStorage::calculateTeleportations( const PathNodeInfo & source, const PathfinderConfig * pathfinderConfig, const CPathfinderHelper * pathfinderHelper) { std::vector neighbours; if(source.isNodeObjectVisitable()) { auto accessibleExits = pathfinderHelper->getTeleportExits(source); auto srcNode = getAINode(source.node); for(auto & neighbour : accessibleExits) { auto node = getOrCreateNode(neighbour, source.node->layer, srcNode->actor); if(!node) continue; neighbours.push_back(node.value()); } } return neighbours; } struct TowmPortalFinder { const std::vector & initialNodes; MasteryLevel::Type townPortalSkillLevel; uint64_t movementNeeded; const ChainActor * actor; const CGHeroInstance * hero; std::vector targetTowns; AINodeStorage * nodeStorage; SpellID spellID; const CSpell * townPortal; TowmPortalFinder( const ChainActor * actor, const std::vector & initialNodes, std::vector targetTowns, AINodeStorage * nodeStorage) :actor(actor), initialNodes(initialNodes), hero(actor->hero), targetTowns(targetTowns), nodeStorage(nodeStorage) { spellID = SpellID::TOWN_PORTAL; townPortal = spellID.toSpell(); // TODO: Copy/Paste from TownPortalMechanics townPortalSkillLevel = MasteryLevel::Type(hero->getSpellSchoolLevel(townPortal)); movementNeeded = GameConstants::BASE_MOVEMENT_COST * (townPortalSkillLevel >= MasteryLevel::EXPERT ? 2 : 3); } bool actorCanCastTownPortal() { return hero->canCastThisSpell(townPortal) && hero->mana >= hero->getSpellCost(townPortal); } CGPathNode * getBestInitialNodeForTownPortal(const CGTownInstance * targetTown) { for(CGPathNode * node : initialNodes) { auto aiNode = nodeStorage->getAINode(node); if(aiNode->actor->baseActor != actor || node->layer != EPathfindingLayer::LAND || node->moveRemains < movementNeeded) { continue; } if(townPortalSkillLevel < MasteryLevel::ADVANCED) { const CGTownInstance * nearestTown = *vstd::minElementByFun(targetTowns, [&](const CGTownInstance * t) -> int { return node->coord.dist2dSQ(t->visitablePos()); }); if(targetTown != nearestTown) continue; } return node; } return nullptr; } std::optional createTownPortalNode(const CGTownInstance * targetTown) { auto bestNode = getBestInitialNodeForTownPortal(targetTown); if(!bestNode) return std::nullopt; auto nodeOptional = nodeStorage->getOrCreateNode(targetTown->visitablePos(), EPathfindingLayer::LAND, actor->castActor); if(!nodeOptional) return std::nullopt; AIPathNode * node = nodeOptional.value(); float movementCost = (float)movementNeeded / (float)hero->movementPointsLimit(EPathfindingLayer::LAND); movementCost += bestNode->getCost(); if(node->action == EPathNodeAction::UNKNOWN || node->getCost() > movementCost) { nodeStorage->commit( node, nodeStorage->getAINode(bestNode), EPathNodeAction::TELEPORT_NORMAL, bestNode->turns, bestNode->moveRemains - movementNeeded, movementCost, DO_NOT_SAVE_TO_COMMITED_TILES); node->theNodeBefore = bestNode; node->addSpecialAction(std::make_shared(targetTown)); } return nodeOptional; } }; template void AINodeStorage::calculateTownPortal( const ChainActor * actor, const std::map & maskMap, const std::vector & initialNodes, TVector & output) { auto towns = cb->getTownsInfo(false); vstd::erase_if(towns, [&](const CGTownInstance * t) -> bool { return cb->getPlayerRelations(actor->hero->tempOwner, t->tempOwner) == PlayerRelations::ENEMIES; }); if(!towns.size()) { return; // no towns no need to run loop further } TowmPortalFinder townPortalFinder(actor, initialNodes, towns, this); if(townPortalFinder.actorCanCastTownPortal()) { for(const CGTownInstance * targetTown : towns) { if(targetTown->visitingHero && targetTown->getUpperArmy()->stacksCount() && maskMap.find(targetTown->visitingHero.get()) != maskMap.end()) { auto basicMask = maskMap.at(targetTown->visitingHero.get()); bool sameActorInTown = actor->chainMask == basicMask; if(!sameActorInTown) continue; } auto nodeOptional = townPortalFinder.createTownPortalNode(targetTown); if(nodeOptional) { #if NKAI_PATHFINDER_TRACE_LEVEL >= 1 logAi->trace("Adding town portal node at %s", targetTown->getObjectName()); #endif output.push_back(nodeOptional.value()); } } } } void AINodeStorage::calculateTownPortalTeleportations(std::vector & initialNodes) { std::set actorsOfInitial; for(const CGPathNode * node : initialNodes) { auto aiNode = getAINode(node); if(aiNode->actor->hero) actorsOfInitial.insert(aiNode->actor->baseActor); } std::map maskMap; for(std::shared_ptr basicActor : actors) { if(basicActor->hero) maskMap[basicActor->hero] = basicActor->chainMask; } boost::sort(initialNodes, NodeComparer()); std::vector actorsVector(actorsOfInitial.begin(), actorsOfInitial.end()); tbb::concurrent_vector output; if(false) //if (actorsVector.size() * initialNodes.size() > 1000) { tbb::parallel_for(tbb::blocked_range(0, actorsVector.size()), [&](const tbb::blocked_range & r) { for(int i = r.begin(); i != r.end(); i++) { calculateTownPortal(actorsVector[i], maskMap, initialNodes, output); } }); std::copy(output.begin(), output.end(), std::back_inserter(initialNodes)); } else { for(auto actor : actorsVector) { calculateTownPortal(actor, maskMap, initialNodes, initialNodes); } } } bool AINodeStorage::hasBetterChain(const PathNodeInfo & source, CDestinationNodeInfo & destination) const { auto candidateNode = getAINode(destination.node); return hasBetterChain(source.node, *candidateNode); } bool AINodeStorage::hasBetterChain( const CGPathNode * source, const AIPathNode & candidateNode) const { return iterateValidNodesUntil( candidateNode.coord, candidateNode.layer, [this, &source, candidateNode](const AIPathNode & node) -> bool { return isOtherChainBetter(source, candidateNode, node); }); } template bool AINodeStorage::hasBetterChain( const CGPathNode * source, const AIPathNode & candidateNode, const NodeRange & nodes) const { for(const AIPathNode & node : nodes) { if(isOtherChainBetter(source, candidateNode, node)) return true; } return false; } bool AINodeStorage::isOtherChainBetter( const CGPathNode * source, const AIPathNode & candidateNode, const AIPathNode & other) const { auto sameNode = other.actor == candidateNode.actor; if(sameNode || other.action == EPathNodeAction::UNKNOWN || !other.actor || !other.actor->hero) { return false; } if(other.danger <= candidateNode.danger && candidateNode.actor == other.actor->battleActor) { if(other.getCost() < candidateNode.getCost()) { #if NKAI_PATHFINDER_TRACE_LEVEL >= 2 logAi->trace( "Block ineficient battle move %s->%s, hero: %s[%X], army %lld, mp diff: %i", source->coord.toString(), candidateNode.coord.toString(), candidateNode.actor->hero->getNameTranslated(), candidateNode.actor->chainMask, candidateNode.actor->armyValue, other.moveRemains - candidateNode.moveRemains); #endif return true; } } if(candidateNode.actor->chainMask != other.actor->chainMask && heroChainPass != EHeroChainPass::FINAL) return false; auto nodeActor = other.actor; auto nodeArmyValue = nodeActor->armyValue - other.armyLoss; auto candidateArmyValue = candidateNode.actor->armyValue - candidateNode.armyLoss; if(nodeArmyValue > candidateArmyValue && other.getCost() <= candidateNode.getCost()) { #if NKAI_PATHFINDER_TRACE_LEVEL >= 2 logAi->trace( "Block ineficient move because of stronger army %s->%s, hero: %s[%X], army %lld, mp diff: %i", source->coord.toString(), candidateNode.coord.toString(), candidateNode.actor->hero->getNameTranslated(), candidateNode.actor->chainMask, candidateNode.actor->armyValue, other.moveRemains - candidateNode.moveRemains); #endif return true; } if(heroChainPass == EHeroChainPass::FINAL) { if(nodeArmyValue == candidateArmyValue && nodeActor->heroFightingStrength >= candidateNode.actor->heroFightingStrength && other.getCost() <= candidateNode.getCost()) { if(vstd::isAlmostEqual(nodeActor->heroFightingStrength, candidateNode.actor->heroFightingStrength) && vstd::isAlmostEqual(other.getCost(), candidateNode.getCost()) && &other < &candidateNode) { return false; } #if NKAI_PATHFINDER_TRACE_LEVEL >= 2 logAi->trace( "Block ineficient move because of stronger hero %s->%s, hero: %s[%X], army %lld, mp diff: %i", source->coord.toString(), candidateNode.coord.toString(), candidateNode.actor->hero->getNameTranslated(), candidateNode.actor->chainMask, candidateNode.actor->armyValue, other.moveRemains - candidateNode.moveRemains); #endif return true; } } return false; } bool AINodeStorage::isTileAccessible(const HeroPtr & hero, const int3 & pos, const EPathfindingLayer layer) const { auto chains = nodes.get(pos); for(const AIPathNode & node : chains) { if(node.version == AISharedStorage::version && node.layer == layer && node.action != EPathNodeAction::UNKNOWN && node.actor && node.actor->hero == hero.h) { return true; } } return false; } void AINodeStorage::calculateChainInfo(std::vector & paths, const int3 & pos, bool isOnLand) const { auto layer = isOnLand ? EPathfindingLayer::LAND : EPathfindingLayer::SAIL; auto chains = nodes.get(pos); for(const AIPathNode & node : chains) { if(node.version != AISharedStorage::version || node.layer != layer || node.action == EPathNodeAction::UNKNOWN || !node.actor || !node.actor->hero) { continue; } AIPath & path = paths.emplace_back(); path.targetHero = node.actor->hero; path.heroArmy = node.actor->creatureSet; path.armyLoss = node.armyLoss; path.targetObjectDanger = evaluateDanger(pos, path.targetHero, !node.actor->allowBattle); path.targetObjectArmyLoss = evaluateArmyLoss( path.targetHero, getHeroArmyStrengthWithCommander(path.targetHero, path.heroArmy), path.targetObjectDanger); path.chainMask = node.actor->chainMask; path.exchangeCount = node.actor->actorExchangeCount; fillChainInfo(&node, path, -1); } } void AINodeStorage::fillChainInfo(const AIPathNode * node, AIPath & path, int parentIndex) const { while(node != nullptr) { if(!node->actor->hero) return; if(node->chainOther) fillChainInfo(node->chainOther, path, parentIndex); AIPathNodeInfo pathNode; pathNode.cost = node->getCost(); pathNode.targetHero = node->actor->hero; pathNode.chainMask = node->actor->chainMask; pathNode.specialAction = node->specialAction; pathNode.turns = node->turns; pathNode.danger = node->danger; pathNode.coord = node->coord; pathNode.parentIndex = parentIndex; pathNode.actionIsBlocked = false; pathNode.layer = node->layer; if(pathNode.specialAction) { auto targetNode =node->theNodeBefore ? getAINode(node->theNodeBefore) : node; pathNode.actionIsBlocked = !pathNode.specialAction->canAct(ai, targetNode); } parentIndex = path.nodes.size(); path.nodes.push_back(pathNode); node = getAINode(node->theNodeBefore); } } AIPath::AIPath() : nodes({}) { } std::shared_ptr AIPath::getFirstBlockedAction() const { for(auto node = nodes.rbegin(); node != nodes.rend(); node++) { if(node->specialAction && node->actionIsBlocked) return node->specialAction; } return std::shared_ptr(); } int3 AIPath::firstTileToGet() const { if(nodes.size()) { return nodes.back().coord; } return int3(-1, -1, -1); } int3 AIPath::targetTile() const { if(nodes.size()) { return targetNode().coord; } return int3(-1, -1, -1); } const AIPathNodeInfo & AIPath::firstNode() const { return nodes.back(); } const AIPathNodeInfo & AIPath::targetNode() const { auto & node = nodes.front(); return targetHero == node.targetHero ? node : nodes.at(1); } uint64_t AIPath::getPathDanger() const { if(nodes.empty()) return 0; return targetNode().danger; } float AIPath::movementCost() const { if(nodes.empty()) return 0.0f; return targetNode().cost; } uint8_t AIPath::turn() const { if(nodes.empty()) return 0; return targetNode().turns; } uint64_t AIPath::getHeroStrength() const { return targetHero->getFightingStrength() * getHeroArmyStrengthWithCommander(targetHero, heroArmy); } uint64_t AIPath::getTotalDanger() const { uint64_t pathDanger = getPathDanger(); uint64_t danger = pathDanger > targetObjectDanger ? pathDanger : targetObjectDanger; return danger; } bool AIPath::containsHero(const CGHeroInstance * hero) const { if(targetHero == hero) return true; for(auto node : nodes) { if(node.targetHero == hero) return true; } return false; } uint64_t AIPath::getTotalArmyLoss() const { return armyLoss + targetObjectArmyLoss; } std::string AIPath::toString() const { std::stringstream str; str << targetHero->getNameTranslated() << "[" << std::hex << chainMask << std::dec << "]" << ", turn " << (int)(turn()) << ": "; for(auto node : nodes) str << node.targetHero->getNameTranslated() << "[" << std::hex << node.chainMask << std::dec << "]" << "->" << node.coord.toString() << "; "; return str.str(); } }