// Set the user_data to the PathFinderInfo

	result->user_target = PathFinderInfo;

	// Set the start node

	start_node.parent = NULL;

	start_node.node.user_data[0] = 0;

	// Now we add all the starting tiles

	for (x = TileX(PathFinderInfo->start_tile_tl); x <= TileX(PathFinderInfo->start_tile_br); x++) {

		for (y = TileY(PathFinderInfo->start_tile_tl); y <= TileY(PathFinderInfo->start_tile_br); y++) {

			start_node.node.tile = TileXY(x, y);

	// Set the user_data to the PathFinderInfo

	aystar->user_target = PathFinderInfo;

	// Set the start node

	start_node.parent = NULL;

	start_node.node.user_data[0] = 0;

	start_node.node.tile = PathFinderInfo->start_tile_tl;

	// Now we add all the starting tiles

	for (x = TileX(PathFinderInfo->start_tile_tl); x <= TileX(PathFinderInfo->start_tile_br); x++) {

		for (y = TileY(PathFinderInfo->start_tile_tl); y <= TileY(PathFinderInfo->start_tile_br); y++) {

				}

			}

			// The tile can be connected

			aystar->neighbours[aystar->num_neighbours].tile = atile;

			aystar->neighbours[aystar->num_neighbours].user_data[0] = 0;

		}

	}

	// Next step, check for bridges and tunnels

	if (current->path.parent != NULL && current->path.node.user_data[0] == 0) {

		// First we get the dir from this tile and his parent

				// Try building the bridge..

				ret = AI_DoCommand(tile, new_tile, (0 << 8) + (MAX_BRIDGES / 2), DC_AUTO, CMD_BUILD_BRIDGE);

				if (CmdFailed(ret)) continue;

				// We can build a bridge here.. add him to the neighbours

				aystar->neighbours[aystar->num_neighbours].tile = new_tile;

				aystar->neighbours[aystar->num_neighbours].user_data[0] = AI_PATHFINDER_FLAG_BRIDGE + (dir << 8);

				// We can only have 12 neighbours, and we need 1 left for tunnels

				if (aystar->num_neighbours == 11) break;

			}

		}

		// Next, check for tunnels!

			// Now simply check if a tunnel can be build

			ret = AI_DoCommand(tile, (PathFinderInfo->rail_or_road ? 0 : 0x200), 0, DC_AUTO, CMD_BUILD_TUNNEL);

			tileh = GetTileSlope(_build_tunnel_endtile, NULL);

			if (CmdSucceeded(ret) && IsInclinedSlope(tileh)) {

				aystar->neighbours[aystar->num_neighbours].tile = _build_tunnel_endtile;

				aystar->neighbours[aystar->num_neighbours].user_data[0] = AI_PATHFINDER_FLAG_TUNNEL + (dir << 8);

			}

		}

	}

}

#ifndef AYSTAR_H

#define AYSTAR_H

#include "queue.h"

#include "tile_type.h"

//#define AYSTAR_DEBUG

enum {

	AYSTAR_FOUND_END_NODE,

	AYSTAR_EMPTY_OPENLIST,

	AYSTAR_STILL_BUSY,

enum{

	AYSTAR_INVALID_NODE = -1,

};

struct AyStarNode {

	TileIndex tile;

	uint user_data[2];

};

// The resulting path has nodes looking like this.

struct PathNode {

	AyStarNode node;

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

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

 * choice */

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

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

	} else {

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

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

static uint NPFTunnelCost(AyStarNode* current)

{

	TileIndex tile = current->tile;

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

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

		 * facing the tunnel exit */

		return NPF_TILE_LENGTH * (GetTunnelBridgeLength(current->tile, GetOtherTunnelEnd(current->tile)) + 1);

		/* @todo: Penalty for tunnels? */

{

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

}

static uint NPFSlopeCost(AyStarNode* current)

{

	/* Get center of tiles */

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

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

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

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

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

}

static uint NPFReservedTrackCost(AyStarNode *current)

{

	TileIndex tile = current->tile;

	TrackBits res = GetReservedTrackbits(tile);

	if (NPFGetFlag(current, NPF_FLAG_3RD_SIGNAL) || ((res & track) == TRACK_BIT_NONE && !TracksOverlap(res | track))) return 0;

	if (IsTileType(tile, MP_TUNNELBRIDGE)) {

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

			return  _settings_game.pf.npf.npf_rail_pbs_cross_penalty * (GetTunnelBridgeLength(tile, GetOtherTunnelBridgeEnd(tile)) + 1);

		}

	}

	return  _settings_game.pf.npf.npf_rail_pbs_cross_penalty;

}

}

static 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

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

		cost += _settings_game.pf.npf.npf_buoy_penalty; // A small penalty for going over buoys

	/* Check for slope */

	cost += NPFSlopeCost(current);

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

	 * represented by non-diagonal tracks */

		cost += _settings_game.pf.npf.npf_road_curve_penalty;

	NPFMarkTile(tile);

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

	return cost;

}

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

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

{

	TileIndex tile = current->tile;

	int32 cost = 0;

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

	OpenListNode new_node;

	/* Determine base length */

	switch (GetTileType(tile)) {

/** Find any safe and free tile. */

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

{

	const Vehicle *v = ((NPFFindStationOrTileData*)as->user_target)->v;

	return

			AYSTAR_FOUND_END_NODE : AYSTAR_DONE;

}

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

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

{

static const PathNode* FindSafePosition(PathNode *path, const Vehicle *v)

{

	/* If there is no signal, reserve the whole path. */

	PathNode *sig = path;

	for(; path->parent != NULL; path = path->parent) {

			sig = path;

		}

	}

	return sig;

}

 */

static void ClearPathReservation(const PathNode *start, const PathNode *end)

{

	bool first_run = true;

	for (; start != end; start = start->parent) {

		if (IsRailwayStationTile(start->node.tile) && first_run) {

		} else {

		}

		first_run = false;

	}

}

/**

		const PathNode *target = FindSafePosition(&current->path, v);

		ftd->node = target->node;

		/* If the target is a station skip to platform end. */

		if (IsRailwayStationTile(target->node.tile)) {

			uint len = GetStationByTile(target->node.tile)->GetPlatformLength(target->node.tile, dir);

			TileIndex end_tile = TILE_ADD(target->node.tile, (len - 1) * TileOffsByDiagDir(dir));

			/* Update only end tile, trackdir of a station stays the same. */

			ftd->node.tile = end_tile;

			SetRailwayStationPlatformReservation(target->node.tile, dir, true);

			SetRailwayStationReservation(target->node.tile, false);

		} else {

		}

		for (const PathNode *cur = target; cur->parent != NULL; cur = cur->parent) {

				/* Reservation failed, undo. */

				ClearPathReservation(target, cur);

				return;

			}

		}

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

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

{

	/* We leave src_tile on track src_trackdir in direction src_exitdir */

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

	DiagDirection src_exitdir = TrackdirToExitdir(src_trackdir);

	/* Is src_tile valid, and can be used?

	 * When choosing track on a junction src_tile is the tile neighboured to the junction wrt. exitdir.

	 * But we must not check the validity of this move, as src_tile is totally unrelated to the move, if a roadvehicle reversed on a junction. */

	 * far, is shorter than the manhattan distance. This will obviously

	 * always find the closest depot. It will probably be most efficient

	 * for ships, since the heuristic will not be to far off then. I hope.

	 */

	Queue depots;

	int r;

	NPFFoundTargetData result;

	NPFFindStationOrTileData target;

	AyStarNode start;

	Depot* current;

	Depot *depot;