}

/**

 * Needed for SP; we need to delay DoCommand with 1 tick, because else events

 *  will make infinite loops (AIScript).

 */

{

	AICommand *com;

	if (_ai_player[player].queue_tail == NULL) {

		/* There is no item in the queue yet, create the queue */

		_ai_player[player].queue = malloc(sizeof(AICommand));

	_iconsole_cmdline.caretxoffs = 0;

	SetWindowDirty(_iconsole_win);

}

static inline void IConsoleResetHistoryPos(void) {_iconsole_historypos = ICON_HISTORY_SIZE - 1;}

// ** console window ** //

static void IConsoleWndProc(Window* w, WindowEvent* e)

{

	switch (e->event) {

		case WE_PAINT: {

			int i = _iconsole_scroll;

/**

 * Add the entered line into the history so you can look it back

 * scroll, etc. Put it to the beginning as it is the latest text

 * @param cmd Text to be entered into the 'history'

 */

{

	free(_iconsole_history[ICON_HISTORY_SIZE - 1]);

	memmove(&_iconsole_history[1], &_iconsole_history[0], sizeof(_iconsole_history[0]) * (ICON_HISTORY_SIZE - 1));

	_iconsole_history[0] = strdup(cmd);

	IConsoleResetHistoryPos();

}

/**

 * Navigate Up/Down in the history of typed commands

 * @param direction Go further back in history (+1), go to recently typed commands (-1)

 */

{

	int i = _iconsole_historypos + direction;

	// watch out for overflows, just wrap around

	if (i < 0) i = ICON_HISTORY_SIZE - 1;

	if (i >= ICON_HISTORY_SIZE) i = 0;

 * An alias is just another name for a command, or for more commands

 * Execute it as well.

 * @param *alias is the alias of the command

 * @param tokencount the number of parameters passed

 * @param *tokens are the parameters given to the original command (0 is the first param)

 */

{

	const char *cmdptr;

	char *aliases[ICON_MAX_ALIAS_LINES], aliasstream[ICON_MAX_STREAMSIZE];

	int i;

	uint a_index, astream_i;

void IConsoleClearBuffer(void);

void IConsoleResize(void);

void IConsoleSwitch(void);

void IConsoleClose(void);

void IConsoleOpen(void);

// ** console output ** //

void IConsolePrint(uint16 color_code, const char *string);

void CDECL IConsolePrintF(uint16 color_code, const char *s, ...);

void IConsoleDebug(const char *string);

void IConsoleWarning(const char *string);

void IConsoleError(const char *string);

void IConsoleVarPrintGetValue(const IConsoleVar *var);

void IConsoleVarPrintSetValue(const IConsoleVar *var);

// *** Parser *** //

void IConsoleCmdExec(const char *cmdstr);

void IConsoleVarExec(const IConsoleVar *var, byte tokencount, char *token[]);

// ** console std lib (register ingame commands/aliases/variables) ** //

void IConsoleStdLibRegister(void);

// ** Hooking code ** //

void IConsoleCmdHookAdd(const char *name, IConsoleHookTypes type, IConsoleHook *proc);

		return _engine_name_strings[engine];

	ttd_strlcpy(_userstring, _engine_custom_names[engine], lengthof(_userstring));

	return STR_SPEC_USERSTRING;

}

{

	Player *p = GetPlayer(player);

	assert(e->railtype < RAILTYPE_END);

	SETBIT(e->player_avail, player);

	SETBIT(p->avail_railtypes, e->railtype);

void DrawTrainEngine(int x, int y, EngineID engine, uint32 image_ormod);

void DrawRoadVehEngine(int x, int y, EngineID engine, uint32 image_ormod);

void DrawShipEngine(int x, int y, EngineID engine, uint32 image_ormod);

void DrawAircraftEngine(int x, int y, EngineID engine, uint32 image_ormod);

void LoadCustomEngineNames(void);

void DeleteCustomEngineNames(void);

bool IsEngineBuildable(uint engine, byte type);

enum {

bool CheckIfAuthorityAllows(TileIndex tile);

Town *ClosestTownFromTile(TileIndex tile, uint threshold);

void ChangeTownRating(Town *t, int add, int max);

uint GetRoadBitsByTile(TileIndex tile);

int GetTownRadiusGroup(const Town *t, TileIndex tile);

void ShowNetworkChatQueryWindow(byte desttype, byte dest);

void ShowNetworkGiveMoneyWindow(byte player);

void ShowNetworkNeedGamePassword(void);

void ShowNetworkNeedCompanyPassword(void);

int FindFirstBit(uint32 x);

/* settings_gui.c */

void ShowGameOptions(void);

void ShowGameDifficulty(void);

void ShowPatchesSelection(void);

void ShowNewgrf(void);

/* graph_gui.c */

void ShowOperatingProfitGraph(void);

void ShowIncomeGraph(void);

void ShowDeliveredCargoGraph(void);

void ShowPerformanceHistoryGraph(void);

void ShowPlayerAircraft(PlayerID player, StationID station);

/* terraform_gui.c */

void ShowTerraformToolbar(void);

void PlaceProc_DemolishArea(TileIndex tile);

void PlaceProc_LevelLand(TileIndex tile);

bool GUIPlaceProcDragXY(const WindowEvent *we);

enum { // max 32 - 4 = 28 types

	GUI_PlaceProc_DemolishArea    = 0 << 4,

	GUI_PlaceProc_LevelArea       = 1 << 4,

	INDUSTRY_POOL_MAX_BLOCKS      = 8000,

};

/**

 * Called if a new block is added to the industry-pool

 */

{

	Industry *i;

	FOR_ALL_INDUSTRIES_FROM(i, start_item) i->index = start_item++;

}

// So we don't make too much typos ;)

#define MY_CLIENT DEREF_CLIENT(0)

static uint32 last_ack_frame;

// **********

// Sending functions

//   DEF_CLIENT_SEND_COMMAND has no parameters

// **********

extern const SettingDesc patch_settings[];

// This is a TEMPORARY solution to get the patch-settings

//  to the client. When the patch-settings are saved in the savegame

//  this should be removed!!

{

	const SettingDesc *item;

	item = patch_settings;

	while (item->name != NULL) {

#include "station.h"

#include "settings.h"

#include "variables.h"

// This file handles all the server-commands

void NetworkPopulateCompanyInfo(void);

// Is the network enabled?

// **********

// Sending functions

//   DEF_SERVER_SEND_COMMAND has parameter: NetworkClientState *cs

extern const SettingDesc patch_settings[];

// This is a TEMPORARY solution to get the patch-settings

//  to the client. When the patch-settings are saved in the savegame

//  this should be removed!!

{

	const SettingDesc *item;

	Packet *p = NetworkSend_Init(PACKET_SERVER_MAP);

	NetworkSend_uint8(p, MAP_PACKET_PATCH);

	// Now send all the patch-settings in a pretty order..

	}

	return true;

}

// Handle the local command-queue

	CommandPacket *cp;

	while ( (cp = cs->command_queue) != NULL) {

		SEND_COMMAND(PACKET_SERVER_COMMAND)(cs, cp);

		cs->command_queue = cp->next;

	ADVERTISE_NORMAL_INTERVAL = 450,	// interval between advertising in days

	ADVERTISE_RETRY_INTERVAL = 5,			// readvertise when no response after this amount of days

	ADVERTISE_RETRY_TIMES = 3					// give up readvertising after this much failed retries

};

#define DEF_UDP_RECEIVE_COMMAND(type) void NetworkPacketReceive_ ## type ## _command(Packet *p, struct sockaddr_in *client_addr)

static NetworkClientState _udp_cs;

DEF_UDP_RECEIVE_COMMAND(PACKET_UDP_CLIENT_FIND_SERVER)

{

	Packet *packet;

// If this fails, check the array above with network_data.h

assert_compile(lengthof(_network_udp_packet) == PACKET_UDP_END);

{

	byte type;

	/* Fake a client, so we can see when there is an illegal packet */

	_udp_cs.socket = INVALID_SOCKET;

	_udp_cs.quited = false;

		DEBUG(net, 0)("[NET][UDP] Received invalid packet type %d", type);

	}

}

// Send a packet over UDP

{

	int res;

	// Put the length in the buffer

	p->buffer[0] = p->size & 0xFF;

	p->buffer[1] = p->size >> 8;

		free(p);

		p = NULL;

	}

}

// Broadcast to all ips

{

	int i;

	struct sockaddr_in out_addr;

	byte *bcptr;

	uint32 bcaddr;

	Packet *p;

}

/** Handle the user-messages sent to us

 * @param message message sent

 */

{

	switch (message) {

		case MSG_OTTD_SAVETHREAD_START: SaveFileStart(); break;

		case MSG_OTTD_SAVETHREAD_DONE:  SaveFileDone(); break;

		case MSG_OTTD_SAVETHREAD_ERROR: SaveFileError(); break;

		default: NOT_REACHED();

bool CheckOrders(uint data_a, uint data_b);

void DeleteVehicleOrders(Vehicle *v);

bool IsOrderListShared(const Vehicle *v);

void AssignOrder(Order *order, Order data);

bool CheckForValidOrders(const Vehicle* v);

Order UnpackOldOrder(uint16 packed);

#endif /* ORDER_H */

/**

 *

 * Unpacks a order from savegames with version 4 and lower

 *

 */

{

	Order order;

	order.type    = GB(packed, 0, 4);

	order.flags   = GB(packed, 4, 4);

	order.station = GB(packed, 8, 8);

	order.next    = NULL;

int8 SaveHighScoreValue(const Player *p);

int8 SaveHighScoreValueNetwork(void);

void InitialiseEngineReplacement(Player *p);

EngineID EngineReplacement(const Player *p, EngineID engine);

bool EngineHasReplacement(const Player *p, EngineID engine);

#endif /* PLAYER_H */

	DeleteName(p->name_1);

	DeleteName(p->president_name_1);

	p->name_1 = 0;

	p->president_name_1 = 0;

}

/** Change engine renewal parameters

 * @param x,y unused

 * @param p1 bits 0-3 command

 * - p1 = 0 - change auto renew bool

 * - p1 = 1 - change auto renew months

 * - p1 = 2 - change auto renew money

 * @param p Player.

 * @param old_engine The original engine type.

 * @param new_engine The replacement engine type.

 * @param flags The calling command flags.

 * @return 0 on success, CMD_ERROR on failure.

 */

{

	if (flags & DC_EXEC) p->engine_replacement[old_engine] = new_engine;

	return 0;

}

/**

 * Remove an engine replacement for the player.

 * @param p Player.

 * @param engine The original engine type.

 * @param flags The calling command flags.

 * @return 0 on success, CMD_ERROR on failure.

 */

{

	if (flags & DC_EXEC) p->engine_replacement[engine] = INVALID_ENGINE;

	return 0;

}

// Save/load of players

   * always overlap unless they are lower & upper or right & left. */

  if ((bits == (TRACK_BIT_UPPER|TRACK_BIT_LOWER)) || (bits == (TRACK_BIT_LEFT | TRACK_BIT_RIGHT)))

    return false;

  return true;

}

void DrawTrainDepotSprite(int x, int y, int image, RailType railtype);

void DrawDefaultWaypointSprite(int x, int y, RailType railtype);

#endif /* RAIL_H */

 * @param ti TileInfo

 * @param track TrackBits to draw

 * @param earth Draw as earth

 * @param snow Draw as snow

 * @param flat Always draw foundation

 */

{

	const RailtypeInfo *rti = GetRailTypeInfo(GetRailType(ti->tile));

	PalSpriteID image;

	bool junction = false;

	// Select the sprite to use.

 * @param ti TileInfo

 * @param road RoadBits to draw

 * @param ground_type Ground type

 * @param snow Draw snow

 * @param flat Draw foundation

 */

{

	const DrawRoadTileStruct *drts;

	PalSpriteID image = 0;

	if (ti->tileh != 0) {

		int foundation;

		}

		spritenum = orig_road_vehicle_info[engine - ROAD_ENGINES_INDEX].image_index;

	}

	DrawSprite((6 + _roadveh_images[spritenum]) | image_ormod, x, y);

}

{

	return ((_price.roadveh_base >> 3) * RoadVehInfo(engine_type)->base_cost) >> 5;

}

/** Build a road vehicle.

 * @param x,y tile coordinates of depot where road vehicle is built

	FOR_ALL_VEHICLES(v) {

		if (v->type == VEH_Road) return true;

	}

	return false;

}

static void GameOptionsWndProc(Window *w, WindowEvent *e)

{

	switch (e->event) {

	case WE_PAINT: {

		int i;

		StringID str = STR_02BE_DEFAULT;

	WC_CUSTOM_CURRENCY, 0,

	WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET | WDF_UNCLICK_BUTTONS,

	_cust_currency_widgets,

	CustCurrencyWndProc,

};

{

	_str_separator[0] = _custom_currency.separator;

	_str_separator[1] = '\0';

	DeleteWindowById(WC_CUSTOM_CURRENCY, 0);

	AllocateWindowDesc(&_cust_currency_desc);

	v->progress = (t = v->progress) - (byte)spd;

	return (t < v->progress);

}

{

	return ShipVehInfo(engine_type)->base_cost * (_price.ship_base>>3)>>5;

}

static void ShipEnterDepot(Vehicle *v)

{

RoadStop * GetRoadStopByTile(TileIndex tile, RoadStopType type);

static inline int GetRoadStopType(TileIndex tile)

{

	return (_m[tile].m5 < 0x47) ? RS_TRUCK : RS_BUS;

}

RoadStop * GetPrimaryRoadStop(const Station *st, RoadStopType type);

RoadStop * AllocateRoadStop( void );

void ClearSlot(Vehicle *v, RoadStop *rs);

static inline bool IsTrainStationTile(TileIndex tile)

{

		assert(rs->next != NULL);

	}

	return rs;

}

{

	uint num = 0;

	const RoadStop *rs;

	assert(st != NULL);

	for (rs = GetPrimaryRoadStop(st, type); rs != NULL; rs = rs->next) num++;

void PlaceProc_DemolishArea(TileIndex tile)

{

	VpStartPlaceSizing(tile, VPM_X_AND_Y | GUI_PlaceProc_DemolishArea);

}

{

	GenericRaiseLowerLand(tile, 1);

}

{

	GenericRaiseLowerLand(tile, 0);

}

void PlaceProc_LevelLand(TileIndex tile)

{

void UpdateTownVirtCoord(Town *t);

void InitializeTown(void);

void ShowTownViewWindow(uint town);

void DeleteTown(Town *t);

void ExpandTown(Town *t);

Town *CreateRandomTown(uint attempts);

enum {

	ROAD_REMOVE = 0,

	UNMOVEABLE_REMOVE = 1,

	TUNNELBRIDGE_REMOVE = 1,

	// Lets us rotate without using &3.

	{ 0, -1},

	{ 1,  0},

	{ 0,  1}

};

static void TownTickHandler(Town *t)

{

	if (t->flags12&1) {

		int i = t->grow_counter - 1;

		if (i < 0) {

			if (GrowTown(t)) {

	if (a == b) b ^= 2;

	return (1 << a) + (1 << b);

}

// Grow the town

// Returns true if a house was built, or no if the build failed.

{

	TileIndex tile;

	const TileIndexDiffC *ptr;

	TileInfo ti;

	PlayerID old_player;

		return (force - resistance) / (mass * 4);

	} else {

		return min((-force - resistance) / (mass * 4), 10000 / (mass * 4));

	}

}

{

	uint power = 0;

	uint weight = 0;

	assert(IsFrontEngine(v));

static int32 EstimateTrainCost(const RailVehicleInfo* rvi)

{

	return (rvi->base_cost * (_price.build_railvehicle >> 3)) >> 5;

}

{

	u->direction = v->direction;

	u->owner = v->owner;

	u->tile = v->tile;

	u->x_pos = v->x_pos;

	u->y_pos = v->y_pos;

/** 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 tile tile coordinates where HQ is located to destroy

 * @param flags docommand flags of calling function

 */

{

	Player *p;

	SET_EXPENSES_TYPE(EXPENSES_PROPERTY);

	/* Find player that has HQ flooded, and reset their location_of_house */

			}

		}

	}

	return NULL;

}

void VehiclePositionChanged(Vehicle *v)

{

	int img = v->cur_image;

	Point pt = RemapCoords(v->x_pos + v->x_offs, v->y_pos + v->y_offs, v->z_pos);

	const Sprite* spr = GetSprite(img);

	}

	return NULL;

}

{

	VehicleID *old_hash, *new_hash;

	int old_x = v->left_coord;

	int old_y = v->top_coord;

	Vehicle *u;

void VehicleServiceInDepot(Vehicle *v);

Vehicle *AllocateVehicle(void);

bool AllocateVehicles(Vehicle **vl, int num);

Vehicle *ForceAllocateVehicle(void);

Vehicle *ForceAllocateSpecialVehicle(void);

void VehiclePositionChanged(Vehicle *v);

void AfterLoadVehicles(void);

Vehicle *GetLastVehicleInChain(Vehicle *v);

Vehicle *GetPrevVehicleInChain(const Vehicle *v);

Vehicle *GetFirstVehicleInChain(const Vehicle *v);

uint CountVehiclesInChain(const Vehicle* v);

bool CanRefitTo(EngineID engine_type, CargoID cid_to);

void ViewportAddVehicles(DrawPixelInfo *dpi);

void TrainEnterDepot(Vehicle *v, TileIndex tile);

/* train_cmd.h */

int GetTrainImage(const Vehicle *v, byte direction);