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

 */

#define NPF_STRAIGHT_LENGTH (uint)(NPF_TILE_LENGTH * STRAIGHT_TRACK_LENGTH)

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

	0, 0,

	NPF_TILE_LENGTH, NPF_TILE_LENGTH, NPF_STRAIGHT_LENGTH, NPF_STRAIGHT_LENGTH, NPF_STRAIGHT_LENGTH, NPF_STRAIGHT_LENGTH

	return PATHFIND_HASH_TILE(key1);

}

uint NPFHash(uint key1, uint key2)

{

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

	uint part1 = TileX(key1) & NPF_HASH_HALFMASK;

	uint part2 = TileY(key1) & NPF_HASH_HALFMASK;

}

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

void NPFFillTrackdirChoice(AyStarNode* current, OpenListNode* parent)

{

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

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

		 * direction we chose */

		current->user_data[NPF_TRACKDIR_CHOICE] = trackdir;

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

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

uint NPFTunnelCost(AyStarNode* current) {

	TileIndex tile = current->tile;

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

		 * facing the tunnel exit */

		FindLengthOfTunnelResult flotr;

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

	//TileIndex tile = current->tile;

	int32 cost = 0;

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

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

		cost += _patches.npf_water_curve_penalty;

	/* TODO More penalties? */

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

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

	TileIndex tile = current->tile;

	int32 cost = 0;

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

	OpenListNode new_node;

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

	 * red */

	new_node.path.node = *current;

		cost += _patches.npf_rail_lastred_penalty;

	/* Check for slope */

	cost += NPFSlopeCost(current);

	/* Check for turns */

		cost += _patches.npf_rail_curve_penalty;

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

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

 */

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

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

	ftd->best_path_dist = current->g;

	ftd->best_bird_dist = 0;

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

}

/* Will just follow the results of GetTileTrackStatus concerning where we can

 * go and where not. Uses AyStar.user_data[NPF_TYPE] as the transport type and

 * an argument to GetTileTrackStatus. Will skip tunnels, meaning that the

 * AyStarNode.user_data[NPF_TRACKDIR_CHOICE] with an appropriate value, and

 * copy AyStarNode.user_data[NPF_NODE_FLAGS] from the parent */

void NPFFollowTrack(AyStar* aystar, OpenListNode* current) {

	TileIndex src_tile = current->path.node.tile;

	DiagDirection src_exitdir = TrackdirToExitdir(src_trackdir);

	FindLengthOfTunnelResult flotr;

	TileIndex dst_tile;

	TrackdirBits trackdirbits, ts;

	TransportType type = aystar->user_data[NPF_TYPE];

	/* Initialize to 0, so we can jump out (return) somewhere an have no neighbours */

			 * those from one side only. Trackdirs don't support that (yet), so we'll

			 * do this here. */

			/* Find out the exit direction first */

			if (IsRoadStationTile(src_tile))

				exitdir = GetRoadStationDir(src_tile);

	 * problem, but it might be nicer to compare with the first tile, or even

	 * the type of the vehicle... Maybe an NPF_RAILTYPE userdata sometime? */

	if (type == TRANSPORT_RAIL) {

		if (src_type != dst_type) {

			return;

		}

	/* Determine available tracks */

	if (type != TRANSPORT_WATER && (IsRoadStationTile(dst_tile) || IsTileDepotType(dst_tile, type))){

		/* Road stations and road and train depots return 0 on GTTS, so we have to do this by hand... */

		if (IsRoadStationTile(dst_tile))

			exitdir = GetRoadStationDir(dst_tile);

		else /* Road or train depot */

		trackdirbits &= ~TrackdirCrossesTrackdirs(src_trackdir);

	DEBUG(npf,6)("After filtering: (%d, %d), possible trackdirs: %#x", TileX(dst_tile), TileY(dst_tile), trackdirbits);

	/* Enumerate possible track */

	while (trackdirbits != 0) {

		dst_trackdir =  FindFirstBit2x64(trackdirbits);

		trackdirbits = KillFirstBit2x64(trackdirbits);

		DEBUG(npf, 5)("Expanded into trackdir: %d, remaining trackdirs: %#x", dst_trackdir, trackdirbits);

#include "stdafx.h"

#include "openttd.h"

#include "rail.h"

/* XXX: Below 3 tables store duplicate data. Maybe remove some? */

/* Maps a trackdir to the bit that stores its status in the map arrays, in the

	TRACKDIR_DIAG1_SW, TRACKDIR_DIAG2_NW, TRACKDIR_UPPER_W, TRACKDIR_LOWER_W, TRACKDIR_LEFT_N, TRACKDIR_RIGHT_N, INVALID_TRACKDIR, INVALID_TRACKDIR,

	TRACKDIR_DIAG1_NE, TRACKDIR_DIAG2_SE, TRACKDIR_UPPER_E, TRACKDIR_LOWER_E, TRACKDIR_LEFT_S, TRACKDIR_RIGHT_S

};

	return (_map3_hi[tile] & SIG_SEMAPHORE_MASK);

}

#endif // RAIL_H