/* * CPathfinder.h, part of VCMI engine * * Authors: listed in file AUTHORS in main folder * * License: GNU General Public License v2.0 or later * Full text of license available in license.txt file, in main folder * */ #pragma once #include "VCMI_Lib.h" #include "IGameCallback.h" #include "HeroBonus.h" #include "int3.h" #include class CGHeroInstance; class CGObjectInstance; struct TerrainTile; class CPathfinderHelper; class CMap; class CGWhirlpool; struct DLL_LINKAGE CGPathNode { typedef EPathfindingLayer ELayer; enum ENodeAction : ui8 { UNKNOWN = 0, EMBARK = 1, DISEMBARK, NORMAL, BATTLE, VISIT, BLOCKING_VISIT, TELEPORT_NORMAL, TELEPORT_BLOCKING_VISIT, TELEPORT_BATTLE }; enum EAccessibility : ui8 { NOT_SET = 0, ACCESSIBLE = 1, //tile can be entered and passed VISITABLE, //tile can be entered as the last tile in path BLOCKVIS, //visitable from neighbouring tile but not passable FLYABLE, //can only be accessed in air layer BLOCKED //tile can't be entered nor visited }; CGPathNode * theNodeBefore; int3 coord; //coordinates ui32 moveRemains; //remaining tiles after hero reaches the tile ui8 turns; //how many turns we have to wait before reachng the tile - 0 means current turn ELayer layer; EAccessibility accessible; ENodeAction action; bool locked; CGPathNode(); void reset(); void update(const int3 & Coord, const ELayer Layer, const EAccessibility Accessible); bool reachable() const; }; struct DLL_LINKAGE CGPath { std::vector nodes; //just get node by node int3 startPos() const; // start point int3 endPos() const; //destination point void convert(ui8 mode); //mode=0 -> from 'manifest' to 'object' }; struct DLL_LINKAGE CPathsInfo { typedef EPathfindingLayer ELayer; mutable boost::mutex pathMx; const CGHeroInstance * hero; int3 hpos; int3 sizes; boost::multi_array nodes; //[w][h][level][layer] CPathsInfo(const int3 & Sizes); ~CPathsInfo(); const CGPathNode * getPathInfo(const int3 & tile) const; bool getPath(CGPath & out, const int3 & dst) const; int getDistance(const int3 & tile) const; const CGPathNode * getNode(const int3 & coord) const; CGPathNode * getNode(const int3 & coord, const ELayer layer); }; class CPathfinder : private CGameInfoCallback { public: friend class CPathfinderHelper; CPathfinder(CPathsInfo & _out, CGameState * _gs, const CGHeroInstance * _hero); void calculatePaths(); //calculates possible paths for hero, uses current hero position and movement left; returns pointer to newly allocated CPath or nullptr if path does not exists private: typedef EPathfindingLayer ELayer; struct PathfinderOptions { bool useFlying; bool useWaterWalking; bool useEmbarkAndDisembark; bool useTeleportTwoWay; // Two-way monoliths and Subterranean Gate bool useTeleportOneWay; // One-way monoliths with one known exit only bool useTeleportOneWayRandom; // One-way monoliths with more than one known exit bool useTeleportWhirlpool; // Force enabled if hero protected or unaffected (have one stack of one creature) /// TODO: Find out with client and server code, merge with normal teleporters. /// Likely proper implementation would require some refactoring of CGTeleport. /// So for now this is unfinished and disabled by default. bool useCastleGate; /// If true transition into air layer only possible from initial node. /// This is drastically decrease path calculation complexity (and time). /// Downside is less MP effective paths calculation. /// /// TODO: If this option end up useful for slow devices it's can be improved: /// - Allow transition into air layer not only from initial position, but also from teleporters. /// Movement into air can be also allowed when hero disembarked. /// - Other idea is to allow transition into air within certain radius of N tiles around hero. /// Patrol support need similar functionality so it's won't be ton of useless code. /// Such limitation could be useful as it's can be scaled depend on device performance. bool lightweightFlyingMode; /// This option enable one turn limitation for flying and water walking. /// So if we're out of MP while cp is blocked or water tile we won't add dest tile to queue. /// /// Following imitation is default H3 mechanics, but someone may want to disable it in mods. /// After all this limit should benefit performance on maps with tons of water or blocked tiles. /// /// TODO: /// - Behavior when option is disabled not implemented and will lead to crashes. bool oneTurnSpecialLayersLimit; /// VCMI have different movement rules to solve flaws original engine has. /// If this option enabled you'll able to do following things in fly: /// - Move from blocked tiles to visitable one /// - Move from guarded tiles to blockvis tiles without being attacked /// - Move from guarded tiles to guarded visitable tiles with being attacked after /// TODO: /// - Option should also allow same tile land <-> air layer transitions. /// Current implementation only allow go into (from) air layer only to neighbour tiles. /// I find it's reasonable limitation, but it's will make some movements more expensive than in H3. bool originalMovementRules; PathfinderOptions(); } options; CPathsInfo & out; const CGHeroInstance * hero; const std::vector > > &FoW; std::unique_ptr hlp; enum EPatrolState { PATROL_NONE = 0, PATROL_LOCKED = 1, PATROL_RADIUS } patrolState; std::unordered_set patrolTiles; struct NodeComparer { bool operator()(const CGPathNode * lhs, const CGPathNode * rhs) const { if(rhs->turns > lhs->turns) return false; else if(rhs->turns == lhs->turns && rhs->moveRemains <= lhs->moveRemains) return false; return true; } }; boost::heap::priority_queue > pq; std::vector neighbourTiles; std::vector neighbours; CGPathNode * cp; //current (source) path node -> we took it from the queue CGPathNode * dp; //destination node -> it's a neighbour of cp that we consider const TerrainTile * ct, * dt; //tile info for both nodes const CGObjectInstance * ctObj, * dtObj; CGPathNode::ENodeAction destAction; void addNeighbours(); void addTeleportExits(); bool isHeroPatrolLocked() const; bool isPatrolMovementAllowed(const int3 & dst) const; bool isLayerTransitionPossible(const ELayer dstLayer) const; bool isLayerTransitionPossible() const; bool isMovementToDestPossible() const; bool isMovementAfterDestPossible() const; CGPathNode::ENodeAction getDestAction() const; CGPathNode::ENodeAction getTeleportDestAction() const; bool isSourceInitialPosition() const; bool isSourceVisitableObj() const; bool isSourceGuarded() const; bool isDestVisitableObj() const; bool isDestinationGuarded(const bool ignoreAccessibility = true) const; bool isDestinationGuardian() const; void initializePatrol(); void initializeGraph(); CGPathNode::EAccessibility evaluateAccessibility(const int3 & pos, const TerrainTile * tinfo, const ELayer layer) const; bool isVisitableObj(const CGObjectInstance * obj, const ELayer layer) const; bool canSeeObj(const CGObjectInstance * obj) const; bool canMoveBetween(const int3 & a, const int3 & b) const; //checks only for visitable objects that may make moving between tiles impossible, not other conditions (like tiles itself accessibility) bool isAllowedTeleportEntrance(const CGTeleport * obj) const; bool addTeleportTwoWay(const CGTeleport * obj) const; bool addTeleportOneWay(const CGTeleport * obj) const; bool addTeleportOneWayRandom(const CGTeleport * obj) const; bool addTeleportWhirlpool(const CGWhirlpool * obj) const; }; struct DLL_LINKAGE TurnInfo { /// This is certainly not the best design ever and certainly can be improved /// Unfortunately for pathfinder that do hundreds of thousands calls onus system add too big overhead struct BonusCache { std::vector noTerrainPenalty; bool freeShipBoarding; bool flyingMovement; int flyingMovementVal; bool waterWalking; int waterWalkingVal; BonusCache(TBonusListPtr bonusList); }; std::unique_ptr bonusCache; const CGHeroInstance * hero; TBonusListPtr bonuses; mutable int maxMovePointsLand; mutable int maxMovePointsWater; int nativeTerrain; TurnInfo(const CGHeroInstance * Hero, const int Turn = 0); bool isLayerAvailable(const EPathfindingLayer layer) const; bool hasBonusOfType(const Bonus::BonusType type, const int subtype = -1) const; int valOfBonuses(const Bonus::BonusType type, const int subtype = -1) const; int getMaxMovePoints(const EPathfindingLayer layer) const; }; class DLL_LINKAGE CPathfinderHelper { public: CPathfinderHelper(const CGHeroInstance * Hero, const CPathfinder::PathfinderOptions & Options); ~CPathfinderHelper(); void updateTurnInfo(const int turn = 0); bool isLayerAvailable(const EPathfindingLayer layer) const; const TurnInfo * getTurnInfo() const; bool hasBonusOfType(const Bonus::BonusType type, const int subtype = -1) const; int getMaxMovePoints(const EPathfindingLayer layer) const; static void getNeighbours(const CMap * map, const TerrainTile & srct, const int3 & tile, std::vector & vec, const boost::logic::tribool & onLand, const bool limitCoastSailing); static int getMovementCost(const CGHeroInstance * h, const int3 & src, const int3 & dst, const TerrainTile * ct, const TerrainTile * dt, const int remainingMovePoints =- 1, const TurnInfo * ti = nullptr, const bool checkLast = true); static int getMovementCost(const CGHeroInstance * h, const int3 & dst); private: int turn; const CGHeroInstance * hero; std::vector turnsInfo; const CPathfinder::PathfinderOptions & options; };