path_found = (ftd.best_bird_dist == 0);

	return ftd.best_trackdir;

}

/*** Ships ***/

{

	NPFFindStationOrTileData fstd;

	Trackdir trackdir = v->GetVehicleTrackdir();

	assert(trackdir != INVALID_TRACKDIR); // Check that we are not in a depot

	NPFFillWithOrderData(&fstd, v);

	NPFFoundTargetData ftd = NPFRouteToStationOrTile(tile - TileOffsByDiagDir(enterdir), trackdir, true, &fstd, TRANSPORT_WATER, 0, v->owner, INVALID_RAILTYPES);

	/* If ftd.best_bird_dist is 0, we found our target and ftd.best_trackdir contains

	 * the direction we need to take to get there, if ftd.best_bird_dist is not 0,

	 * we did not find our target, but ftd.best_trackdir contains the direction leading

	 * to the tile closest to our target. */

	if (ftd.best_trackdir == 0xff) return INVALID_TRACK;

	return TrackdirToTrack(ftd.best_trackdir);

}

/*** Trains ***/

/**

 * Finds the best path for given ship using NPF.

 * @param v        the ship that needs to find a path

 * @param tile     the tile to find the path from (should be next tile the ship is about to enter)

 * @param enterdir diagonal direction which the ship will enter this new tile from

 * @param tracks   available tracks on the new tile (to choose from)

 * @return         the best trackdir for next turn or INVALID_TRACK if the path could not be found

 */

/**

 * Used when user sends train to the nearest depot or if train needs servicing using NPF

 * @param v            train that needs to go to some depot

 * @param max_penalty  max max_penalty (in pathfinder penalty) from the current train position

 *                     (used also as optimization - the pathfinder can stop path finding if max_penalty

/**

 * returns the track to choose on the next tile, or -1 when it's better to

 * reverse. The tile given is the tile we are about to enter, enterdir is the

 * direction in which we are entering the tile

 */

{

	assert(IsValidDiagDirection(enterdir));

	TileIndex tile2 = TILE_ADD(tile, -TileOffsByDiagDir(enterdir));

	Track track;

		if (distr != UINT_MAX) distr++; // penalty for reversing

	}

	/* And if we would not reverse? */

	uint dist = FindShipTrack(v, tile, enterdir, tracks, 0, &track);

	if (dist <= distr) return track;

	return INVALID_TRACK; // We could better reverse

}

/**

 * Finds the best path for given ship using OPF.

 * @param v        the ship that needs to find a path

 * @param tile     the tile to find the path from (should be next tile the ship is about to enter)

 * @param enterdir diagonal direction which the ship will enter this new tile from

 * @param tracks   available tracks on the new tile (to choose from)

 * @return         the best trackdir for next turn or INVALID_TRACK if the path could not be found

 */

#endif /* OPF_SHIP_H */

/**

 * Finds the best path for given ship using YAPF.

 * @param v        the ship that needs to find a path

 * @param tile     the tile to find the path from (should be next tile the ship is about to enter)

 * @param enterdir diagonal direction which the ship will enter this new tile from

 * @param tracks   available tracks on the new tile (to choose from)

 * @return         the best trackdir for next turn or INVALID_TRACK if the path could not be found

 */

/**

 * Finds the best path for given road vehicle using YAPF.

 * @param v         the RV that needs to find a path

 * @param tile      the tile to find the path from (should be next tile the RV is about to enter)

 * @param enterdir  diagonal direction which the RV will enter this new tile from

	/** return debug report character to identify the transportation type */

	FORCEINLINE char TransportTypeChar() const

	{

		return 'w';

	}

	{

		/* handle special case - when next tile is destination tile */

		if (tile == v->dest_tile) {

			/* convert tracks to trackdirs */

			TrackdirBits trackdirs = (TrackdirBits)(tracks | ((int)tracks << 8));

			/* choose any trackdir reachable from enterdir */

		/* create pathfinder instance */

		Tpf pf;

		/* set origin and destination nodes */

		pf.SetOrigin(src_tile, trackdirs);

		pf.SetDestination(v->dest_tile, dest_trackdirs);

		/* find best path */

		Trackdir next_trackdir = INVALID_TRACKDIR; // this would mean "path not found"

		Node *pNode = pf.GetBestNode();

		if (pNode != NULL) {

			/* walk through the path back to the origin */

/* YAPF type 2 - uses TileIndex/DiagDirection as Node key, allows 90-deg turns */

struct CYapfShip2 : CYapfT<CYapfShip_TypesT<CYapfShip2, CFollowTrackWater    , CShipNodeListExitDir > > {};

/* YAPF type 3 - uses TileIndex/Trackdir as Node key, forbids 90-deg turns */

struct CYapfShip3 : CYapfT<CYapfShip_TypesT<CYapfShip3, CFollowTrackWaterNo90, CShipNodeListTrackDir> > {};

/** Ship controller helper - path finder invoker */

{

	/* default is YAPF type 2 */

	PfnChooseShipTrack pfnChooseShipTrack = CYapfShip2::ChooseShipTrack; // default: ExitDir, allow 90-deg

	/* check if non-default YAPF type needed */

	if (_settings_game.pf.forbid_90_deg) {

		pfnChooseShipTrack = &CYapfShip3::ChooseShipTrack; // Trackdir, forbid 90-deg

	} else if (_settings_game.pf.yapf.disable_node_optimization) {

		pfnChooseShipTrack = &CYapfShip1::ChooseShipTrack; // Trackdir, allow 90-deg

	}

	return (td_ret != INVALID_TRACKDIR) ? TrackdirToTrack(td_ret) : INVALID_TRACK;

}

/**

 * returns the track to choose on the next tile, or -1 when it's better to

 * reverse. The tile given is the tile we are about to enter, enterdir is the

 * direction in which we are entering the tile

 */

{

	assert(IsValidDiagDirection(enterdir));

	switch (_settings_game.pf.pathfinder_for_ships) {

		default: NOT_REACHED();

	}

}

static const Direction _new_vehicle_direction_table[] = {

	DIR_N , DIR_NW, DIR_W , INVALID_DIR,

	DIR_NE, DIR_N , DIR_SW, INVALID_DIR,

	DIR_E , DIR_SE, DIR_S