switch (type)

	{

		case TRANSPORT_RAIL:

		case TRANSPORT_ROAD:

			/* Rail and road store a diagonal direction in bits 0 and 1 */

		case TRANSPORT_WATER:

			/* Water is stubborn, it stores the directions in a different order. */

			switch (_map5[tile] & 3) {

				case 0: return DIAGDIR_NE;

				case 1: return DIAGDIR_SW;

				case 2: return DIAGDIR_NW;

}

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

 * 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;

	if ( (uint)(_map5[tile] & 3) == ReverseDiagdir(exitdir)) {

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

		 * facing the tunnel exit */

		FindLengthOfTunnelResult flotr;

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

		 * straight track */

		return NPF_TILE_LENGTH;

	}

}

uint NPFSlopeCost(AyStarNode* current) {

	int x,y;

	int8 z1,z2;

	x = TileX(current->tile) * TILE_SIZE;

	y = TileY(current->tile) * TILE_SIZE;

	/* get the height of the center of the current tile */

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

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

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

		cost += _patches.npf_water_curve_penalty;

	/* TODO More penalties? */

	return cost;

}

			break;

	}

	/* Determine extra costs */

	/* Check for signals */

		/* Ordinary track with signals */

			/* Signal facing us is red */

			if (!NPFGetFlag(current, NPF_FLAG_SEEN_SIGNAL)) {

				/* Penalize the first signal we

				 * encounter, if it is red */

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

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

					cost += _patches.npf_rail_firstred_exit_penalty;

				else

					cost += _patches.npf_rail_firstred_penalty;

			}

			/* Record the state of this signal */

		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.

	/* Check for reverse in depot */

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

 * 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

 * entry and exit are neighbours. Will fill

 * 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;

	FindLengthOfTunnelResult flotr;

	TileIndex dst_tile;

	int i = 0;

	TransportType type = aystar->user_data[NPF_TYPE];

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

	aystar->num_neighbours = 0;

	DEBUG(npf, 4)("Expanding: (%d, %d, %d) [%d]", TileX(src_tile), TileY(src_tile), src_trackdir, src_tile);

	/* Find dest tile */

		/* This is a tunnel. We know this tunnel is our type,

		 * otherwise we wouldn't have got here. It is also facing us,

		 * so we should skip it's body */

		flotr = FindLengthOfTunnel(src_tile, src_exitdir);

		dst_tile = flotr.tile;

	} else {

				exitdir = GetDepotDirection(src_tile, type);

			/* Let's see if were headed the right way into the depot, and reverse

			 * otherwise (only for trains, since only with trains you can

			 * (sometimes) reach tiles after reversing that you couldn't reach

			 * without reversing. */

				/* We are headed inwards. We can only reverse here, so we'll not

				 * consider this direction, but jump ahead to the reverse direction.

				 * It would be nicer to return one neighbour here (the reverse

				 * trackdir of the one we are considering now) and then considering

				 * that one to return the tracks outside of the depot. But, because

				 * the code layout is cleaner this way, we will just pretend we are

				 * reversed already */

		}

		/* This a normal tile, a bridge, a tunnel exit, etc. */

		if (dst_tile == INVALID_TILE) {

			/* We reached the border of the map */

			/* TODO Nicer control flow for this */

			return;

		}

	}

	/* check correct rail type (mono, maglev, etc)

	 * XXX: This now compares with the previous tile, which should not pose a

	 * 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) {

		byte src_type = GetTileRailType(src_tile, src_trackdir);

		if (src_type != dst_type) {

			return;

		}

	}

	/* Check the owner of the tile */

		 * from some other tile. This prevents vehicles driving into depots from

		 * the back */

		ts = TrackdirToTrackdirBits(DiagdirToDiagTrackdir(ReverseDiagdir(exitdir)));

	} else {

		ts = GetTileTrackStatus(dst_tile, type);

	}

	/* Select only trackdirs we can reach from our current trackdir */

	if (_patches.forbid_90_deg && (type == TRANSPORT_RAIL || type == TRANSPORT_WATER)) /* Filter out trackdirs that would make 90 deg turns for trains */

	/* Enumerate possible track */

		byte dst_trackdir;

		/* Check for oneway signal against us */

				// if one way signal not pointing towards us, stop going in this direction.

		}

		{

			/* We've found ourselves a neighbour :-) */

			AyStarNode* neighbour = &aystar->neighbours[i];

			neighbour->tile = dst_tile;

			neighbour->direction = dst_trackdir;

#include "rail.h"

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

 * direction along with the trackdir */

const byte _signal_along_trackdir[] = {

	0x80, 0x80, 0x80, 0x20, 0x40, 0x10, 0, 0,

	0x40, 0x40, 0x40, 0x10, 0x80, 0x20

};

};

/* Maps a diagonal direction to the all trackdirs that are connected to any

 * track entering in this direction (including those making 90 degree turns)

 */

const TrackdirBits _exitdir_reaches_trackdirs[] = {

};

};

/* Maps a trackdir to all trackdirs that make 90 deg turns with it. */

};

/* Maps a track to all tracks that make 90 deg turns with it. */

const TrackBits _track_crosses_tracks[] = {

};

/* Maps a trackdir to the (4-way) direction the tile is exited when following

 * that trackdir */

const DiagDirection _trackdir_to_exitdir[] = {

};

const Trackdir _track_exitdir_to_trackdir[][DIAGDIR_END] = {

};

const Trackdir _track_direction_to_trackdir[][DIR_END] = {

};

const Trackdir _dir_to_diag_trackdir[] = {

};

const DiagDirection _reverse_diagdir[] = {

};

const Trackdir _reverse_trackdir[] = {

};

	/* There used to be RAIL_BIT_* enums here, they moved to (for now) npf.c as

	 * TRACK_BIT_* */

};

/* These subtypes are used in the map5 byte when the main rail type is

 * RAIL_TYPE_DEPOT_WAYPOINT */

	RAIL_SUBTYPE_DEPOT    = 0x00,

	RAIL_SUBTYPE_WAYPOINT = 0x04,

	RAIL_SUBTYPE_MASK     = 0x3C,

} RailTileSubtype;

	/* Stored in _map3_hi[0..1] for MP_RAILWAY */

  SIGTYPE_NORMAL  = 0,        // normal signal

  SIGTYPE_ENTRY   = 1,        // presignal block entry

  SIGTYPE_EXIT    = 2,        // presignal block exit

  SIGTYPE_COMBO   = 3,        // presignal inter-block

	SIGTYPE_END,

	SIGTYPE_MASK    = 3,

} SignalType;

	RAILTYPE_RAIL   = 0,

	RAILTYPE_MONO   = 1,

	RAILTYPE_MAGLEV = 2,

	RAILTYPE_END,

	RAILTYPE_MASK   = 0x3,

	INVALID_RAILTYPE = 0xFF,

enum {

	SIG_SEMAPHORE_MASK = 4,

};

/* These are used to specify a single track. Can be translated to a trackbit

 * with TrackToTrackbit */

  TRACK_DIAG1 = 0,

  TRACK_DIAG2 = 1,

  TRACK_UPPER = 2,

  TRACK_LOWER = 3,

  TRACK_LEFT  = 4,

  TRACK_RIGHT = 5,

  TRACK_END,

  INVALID_TRACK = 0xFF,

} Track;

/* These are the bitfield variants of the above */

  TRACK_BIT_DIAG1 = 1,  // 0

  TRACK_BIT_DIAG2 = 2,  // 1

  TRACK_BIT_UPPER = 4,  // 2

  TRACK_BIT_LOWER = 8,  // 3

  TRACK_BIT_LEFT  = 16, // 4

  TRACK_BIT_RIGHT = 32, // 5

	TRACK_BIT_MASK  = 0x3F,

} TrackBits;

/* These are a combination of tracks and directions. Values are 0-5 in one

direction (corresponding to the Track enum) and 8-13 in the other direction. */

  TRACKDIR_DIAG1_NE = 0,

  TRACKDIR_DIAG2_SE = 1,

  TRACKDIR_UPPER_E  = 2,

  TRACKDIR_LOWER_E  = 3,

  TRACKDIR_LEFT_S   = 4,

  TRACKDIR_RIGHT_S  = 5,

  TRACKDIR_END,

  INVALID_TRACKDIR  = 0xFF,

} Trackdir;

/* These are a combination of tracks and directions. Values are 0-5 in one

direction (corresponding to the Track enum) and 8-13 in the other direction. */

  TRACKDIR_BIT_DIAG1_NE = 0x1,

  TRACKDIR_BIT_DIAG2_SE = 0x2,

  TRACKDIR_BIT_UPPER_E  = 0x4,

  TRACKDIR_BIT_LOWER_E  = 0x8,

  TRACKDIR_BIT_LEFT_S   = 0x10,

  TRACKDIR_BIT_RIGHT_S  = 0x20,

} TrackdirBits;

/* These are states in which a signal can be. Currently these are only two, so

 * simple boolean logic will do. But do try to compare to this enum instead of

 * normal boolean evaluation, since that will make future additions easier.

 */

} SignalState;

/*

 * These functions check the validity of Tracks and Trackdirs. assert against

 * them when convenient.

	return (_map5[tile] & RAIL_TILE_TYPE_MASK);

}

/**

 * Returns the rail type of the given rail tile (ie rail, mono, maglev).

 */

/**

 * Checks if a rail tile has signals.

 */

static inline bool HasSignals(TileIndex tile)

{

 * Returns the RailTileSubtype of a given rail tile with type

 * RAIL_TYPE_DEPOT_WAYPOINT

 */

static inline RailTileSubtype GetRailTileSubtype(TileIndex tile)

{

	assert(GetRailTileType(tile) == RAIL_TYPE_DEPOT_WAYPOINT);

}

/**

 * Returns whether this is plain rails, with or without signals. Iow, if this

 * tiles RailTileType is RAIL_TYPE_NORMAL or RAIL_TYPE_SIGNALS.

 */

/**

 * Returns the tracks present on the given plain rail tile (IsPlainRailTile())

 */

static inline TrackBits GetTrackBits(TileIndex tile)

{

	assert(GetRailTileType(tile) == RAIL_TYPE_NORMAL || GetRailTileType(tile) == RAIL_TYPE_SIGNALS);

}

/**

 * Returns whether the given track is present on the given tile. Tile must be

 * a plain rail tile (IsPlainRailTile()).

 */

 *

 * TODO: Add #unndefs or something similar to remove the arrays used below

 * from the global scope and expose direct uses of them.

 */

/**

 * Maps a trackdir to the trackdir that you will end up on if you go straight

 * ahead. This will be the same trackdir for diagonal trackdirs, but a

 * different (alternating) one for straight trackdirs

 */

const Trackdir _next_trackdir[TRACKDIR_END];

static inline Trackdir NextTrackdir(Trackdir trackdir) { return _next_trackdir[trackdir]; }

 * but it uses two simpeler tables to achieve the result */

static inline TrackdirBits TrackdirReachesTrackdirs(Trackdir trackdir) { return _exitdir_reaches_trackdirs[TrackdirToExitdir(trackdir)]; }

/**

 * Maps a trackdir to all trackdirs that make 90 deg turns with it.

 */

/**

 * Maps a (4-way) direction to the reverse.

 */

const DiagDirection _reverse_diagdir[DIAGDIR_END];

static inline DiagDirection ReverseDiagdir(DiagDirection diagdir) { return _reverse_diagdir[diagdir]; }

/* Checks if a given Track is diagonal */

/* Checks if a given Trackdir is diagonal. */

static inline bool IsDiagonalTrackdir(Trackdir trackdir) { return IsDiagonalTrack(TrackdirToTrack(trackdir)); }

/*

 * Functions quering signals on tiles.

 */

/**

 */

static inline bool HasSignalOnTrack(TileIndex tile, Track track)

{

	assert(IsValidTrack(track));

}

/**

 * Gets the state of the signal along the given trackdir.

 *

 * Along meaning if you are currently driving on the given trackdir, this is

 * the signal that is facing us (for which we stop when it's red).

 */

static inline SignalState GetSignalState(TileIndex tile, Trackdir trackdir)

{

	assert(IsValidTrackdir(trackdir));

	assert(HasSignalOnTrack(tile, TrackdirToTrack(trackdir)));

}

/**

 * Gets the type of signal on a given track on a given rail tile with signals.

 *

 * Note that currently, the track argument is not used, since

 * future-compatible, though.

 */

static inline SignalType GetSignalType(TileIndex tile, Track track)

{

	assert(IsValidTrack(track));

	assert(GetRailTileType(tile) == RAIL_TYPE_SIGNALS);

}

/**

 * Checks if this tile contains semaphores (returns true) or normal signals

 * (returns false) on the given track. Does not check if there are actually

 * signals on the track, you should use HasSignalsOnTrack() for that.

 * semaphores/electric signals cannot be mixed. This function is trying to be

 * future-compatible, though.

 */

static inline bool HasSemaphores(TileIndex tile, Track track)

{

	assert(IsValidTrack(track));

}

#endif // RAIL_H

#ifndef TILE_H

#define TILE_H

#include "macros.h"

#include "map.h"

	MP_CLEAR,

	MP_RAILWAY,

	MP_STREET,

	MP_HOUSE,

	MP_TREES,

	MP_STATION,

	dirdiff = _new_direction_table[i] - dir;

	if (dirdiff == 0)

		return dir;

	return (dir+((dirdiff&7)<5?1:-1)) & 7;

}

{

	if (v->vehstatus & VS_CRASHED) return 0xFF;

	switch(v->type)

	{

		case VEH_Train:

			if (v->u.rail.track == 0x80) /* We'll assume the train is facing outwards */

			if (v->u.rail.track == 0x40) /* train in tunnel, so just use his direction and assume a diagonal track */

			break;

		case VEH_Ship:

			if (v->u.ship.state == 0x80)  /* Inside a depot? */

				/* We'll assume the ship is facing outwards */

			break;

		case VEH_Road:

			if (v->u.road.state == 254) /* We'll assume the road vehicle is facing outwards */

			if (IsRoadStationTile(v->tile)) /* We'll assume the road vehicle is facing outwards */

			break;

		/* case VEH_Aircraft: case VEH_Special: case VEH_Disaster: */

		default: return 0xFF;

	}

}

/* Return value has bit 0x2 set, when the vehicle enters a station. Then,

#ifndef VEHICLE_H

#define VEHICLE_H

#include "pool.h"

#include "order.h"

enum {

	VEH_Train = 0x10,

	VEH_Road = 0x11,

	VEH_Ship = 0x12,

	VEH_Aircraft = 0x13,

 * vehicle that is halfway a tile, never really understood that part. For road

 * vehicles that are at the beginning or end of the tile, should just return

 * the diagonal trackdir on which they are driving. I _think_.

 * For other vehicles types, or vehicles with no clear trackdir (such as those

 * in depots), returns 0xFF.

 */

/* returns true if staying in the same tile */

bool GetNewVehiclePos(Vehicle *v, GetNewVehiclePosResult *gp);

byte GetDirectionTowards(Vehicle *v, int x, int y);

#define BEGIN_ENUM_WAGONS(v) do {