1

/* $Id$ */

     2

     3

#ifndef  YAPF_BASE_HPP

     4

#define  YAPF_BASE_HPP

     5

     6

EXTERN_C_BEGIN

     7

#include "../debug.h"

     8

EXTERN_C_END

     9

    10

#include "fixedsizearray.hpp"

    11

#include "blob.hpp"

    12

#include "nodelist.hpp"

    13

    14

extern int _total_pf_time_us;

    15

    16

/** CYapfBaseT - A-star type path finder base class.

    17

		Derive your own pathfinder from it. You must provide the following template argument:

    18

			Types      - used as collection of local types used in pathfinder

    19

    20

		Requirements for the Types struct:

    21

		----------------------------------

    22

		The following types must be defined in the 'Types' argument:

    23

			- Types::Tpf - your pathfinder derived from CYapfBaseT

    24

			- Types::NodeList - open/closed node list (look at CNodeList_HashTableT)

    25

		NodeList needs to have defined local type Titem - defines the pathfinder node type.

    26

		Node needs to define local type Key - the node key in the collection ()

    27

    28

		For node list you can use template class CNodeList_HashTableT, for which

    29

		you need to declare only your node type. Look at test_yapf.h for an example.

    30

    31

    32

		Requrements to your pathfinder class derived from CYapfBaseT:

    33

		-------------------------------------------------------------

    34

		Your pathfinder derived class needs to implement following methods:

    35

			FORCEINLINE void PfSetStartupNodes()

    36

			FORCEINLINE void PfFollowNode(Node& org)

    37

			FORCEINLINE bool PfCalcCost(Node& n)

    38

			FORCEINLINE bool PfCalcEstimate(Node& n)

    39

			FORCEINLINE bool PfDetectDestination(Node& n)

    40

    41

		For more details about those methods, look at the end of CYapfBaseT

    42

		declaration. There are some examples. For another example look at

    43

		test_yapf.h (part or unittest project).

    44

*/

    45

template <class Types>

    46

class CYapfBaseT {

    47

public:

    48

	typedef typename Types::Tpf Tpf;           ///< the pathfinder class (derived from THIS class)

    49

	typedef typename Types::NodeList NodeList; ///< our node list

    50

	typedef typename NodeList::Titem Node;     ///< this will be our node type

    51

	typedef typename Node::Key Key;            ///< key to hash tables

    52

    53

    54

	NodeList             m_nodes;              ///< node list multi-container

    55

protected:

    56

	Node*                m_pBestDestNode;      ///< pointer to the destination node found at last round

    57

	Node*                m_pBestIntermediateNode; ///< here should be node closest to the destination if path not found

    58

	const YapfSettings  *m_settings;           ///< current settings (_patches.yapf)

    59

	int                  m_max_search_nodes;   ///< maximum number of nodes we are allowed to visit before we give up

    60

	const Vehicle*       m_veh;                ///< vehicle that we are trying to drive

    61

    62

	int                  m_stats_cost_calcs;   ///< stats - how many node's costs were calculated

    63

	int                  m_stats_cache_hits;   ///< stats - how many node's costs were reused from cache

    64

    65

public:

    66

	CPerformanceTimer    m_perf_cost;          ///< stats - total CPU time of this run

    67

	CPerformanceTimer    m_perf_slope_cost;    ///< stats - slope calculation CPU time

    68

	CPerformanceTimer    m_perf_ts_cost;       ///< stats - GetTrackStatus() CPU time

    69

	CPerformanceTimer    m_perf_other_cost;    ///< stats - other CPU time

    70

    71

public:

    72

	int                  m_num_steps;          ///< this is there for debugging purposes (hope it doesn't hurt)

    73

    74

public:

    75

	/// default constructor

    76

	FORCEINLINE CYapfBaseT()

    77

		: m_pBestDestNode(NULL)

    78

		, m_pBestIntermediateNode(NULL)

    79

#if defined(UNITTEST)

    80

		, m_settings(NULL)

    81

		, m_max_search_nodes(100000)

    82

#else

    83

		, m_settings(&_patches.yapf)

    84

		, m_max_search_nodes(PfGetSettings().max_search_nodes)

    85

#endif

    86

		, m_veh(NULL)

    87

		, m_stats_cost_calcs(0)

    88

		, m_stats_cache_hits(0)

    89

		, m_num_steps(0)

    90

	{

    91

	}

    92

    93

	/// default destructor

    94

	~CYapfBaseT() {}

    95

    96

protected:

    97

	/// to access inherited path finder

    98

	FORCEINLINE Tpf& Yapf() {return *static_cast<Tpf*>(this);}

    99

   100

public:

   101

	/// return current settings (can be custom - player based - but later)

   102

	FORCEINLINE const YapfSettings& PfGetSettings() const

   103

	{

   104

		return *m_settings;

   105

	}

   106

   107

	/** Main pathfinder routine:

   108

			 - set startup node(s)

   109

			 - main loop that stops if:

   110

					- the destination was found

   111

					- or the open list is empty (no route to destination).

   112

					- or the maximum amount of loops reached - m_max_search_nodes (default = 10000)

   113

			@return true if the path was found */

   114

	inline bool FindPath(const Vehicle* v)

   115

	{

   116

		m_veh = v;

   117

   118

		CPerformanceTimer perf;

   119

		perf.Start();

   120

		Yapf().PfSetStartupNodes();

   121

   122

		while (true) {

   123

			m_num_steps++;

   124

			Node& n = m_nodes.GetBestOpenNode();

   125

			if (&n == NULL)

   126

				break;

   127

   128

			// if the best open node was worse than the best path found, we can finish

   129

			if (m_pBestDestNode != NULL && m_pBestDestNode->GetCost() < n.GetCostEstimate())

   130

				break;

   131

   132

			Yapf().PfFollowNode(n);

   133

			if (m_max_search_nodes == 0 || m_nodes.ClosedCount() < m_max_search_nodes) {

   134

				m_nodes.PopOpenNode(n.GetKey());

   135

				m_nodes.InsertClosedNode(n);

   136

			} else {

   137

				m_pBestDestNode = m_pBestIntermediateNode;

   138

				break;

   139

			}

   140

		}

   141

		bool bDestFound = (m_pBestDestNode != NULL);

   142

   143

		int16 veh_idx = (m_veh != NULL) ? m_veh->unitnumber : 0;

   144

   145

//		if (veh_idx != 433) return bDestFound;

   146

   147

		perf.Stop();

   148

		int t = perf.Get(1000000);

   149

		_total_pf_time_us += t;

   150

		char ttc = Yapf().TransportTypeChar();

   151

		float cache_hit_ratio = (float)m_stats_cache_hits / (float)(m_stats_cache_hits + m_stats_cost_calcs) * 100.0f;

   152

		int cost = bDestFound ? m_pBestDestNode->m_cost : -1;

   153

		int dist = bDestFound ? m_pBestDestNode->m_estimate - m_pBestDestNode->m_cost : -1;

   154

#ifdef UNITTEST

   155

		printf("%c%c%4d-%6d us -%5d rounds -%4d open -%5d closed - CHR %4.1f%% - c/d(%d, %d) - c%d(sc%d, ts%d, o%d) -- \n", bDestFound ? '-' : '!', ttc, veh_idx, t, m_num_steps, m_nodes.OpenCount(), m_nodes.ClosedCount(), cache_hit_ratio, cost, dist, m_perf_cost.Get(1000000), m_perf_slope_cost.Get(1000000), m_perf_ts_cost.Get(1000000), m_perf_other_cost.Get(1000000));

   156

#else

   157

		DEBUG(yapf, 1)("[YAPF][YAPF%c]%c%4d- %d us - %d rounds - %d open - %d closed - CHR %4.1f%% - c%d(sc%d, ts%d, o%d) -- ", ttc, bDestFound ? '-' : '!', veh_idx, t, m_num_steps, m_nodes.OpenCount(), m_nodes.ClosedCount(), cache_hit_ratio, cost, dist, m_perf_cost.Get(1000000), m_perf_slope_cost.Get(1000000), m_perf_ts_cost.Get(1000000), m_perf_other_cost.Get(1000000));

   158

#endif

   159

		return bDestFound;

   160

	}

   161

   162

	/** If path was found return the best node that has reached the destination. Otherwise

   163

			return the best visited node (which was nearest to the destination).

   164

	*/

   165

	FORCEINLINE Node& GetBestNode()

   166

	{

   167

		return (m_pBestDestNode != NULL) ? *m_pBestDestNode : *m_pBestIntermediateNode;

   168

	}

   169

   170

	/** Calls NodeList::CreateNewNode() - allocates new node that can be filled and used

   171

			as argument for AddStartupNode() or AddNewNode()

   172

	*/

   173

	FORCEINLINE Node& CreateNewNode()

   174

	{

   175

		Node& node = *m_nodes.CreateNewNode();

   176

		return node;

   177

	}

   178

   179

	/** Add new node (created by CreateNewNode and filled with data) into open list */

   180

	FORCEINLINE void AddStartupNode(Node& n)

   181

	{

   182

		Yapf().PfNodeCacheFetch(n);

   183

		m_nodes.InsertOpenNode(n);

   184

	}

   185

   186

	/** add multiple nodes - direct children of the given node */

   187

	FORCEINLINE void AddMultipleNodes(Node* parent, TileIndex tile, TrackdirBits td_bits)

   188

	{

   189

		for (TrackdirBits rtds = td_bits; rtds != TRACKDIR_BIT_NONE; rtds = (TrackdirBits)KillFirstBit2x64(rtds)) {

   190

			Trackdir td = (Trackdir)FindFirstBit2x64(rtds);

   191

			Node& n = Yapf().CreateNewNode();

   192

			n.Set(parent, tile, td);

   193

			Yapf().AddNewNode(n);

   194

		}

   195

	}

   196

   197

	/** AddNewNode() - called by Tderived::PfFollowNode() for each child node.

   198

	    Nodes are evaluated here and added into open list */

   199

	void AddNewNode(Node& n)

   200

	{

   201

		// evaluate the node

   202

		bool bCached = Yapf().PfNodeCacheFetch(n);

   203

		if (!bCached) {

   204

			m_stats_cost_calcs++;

   205

		} else {

   206

			m_stats_cache_hits++;

   207

		}

   208

   209

		bool bValid = Yapf().PfCalcCost(n);

   210

   211

		if (bCached) {

   212

			Yapf().PfNodeCacheFlush(n);

   213

		}

   214

   215

		if (bValid) bValid = Yapf().PfCalcEstimate(n);

   216

   217

		// have the cost or estimate callbacks marked this node as invalid?

   218

		if (!bValid) return;

   219

   220

		// detect the destination

   221

		bool bDestination = Yapf().PfDetectDestination(n);

   222

		if (bDestination) {

   223

			if (m_pBestDestNode == NULL || n < *m_pBestDestNode) {

   224

				m_pBestDestNode = &n;

   225

			}

   226

			m_nodes.FoundBestNode(n);

   227

			return;

   228

		}

   229

   230

		if (m_max_search_nodes > 0 && (m_pBestIntermediateNode == NULL || (m_pBestIntermediateNode->GetCostEstimate() - m_pBestIntermediateNode->GetCost()) > (n.GetCostEstimate() - n.GetCost()))) {

   231

			m_pBestIntermediateNode = &n;

   232

		}

   233

   234

		// check new node against open list

   235

		Node& openNode = m_nodes.FindOpenNode(n.GetKey());

   236

		if (&openNode != NULL) {

   237

			// another node exists with the same key in the open list

   238

			// is it better than new one?

   239

			if (n.GetCostEstimate() < openNode.GetCostEstimate()) {

   240

				// update the old node by value from new one

   241

				m_nodes.PopOpenNode(n.GetKey());

   242

				openNode = n;

   243

				// add the updated old node back to open list

   244

				m_nodes.InsertOpenNode(openNode);

   245

			}

   246

			return;

   247

		}

   248

   249

		// check new node against closed list

   250

		Node& closedNode = m_nodes.FindClosedNode(n.GetKey());

   251

		if (&closedNode != NULL) {

   252

			// another node exists with the same key in the closed list

   253

			// is it better than new one?

   254

			int node_est = n.GetCostEstimate();

   255

			int closed_est = closedNode.GetCostEstimate();

   256

			if (node_est < closed_est) {

   257

				// If this assert occurs, you have probably problem in

   258

				// your Tderived::PfCalcCost() or Tderived::PfCalcEstimate().

   259

				// The problem could be:

   260

				//  - PfCalcEstimate() gives too large numbers

   261

				//  - PfCalcCost() gives too small numbers

   262

				//  - You have used negative cost penalty in some cases (cost bonus)

   263

				assert(0);

   264

   265

				return;

   266

			}

   267

			return;

   268

		}

   269

		// the new node is really new

   270

		// add it to the open list

   271

		m_nodes.InsertOpenNode(n);

   272

	}

   273

   274

	const Vehicle* GetVehicle() const {return m_veh;}

   275

   276

	// methods that should be implemented at derived class Types::Tpf (derived from CYapfBaseT)

   277

   278

#if 0

   279

	/** Example: PfSetStartupNodes() - set source (origin) nodes */

   280

	FORCEINLINE void PfSetStartupNodes()

   281

	{

   282

		// example:

   283

		Node& n1 = *base::m_nodes.CreateNewNode();

   284

		.

   285

		. // setup node members here

   286

		.

   287

		base::m_nodes.InsertOpenNode(n1);

   288

	}

   289

   290

	/** Example: PfFollowNode() - set following (child) nodes of the given node */

   291

	FORCEINLINE void PfFollowNode(Node& org)

   292

	{

   293

		for (each follower of node org) {

   294

			Node& n = *base::m_nodes.CreateNewNode();

   295

			.

   296

			. // setup node members here

   297

			.

   298

			n.m_parent   = &org; // set node's parent to allow back tracking

   299

			AddNewNode(n);

   300

		}

   301

	}

   302

   303

	/** Example: PfCalcCost() - set path cost from origin to the given node */

   304

	FORCEINLINE bool PfCalcCost(Node& n)

   305

	{

   306

		// evaluate last step cost

   307

		int cost = ...;

   308

		// set the node cost as sum of parent's cost and last step cost

   309

		n.m_cost = n.m_parent->m_cost + cost;

   310

		return true; // true if node is valid follower (i.e. no obstacle was found)

   311

	}

   312

   313

	/** Example: PfCalcEstimate() - set path cost estimate from origin to the target through given node */

   314

	FORCEINLINE bool PfCalcEstimate(Node& n)

   315

	{

   316

		// evaluate the distance to our destination

   317

		int distance = ...;

   318

		// set estimate as sum of cost from origin + distance to the target

   319

		n.m_estimate = n.m_cost + distance;

   320

		return true; // true if node is valid (i.e. not too far away :)

   321

	}

   322

   323

	/** Example: PfDetectDestination() - return true if the given node is our destination */

   324

	FORCEINLINE bool PfDetectDestination(Node& n)

   325

	{

   326

		bool bDest = (n.m_key.m_x == m_x2) && (n.m_key.m_y == m_y2);

   327

		return bDest;

   328

	}

   329

#endif

   330

};

   331

   332

#endif /* YAPF_BASE_HPP */