// Checks if a tile 'a' is between the tiles 'b' and 'c'

#define TILES_BETWEEN(a, b, c) (TileX(a) >= TileX(b) && TileX(a) <= TileX(c) && TileY(a) >= TileY(b) && TileY(a) <= TileY(c))

// Check if the current tile is in our end-area

{

	Ai_PathFinderInfo *PathFinderInfo = (Ai_PathFinderInfo*)aystar->user_target;

	// It is not allowed to have a station on the end of a bridge or tunnel ;)

    			return AYSTAR_FOUND_END_NODE;

	return AYSTAR_DONE;

}

// Calculates the hash

	// Get the best node from OpenList

	OpenListNode *current = AyStarMain_OpenList_Pop(aystar);

	// If empty, drop an error

	if (current == NULL) return AYSTAR_EMPTY_OPENLIST;

	// Check for end node and if found, return that code

		if (aystar->FoundEndNode != NULL)

			aystar->FoundEndNode(aystar, current);

		free(current);

		return AYSTAR_FOUND_END_NODE;

	}

/*

 * This function is called to check if the end-tile is found

 *  return values can be:

 *	AYSTAR_FOUND_END_NODE : indicates this is the end tile

 *	AYSTAR_DONE : indicates this is not the end tile (or direction was wrong)

 */

/*

 * This function is called to calculate the G-value for AyStar Algorithm.

 *  return values can be:

 *	AYSTAR_INVALID_NODE : indicates an item is not valid (e.g.: unwalkable)

 *	Any value >= 0 : the g-value for this tile

		default:

			break;

	}

	/* Determine extra costs */

	if (IsTileType(tile, MP_RAILWAY) && (_map5[tile] & 0xC0) == 0x40) {

		if ((_map2[tile] & _signal_along_trackdir[trackdir]) == 0) {

			/* Signal facing us is red */

				/* Penalize the first signal we

				 * encounter, if it is red */

				cost += _patches.npf_rail_firstred_penalty;

			}

		}

	}

	/* Check for slope */

	cost += NPFSlopeCost(current);

	/* Check for turns */

	//TODO

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

	#endif

	return cost;

}

/* Will find any depot */

	if (IsTileDepotType(tile, as->user_data[NPF_TYPE]))

		return AYSTAR_FOUND_END_NODE;

	else

		return AYSTAR_DONE;

}

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

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

	 * is correct */

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

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

		return AYSTAR_DONE;

}

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

 * Will fill the contents of the NPFFoundTargetData using

 * AyStarNode[NPF_TRACKDIR_CHOICE].

 */

	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

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

	byte src_trackdir = current->path.node.direction;

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

	byte src_exitdir = _trackdir_to_exitdir[src_trackdir];

	FindLengthOfTunnelResult flotr;

	TileIndex dst_tile;

	/* Initialize Start Node(s) */

	start1->user_data[NPF_TRACKDIR_CHOICE] = 0xff;

	start1->user_data[NPF_NODE_FLAGS] = 0;

	_npf_aystar.addstart(&_npf_aystar, start1);

	if (start2) {

		start2->user_data[NPF_TRACKDIR_CHOICE] = 0xff;

		_npf_aystar.addstart(&_npf_aystar, start2);

	}

	/* Initialize result */

	result.best_bird_dist = (uint)-1;

	result.best_path_dist = (uint)-1;

};

enum { /* Indices into AyStarNode.userdata[] */

	NPF_TRACKDIR_CHOICE = 0, /* The trackdir chosen to get here */

	NPF_NODE_FLAGS,

};

typedef struct NPFFoundTargetData { /* Meant to be stored in AyStar.userpath */

	uint best_bird_dist; /* The best heuristic found. Is 0 if the target was found */

	uint best_path_dist; /* The shortest path. Is (uint)-1 if no path is found */

	byte best_trackdir; /* The trackdir that leads to the shortest path/closest birds dist */

	AyStarNode node; /* The node within the target the search led us to */

/* Will search from the given tile and direction, for a route to the given

 * station for the given transport type. See the declaration of

 * NPFFoundTargetData above for the meaning of the result. */

NPFFoundTargetData NPFRouteToStationOrTile(TileIndex tile, byte trackdir, NPFFindStationOrTileData* target, TransportType type, Owner owner);

/* Will search as above, but with two start nodes, the second being the

NPFFoundTargetData NPFRouteToStationOrTileTwoWay(TileIndex tile1, byte trackdir1, TileIndex tile2, byte trackdir2, NPFFindStationOrTileData* target, TransportType type, Owner owner);

/* Will search a route to the closest depot. */

/* Search using breadth first. Good for little track choice and inaccurate

 * heuristic, such as railway/road */

/* Search by trying each depot in order of Manhattan Distance. Good for lots

 * of choices and accurate heuristics, such as water. */

NPFFoundTargetData NPFRouteToDepotTrialError(TileIndex tile, byte trackdir, TransportType type, Owner owner);

void NPFFillWithOrderData(NPFFindStationOrTileData* fstd, Vehicle* v);

/*

 * Some tables considering tracks, directions and signals.

 * XXX: Better place to but these?

 */

/**

	* station on another platform and exit the station on the right side

	* again, just because the sign at the right side was red. If we take

	* a typical 5 length station, this detour is 10 or 11 tiles (not

	* sure), so we set the default penalty at 10 (the station tile

	* penalty will further prevent this */

	{"npf_rail_firstred_penalty",		SDT_UINT32, (void*)(10 * NPF_TILE_LENGTH),	&_patches.npf_rail_firstred_penalty,		NULL},

	/* When a train plans a route over a station tile, this penalty is

	* applied. We want that trains plan a route around a typical, 4x5

	* station, which means two tiles to the right, and two tiles back to

	* the left around it, or 5 tiles of station through it. If we assign

	* a penalty of 1 tile for every station tile passed, the route will

	* be around it.

		InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);

	/* Check if we were approaching a rail/road-crossing */

	{

		TileIndex tile = v->tile;

		int t;

		t = v->direction >> 1;

		if (!(v->direction & 1) && v->u.rail.track != _state_dir_table[t]) {

			t = (t - 1) & 3;

		}

		/* Calculate next tile */

		tile += TileOffsByDir(t);

	bool ainew_active;  // Is the new AI active?

	/* New Path Finding */

	bool new_pathfinding_all; /* Use the newest pathfinding algorithm for all */

	uint32 npf_rail_firstred_penalty; /* The penalty for when the first signal is red */

	uint32 npf_rail_station_penalty; /* The penalty for station tiles */

	uint32 npf_rail_slope_penalty; /* The penalty for sloping upwards */

	bool population_in_label; // Show the population of a town in his label?

} Patches;