From 21ac20aeca92c76ba3521eda4dec316eee098974 Mon Sep 17 00:00:00 2001 From: rubidium Date: Mon, 4 Sep 2006 20:40:33 +0000 Subject: (svn r6381) -Cleanup: make the '/* */' comments that span multiple lines more uniform. -Cleanup: whitespace alignment of a few tables. --- yapf/array.hpp | 2 +- yapf/autocopyptr.hpp | 20 +++++------ yapf/binaryheap.hpp | 44 ++++++++++++------------ yapf/blob.hpp | 20 +++++------ yapf/countedptr.hpp | 18 +++++----- yapf/fixedsizearray.hpp | 8 ++--- yapf/follow_track.hpp | 6 ++-- yapf/hashtable.hpp | 42 +++++++++++----------- yapf/nodelist.hpp | 4 +-- yapf/unittest/test_yapf.h | 10 +++--- yapf/unittest/unittest.cpp | 34 +++++++++--------- yapf/yapf.h | 86 +++++++++++++++++++++++----------------------- yapf/yapf_base.hpp | 78 ++++++++++++++++++++--------------------- yapf/yapf_common.hpp | 8 ++--- yapf/yapf_costcache.hpp | 50 +++++++++++++-------------- yapf/yapf_costrail.hpp | 4 +-- yapf/yapf_destrail.hpp | 4 +-- yapf/yapf_rail.cpp | 8 ++--- yapf/yapf_road.cpp | 12 +++---- yapf/yapf_settings.h | 18 +++++----- yapf/yapf_ship.cpp | 12 +++---- 21 files changed, 244 insertions(+), 244 deletions(-) (limited to 'yapf') diff --git a/yapf/array.hpp b/yapf/array.hpp index cfee3c3e6..0d330aeed 100644 --- a/yapf/array.hpp +++ b/yapf/array.hpp @@ -6,7 +6,7 @@ #include "fixedsizearray.hpp" /** Flexible array with size limit. Implemented as fixed size - array of fixed size arrays */ + * array of fixed size arrays */ template class CArrayT { public: diff --git a/yapf/autocopyptr.hpp b/yapf/autocopyptr.hpp index 46c727789..42822c324 100644 --- a/yapf/autocopyptr.hpp +++ b/yapf/autocopyptr.hpp @@ -4,16 +4,16 @@ #define AUTOCOPYPTR_HPP /** CAutoCopyPtrT - kind of CoW (Copy on Write) pointer. - It is non-invasive smart pointer (reference counter is held outside - of Tdata). - When copied, its new copy shares the same underlaying structure Tdata. - When dereferenced, its behavior depends on 2 factors: - - whether the data is shared (used by more than one pointer) - - type of access (read/write) - When shared pointer is dereferenced for write, new clone of Tdata - is made first. - Can't be used for polymorphic data types (interfaces). -*/ + * It is non-invasive smart pointer (reference counter is held outside + * of Tdata). + * When copied, its new copy shares the same underlaying structure Tdata. + * When dereferenced, its behavior depends on 2 factors: + * - whether the data is shared (used by more than one pointer) + * - type of access (read/write) + * When shared pointer is dereferenced for write, new clone of Tdata + * is made first. + * Can't be used for polymorphic data types (interfaces). + */ template class CAutoCopyPtrT { protected: diff --git a/yapf/binaryheap.hpp b/yapf/binaryheap.hpp index 9537dff63..7b72a25af 100644 --- a/yapf/binaryheap.hpp +++ b/yapf/binaryheap.hpp @@ -10,22 +10,22 @@ /** -* Binary Heap as C++ template. -* -* For information about Binary Heap algotithm, -* see: http://www.policyalmanac.org/games/binaryHeaps.htm -* -* Implementation specific notes: -* -* 1) It allocates space for item pointers (array). Items are allocated elsewhere. -* -* 2) ItemPtr [0] is never used. Total array size is max_items + 1, because we -* use indices 1..max_items instead of zero based C indexing. -* -* 3) Item of the binary heap should support these public members: -* - 'lower-then' operator '<' - used for comparing items before moving -* -*/ + * Binary Heap as C++ template. + * + * For information about Binary Heap algotithm, + * see: http://www.policyalmanac.org/games/binaryHeaps.htm + * + * Implementation specific notes: + * + * 1) It allocates space for item pointers (array). Items are allocated elsewhere. + * + * 2) ItemPtr [0] is never used. Total array size is max_items + 1, because we + * use indices 1..max_items instead of zero based C indexing. + * + * 3) Item of the binary heap should support these public members: + * - 'lower-then' operator '<' - used for comparing items before moving + * + */ template class CBinaryHeapT { @@ -53,23 +53,23 @@ public: public: /** Return the number of items stored in the priority queue. - * @return number of items in the queue */ + * @return number of items in the queue */ FORCEINLINE int Size() const {return m_size;}; /** Test if the priority queue is empty. - * @return true if empty */ + * @return true if empty */ FORCEINLINE bool IsEmpty() const {return (m_size == 0);}; /** Test if the priority queue is full. - * @return true if full. */ + * @return true if full. */ FORCEINLINE bool IsFull() const {return (m_size >= m_max_size);}; /** Find the smallest item in the priority queue. - * Return the smallest item, or throw assert if empty. */ + * Return the smallest item, or throw assert if empty. */ FORCEINLINE Titem_& GetHead() {assert(!IsEmpty()); return *m_items[1];} /** Insert new item into the priority queue, maintaining heap order. - * @return false if the queue is full. */ + * @return false if the queue is full. */ bool Push(Titem_& new_item); /** Remove and return the smallest item from the priority queue. */ @@ -85,7 +85,7 @@ public: int FindLinear(const Titem_& item) const; /** Make the priority queue empty. - * All remaining items will remain untouched. */ + * All remaining items will remain untouched. */ void Clear() {m_size = 0;}; /** verifies the heap consistency (added during first YAPF debug phase) */ diff --git a/yapf/blob.hpp b/yapf/blob.hpp index 6cc460e41..8c2da84a4 100644 --- a/yapf/blob.hpp +++ b/yapf/blob.hpp @@ -11,14 +11,14 @@ FORCEINLINE void MemCpyT(Titem_* d, const Titem_* s, int num_items = 1) /** Base class for simple binary blobs. - Item is byte. - The word 'simple' means: - - no configurable allocator type (always made from heap) - - no smart deallocation - deallocation must be called from the same - module (DLL) where the blob was allocated - - no configurable allocation policy (how big blocks should be allocated) - - no extra ownership policy (i.e. 'copy on write') when blob is copied - - no thread synchronization at all */ + * Item is byte. + * The word 'simple' means: + * - no configurable allocator type (always made from heap) + * - no smart deallocation - deallocation must be called from the same + * module (DLL) where the blob was allocated + * - no configurable allocation policy (how big blocks should be allocated) + * - no extra ownership policy (i.e. 'copy on write') when blob is copied + * - no thread synchronization at all */ class CBlobBaseSimple { protected: struct CHdr { @@ -78,7 +78,7 @@ public: } /** Reallocate if there is no free space for num_bytes bytes. - @return pointer to the new data to be added */ + * @return pointer to the new data to be added */ FORCEINLINE int8* MakeRawFreeSpace(int num_bytes) { assert(num_bytes >= 0); @@ -89,7 +89,7 @@ public: } /** Increase RawSize() by num_bytes. - @return pointer to the new data added */ + * @return pointer to the new data added */ FORCEINLINE int8* GrowRawSize(int num_bytes) { int8* pNewData = MakeRawFreeSpace(num_bytes); diff --git a/yapf/countedptr.hpp b/yapf/countedptr.hpp index 1ac986cf5..c1bb48e06 100644 --- a/yapf/countedptr.hpp +++ b/yapf/countedptr.hpp @@ -6,15 +6,15 @@ /** @file CCountedPtr - smart pointer implementation */ /** CCountedPtr - simple reference counting smart pointer. -* -* One of the standard ways how to maintain object's lifetime. -* -* See http://ootips.org/yonat/4dev/smart-pointers.html for more -* general info about smart pointers. -* -* This class implements ref-counted pointer for objects/interfaces that -* support AddRef() and Release() methods. -*/ + * + * One of the standard ways how to maintain object's lifetime. + * + * See http://ootips.org/yonat/4dev/smart-pointers.html for more + * general info about smart pointers. + * + * This class implements ref-counted pointer for objects/interfaces that + * support AddRef() and Release() methods. + */ template class CCountedPtr { /** redefine the template argument to make it visible for derived classes */ diff --git a/yapf/fixedsizearray.hpp b/yapf/fixedsizearray.hpp index 9d67c6877..06ff0703f 100644 --- a/yapf/fixedsizearray.hpp +++ b/yapf/fixedsizearray.hpp @@ -5,13 +5,13 @@ /** fixed size array - Upon construction it preallocates fixed size block of memory - for all items, but doesn't construct them. Item's construction - is delayed. */ + * Upon construction it preallocates fixed size block of memory + * for all items, but doesn't construct them. Item's construction + * is delayed. */ template struct CFixedSizeArrayT { /** the only member of fixed size array is pointer to the block - of C array of items. Header can be found on the offset -sizeof(CHdr). */ + * of C array of items. Header can be found on the offset -sizeof(CHdr). */ Titem_ *m_items; /** header for fixed size array */ diff --git a/yapf/follow_track.hpp b/yapf/follow_track.hpp index 5bb3ad8ac..218de53b4 100644 --- a/yapf/follow_track.hpp +++ b/yapf/follow_track.hpp @@ -6,8 +6,8 @@ #include "yapf.hpp" /** Track follower helper template class (can serve pathfinders and vehicle - controllers). See 6 different typedefs below for 3 different transport - types w/ of w/o 90-deg turns allowed */ + * controllers). See 6 different typedefs below for 3 different transport + * types w/ of w/o 90-deg turns allowed */ template struct CFollowTrackT : public FollowTrack_t { @@ -38,7 +38,7 @@ struct CFollowTrackT : public FollowTrack_t FORCEINLINE static bool Allow90degTurns() {return T90deg_turns_allowed_;} /** main follower routine. Fills all members and return true on success. - Otherwise returns false if track can't be followed. */ + * Otherwise returns false if track can't be followed. */ FORCEINLINE bool Follow(TileIndex old_tile, Trackdir old_td) { m_old_tile = old_tile; diff --git a/yapf/hashtable.hpp b/yapf/hashtable.hpp index bab5bccfc..3933eb8f1 100644 --- a/yapf/hashtable.hpp +++ b/yapf/hashtable.hpp @@ -95,26 +95,26 @@ struct CHashTableSlotT }; /** @class CHashTableT - simple hash table - of pointers allocated elsewhere. - - Supports: Add/Find/Remove of Titems. - - Your Titem must meet some extra requirements to be CHashTableT - compliant: - - its constructor/destructor (if any) must be public - - if the copying of item requires an extra resource management, - you must define also copy constructor - - must support nested type (struct, class or typedef) Titem::Key - that defines the type of key class for that item - - must support public method: - const Key& GetKey() const; // return the item's key object - - In addition, the Titem::Key class must support: - - public method that calculates key's hash: - int CalcHash() const; - - public 'equality' operator to compare the key with another one - bool operator == (const Key& other) const; -*/ + * of pointers allocated elsewhere. + * + * Supports: Add/Find/Remove of Titems. + * + * Your Titem must meet some extra requirements to be CHashTableT + * compliant: + * - its constructor/destructor (if any) must be public + * - if the copying of item requires an extra resource management, + * you must define also copy constructor + * - must support nested type (struct, class or typedef) Titem::Key + * that defines the type of key class for that item + * - must support public method: + * const Key& GetKey() const; // return the item's key object + * + * In addition, the Titem::Key class must support: + * - public method that calculates key's hash: + * int CalcHash() const; + * - public 'equality' operator to compare the key with another one + * bool operator == (const Key& other) const; + */ template class CHashTableT { public: @@ -125,7 +125,7 @@ public: protected: /** each slot contains pointer to the first item in the list, - Titem contains pointer to the next item - GetHashNext(), SetHashNext() */ + * Titem contains pointer to the next item - GetHashNext(), SetHashNext() */ typedef CHashTableSlotT Slot; Slot* m_slots; // here we store our data (array of blobs) diff --git a/yapf/nodelist.hpp b/yapf/nodelist.hpp index 204282e93..5dc8170af 100644 --- a/yapf/nodelist.hpp +++ b/yapf/nodelist.hpp @@ -8,8 +8,8 @@ #include "binaryheap.hpp" /** Hash table based node list multi-container class. - Implements open list, closed list and priority queue for A-star - path finder. */ + * Implements open list, closed list and priority queue for A-star + * path finder. */ template class CNodeList_HashTableT { public: diff --git a/yapf/unittest/test_yapf.h b/yapf/unittest/test_yapf.h index 4e2f2c0e5..952040faa 100644 --- a/yapf/unittest/test_yapf.h +++ b/yapf/unittest/test_yapf.h @@ -160,8 +160,8 @@ struct CYapfTestBaseT FORCEINLINE char TransportTypeChar() const {return 'T';} /** Called by YAPF to move from the given node to the next tile. For each - * reachable trackdir on the new tile creates new node, initializes it - * and adds it to the open list by calling Yapf().AddNewNode(n) */ + * reachable trackdir on the new tile creates new node, initializes it + * and adds it to the open list by calling Yapf().AddNewNode(n) */ FORCEINLINE void PfFollowNode(Node& org) { int x_org = org.m_key.m_x; @@ -207,8 +207,8 @@ struct CYapfTestBaseT } /** Called by YAPF to calculate the cost from the origin to the given node. - * Calculates only the cost of given node, adds it to the parent node cost - * and stores the result into Node::m_cost member */ + * Calculates only the cost of given node, adds it to the parent node cost + * and stores the result into Node::m_cost member */ FORCEINLINE bool PfCalcCost(Node& n) { // base tile cost depending on distance @@ -225,7 +225,7 @@ struct CYapfTestBaseT } /** Called by YAPF to calculate cost estimate. Calculates distance to the destination - * adds it to the actual cost from origin and stores the sum to the Node::m_estimate */ + * adds it to the actual cost from origin and stores the sum to the Node::m_estimate */ FORCEINLINE bool PfCalcEstimate(Node& n) { int dx = abs(n.m_key.m_x - m_x2); diff --git a/yapf/unittest/unittest.cpp b/yapf/unittest/unittest.cpp index 099862bee..33d3f3065 100644 --- a/yapf/unittest/unittest.cpp +++ b/yapf/unittest/unittest.cpp @@ -109,23 +109,23 @@ const TileIndexDiffC _tileoffs_by_dir[] = { extern "C" const byte _ffb_64[128] = { - 0,0,1,0,2,0,1,0, - 3,0,1,0,2,0,1,0, - 4,0,1,0,2,0,1,0, - 3,0,1,0,2,0,1,0, - 5,0,1,0,2,0,1,0, - 3,0,1,0,2,0,1,0, - 4,0,1,0,2,0,1,0, - 3,0,1,0,2,0,1,0, - - 0,0,0,2,0,4,4,6, - 0,8,8,10,8,12,12,14, - 0,16,16,18,16,20,20,22, - 16,24,24,26,24,28,28,30, - 0,32,32,34,32,36,36,38, - 32,40,40,42,40,44,44,46, - 32,48,48,50,48,52,52,54, - 48,56,56,58,56,60,60,62, + 0, 0, 1, 0, 2, 0, 1, 0, + 3, 0, 1, 0, 2, 0, 1, 0, + 4, 0, 1, 0, 2, 0, 1, 0, + 3, 0, 1, 0, 2, 0, 1, 0, + 5, 0, 1, 0, 2, 0, 1, 0, + 3, 0, 1, 0, 2, 0, 1, 0, + 4, 0, 1, 0, 2, 0, 1, 0, + 3, 0, 1, 0, 2, 0, 1, 0, + + 0, 0, 0, 2, 0, 4, 4, 6, + 0, 8, 8, 10, 8, 12, 12, 14, + 0, 16, 16, 18, 16, 20, 20, 22, + 16, 24, 24, 26, 24, 28, 28, 30, + 0, 32, 32, 34, 32, 36, 36, 38, + 32, 40, 40, 42, 40, 44, 44, 46, + 32, 48, 48, 50, 48, 52, 52, 54, + 48, 56, 56, 58, 56, 60, 60, 62, }; /* Maps a trackdir to the (4-way) direction the tile is exited when following diff --git a/yapf/yapf.h b/yapf/yapf.h index 20a2e89ee..55b9f73ca 100644 --- a/yapf/yapf.h +++ b/yapf/yapf.h @@ -6,54 +6,54 @@ #include "../debug.h" /** Finds the best path for given ship. - @param v - the ship that needs to find a path - @param tile - the tile to find the path from (should be next tile the ship is about to enter) - @param enterdir - diagonal direction which the ship will enter this new tile from - @param tracks - available tracks on the new tile (to choose from) - @return - the best trackdir for next turn or INVALID_TRACKDIR if the path could not be found + * @param v the ship that needs to find a path + * @param tile the tile to find the path from (should be next tile the ship is about to enter) + * @param enterdir diagonal direction which the ship will enter this new tile from + * @param tracks available tracks on the new tile (to choose from) + * @return the best trackdir for next turn or INVALID_TRACKDIR if the path could not be found */ Trackdir YapfChooseShipTrack(Vehicle *v, TileIndex tile, DiagDirection enterdir, TrackBits tracks); /** Finds the best path for given road vehicle. - @param v - the RV that needs to find a path - @param tile - the tile to find the path from (should be next tile the RV is about to enter) - @param enterdir - diagonal direction which the RV will enter this new tile from - @param tracks - available tracks on the new tile (to choose from) - @return - the best trackdir for next turn or INVALID_TRACKDIR if the path could not be found -*/ + * @param v the RV that needs to find a path + * @param tile the tile to find the path from (should be next tile the RV is about to enter) + * @param enterdir diagonal direction which the RV will enter this new tile from + * @param tracks available tracks on the new tile (to choose from) + * @return the best trackdir for next turn or INVALID_TRACKDIR if the path could not be found + */ Trackdir YapfChooseRoadTrack(Vehicle *v, TileIndex tile, DiagDirection enterdir); /** Finds the best path for given train. - @param v - the train that needs to find a path - @param tile - the tile to find the path from (should be next tile the train is about to enter) - @param enterdir - diagonal direction which the RV will enter this new tile from - @param tracks - available tracks on the new tile (to choose from) - @return - the best trackdir for next turn or INVALID_TRACKDIR if the path could not be found -*/ + * @param v the train that needs to find a path + * @param tile the tile to find the path from (should be next tile the train is about to enter) + * @param enterdir diagonal direction which the RV will enter this new tile from + * @param tracks available tracks on the new tile (to choose from) + * @return the best trackdir for next turn or INVALID_TRACKDIR if the path could not be found + */ Trackdir YapfChooseRailTrack(Vehicle *v, TileIndex tile, DiagDirection enterdir, TrackdirBits trackdirs); /** Used by RV multistop feature to find the nearest road stop that has a free slot. - @param v - RV (its current tile will be the origin) - @param tile - destination tile - @return - distance from origin tile to the destination (number of road tiles) or UINT_MAX if path not found -*/ + * @param v RV (its current tile will be the origin) + * @param tile destination tile + * @return distance from origin tile to the destination (number of road tiles) or UINT_MAX if path not found + */ uint YapfRoadVehDistanceToTile(const Vehicle* v, TileIndex tile); /** Used when user sends RV to the nearest depot or if RV needs servicing. - Returns the nearest depot (or NULL if depot was not found). -*/ + * Returns the nearest depot (or NULL if depot was not found). + */ Depot* YapfFindNearestRoadDepot(const Vehicle *v); /** Used when user sends train to the nearest depot or if train needs servicing. - @v - train that needs to go to some depot - @max_distance - max distance (number of track tiles) from the current train position - (used also as optimization - the pathfinder can stop path finding if max_distance - was reached and no depot was seen) - @reverse_penalty - penalty that should be added for the path that requires reversing the train first - @depot_tile - receives the depot tile if depot was found - @reversed - receives true if train needs to reversed first - @return - the true if depot was found. -*/ + * @v train that needs to go to some depot + * @max_distance max distance (number of track tiles) from the current train position + * (used also as optimization - the pathfinder can stop path finding if max_distance + * was reached and no depot was seen) + * @reverse_penalty penalty that should be added for the path that requires reversing the train first + * @depot_tile receives the depot tile if depot was found + * @reversed receives true if train needs to reversed first + * @return the true if depot was found. + */ bool YapfFindNearestRailDepotTwoWay(Vehicle *v, int max_distance, int reverse_penalty, TileIndex* depot_tile, bool* reversed); /** Returns true if it is better to reverse the train before leaving station */ @@ -72,17 +72,17 @@ extern int _aystar_stats_closed_size; /** Track followers. They should help whenever any new code will need to walk through -tracks, road or water tiles (pathfinders, signal controllers, vehicle controllers). -It is an attempt to introduce API that should simplify tasks listed above. -If you will need to use it: - 1. allocate/declare FollowTrack_t structure; - 2. call FollowTrackInit() and provide vehicle (if relevant) - 3. call one of 6 FollowTrackXxxx() APIs below - 4. check return value (if true then continue else stop) - 5. look at FollowTrack_t structure for the result - 6. optionally repeat steps 3..5 - 7. in case of troubles contact KUDr -*/ + * tracks, road or water tiles (pathfinders, signal controllers, vehicle controllers). + * It is an attempt to introduce API that should simplify tasks listed above. + * If you will need to use it: + * 1. allocate/declare FollowTrack_t structure; + * 2. call FollowTrackInit() and provide vehicle (if relevant) + * 3. call one of 6 FollowTrackXxxx() APIs below + * 4. check return value (if true then continue else stop) + * 5. look at FollowTrack_t structure for the result + * 6. optionally repeat steps 3..5 + * 7. in case of troubles contact KUDr + */ /** Base struct for track followers. */ typedef struct FollowTrack_t diff --git a/yapf/yapf_base.hpp b/yapf/yapf_base.hpp index 96893b39d..98ca6ba9c 100644 --- a/yapf/yapf_base.hpp +++ b/yapf/yapf_base.hpp @@ -14,34 +14,34 @@ EXTERN_C_END extern int _total_pf_time_us; /** CYapfBaseT - A-star type path finder base class. - Derive your own pathfinder from it. You must provide the following template argument: - Types - used as collection of local types used in pathfinder - - Requirements for the Types struct: - ---------------------------------- - The following types must be defined in the 'Types' argument: - - Types::Tpf - your pathfinder derived from CYapfBaseT - - Types::NodeList - open/closed node list (look at CNodeList_HashTableT) - NodeList needs to have defined local type Titem - defines the pathfinder node type. - Node needs to define local type Key - the node key in the collection () - - For node list you can use template class CNodeList_HashTableT, for which - you need to declare only your node type. Look at test_yapf.h for an example. - - - Requrements to your pathfinder class derived from CYapfBaseT: - ------------------------------------------------------------- - Your pathfinder derived class needs to implement following methods: - FORCEINLINE void PfSetStartupNodes() - FORCEINLINE void PfFollowNode(Node& org) - FORCEINLINE bool PfCalcCost(Node& n) - FORCEINLINE bool PfCalcEstimate(Node& n) - FORCEINLINE bool PfDetectDestination(Node& n) - - For more details about those methods, look at the end of CYapfBaseT - declaration. There are some examples. For another example look at - test_yapf.h (part or unittest project). -*/ + * Derive your own pathfinder from it. You must provide the following template argument: + * Types - used as collection of local types used in pathfinder + * + * Requirements for the Types struct: + * ---------------------------------- + * The following types must be defined in the 'Types' argument: + * - Types::Tpf - your pathfinder derived from CYapfBaseT + * - Types::NodeList - open/closed node list (look at CNodeList_HashTableT) + * NodeList needs to have defined local type Titem - defines the pathfinder node type. + * Node needs to define local type Key - the node key in the collection () + * + * For node list you can use template class CNodeList_HashTableT, for which + * you need to declare only your node type. Look at test_yapf.h for an example. + * + * + * Requrements to your pathfinder class derived from CYapfBaseT: + * ------------------------------------------------------------- + * Your pathfinder derived class needs to implement following methods: + * FORCEINLINE void PfSetStartupNodes() + * FORCEINLINE void PfFollowNode(Node& org) + * FORCEINLINE bool PfCalcCost(Node& n) + * FORCEINLINE bool PfCalcEstimate(Node& n) + * FORCEINLINE bool PfDetectDestination(Node& n) + * + * For more details about those methods, look at the end of CYapfBaseT + * declaration. There are some examples. For another example look at + * test_yapf.h (part or unittest project). + */ template class CYapfBaseT { public: @@ -105,12 +105,12 @@ public: } /** Main pathfinder routine: - - set startup node(s) - - main loop that stops if: - - the destination was found - - or the open list is empty (no route to destination). - - or the maximum amount of loops reached - m_max_search_nodes (default = 10000) - @return true if the path was found */ + * - set startup node(s) + * - main loop that stops if: + * - the destination was found + * - or the open list is empty (no route to destination). + * - or the maximum amount of loops reached - m_max_search_nodes (default = 10000) + * @return true if the path was found */ inline bool FindPath(const Vehicle* v) { m_veh = v; @@ -160,16 +160,16 @@ public: } /** If path was found return the best node that has reached the destination. Otherwise - return the best visited node (which was nearest to the destination). - */ + * return the best visited node (which was nearest to the destination). + */ FORCEINLINE Node& GetBestNode() { return (m_pBestDestNode != NULL) ? *m_pBestDestNode : *m_pBestIntermediateNode; } /** Calls NodeList::CreateNewNode() - allocates new node that can be filled and used - as argument for AddStartupNode() or AddNewNode() - */ + * as argument for AddStartupNode() or AddNewNode() + */ FORCEINLINE Node& CreateNewNode() { Node& node = *m_nodes.CreateNewNode(); @@ -203,7 +203,7 @@ public: } /** AddNewNode() - called by Tderived::PfFollowNode() for each child node. - Nodes are evaluated here and added into open list */ + * Nodes are evaluated here and added into open list */ void AddNewNode(Node& n) { // evaluate the node diff --git a/yapf/yapf_common.hpp b/yapf/yapf_common.hpp index e9e827323..869bc820c 100644 --- a/yapf/yapf_common.hpp +++ b/yapf/yapf_common.hpp @@ -129,7 +129,7 @@ public: } /** Called by YAPF to calculate cost estimate. Calculates distance to the destination - * adds it to the actual cost from origin and stores the sum to the Node::m_estimate */ + * adds it to the actual cost from origin and stores the sum to the Node::m_estimate */ inline bool PfCalcEstimate(Node& n) { int dx = abs(TileX(n.GetTile()) - TileX(m_destTile)); @@ -144,9 +144,9 @@ public: }; /** YAPF template that uses Ttypes template argument to determine all YAPF -* components (base classes) from which the actual YAPF is composed. -* For example classes consult: CYapfRail_TypesT template and its instantiations: -* CYapfRail1, CYapfRail2, CYapfRail3, CYapfAnyDepotRail1, CYapfAnyDepotRail2, CYapfAnyDepotRail3 */ + * components (base classes) from which the actual YAPF is composed. + * For example classes consult: CYapfRail_TypesT template and its instantiations: + * CYapfRail1, CYapfRail2, CYapfRail3, CYapfAnyDepotRail1, CYapfAnyDepotRail2, CYapfAnyDepotRail3 */ template class CYapfT : public Ttypes::PfBase ///< Instance of CYapfBaseT - main YAPF loop and support base class diff --git a/yapf/yapf_costcache.hpp b/yapf/yapf_costcache.hpp index 5ad6f8cdc..e1f635e68 100644 --- a/yapf/yapf_costcache.hpp +++ b/yapf/yapf_costcache.hpp @@ -4,9 +4,9 @@ /** CYapfSegmentCostCacheNoneT - the formal only yapf cost cache provider that implements -PfNodeCacheFetch() and PfNodeCacheFlush() callbacks. Used when nodes don't have CachedData -defined (they don't count with any segment cost caching). -*/ + * PfNodeCacheFetch() and PfNodeCacheFlush() callbacks. Used when nodes don't have CachedData + * defined (they don't count with any segment cost caching). + */ template class CYapfSegmentCostCacheNoneT { @@ -15,14 +15,14 @@ public: typedef typename Types::NodeList::Titem Node; ///< this will be our node type /** Called by YAPF to attach cached or local segment cost data to the given node. - * @return true if globally cached data were used or false if local data was used */ + * @return true if globally cached data were used or false if local data was used */ FORCEINLINE bool PfNodeCacheFetch(Node& n) { return false; }; /** Called by YAPF to flush the cached segment cost data back into cache storage. - * Current cache implementation doesn't use that. */ + * Current cache implementation doesn't use that. */ FORCEINLINE void PfNodeCacheFlush(Node& n) { }; @@ -30,9 +30,9 @@ public: /** CYapfSegmentCostCacheLocalT - the yapf cost cache provider that implements fake segment -cost caching functionality for yapf. Used when node needs caching, but you don't want to -cache the segment costs. -*/ + * cost caching functionality for yapf. Used when node needs caching, but you don't want to + * cache the segment costs. + */ template class CYapfSegmentCostCacheLocalT { @@ -52,7 +52,7 @@ protected: public: /** Called by YAPF to attach cached or local segment cost data to the given node. - * @return true if globally cached data were used or false if local data was used */ + * @return true if globally cached data were used or false if local data was used */ FORCEINLINE bool PfNodeCacheFetch(Node& n) { CacheKey key(n.GetKey()); @@ -61,7 +61,7 @@ public: }; /** Called by YAPF to flush the cached segment cost data back into cache storage. - * Current cache implementation doesn't use that. */ + * Current cache implementation doesn't use that. */ FORCEINLINE void PfNodeCacheFlush(Node& n) { }; @@ -69,10 +69,10 @@ public: /** Base class for segment cost cache providers. Contains global counter -* of track layout changes and static notification function called whenever -* the track layout changes. It is implemented as base class because it needs -* to be shared between all rail YAPF types (one shared counter, one notification -* function. */ + * of track layout changes and static notification function called whenever + * the track layout changes. It is implemented as base class because it needs + * to be shared between all rail YAPF types (one shared counter, one notification + * function. */ struct CSegmentCostCacheBase { static int s_rail_change_counter; @@ -82,13 +82,13 @@ struct CSegmentCostCacheBase /** CSegmentCostCacheT - template class providing hash-map and storage (heap) - of Tsegment structures. Each rail node contains pointer to the segment - that contains cached (or non-cached) segment cost information. Nodes can - differ by key type, but they use the same segment type. Segment key should - be always the same (TileIndex + DiagDirection) that represent the beginning - of the segment (origin tile and exit-dir from this tile). - Different CYapfCachedCostT types can share the same type of CSegmentCostCacheT. - Look at CYapfRailSegment (yapf_node_rail.hpp) for the segment example */ + * of Tsegment structures. Each rail node contains pointer to the segment + * that contains cached (or non-cached) segment cost information. Nodes can + * differ by key type, but they use the same segment type. Segment key should + * be always the same (TileIndex + DiagDirection) that represent the beginning + * of the segment (origin tile and exit-dir from this tile). + * Different CYapfCachedCostT types can share the same type of CSegmentCostCacheT. + * Look at CYapfRailSegment (yapf_node_rail.hpp) for the segment example */ template struct CSegmentCostCacheT : public CSegmentCostCacheBase @@ -119,8 +119,8 @@ struct CSegmentCostCacheT }; /** CYapfSegmentCostCacheGlobalT - the yapf cost cache provider that adds the segment cost - caching functionality to yapf. Using this class as base of your will provide the global - segment cost caching services for your Nodes. + * caching functionality to yapf. Using this class as base of your will provide the global + * segment cost caching services for your Nodes. */ template class CYapfSegmentCostCacheGlobalT @@ -173,7 +173,7 @@ protected: public: /** Called by YAPF to attach cached or local segment cost data to the given node. - * @return true if globally cached data were used or false if local data was used */ + * @return true if globally cached data were used or false if local data was used */ FORCEINLINE bool PfNodeCacheFetch(Node& n) { if (!Yapf().CanUseGlobalCache(n)) { @@ -187,7 +187,7 @@ public: }; /** Called by YAPF to flush the cached segment cost data back into cache storage. - * Current cache implementation doesn't use that. */ + * Current cache implementation doesn't use that. */ FORCEINLINE void PfNodeCacheFlush(Node& n) { }; diff --git a/yapf/yapf_costrail.hpp b/yapf/yapf_costrail.hpp index b87793c60..c19e296d8 100644 --- a/yapf/yapf_costrail.hpp +++ b/yapf/yapf_costrail.hpp @@ -160,8 +160,8 @@ public: FORCEINLINE void SetMaxCost(int max_cost) {m_max_cost = max_cost;} /** Called by YAPF to calculate the cost from the origin to the given node. - * Calculates only the cost of given node, adds it to the parent node cost - * and stores the result into Node::m_cost member */ + * Calculates only the cost of given node, adds it to the parent node cost + * and stores the result into Node::m_cost member */ FORCEINLINE bool PfCalcCost(Node& n) { assert(!n.flags_u.flags_s.m_targed_seen); diff --git a/yapf/yapf_destrail.hpp b/yapf/yapf_destrail.hpp index f22166840..9a5bd0536 100644 --- a/yapf/yapf_destrail.hpp +++ b/yapf/yapf_destrail.hpp @@ -46,7 +46,7 @@ public: } /** Called by YAPF to calculate cost estimate. Calculates distance to the destination - * adds it to the actual cost from origin and stores the sum to the Node::m_estimate */ + * adds it to the actual cost from origin and stores the sum to the Node::m_estimate */ FORCEINLINE bool PfCalcEstimate(Node& n) { n.m_estimate = n.m_cost; @@ -118,7 +118,7 @@ public: } /** Called by YAPF to calculate cost estimate. Calculates distance to the destination - * adds it to the actual cost from origin and stores the sum to the Node::m_estimate */ + * adds it to the actual cost from origin and stores the sum to the Node::m_estimate */ FORCEINLINE bool PfCalcEstimate(Node& n) { static int dg_dir_to_x_offs[] = {-1, 0, 1, 0}; diff --git a/yapf/yapf_rail.cpp b/yapf/yapf_rail.cpp index 72cfe3fad..c830d2b44 100644 --- a/yapf/yapf_rail.cpp +++ b/yapf/yapf_rail.cpp @@ -28,8 +28,8 @@ protected: public: /** Called by YAPF to move from the given node to the next tile. For each - * reachable trackdir on the new tile creates new node, initializes it - * and adds it to the open list by calling Yapf().AddNewNode(n) */ + * reachable trackdir on the new tile creates new node, initializes it + * and adds it to the open list by calling Yapf().AddNewNode(n) */ inline void PfFollowNode(Node& old_node) { TrackFollower F(Yapf().GetVehicle()); @@ -91,8 +91,8 @@ protected: public: /** Called by YAPF to move from the given node to the next tile. For each - * reachable trackdir on the new tile creates new node, initializes it - * and adds it to the open list by calling Yapf().AddNewNode(n) */ + * reachable trackdir on the new tile creates new node, initializes it + * and adds it to the open list by calling Yapf().AddNewNode(n) */ inline void PfFollowNode(Node& old_node) { TrackFollower F(Yapf().GetVehicle()); diff --git a/yapf/yapf_road.cpp b/yapf/yapf_road.cpp index 1b9000f13..2a4680b8c 100644 --- a/yapf/yapf_road.cpp +++ b/yapf/yapf_road.cpp @@ -64,8 +64,8 @@ protected: public: /** Called by YAPF to calculate the cost from the origin to the given node. - * Calculates only the cost of given node, adds it to the parent node cost - * and stores the result into Node::m_cost member */ + * Calculates only the cost of given node, adds it to the parent node cost + * and stores the result into Node::m_cost member */ FORCEINLINE bool PfCalcCost(Node& n) { int segment_cost = 0; @@ -144,7 +144,7 @@ public: } /** Called by YAPF to calculate cost estimate. Calculates distance to the destination - * adds it to the actual cost from origin and stores the sum to the Node::m_estimate */ + * adds it to the actual cost from origin and stores the sum to the Node::m_estimate */ FORCEINLINE bool PfCalcEstimate(Node& n) { n.m_estimate = n.m_cost; @@ -186,7 +186,7 @@ public: } /** Called by YAPF to calculate cost estimate. Calculates distance to the destination - * adds it to the actual cost from origin and stores the sum to the Node::m_estimate */ + * adds it to the actual cost from origin and stores the sum to the Node::m_estimate */ inline bool PfCalcEstimate(Node& n) { static int dg_dir_to_x_offs[] = {-1, 0, 1, 0}; @@ -231,8 +231,8 @@ protected: public: /** Called by YAPF to move from the given node to the next tile. For each - * reachable trackdir on the new tile creates new node, initializes it - * and adds it to the open list by calling Yapf().AddNewNode(n) */ + * reachable trackdir on the new tile creates new node, initializes it + * and adds it to the open list by calling Yapf().AddNewNode(n) */ inline void PfFollowNode(Node& old_node) { TrackFollower F(Yapf().GetVehicle()); diff --git a/yapf/yapf_settings.h b/yapf/yapf_settings.h index 724196ac2..77c4f2da4 100644 --- a/yapf/yapf_settings.h +++ b/yapf/yapf_settings.h @@ -7,15 +7,15 @@ # ifndef YS_DEF /* -* if YS_DEF is not defined, we will only do following declaration: -* typedef struct YapfSettings { -* bool disable_node_optimization; -* uint32 max_search_nodes; -* .... all other yapf related settings ... -* } YapfSettings; -* -* otherwise we will just expand YS_DEF_xx macros and then #undef them -*/ + * if YS_DEF is not defined, we will only do following declaration: + * typedef struct YapfSettings { + * bool disable_node_optimization; + * uint32 max_search_nodes; + * .... all other yapf related settings ... + * } YapfSettings; + * + * otherwise we will just expand YS_DEF_xx macros and then #undef them + */ # define YS_DEF_BEGIN typedef struct YapfSettings { # define YS_DEF(type, name) type name; # define YS_DEF_END } YapfSettings; diff --git a/yapf/yapf_ship.cpp b/yapf/yapf_ship.cpp index 0682cd45f..728c41cd9 100644 --- a/yapf/yapf_ship.cpp +++ b/yapf/yapf_ship.cpp @@ -20,8 +20,8 @@ protected: public: /** Called by YAPF to move from the given node to the next tile. For each - * reachable trackdir on the new tile creates new node, initializes it - * and adds it to the open list by calling Yapf().AddNewNode(n) */ + * reachable trackdir on the new tile creates new node, initializes it + * and adds it to the open list by calling Yapf().AddNewNode(n) */ inline void PfFollowNode(Node& old_node) { TrackFollower F; @@ -95,8 +95,8 @@ protected: public: /** Called by YAPF to calculate the cost from the origin to the given node. - * Calculates only the cost of given node, adds it to the parent node cost - * and stores the result into Node::m_cost member */ + * Calculates only the cost of given node, adds it to the parent node cost + * and stores the result into Node::m_cost member */ FORCEINLINE bool PfCalcCost(Node& n) { // base tile cost depending on distance @@ -110,8 +110,8 @@ public: }; /** Config struct of YAPF for ships. - Defines all 6 base YAPF modules as classes providing services for CYapfBaseT. -*/ + * Defines all 6 base YAPF modules as classes providing services for CYapfBaseT. + */ template struct CYapfShip_TypesT { -- cgit v1.2.3-54-g00ecf