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 = TILE_XY(x, y);

		}

	}

			if (!(IsTileType(TILE_XY(x, y), MP_CLEAR) || IsTileType(TILE_XY(x, y), MP_TREES))) continue;

			if (!TestCanBuildStationHere(TILE_XY(x, y), TEST_STATION_NO_DIR)) continue;

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

		}

	}

}

// Adds a node to the OpenList

//  It makes a copy of node, and puts the pointer of parent in the struct

{

	// Add a new Node to the OpenList

	OpenListNode* new_node = malloc(sizeof(OpenListNode));

		aystar->OpenListQueue.push(&aystar->OpenListQueue, check, new_f);

	} else {

		// A new node, add him to the OpenList

	}

	return AYSTAR_DONE;

 * if wanted. You should make sure that clear() is called before adding nodes

 * if the AyStar has been used before (though the normal main loop calls

 * clear() automatically when the algorithm finishes

 */

#ifdef AYSTAR_DEBUG

	printf("[AyStar] Starting A* Algorithm from node (%d, %d, %d)\n",

		TileX(start_node->tile), TileY(start_node->tile), start_node->direction);

#endif

}

void init_AyStar(AyStar* aystar, Hash_HashProc hash, uint num_buckets) {

typedef void AyStar_FoundEndNode(AyStar *aystar, OpenListNode *current);

// For internal use, see aystar.c

typedef int AyStar_Main(AyStar *aystar);

typedef int AyStar_Loop(AyStar *aystar);

typedef int AyStar_CheckTile(AyStar *aystar, AyStarNode *current, OpenListNode *parent);

};

int AyStarMain_Main(AyStar *aystar);

int AyStarMain_Loop(AyStar *aystar);

int AyStarMain_CheckTile(AyStar *aystar, AyStarNode *current, OpenListNode *parent);

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

	TileIndex tile = current->tile;

	int32 cost = 0;

	/* Determine base length */

	switch (GetTileType(tile)) {

		case MP_TUNNELBRIDGE:

	TileIndex tile = current->tile;

	byte trackdir = current->direction;

	int32 cost = 0;

	OpenListNode new_node;

	/* Determine base length */

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

	//TODO

/* Will find any depot */

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

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

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

		return AYSTAR_FOUND_END_NODE;

	else

			else /* Train or road depot. Direction is stored the same for both, in map5 */

				exitdir = GetDepotDirection(src_tile, type);

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

/*

 * Plan a route to the specified target (which is checked by target_proc),

 * from start1 and if not NULL, from start2 as well. The type of transport we

 * When we are looking for one specific target (optionally multiple tiles), we

 * should use a good heuristic to perform aystar search. When we search for

 * multiple targets that are spread around, we should perform a breadth first

 * search by specifiying CalcZero as our heuristic.

 */

	int r;

	NPFFoundTargetData result;

	/* Initialize Start Node(s) */

	start1->user_data[NPF_TRACKDIR_CHOICE] = 0xff;

	start1->user_data[NPF_NODE_FLAGS] = 0;

	if (start2) {

		start2->user_data[NPF_TRACKDIR_CHOICE] = 0xff;

		start2->user_data[NPF_NODE_FLAGS] = 0;

		NPFSetFlag(start2, NPF_FLAG_REVERSE, true);

	}

	/* Initialize result */

	start1.tile = tile1;

	start2.tile = tile2;

	start1.direction = trackdir1;

	start2.direction = trackdir2;

}

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

	/* We set this in case the target is also the start tile, we will just

	 * return a not found then */

}

NPFFoundTargetData NPFRouteToDepotBreadthFirst(TileIndex tile, byte trackdir, TransportType type, Owner owner) {

}

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

		 * return a not found then */

		start.user_data[NPF_TRACKDIR_CHOICE] = 0xff;

		start.user_data[NPF_NODE_FLAGS] = 0;

		/* Initialize result */

		result.best_bird_dist = (uint)-1;

	NPF_HASH_HALFMASK = (1 << NPF_HASH_HALFBITS) - 1

};

typedef struct NPFFindStationOrTileData { /* Meant to be stored in AyStar.targetdata */

	TileIndex dest_coords; /* An indication of where the station is, for heuristic purposes, or the target tile */

	int station_index; /* station index we're heading for, or -1 when we're heading for a tile */

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

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

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

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

	 * sure that it has a minimal impact on the pathfinding, only when two

	 * paths have equal length it will make a difference */

	{"npf_rail_curve_penalty",      SDT_UINT32, (void*)(1),                     &_patches.npf_rail_curve_penalty,       NULL},

	{"npf_buoy_penalty",            SDT_UINT32, (void*)(2 * NPF_TILE_LENGTH),   &_patches.npf_buoy_penalty,             NULL},

	/* This penalty is applied when a ship makes a turn. It is bigger than the

	 * rail curve penalty, since ships (realisticly) have more trouble with

	uint best_length;

	uint tile;

	byte owner;

} TrainFindDepotData;

static bool TrainFindDepotEnumProc(uint tile, TrainFindDepotData *tfdd, int track, uint length, byte *state)

	tfdd.owner = v->owner;

	tfdd.best_length = (uint)-1;

	if (IsTileDepotType(tile, TRANSPORT_RAIL)){

		tfdd.tile = tile;

	if (_patches.new_pathfinding_all) {

		NPFFoundTargetData ftd;

		byte trackdir = GetVehicleTrackdir(v);

		assert (trackdir != 0xFF);

		if (ftd.best_bird_dist == 0) {

			/* Found target */

			tfdd.tile = ftd.node.tile;

			/* Our caller expects a number of tiles, so we just approximate that

			* number by this. It might not be completely what we want, but it will

			* work for now :-) We can possibly change this when the old pathfinder

			* is removed. */

		}

	} else if (!_patches.new_depot_finding) {

		// search in all directions

		if (!(v->direction & 1) && v->u.rail.track != _state_dir_table[i]) { i = (i - 1) & 3; }

		NewTrainPathfind(tile, i, (TPFEnumProc*)TrainFindDepotEnumProc, &tfdd, NULL);

		if (tfdd.best_length == (uint)-1){

			// search in backwards direction

			i = (v->direction^4) >> 1;

			if (!(v->direction & 1) && v->u.rail.track != _state_dir_table[i]) { i = (i - 1) & 3; }

		v->current_order.flags = OF_NON_STOP | OF_FULL_LOAD;

		v->current_order.station = GetDepotByTile(tfdd.tile)->index;

		InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, STATUS_BAR);

	}

	return 0;

		NPFFillWithOrderData(&fstd, v);

		trackdir = GetVehicleTrackdir(v);

		assert(trackdir != 0xff);

		assert(trackdir_rev != 0xff);

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

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

	uint32 npf_rail_curve_penalty; /* The penalty for curves */

	uint32 npf_buoy_penalty; /* The penalty for going over (through) a buoy */

	uint32 npf_water_curve_penalty; /* The penalty for curves */

/* tunnelbridge */

#define MAX_BRIDGES 13

#define NPF_TILE_LENGTH 100

/* Autoreplace vehicle stuff*/