1

/* $Id$ */

     2

     3

/** @file npf.cpp */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "bridge_map.h"

     8

#include "debug.h"

     9

#include "tile_cmd.h"

    10

#include "bridge.h"

    11

#include "landscape.h"

    12

#include "npf.h"

    13

#include "aystar.h"

    14

#include "pathfind.h"

    15

#include "station.h"

    16

#include "station_map.h"

    17

#include "depot.h"

    18

#include "tunnel_map.h"

    19

#include "network/network.h"

    20

#include "water_map.h"

    21

#include "tunnelbridge_map.h"

    22

#include "functions.h"

    23

    24

static AyStar _npf_aystar;

    25

    26

/* The cost of each trackdir. A diagonal piece is the full NPF_TILE_LENGTH,

    27

 * the shorter piece is sqrt(2)/2*NPF_TILE_LENGTH =~ 0.7071

    28

 */

    29

#define NPF_STRAIGHT_LENGTH (uint)(NPF_TILE_LENGTH * STRAIGHT_TRACK_LENGTH)

    30

static const uint _trackdir_length[TRACKDIR_END] = {

    31

	NPF_TILE_LENGTH, NPF_TILE_LENGTH, NPF_STRAIGHT_LENGTH, NPF_STRAIGHT_LENGTH, NPF_STRAIGHT_LENGTH, NPF_STRAIGHT_LENGTH,

    32

	0, 0,

    33

	NPF_TILE_LENGTH, NPF_TILE_LENGTH, NPF_STRAIGHT_LENGTH, NPF_STRAIGHT_LENGTH, NPF_STRAIGHT_LENGTH, NPF_STRAIGHT_LENGTH

    34

};

    35

    36

/**

    37

 * Calculates the minimum distance traveled to get from t0 to t1 when only

    38

 * using tracks (ie, only making 45 degree turns). Returns the distance in the

    39

 * NPF scale, ie the number of full tiles multiplied by NPF_TILE_LENGTH to

    40

 * prevent rounding.

    41

 */

    42

static uint NPFDistanceTrack(TileIndex t0, TileIndex t1)

    43

{

    44

	const uint dx = Delta(TileX(t0), TileX(t1));

    45

	const uint dy = Delta(TileY(t0), TileY(t1));

    46

    47

	const uint straightTracks = 2 * min(dx, dy); /* The number of straight (not full length) tracks */

    48

	/* OPTIMISATION:

    49

	 * Original: diagTracks = max(dx, dy) - min(dx,dy);

    50

	 * Proof:

    51

	 * (dx+dy) - straightTracks  == (min + max) - straightTracks = min + max - 2 * min = max - min */

    52

	const uint diagTracks = dx + dy - straightTracks; /* The number of diagonal (full tile length) tracks. */

    53

    54

	/* Don't factor out NPF_TILE_LENGTH below, this will round values and lose

    55

	 * precision */

    56

	return diagTracks * NPF_TILE_LENGTH + straightTracks * NPF_TILE_LENGTH * STRAIGHT_TRACK_LENGTH;

    57

}

    58

    59

    60

#if 0

    61

static uint NTPHash(uint key1, uint key2)

    62

{

    63

	/* This function uses the old hash, which is fixed on 10 bits (1024 buckets) */

    64

	return PATHFIND_HASH_TILE(key1);

    65

}

    66

#endif

    67

    68

/**

    69

 * Calculates a hash value for use in the NPF.

    70

 * @param key1 The TileIndex of the tile to hash

    71

 * @param key2 The Trackdir of the track on the tile.

    72

 *

    73

 * @todo Think of a better hash.

    74

 */

    75

static uint NPFHash(uint key1, uint key2)

    76

{

    77

	/* TODO: think of a better hash? */

    78

	uint part1 = TileX(key1) & NPF_HASH_HALFMASK;

    79

	uint part2 = TileY(key1) & NPF_HASH_HALFMASK;

    80

    81

	assert(IsValidTrackdir((Trackdir)key2));

    82

	assert(IsValidTile(key1));

    83

	return ((part1 << NPF_HASH_HALFBITS | part2) + (NPF_HASH_SIZE * key2 / TRACKDIR_END)) % NPF_HASH_SIZE;

    84

}

    85

    86

static int32 NPFCalcZero(AyStar* as, AyStarNode* current, OpenListNode* parent)

    87

{

    88

	return 0;

    89

}

    90

    91

/* Calcs the tile of given station that is closest to a given tile

    92

 * for this we assume the station is a rectangle,

    93

 * as defined by its top tile (st->train_tile) and its width/height (st->trainst_w, st->trainst_h)

    94

 */

    95

static TileIndex CalcClosestStationTile(StationID station, TileIndex tile)

    96

{

    97

	const Station* st = GetStation(station);

    98

    99

	uint minx = TileX(st->train_tile);  // topmost corner of station

   100

	uint miny = TileY(st->train_tile);

   101

	uint maxx = minx + st->trainst_w - 1; // lowermost corner of station

   102

	uint maxy = miny + st->trainst_h - 1;

   103

	uint x;

   104

	uint y;

   105

   106

	/* we are going the aim for the x coordinate of the closest corner

   107

	 * but if we are between those coordinates, we will aim for our own x coordinate */

   108

	x = Clamp(TileX(tile), minx, maxx);

   109

   110

	/* same for y coordinate, see above comment */

   111

	y = Clamp(TileY(tile), miny, maxy);

   112

   113

	/* return the tile of our target coordinates */

   114

	return TileXY(x, y);

   115

}

   116

   117

/* Calcs the heuristic to the target station or tile. For train stations, it

   118

 * takes into account the direction of approach.

   119

 */

   120

static int32 NPFCalcStationOrTileHeuristic(AyStar* as, AyStarNode* current, OpenListNode* parent)

   121

{

   122

	NPFFindStationOrTileData* fstd = (NPFFindStationOrTileData*)as->user_target;

   123

	NPFFoundTargetData* ftd = (NPFFoundTargetData*)as->user_path;

   124

	TileIndex from = current->tile;

   125

	TileIndex to = fstd->dest_coords;

   126

	uint dist;

   127

   128

	/* for train-stations, we are going to aim for the closest station tile */

   129

	if (as->user_data[NPF_TYPE] == TRANSPORT_RAIL && fstd->station_index != INVALID_STATION)

   130

		to = CalcClosestStationTile(fstd->station_index, from);

   131

   132

	if (as->user_data[NPF_TYPE] == TRANSPORT_ROAD) {

   133

		/* Since roads only have diagonal pieces, we use manhattan distance here */

   134

		dist = DistanceManhattan(from, to) * NPF_TILE_LENGTH;

   135

	} else {

   136

		/* Ships and trains can also go diagonal, so the minimum distance is shorter */

   137

		dist = NPFDistanceTrack(from, to);

   138

	}

   139

   140

	DEBUG(npf, 4, "Calculating H for: (%d, %d). Result: %d", TileX(current->tile), TileY(current->tile), dist);

   141

   142

	if (dist < ftd->best_bird_dist) {

   143

		ftd->best_bird_dist = dist;

   144

		ftd->best_trackdir = (Trackdir)current->user_data[NPF_TRACKDIR_CHOICE];

   145

	}

   146

	return dist;

   147

}

   148

   149

   150

/* Fills AyStarNode.user_data[NPF_TRACKDIRCHOICE] with the chosen direction to

   151

 * get here, either getting it from the current choice or from the parent's

   152

 * choice */

   153

static void NPFFillTrackdirChoice(AyStarNode* current, OpenListNode* parent)

   154

{

   155

	if (parent->path.parent == NULL) {

   156

		Trackdir trackdir = (Trackdir)current->direction;

   157

		/* This is a first order decision, so we'd better save the

   158

		 * direction we chose */

   159

		current->user_data[NPF_TRACKDIR_CHOICE] = trackdir;

   160

		DEBUG(npf, 6, "Saving trackdir: 0x%X", trackdir);

   161

	} else {

   162

		/* We've already made the decision, so just save our parent's decision */

   163

		current->user_data[NPF_TRACKDIR_CHOICE] = parent->path.node.user_data[NPF_TRACKDIR_CHOICE];

   164

	}

   165

}

   166

   167

/* Will return the cost of the tunnel. If it is an entry, it will return the

   168

 * cost of that tile. If the tile is an exit, it will return the tunnel length

   169

 * including the exit tile. Requires that this is a Tunnel tile */

   170

static uint NPFTunnelCost(AyStarNode* current)

   171

{

   172

	DiagDirection exitdir = TrackdirToExitdir((Trackdir)current->direction);

   173

	TileIndex tile = current->tile;

   174

	if (GetTunnelBridgeDirection(tile) == ReverseDiagDir(exitdir)) {

   175

		/* We just popped out if this tunnel, since were

   176

		 * facing the tunnel exit */

   177

		FindLengthOfTunnelResult flotr;

   178

		flotr = FindLengthOfTunnel(tile, ReverseDiagDir(exitdir));

   179

		return flotr.length * NPF_TILE_LENGTH;

   180

		/* @todo: Penalty for tunnels? */

   181

	} else {

   182

		/* We are entering the tunnel, the enter tile is just a

   183

		 * straight track */

   184

		return NPF_TILE_LENGTH;

   185

	}

   186

}

   187

   188

static inline uint NPFBridgeCost(AyStarNode *current)

   189

{

   190

	return NPF_TILE_LENGTH * GetBridgeLength(current->tile, GetOtherBridgeEnd(current->tile));

   191

}

   192

   193

static uint NPFSlopeCost(AyStarNode* current)

   194

{

   195

	TileIndex next = current->tile + TileOffsByDiagDir(TrackdirToExitdir((Trackdir)current->direction));

   196

   197

	/* Get center of tiles */

   198

	int x1 = TileX(current->tile) * TILE_SIZE + TILE_SIZE / 2;

   199

	int y1 = TileY(current->tile) * TILE_SIZE + TILE_SIZE / 2;

   200

	int x2 = TileX(next) * TILE_SIZE + TILE_SIZE / 2;

   201

	int y2 = TileY(next) * TILE_SIZE + TILE_SIZE / 2;

   202

   203

	int dx4 = (x2 - x1) / 4;

   204

	int dy4 = (y2 - y1) / 4;

   205

   206

	/* Get the height on both sides of the tile edge.

   207

	 * Avoid testing the height on the tile-center. This will fail for halftile-foundations.

   208

	 */

   209

	int z1 = GetSlopeZ(x1 + dx4, y1 + dy4);

   210

	int z2 = GetSlopeZ(x2 - dx4, y2 - dy4);

   211

   212

	if (z2 - z1 > 1) {

   213

		/* Slope up */

   214

		return _patches.npf_rail_slope_penalty;

   215

	}

   216

	return 0;

   217

	/* Should we give a bonus for slope down? Probably not, we

   218

	 * could just substract that bonus from the penalty, because

   219

	 * there is only one level of steepness... */

   220

}

   221

   222

/**

   223

 * Mark tiles by mowing the grass when npf debug level >= 1.

   224

 * Will not work for multiplayer games, since it can (will) cause desyncs.

   225

 */

   226

static void NPFMarkTile(TileIndex tile)

   227

{

   228

#ifndef NO_DEBUG_MESSAGES

   229

	if (_debug_npf_level < 1 || _networking) return;

   230

	switch (GetTileType(tile)) {

   231

		case MP_RAILWAY:

   232

			/* DEBUG: mark visited tiles by mowing the grass under them ;-) */

   233

			if (!IsTileDepotType(tile, TRANSPORT_RAIL)) {

   234

				SetRailGroundType(tile, RAIL_GROUND_BARREN);

   235

				MarkTileDirtyByTile(tile);

   236

			}

   237

			break;

   238

   239

		case MP_ROAD:

   240

			if (!IsTileDepotType(tile, TRANSPORT_ROAD)) {

   241

				SetRoadside(tile, ROADSIDE_BARREN);

   242

				MarkTileDirtyByTile(tile);

   243

			}

   244

			break;

   245

   246

		default:

   247

			break;

   248

	}

   249

#endif

   250

}

   251

   252

static int32 NPFWaterPathCost(AyStar* as, AyStarNode* current, OpenListNode* parent)

   253

{

   254

	/* TileIndex tile = current->tile; */

   255

	int32 cost = 0;

   256

	Trackdir trackdir = (Trackdir)current->direction;

   257

   258

	cost = _trackdir_length[trackdir]; // Should be different for diagonal tracks

   259

   260

	if (IsBuoyTile(current->tile) && IsDiagonalTrackdir(trackdir))

   261

		cost += _patches.npf_buoy_penalty; // A small penalty for going over buoys

   262

   263

	if (current->direction != NextTrackdir((Trackdir)parent->path.node.direction))

   264

		cost += _patches.npf_water_curve_penalty;

   265

   266

	/* @todo More penalties? */

   267

   268

	return cost;

   269

}

   270

   271

/* Determine the cost of this node, for road tracks */

   272

static int32 NPFRoadPathCost(AyStar* as, AyStarNode* current, OpenListNode* parent)

   273

{

   274

	TileIndex tile = current->tile;

   275

	int32 cost = 0;

   276

   277

	/* Determine base length */

   278

	switch (GetTileType(tile)) {

   279

		case MP_TUNNELBRIDGE:

   280

			cost = IsTunnel(tile) ? NPFTunnelCost(current) : NPFBridgeCost(current);

   281

			break;

   282

   283

		case MP_ROAD:

   284

			cost = NPF_TILE_LENGTH;

   285

			/* Increase the cost for level crossings */

   286

			if (IsLevelCrossing(tile)) cost += _patches.npf_crossing_penalty;

   287

			break;

   288

   289

		case MP_STATION:

   290

			cost = NPF_TILE_LENGTH;

   291

			/* Increase the cost for drive-through road stops */

   292

			if (IsDriveThroughStopTile(tile)) cost += _patches.npf_road_drive_through_penalty;

   293

			break;

   294

   295

		default:

   296

			break;

   297

	}

   298

   299

	/* Determine extra costs */

   300

   301

	/* Check for slope */

   302

	cost += NPFSlopeCost(current);

   303

   304

	/* Check for turns. Road vehicles only really drive diagonal, turns are

   305

	 * represented by non-diagonal tracks */

   306

	if (!IsDiagonalTrackdir((Trackdir)current->direction))

   307

		cost += _patches.npf_road_curve_penalty;

   308

   309

	NPFMarkTile(tile);

   310

	DEBUG(npf, 4, "Calculating G for: (%d, %d). Result: %d", TileX(current->tile), TileY(current->tile), cost);

   311

	return cost;

   312

}

   313

   314

   315

/* Determine the cost of this node, for railway tracks */

   316

static int32 NPFRailPathCost(AyStar* as, AyStarNode* current, OpenListNode* parent)

   317

{

   318

	TileIndex tile = current->tile;

   319

	Trackdir trackdir = (Trackdir)current->direction;

   320

	int32 cost = 0;

   321

	/* HACK: We create a OpenListNode manually, so we can call EndNodeCheck */

   322

	OpenListNode new_node;

   323

   324

	/* Determine base length */

   325

	switch (GetTileType(tile)) {

   326

		case MP_TUNNELBRIDGE:

   327

			cost = IsTunnel(tile) ? NPFTunnelCost(current) : NPFBridgeCost(current);

   328

			break;

   329

   330

		case MP_RAILWAY:

   331

			cost = _trackdir_length[trackdir]; /* Should be different for diagonal tracks */

   332

			break;

   333

   334

		case MP_ROAD: /* Railway crossing */

   335

			cost = NPF_TILE_LENGTH;

   336

			break;

   337

   338

		case MP_STATION:

   339

			/* We give a station tile a penalty. Logically we would only want to give

   340

			 * station tiles that are not our destination this penalty. This would

   341

			 * discourage trains to drive through busy stations. But, we can just

   342

			 * give any station tile a penalty, because every possible route will get

   343

			 * this penalty exactly once, on its end tile (if it's a station) and it

   344

			 * will therefore not make a difference. */

   345

			cost = NPF_TILE_LENGTH + _patches.npf_rail_station_penalty;

   346

			break;

   347

   348

		default:

   349

			break;

   350

	}

   351

   352

	/* Determine extra costs */

   353

   354

	/* Check for signals */

   355

	if (IsTileType(tile, MP_RAILWAY) && HasSignalOnTrackdir(tile, trackdir)) {

   356

		/* Ordinary track with signals */

   357

		if (GetSignalStateByTrackdir(tile, trackdir) == SIGNAL_STATE_RED) {

   358

			/* Signal facing us is red */

   359

			if (!NPFGetFlag(current, NPF_FLAG_SEEN_SIGNAL)) {

   360

				/* Penalize the first signal we

   361

				 * encounter, if it is red */

   362

   363

				/* Is this a presignal exit or combo? */

   364

				SignalType sigtype = GetSignalType(tile, TrackdirToTrack(trackdir));

   365

				if (sigtype == SIGTYPE_EXIT || sigtype == SIGTYPE_COMBO) {

   366

					/* Penalise exit and combo signals differently (heavier) */

   367

					cost += _patches.npf_rail_firstred_exit_penalty;

   368

				} else {

   369

					cost += _patches.npf_rail_firstred_penalty;

   370

				}

   371

			}

   372

			/* Record the state of this signal */

   373

			NPFSetFlag(current, NPF_FLAG_LAST_SIGNAL_RED, true);

   374

		} else {

   375

			/* Record the state of this signal */

   376

			NPFSetFlag(current, NPF_FLAG_LAST_SIGNAL_RED, false);

   377

		}

   378

		NPFSetFlag(current, NPF_FLAG_SEEN_SIGNAL, true);

   379

	}

   380

   381

	/* Penalise the tile if it is a target tile and the last signal was

   382

	 * red */

   383

	/* HACK: We create a new_node here so we can call EndNodeCheck. Ugly as hell

   384

	 * of course... */

   385

	new_node.path.node = *current;

   386

	if (as->EndNodeCheck(as, &new_node) == AYSTAR_FOUND_END_NODE && NPFGetFlag(current, NPF_FLAG_LAST_SIGNAL_RED))

   387

		cost += _patches.npf_rail_lastred_penalty;

   388

   389

	/* Check for slope */

   390

	cost += NPFSlopeCost(current);

   391

   392

	/* Check for turns */

   393

	if (current->direction != NextTrackdir((Trackdir)parent->path.node.direction))

   394

		cost += _patches.npf_rail_curve_penalty;

   395

	/*TODO, with realistic acceleration, also the amount of straight track between

   396

	 *      curves should be taken into account, as this affects the speed limit. */

   397

   398

	/* Check for reverse in depot */

   399

	if (IsTileDepotType(tile, TRANSPORT_RAIL) && as->EndNodeCheck(as, &new_node) != AYSTAR_FOUND_END_NODE) {

   400

		/* Penalise any depot tile that is not the last tile in the path. This

   401

		 * _should_ penalise every occurence of reversing in a depot (and only

   402

		 * that) */

   403

		cost += _patches.npf_rail_depot_reverse_penalty;

   404

	}

   405

   406

	/* Check for occupied track */

   407

	//TODO

   408

   409

	NPFMarkTile(tile);

   410

	DEBUG(npf, 4, "Calculating G for: (%d, %d). Result: %d", TileX(current->tile), TileY(current->tile), cost);

   411

	return cost;

   412

}

   413

   414

/* Will find any depot */

   415

static int32 NPFFindDepot(AyStar* as, OpenListNode *current)

   416

{

   417

	/* It's not worth caching the result with NPF_FLAG_IS_TARGET here as below,

   418

	 * since checking the cache not that much faster than the actual check */

   419

	return IsTileDepotType(current->path.node.tile, (TransportType)as->user_data[NPF_TYPE]) ?

   420

		AYSTAR_FOUND_END_NODE : AYSTAR_DONE;

   421

}

   422

   423

/* Will find a station identified using the NPFFindStationOrTileData */

   424

static int32 NPFFindStationOrTile(AyStar* as, OpenListNode *current)

   425

{

   426

	NPFFindStationOrTileData* fstd = (NPFFindStationOrTileData*)as->user_target;

   427

	AyStarNode *node = &current->path.node;

   428

	TileIndex tile = node->tile;

   429

   430

	/* If GetNeighbours said we could get here, we assume the station type

   431

	 * is correct */

   432

	if (

   433

		(fstd->station_index == INVALID_STATION && tile == fstd->dest_coords) || /* We've found the tile, or */

   434

		(IsTileType(tile, MP_STATION) && GetStationIndex(tile) == fstd->station_index) /* the station */

   435

	) {

   436

		return AYSTAR_FOUND_END_NODE;

   437

	} else {

   438

		return AYSTAR_DONE;

   439

	}

   440

}

   441

   442

/* To be called when current contains the (shortest route to) the target node.

   443

 * Will fill the contents of the NPFFoundTargetData using

   444

 * AyStarNode[NPF_TRACKDIR_CHOICE].

   445

 */

   446

static void NPFSaveTargetData(AyStar* as, OpenListNode* current)

   447

{

   448

	NPFFoundTargetData* ftd = (NPFFoundTargetData*)as->user_path;

   449

	ftd->best_trackdir = (Trackdir)current->path.node.user_data[NPF_TRACKDIR_CHOICE];

   450

	ftd->best_path_dist = current->g;

   451

	ftd->best_bird_dist = 0;

   452

	ftd->node = current->path.node;

   453

}

   454

   455

/**

   456

 * Finds out if a given player's vehicles are allowed to enter a given tile.

   457

 * @param owner    The owner of the vehicle.

   458

 * @param tile     The tile that is about to be entered.

   459

 * @param enterdir The direction from which the vehicle wants to enter the tile.

   460

 * @return         true if the vehicle can enter the tile.

   461

 * @todo           This function should be used in other places than just NPF,

   462

 *                 maybe moved to another file too.

   463

 */

   464

static bool VehicleMayEnterTile(Owner owner, TileIndex tile, DiagDirection enterdir)

   465

{

   466

	if (IsTileType(tile, MP_RAILWAY) ||           /* Rail tile (also rail depot) */

   467

			IsRailwayStationTile(tile) ||               /* Rail station tile */

   468

			IsTileDepotType(tile, TRANSPORT_ROAD) ||  /* Road depot tile */

   469

			IsStandardRoadStopTile(tile) || /* Road station tile (but not drive-through stops) */

   470

			IsTileDepotType(tile, TRANSPORT_WATER)) { /* Water depot tile */

   471

		return IsTileOwner(tile, owner); /* You need to own these tiles entirely to use them */

   472

	}

   473

   474

	switch (GetTileType(tile)) {

   475

		case MP_ROAD:

   476

			/* rail-road crossing : are we looking at the railway part? */

   477

			if (IsLevelCrossing(tile) &&

   478

					DiagDirToAxis(enterdir) != GetCrossingRoadAxis(tile)) {

   479

				return IsTileOwner(tile, owner); /* Railway needs owner check, while the street is public */

   480

			}

   481

			break;

   482

   483

		case MP_TUNNELBRIDGE:

   484

			if (GetTunnelBridgeTransportType(tile) == TRANSPORT_RAIL) {

   485

				return IsTileOwner(tile, owner);

   486

			}

   487

			break;

   488

   489