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

 *  will make infinite loops (AIScript).

 */

{

	AICommand *com;

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

// ** console window ** //

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

{

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

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

 * @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];

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, ...);

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

}

{

	Player *p = GetPlayer(player);

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

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 ShowGameDifficulty(void);

void ShowPatchesSelection(void);

void ShowNewgrf(void);

/* graph_gui.c */

void ShowOperatingProfitGraph(void);

void ShowTerraformToolbar(void);

void PlaceProc_DemolishArea(TileIndex tile);

void PlaceProc_LevelLand(TileIndex tile);

bool GUIPlaceProcDragXY(const WindowEvent *we);

/**

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

 */

{

	Industry *i;

static uint32 last_ack_frame;

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

// Sending functions

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

// This file handles all the server-commands

void NetworkPopulateCompanyInfo(void);

// Is the network enabled?

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

}

// Handle the local command-queue

	CommandPacket *cp;

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

};

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

static NetworkClientState _udp_cs;

assert_compile(lengthof(_network_udp_packet) == PACKET_UDP_END);

{

	byte type;

// Send a packet over UDP

{

	int res;

}

// Broadcast to all ips

{

	int i;

	struct sockaddr_in out_addr;

/** Handle the user-messages sent to us

 * @param message message sent

 */

{

	switch (message) {

		case MSG_OTTD_SAVETHREAD_START: SaveFileStart(); break;

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

void InitialiseEngineReplacement(Player *p);

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

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

#endif /* PLAYER_H */

	p->president_name_1 = 0;

}

/** Change engine renewal parameters

 * @param x,y unused

 * @param p1 bits 0-3 command

 * @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;

 * @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;

  return true;

}

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

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

#endif /* RAIL_H */

 * @param snow Draw as snow

 * @param flat Always draw foundation

 */

{

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

	PalSpriteID image;

 * @param snow Draw snow

 * @param flat Draw foundation

 */

{

	const DrawRoadTileStruct *drts;

	PalSpriteID image = 0;

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

}

{

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

}

	return false;

}

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

{

	switch (e->event) {

	CustCurrencyWndProc,

};

{

	_str_separator[0] = _custom_currency.separator;

	_str_separator[1] = '\0';

	return (t < v->progress);

}

{

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

}

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

	return rs;

}

{

	uint num = 0;

	const RoadStop *rs;

	VpStartPlaceSizing(tile, VPM_X_AND_Y | GUI_PlaceProc_DemolishArea);

}

{

	GenericRaiseLowerLand(tile, 1);

}

{

	GenericRaiseLowerLand(tile, 0);

}

void ShowTownViewWindow(uint town);

void DeleteTown(Town *t);

void ExpandTown(Town *t);

Town *CreateRandomTown(uint attempts);

enum {

	{ 0,  1}

};

static void TownTickHandler(Town *t)

{

	if (t->flags12&1) {

// Grow the town

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

{

	TileIndex tile;

	const TileIndexDiffC *ptr;

	}

}

{

	uint power = 0;

	uint weight = 0;

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

}

{

	u->direction = v->direction;

	u->owner = v->owner;

 * @param tile tile coordinates where HQ is located to destroy

 * @param flags docommand flags of calling function

 */

{

	Player *p;

	return NULL;

}

void VehiclePositionChanged(Vehicle *v)

{

	int img = v->cur_image;

{

	VehicleID *old_hash, *new_hash;

	int old_x = v->left_coord;

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

Vehicle *ForceAllocateVehicle(void);

Vehicle *ForceAllocateSpecialVehicle(void);

void VehiclePositionChanged(Vehicle *v);

void AfterLoadVehicles(void);

Vehicle *GetLastVehicleInChain(Vehicle *v);

void TrainEnterDepot(Vehicle *v, TileIndex tile);

/* train_cmd.h */

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

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

int LoadUnloadVehicle(Vehicle *v);

void TrainConsistChanged(Vehicle *v);

int32 GetTrainRunningCost(const Vehicle *v);

int CheckTrainStoppedInDepot(const Vehicle *v);

	}

}

{

	ViewPort *vp = w->viewport;

	int old_left = vp->virtual_left;

	_thd.next_drawstyle = HT_RECT;

}

{

	_thd.selend.x = -1;

	_special_mouse_mode = WSM_PRESIZE;

/* viewport.c */

void AssignWindowViewport(Window *w, int x, int y,

	int width, int height, uint32 follow_flags, byte zoom);

ViewPort *IsPtInWindowViewport(const Window *w, int x, int y);

Point GetTileBelowCursor(void);

void ZoomInOrOutToCursorWindow(bool in, Window * w);

void SetTileSelectBigSize(int ox, int oy, int sx, int sy);

void VpStartPlaceSizing(TileIndex tile, int user);

void VpSetPresizeRange(uint from, uint to);

void VpSetPlaceSizingLimit(int limit);

}

/* Update the sign for the waypoint */

{

	Point pt = RemapCoords2(TileX(wp->xy) * 16, TileY(wp->xy) * 16);

	SetDParam(0, wp->index);

Station *ComposeWaypointStation(TileIndex tile);

void ShowRenameWaypointWindow(const Waypoint *cp);

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

void FixOldWaypoints(void);

void UpdateAllWaypointSigns(void);

void UpdateAllWaypointCustomGraphics(void);

	InvalidateWidget(w, widget);

}

static void DispatchLeftClickEvent(Window* w, int x, int y)

{

	WindowEvent e;

}

void DrawOverlappedWindowForAll(int left, int top, int right, int bottom)

{

	Window *w;

	}

}

{

	const Window* v = w;

	int x;

	}

}

Window *BringWindowToFrontById(WindowClass cls, WindowNumber number)

{

	Window *w = FindWindowById(cls, number);

 * - New window, Chatbar (only if open)

 * @param w window that is put into the foreground

 */

{

	Window *v;

	Window temp;

	return false;

}

{

	w->flags4 |= WF_DRAGGING;

	_dragging_window = true;

	return w;

}

{

	w->flags4 |= WF_SIZING;

	_dragging_window = true;

};

/* window.c */

void CallWindowEventNP(Window *w, int event);

void CallWindowTickEvent(void);

void SetWindowDirty(const Window* w);

Window *FindWindowById(WindowClass cls, WindowNumber number);

void DeleteWindow(Window *w);

Window *BringWindowToFrontById(WindowClass cls, WindowNumber number);

Window *FindWindowFromPt(int x, int y);

bool IsWindowOfPrototype(const Window* w, const Widget* widget);