}

}

/** Build a bus or truck stop

 * @param tile tile to build the stop at

 * @param flags operation to perform

 * @param p1 entrance direction (DiagDirection)

 * @param p2 bit 0: 0 for Bus stops, 1 for truck stops

 *           bit 1: 0 for normal, 1 for drive-through

 */

int32 CmdBuildRoadStop(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)

{

 * the sprite to be displayed. This variable contains various information:<p>

 * <ul><li> SPRITE_WIDTH is the number of bits used for the actual sprite to be displayed.

 * This always starts at bit 0.</li>

 * <li> TRANSPARENT_BIT is the bit number which toggles sprite transparency</li>

 * <li> RECOLOR_BIT toggles the recoloring system</li>

 * <li> PALETTE_SPRITE_WIDTH and PALETTE_SPRITE_START determine the position and number of

 */

enum SpriteSetup {

	TRANSPARENT_BIT = 31,       ///< toggles transparency in the sprite

	RECOLOR_BIT = 30,           ///< toggles recoloring in the sprite

	OFFSET_BIT = 29,

{

	return town->xy != 0;

}

/**

 * Check if a TownID is valid.

 * @return true if it exists

 */

static inline bool IsValidTownID(TownID index)

{

	return index < GetTownPoolSize() && IsValidTown(GetTown(index));

}

	return true;

}

/**

 * Search callback function for TownActionBuildStatue

 * @param town_id The town_id for which we want a statue

 * @return the result of the test

 */

static bool SearchTileForStatue(TileIndex tile, uint32 town_id)

{

	return DoBuildStatueOfCompany(tile, town_id);

/**

 * Deletes/Clears the last wagon of a crashed train. It takes the engine of the

 * train, then goes to the last wagon and deletes that. Each call to this function

 * will remove the last wagon of a crashed train. If this wagon was on a crossing,

 * or inside a tunnel, recalculate the signals as they might need updating

 */

static void DeleteLastWagon(Vehicle *v)

{

	/* Go to the last wagon and delete the link pointing there

	 * *u is then the one-before-last wagon, and *v the last

	 * one which will physicially be removed */

	return cost;

}

/** Build Tunnel.

 * @param flags type of operation

 * @param p1 railtype, 0x200 for road tunnel

 * @param p2 unused

 */

int32 CmdBuildTunnel(TileIndex start_tile, uint32 flags, uint32 p1, uint32 p2)

{

#include "genworld.h"

#include "bridge.h"

/** Destroy a HQ.

 * During normal gameplay you can only implicitely destroy a HQ when you are

 * rebuilding it. Otherwise, only water can destroy it.

 * @param flags docommand flags of calling function

 */

static int32 DestroyCompanyHQ(PlayerID pid, uint32 flags)

{

	Player* p = GetPlayer(pid);

	SET_EXPENSES_TYPE(EXPENSES_PROPERTY);

bool CanRefitTo(EngineID engine_type, CargoID cid_to)

{

	return HASBIT(EngInfo(engine_type)->refit_mask, cid_to);

}

/** Find the first cargo type that an engine can be refitted to.

 * @return A climate dependent cargo type. CT_INVALID is returned if not refittable.

 */

CargoID FindFirstRefittableCargo(EngineID engine_type)

{

	uint32 refit_mask = EngInfo(engine_type)->refit_mask;

	}

	return CT_INVALID;

}

/** Learn the price of refitting a certain engine

* @return Price for refitting

*/

int32 GetRefitCost(EngineID engine_type)

{

	int32 base_cost = 0;

	*engine_list = ReallocT(*engine_list, *engine_list_length);

}

/** Generates a list of vehicles inside a depot

 * Will enlarge allocated space for the list if they are too small, so it's ok to call with (pointer to NULL array, pointer to uninitised uint16, pointer to 0)

 * If one of the lists is not needed (say wagons when finding ships), all the pointers regarding that list should be set to NULL

 * @param tile The tile the depot is located in

 * @param ***engine_list Pointer to a pointer to an array of vehicles in the depot (old list is freed and a new one is malloced)

 * @param *engine_list_length Allocated size of engine_list. Needs to be set to 0 when engine_list points to a NULL array

 * @param *engine_count The number of engines stored in the list

 * @param ***wagon_list Pointer to a pointer to an array of free wagons in the depot (old list is freed and a new one is malloced)

 * @param *wagon_list_length Allocated size of wagon_list. Needs to be set to 0 when wagon_list points to a NULL array

/**

* @param sort_list list to store the list in. Either NULL or the length length_of_array tells

* @param length_of_array informs the length allocated for sort_list. This is not the same as the number of vehicles in the list. Needs to be 0 when sort_list is NULL

* @param type type of vehicle

* @param owner PlayerID of owner to generate a list for

* @param window_type tells what kind of window the list is for. Use the VLW flags in vehicle_gui.h

* @return the number of vehicles added to the list

*/

uint GenerateVehicleSortList(const Vehicle ***sort_list, uint16 *length_of_array, byte type, PlayerID owner, uint32 index, uint16 window_type)

{

	const byte subtype = (type != VEH_AIRCRAFT) ? (byte)Train_Front : (byte)AIR_AIRCRAFT;

/** send all vehicles of type to depots

 * @param type type of vehicle

 * @param flags the flags used for DoCommand()

 * @param service should the vehicles only get service in the depots

 * @param owner PlayerID of owner of the vehicles to send

 * @return 0 for success and CMD_ERROR if no vehicle is able to go to depot

 */

int32 SendAllVehiclesToDepot(byte type, uint32 flags, bool service, PlayerID owner, uint16 vlw_flag, uint32 id)

{

	const Vehicle **sort_list = NULL;

	uint n, i;

	return list;

}

/** Draw the list of available refit options for a consist.

 * Draw the list and highlight the selected refit option (if any)

 * @param sel selected refit cargo-type in the window

 * @return the refit option that is hightlighted, NULL if none

 */

static RefitOption *DrawVehicleRefitWindow(const RefitList *list, int sel, uint pos, uint rows, uint delta)

{

	RefitOption *refit = list->items;

	RefitOption *selected = NULL;

 * in the case of a line (HT_RAIL, HT_LINE):  DIR_NE, DIR_NW, DIR_N, DIR_E

 * in the case of a rect (HT_RECT, HT_POINT): DIR_S, DIR_E

 * For example dragging a rectangle area from south to north should be swapped to

 * north-south (DIR_S) to obtain the same results with less code. This is what

 * the return value signifies.

 * @param style HighLightStyle dragging style

static bool SwapDirection(HighLightStyle style, TileIndex start_tile, TileIndex end_tile)

{

	uint start_x = TileX(start_tile);

	uint start_y = TileY(start_tile);

	uint end_x = TileX(end_tile);

	uint end_y = TileY(end_tile);

Trackdir YapfChooseShipTrack(Vehicle *v, TileIndex tile, DiagDirection enterdir, TrackBits tracks);

/** Finds the best path for given road vehicle.

 * @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         the best trackdir for next turn or INVALID_TRACKDIR if the path could not be found

 */

Trackdir YapfChooseRoadTrack(Vehicle *v, TileIndex tile, DiagDirection enterdir);

/** Finds the best path for given train.

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

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

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

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

 */

Trackdir YapfChooseRailTrack(Vehicle *v, TileIndex tile, DiagDirection enterdir, TrackBits tracks, bool *path_not_found);

/** Used by RV multistop feature to find the nearest road stop that has a free slot.

 * @param v      RV (its current tile will be the origin)

/** Used when user sends RV to the nearest depot or if RV needs servicing.

 * Returns the nearest depot (or NULL if depot was not found).

 */

Depot* YapfFindNearestRoadDepot(const Vehicle *v);

/** Used when user sends train to the nearest depot or if train needs servicing.

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

 *                  was reached and no depot was seen)

 * @return       the true if depot was found.

 */

bool YapfFindNearestRailDepotTwoWay(Vehicle *v, int max_distance, int reverse_penalty, TileIndex* depot_tile, bool* reversed);

/** Returns true if it is better to reverse the train before leaving station */

bool YapfCheckReverseTrain(Vehicle* v);