2018-08-12 13:31:31 +02:00
|
|
|
/*
|
2018-12-01 10:30:37 +02:00
|
|
|
* AINodeStorage.cpp, part of VCMI engine
|
2018-08-12 13:31:31 +02:00
|
|
|
*
|
|
|
|
* 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"
|
|
|
|
|
|
|
|
|
|
|
|
AINodeStorage::AINodeStorage(const int3 & Sizes)
|
|
|
|
: sizes(Sizes)
|
|
|
|
{
|
|
|
|
nodes.resize(boost::extents[sizes.x][sizes.y][sizes.z][EPathfindingLayer::NUM_LAYERS][NUM_CHAINS]);
|
|
|
|
}
|
|
|
|
|
|
|
|
AINodeStorage::~AINodeStorage()
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2018-10-07 13:51:27 +02:00
|
|
|
const AIPathNode * AINodeStorage::getAINode(const CGPathNode * node) const
|
2018-08-12 13:31:31 +02:00
|
|
|
{
|
2018-10-07 13:51:27 +02:00
|
|
|
return static_cast<const AIPathNode *>(node);
|
2018-08-12 13:31:31 +02:00
|
|
|
}
|
|
|
|
|
2018-10-07 13:51:27 +02:00
|
|
|
void AINodeStorage::updateAINode(CGPathNode * node, std::function<void(AIPathNode *)> updater)
|
2018-08-12 13:31:31 +02:00
|
|
|
{
|
2018-10-07 13:51:27 +02:00
|
|
|
auto aiNode = static_cast<AIPathNode *>(node);
|
|
|
|
|
|
|
|
updater(aiNode);
|
2018-08-12 13:31:31 +02:00
|
|
|
}
|
|
|
|
|
2018-10-07 13:51:27 +02:00
|
|
|
bool AINodeStorage::isBattleNode(const CGPathNode * node) const
|
2018-08-12 13:31:31 +02:00
|
|
|
{
|
2018-10-10 15:07:28 +02:00
|
|
|
return (getAINode(node)->chainMask & BATTLE_CHAIN) > 0;
|
2018-08-12 13:31:31 +02:00
|
|
|
}
|
|
|
|
|
2018-10-09 21:31:44 +02:00
|
|
|
boost::optional<AIPathNode *> AINodeStorage::getOrCreateNode(const int3 & pos, const EPathfindingLayer layer, int chainNumber)
|
2018-08-12 13:31:31 +02:00
|
|
|
{
|
2018-10-09 21:31:44 +02:00
|
|
|
auto chains = nodes[pos.x][pos.y][pos.z][layer];
|
|
|
|
|
|
|
|
for(AIPathNode & node : chains)
|
|
|
|
{
|
|
|
|
if(node.chainMask == chainNumber)
|
|
|
|
{
|
|
|
|
return &node;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(node.chainMask == 0)
|
|
|
|
{
|
|
|
|
node.chainMask = chainNumber;
|
|
|
|
|
|
|
|
return &node;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return boost::none;
|
2018-08-12 13:31:31 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
CGPathNode * AINodeStorage::getInitialNode()
|
|
|
|
{
|
|
|
|
auto hpos = hero->getPosition(false);
|
2019-01-07 23:40:09 +02:00
|
|
|
auto initialNode =
|
2018-10-09 21:31:44 +02:00
|
|
|
getOrCreateNode(hpos, hero->boat ? EPathfindingLayer::SAIL : EPathfindingLayer::LAND, NORMAL_CHAIN)
|
|
|
|
.get();
|
2018-08-12 13:31:31 +02:00
|
|
|
|
|
|
|
initialNode->turns = 0;
|
|
|
|
initialNode->moveRemains = hero->movement;
|
|
|
|
initialNode->danger = 0;
|
|
|
|
|
|
|
|
return initialNode;
|
|
|
|
}
|
|
|
|
|
|
|
|
void AINodeStorage::resetTile(const int3 & coord, EPathfindingLayer layer, CGPathNode::EAccessibility accessibility)
|
|
|
|
{
|
|
|
|
for(int i = 0; i < NUM_CHAINS; i++)
|
|
|
|
{
|
|
|
|
AIPathNode & heroNode = nodes[coord.x][coord.y][coord.z][layer][i];
|
|
|
|
|
2018-10-09 21:31:44 +02:00
|
|
|
heroNode.chainMask = 0;
|
|
|
|
heroNode.danger = 0;
|
2018-12-09 15:20:46 +02:00
|
|
|
heroNode.manaCost = 0;
|
2018-10-09 21:31:44 +02:00
|
|
|
heroNode.specialAction.reset();
|
2018-08-12 13:31:31 +02:00
|
|
|
heroNode.update(coord, layer, accessibility);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-10-07 13:51:27 +02:00
|
|
|
void AINodeStorage::commit(CDestinationNodeInfo & destination, const PathNodeInfo & source)
|
2018-08-12 13:31:31 +02:00
|
|
|
{
|
2018-10-07 13:51:27 +02:00
|
|
|
const AIPathNode * srcNode = getAINode(source.node);
|
|
|
|
|
|
|
|
updateAINode(destination.node, [&](AIPathNode * dstNode) {
|
|
|
|
dstNode->moveRemains = destination.movementLeft;
|
|
|
|
dstNode->turns = destination.turn;
|
|
|
|
dstNode->danger = srcNode->danger;
|
|
|
|
dstNode->action = destination.action;
|
2018-10-10 15:07:28 +02:00
|
|
|
dstNode->theNodeBefore = srcNode->theNodeBefore;
|
2018-12-09 15:20:46 +02:00
|
|
|
dstNode->manaCost = srcNode->manaCost;
|
2019-01-07 23:40:09 +02:00
|
|
|
|
2018-12-09 15:20:46 +02:00
|
|
|
if(dstNode->specialAction)
|
|
|
|
{
|
|
|
|
dstNode->specialAction->applyOnDestination(getHero(), destination, source, dstNode, srcNode);
|
|
|
|
}
|
2018-10-07 13:51:27 +02:00
|
|
|
});
|
2018-08-12 13:31:31 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
std::vector<CGPathNode *> AINodeStorage::calculateNeighbours(
|
2018-10-07 13:51:27 +02:00
|
|
|
const PathNodeInfo & source,
|
|
|
|
const PathfinderConfig * pathfinderConfig,
|
|
|
|
const CPathfinderHelper * pathfinderHelper)
|
2018-08-12 13:31:31 +02:00
|
|
|
{
|
|
|
|
std::vector<CGPathNode *> neighbours;
|
2018-12-16 16:46:48 +02:00
|
|
|
neighbours.reserve(16);
|
2018-10-07 13:51:27 +02:00
|
|
|
const AIPathNode * srcNode = getAINode(source.node);
|
2018-08-12 13:31:31 +02:00
|
|
|
auto accessibleNeighbourTiles = pathfinderHelper->getNeighbourTiles(source);
|
|
|
|
|
|
|
|
for(auto & neighbour : accessibleNeighbourTiles)
|
|
|
|
{
|
|
|
|
for(EPathfindingLayer i = EPathfindingLayer::LAND; i <= EPathfindingLayer::AIR; i.advance(1))
|
|
|
|
{
|
2018-10-09 21:31:44 +02:00
|
|
|
auto nextNode = getOrCreateNode(neighbour, i, srcNode->chainMask);
|
2018-08-12 13:31:31 +02:00
|
|
|
|
2018-10-09 21:31:44 +02:00
|
|
|
if(!nextNode || nextNode.get()->accessible == CGPathNode::NOT_SET)
|
2018-08-12 13:31:31 +02:00
|
|
|
continue;
|
|
|
|
|
2018-10-09 21:31:44 +02:00
|
|
|
neighbours.push_back(nextNode.get());
|
2018-08-12 13:31:31 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return neighbours;
|
|
|
|
}
|
|
|
|
|
|
|
|
std::vector<CGPathNode *> AINodeStorage::calculateTeleportations(
|
2018-10-07 13:51:27 +02:00
|
|
|
const PathNodeInfo & source,
|
|
|
|
const PathfinderConfig * pathfinderConfig,
|
|
|
|
const CPathfinderHelper * pathfinderHelper)
|
2018-08-12 13:31:31 +02:00
|
|
|
{
|
|
|
|
std::vector<CGPathNode *> neighbours;
|
|
|
|
auto accessibleExits = pathfinderHelper->getTeleportExits(source);
|
2018-10-07 13:51:27 +02:00
|
|
|
auto srcNode = getAINode(source.node);
|
2018-08-12 13:31:31 +02:00
|
|
|
|
|
|
|
for(auto & neighbour : accessibleExits)
|
|
|
|
{
|
2018-10-09 21:31:44 +02:00
|
|
|
auto node = getOrCreateNode(neighbour, source.node->layer, srcNode->chainMask);
|
2018-08-12 13:31:31 +02:00
|
|
|
|
2018-10-09 21:31:44 +02:00
|
|
|
if(!node)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
neighbours.push_back(node.get());
|
2018-08-12 13:31:31 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return neighbours;
|
|
|
|
}
|
|
|
|
|
2018-10-07 13:51:27 +02:00
|
|
|
bool AINodeStorage::hasBetterChain(const PathNodeInfo & source, CDestinationNodeInfo & destination) const
|
2018-08-12 13:31:31 +02:00
|
|
|
{
|
|
|
|
auto pos = destination.coord;
|
|
|
|
auto chains = nodes[pos.x][pos.y][pos.z][EPathfindingLayer::LAND];
|
2018-10-07 13:51:27 +02:00
|
|
|
auto destinationNode = getAINode(destination.node);
|
2018-08-12 13:31:31 +02:00
|
|
|
|
|
|
|
for(const AIPathNode & node : chains)
|
|
|
|
{
|
|
|
|
auto sameNode = node.chainMask == destinationNode->chainMask;
|
|
|
|
if(sameNode || node.action == CGPathNode::ENodeAction::UNKNOWN)
|
|
|
|
{
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(node.danger <= destinationNode->danger && destinationNode->chainMask == 1 && node.chainMask == 0)
|
|
|
|
{
|
|
|
|
if(node.turns < destinationNode->turns
|
2018-10-10 15:07:28 +02:00
|
|
|
|| (node.turns == destinationNode->turns && node.moveRemains >= destinationNode->moveRemains))
|
2018-08-12 13:31:31 +02:00
|
|
|
{
|
|
|
|
logAi->trace(
|
|
|
|
"Block ineficient move %s:->%s, mask=%i, mp diff: %i",
|
|
|
|
source.coord.toString(),
|
2018-10-10 15:07:28 +02:00
|
|
|
destination.coord.toString(),
|
2018-08-12 13:31:31 +02:00
|
|
|
destinationNode->chainMask,
|
|
|
|
node.moveRemains - destinationNode->moveRemains);
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2018-12-29 15:55:20 +02:00
|
|
|
bool AINodeStorage::isTileAccessible(int3 pos, const EPathfindingLayer layer) const
|
|
|
|
{
|
|
|
|
std::vector<AIPath> paths;
|
|
|
|
auto chains = nodes[pos.x][pos.y][pos.z][layer];
|
|
|
|
|
|
|
|
for(const AIPathNode & node : chains)
|
|
|
|
{
|
|
|
|
if(node.action != CGPathNode::ENodeAction::UNKNOWN)
|
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2018-10-28 15:03:40 +02:00
|
|
|
std::vector<AIPath> AINodeStorage::getChainInfo(int3 pos, bool isOnLand) const
|
2018-08-12 13:31:31 +02:00
|
|
|
{
|
|
|
|
std::vector<AIPath> paths;
|
2018-10-28 15:03:40 +02:00
|
|
|
auto chains = nodes[pos.x][pos.y][pos.z][isOnLand ? EPathfindingLayer::LAND : EPathfindingLayer::SAIL];
|
2018-12-09 15:20:46 +02:00
|
|
|
auto initialPos = hero->visitablePos();
|
2018-08-12 13:31:31 +02:00
|
|
|
|
|
|
|
for(const AIPathNode & node : chains)
|
|
|
|
{
|
|
|
|
if(node.action == CGPathNode::ENodeAction::UNKNOWN)
|
|
|
|
{
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
AIPath path;
|
|
|
|
const AIPathNode * current = &node;
|
|
|
|
|
2018-12-09 15:20:46 +02:00
|
|
|
while(current != nullptr && current->coord != initialPos)
|
2018-08-12 13:31:31 +02:00
|
|
|
{
|
|
|
|
AIPathNodeInfo pathNode;
|
|
|
|
|
|
|
|
pathNode.movementPointsLeft = current->moveRemains;
|
|
|
|
pathNode.movementPointsUsed = (int)(current->turns * hero->maxMovePoints(true) + hero->movement) - (int)current->moveRemains;
|
|
|
|
pathNode.turns = current->turns;
|
|
|
|
pathNode.danger = current->danger;
|
|
|
|
pathNode.coord = current->coord;
|
|
|
|
|
|
|
|
path.nodes.push_back(pathNode);
|
2018-10-09 21:31:44 +02:00
|
|
|
path.specialAction = current->specialAction;
|
|
|
|
|
2018-08-12 13:31:31 +02:00
|
|
|
current = getAINode(current->theNodeBefore);
|
|
|
|
}
|
2018-10-09 21:31:44 +02:00
|
|
|
|
2018-08-12 13:31:31 +02:00
|
|
|
paths.push_back(path);
|
|
|
|
}
|
|
|
|
|
|
|
|
return paths;
|
|
|
|
}
|
|
|
|
|
|
|
|
AIPath::AIPath()
|
|
|
|
: nodes({})
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
int3 AIPath::firstTileToGet() const
|
|
|
|
{
|
|
|
|
if(nodes.size())
|
|
|
|
{
|
|
|
|
return nodes.back().coord;
|
|
|
|
}
|
|
|
|
|
|
|
|
return int3(-1, -1, -1);
|
|
|
|
}
|
|
|
|
|
|
|
|
uint64_t AIPath::getPathDanger() const
|
|
|
|
{
|
|
|
|
if(nodes.size())
|
|
|
|
{
|
|
|
|
return nodes.front().danger;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
uint32_t AIPath::movementCost() const
|
|
|
|
{
|
|
|
|
if(nodes.size())
|
|
|
|
{
|
|
|
|
return nodes.front().movementPointsUsed;
|
|
|
|
}
|
|
|
|
|
|
|
|
// TODO: boost:optional?
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
uint64_t AIPath::getTotalDanger(HeroPtr hero) const
|
|
|
|
{
|
|
|
|
uint64_t pathDanger = getPathDanger();
|
|
|
|
uint64_t objDanger = evaluateDanger(nodes.front().coord, hero.get()); // bank danger is not checked by pathfinder
|
|
|
|
uint64_t danger = pathDanger > objDanger ? pathDanger : objDanger;
|
|
|
|
|
|
|
|
return danger;
|
2018-10-10 15:07:28 +02:00
|
|
|
}
|