/**

 * Run 1 tick of the AI. Don't overdo it, keep it realistic.

 */

{

	extern void AiNewDoGameLoop(Player *p);

			DeleteWindow(w);

		break;

		if (e->edittext.str[0] != '\0') {

			_cmd_text = e->edittext.str;

			DoCommandP(0, w->window_number, 0, NULL,

				CMD_NAME_VEHICLE | CMD_MSG(STR_A031_CAN_T_NAME_AIRCRAFT));

		}

	}

}

	}

	case WE_CLICK:

			uint ind = ((int)e->click.pt.y - 14) / 22;

			if (ind < 4 && (ind += w->vscroll.pos) < _bridgedata.count)

				BuildBridge(w, ind);

	errmsg = INVALID_STRING_ID;

	// only query bridge building possibility once, result is the same for all bridges!

	ret = DoCommandByTile(end, start, (bridge_type << 8), DC_AUTO | DC_QUERY_COST, CMD_BUILD_BRIDGE);

	if (ret == CMD_ERROR) {

		errmsg = _error_message;

		int bridge_len;			// length of the middle parts of the bridge

		int tot_bridgedata_len;	// total length of bridge

		tot_bridgedata_len = CalcBridgeLenCostFactor(tot_bridgedata_len);

		for (bridge_type = 0; bridge_type != MAX_BRIDGES; bridge_type++) {	// loop for all bridgetypes

			if (CheckBridge_Stuff(bridge_type, bridge_len)) {

				const Bridge *b = &_bridge[bridge_type];

				// bridge is accepted, add to list

{

	ResetDisasterDelay();

}

static OnButtonClick * const _build_docks_button_proc[] = {

	BuildDocksClick_Canal,

	BuildDocksClick_Lock,

	BuildDocksClick_Demolish,

	BuildDocksClick_Depot,

	BuildDocksClick_Dock,

		DrawWindowWidgets(w);

		break;

		if (e->click.widget - 3 >= 0 && e->click.widget != 5) _build_docks_button_proc[e->click.widget - 3](w);

	case WE_KEYPRESS: {

		switch(e->keypress.keycode) {

	return GetPartialZ(ti->x & 0xF, ti->y & 0xF, ti->tileh) + ti->z;

}

	return ti->tileh;

}

	NULL,											/* vehicle_leave_tile_proc */

	GetSlopeTileh_Dummy,			/* get_slope_tileh_proc */

};

static void PlayersPayInterest(void)

{

	int interest = _economy.interest_rate * 54;

	FOR_ALL_PLAYERS(p) {

 * @param v The wagon to check

 * @return true if it is using an override, false otherwise

 */

	assert(v->type == VEH_Train);

	return GetWagonOverrideSpriteSet(v->engine_type, v->u.rail.first_engine) != NULL;

}

	_fio.handles[slot] = f;

	FioSeekToFile(slot << 24);

}

void GfxFillRect(int left, int top, int right, int bottom, int color)

{

	Pixel *dst;

	const int otop = top;

	const int oleft = left;

static void GfxSetPixel(int x, int y, int color)

{

	if ((x-=dpi->left) < 0 || x>=dpi->width || (y-=dpi->top)<0 || y>=dpi->height)

		return;

	dpi->dst_ptr[y * dpi->pitch + x] = color;

		}

		num++;

	}

}

static void GfxMainBlitter(const Sprite* sprite, int x, int y, int mode)

{

	int start_x, start_y;

	byte info;

	BlitterParams bp;

	SetDirtyBlocks(0, 0, _screen.width, _screen.height);

}

{

	int t;

void GfxInitPalettes(void);

/* window.c */

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

	return GetPartialZ(ti->x & 0xF, ti->y & 0xF, ti->tileh) + ti->z;

}

	return 0;

}

	SetupFarmFieldFence(tile + TileDiffXY(0, size_y - 1), size_x, type, 0);

}

{

	TileIndex tile;

static bool CheckIfTooCloseToIndustry(TileIndex tile, int type)

{

	const IndustrySpec *spec;

	spec = &_industry_spec[type];

const ChunkHandler _industry_chunk_handlers[] = {

	{ 'INDY', Save_INDY, Load_INDY, CH_ARRAY | CH_LAST},

};

// direction=true:  check for foundation in east and south corner

// direction=false: check for foundation in west and south corner

{

	bool south, other; // southern corner and east/west corner

	uint slope = _tile_type_procs[ti->type]->get_slope_tileh_proc(ti);

	uint tileh = ti->tileh;

	south = (tileh & 2) != (slope & 2);

		other = (tileh & 4) != (slope & 4);

		other = (tileh & 1) != (slope & 1);

	return south || other;

}

void DrawFoundation(TileInfo *ti, uint f)

#endif

#endif /* LZOCONF_H */

		DoCommandP(0, id, 0, NULL, CMD_RENAME_SIGN | CMD_MSG(STR_280C_CAN_T_CHANGE_SIGN_NAME));

		break;

	case 1: /* Rename a waypoint */

		DoCommandP(0, id, 0, NULL, CMD_RENAME_WAYPOINT | CMD_MSG(STR_CANT_CHANGE_WAYPOINT_NAME));

		break;

#ifdef ENABLE_NETWORK

static void ToolbarBuildRailClick(Window *w)

{

	Window *w2;

	w2 = PopupMainToolbMenu(w, 457, 19, STR_1015_RAILROAD_CONSTRUCTION, RAILTYPE_END, ~p->avail_railtypes);

	WP(w2,menu_d).sel_index = _last_built_railtype;

	_map_size = size_x * size_y;

	_map_tile_mask = _map_size - 1;

	free(_m);

	_m = malloc(_map_size * sizeof(*_m));

//  the result will be tile + TileDiffXY(addx, addy)

uint TileAddWrap(TileIndex tile, int addx, int addy)

{

	// Are we about to wrap?

	if (x < MapMaxX() && y < MapMaxY())

	const uint minh = xh < yh ? xh : yh;

	return minl < minh ? minl : minh;

}

extern Tile* _m;

void AllocateMap(uint size_x, uint size_y);

// binary logarithm of the map size, try to avoid using this one

void SeedMT(uint32 seed) {}

#endif /* MERSENNE_TWISTER */

#endif

/***** End of minilzo.c *****/

#endif

#endif /* MINILZO_H */

#include "openttd.h"

#include "currency.h"

#include "functions.h"

#include "player.h"

#include "string.h"

#include "table/strings.h"

#include "variables.h"

extern void StartupEconomy(void);

char _name_array[512][32];

	OS2MidiIsSongPlaying,

	OS2MidiSetVolume,

};

	SongIsPlaying,

	SetVolume,

};

extern const HalMusicDriver _qtime_music_driver;

#endif /* !MUSIC_MACOSX_QUICKTIME_H */

	SetEvent(_midi.wait_obj);

}

	va_list va;

	char buf[512];

void NetworkServerMonthlyLoop(void);

void NetworkServerYearlyLoop(void);

#endif /* ENABLE_NETWORK */

void LoadNewGRF(uint load_index, uint file_index);

#endif /* NEWGRF_H */

}

{

	char *t = strchr(s, 'x');

	if (t == NULL) {

#include "depot.h"

#include "waypoint.h"

{

	int num = WP(w,order_d).sel;

	if (num < 0 || num > v->num_orders)

		SETBIT(w->disabled_state, 8);	/* full load */

		SETBIT(w->disabled_state, 9);	/* unload */

		SETBIT(w->disabled_state, 10); /* transfer */

	}

	SetDParam(0, v->string_id);

{

	delay(milliseconds);

}

	NTPEnum(&tpf, tile, direction);

}

const ChunkHandler _player_chunk_handlers[] = {

	{ 'PLYR', Save_PLYR, Load_PLYR, CH_ARRAY | CH_LAST},

};

	}

	return type;

}

typedef enum SignalTypes {

	/* Stored in m4[0..1] for MP_RAILWAY */

	SIGTYPE_PBS     = 4,        // pbs signal

	SIGTYPE_END,

	SIGTYPE_MASK    = 7,

/** These are used to specify a single track. Can be translated to a trackbit

 * with TrackToTrackbit */

typedef enum Tracks {

} Track;

/** These are the bitfield variants of the above */

typedef enum TrackBits {

	TRACK_BIT_MASK  = 0x3F,

} TrackBits;

/** These are a combination of tracks and directions. Values are 0-5 in one

direction (corresponding to the Track enum) and 8-13 in the other direction. */

typedef enum Trackdirs {

	/* Note the two missing values here. This enables trackdir -> track

	 * conversion by doing (trackdir & 7) */

} Trackdir;

/** These are a combination of tracks and directions. Values are 0-5 in one

direction (corresponding to the Track enum) and 8-13 in the other direction. */

typedef enum TrackdirBits {

	/* Again, note the two missing values here. This enables trackdir -> track conversion by doing (trackdir & 0xFF) */

	TRACKDIR_BIT_MASK			= 0x3F3F,

} TrackdirBits;

/** These are states in which a signal can be. Currently these are only two, so

static inline RailTileType GetRailTileType(TileIndex tile)

{

	assert(IsTileType(tile, MP_RAILWAY));

}

/**

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

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

#endif /* RAIL_H */

			if (!(flags & DC_EXEC))

				return _price.remove_rail;

			_m[tile].m5 = _m[tile].m5 & 0xC7;

			break;

		case MP_STREET:

			if (!IsLevelCrossing(tile)) return CMD_ERROR;

			SetTileOwner(tile, _m[tile].m3);

			_m[tile].m2 = 0;

			break;

		case MP_RAILWAY:

			if (!IsPlainRailTile(tile))

				return CMD_ERROR;

				goto skip_mark_dirty;

			}

			break;

		default:

			assert(0);

	}

	*/

	if (tileh != 0 && (

	}

	ret = DoCommandByTile(tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);

static void SetSignalsAfterProc(TrackPathFinder *tpf)

{

	SetSignalsData *ssd = tpf->userdata;

	uint offs;

	uint i;

static void ClickTile_Track(TileIndex tile)

{

		ShowTrainDepotWindow(tile);

		ShowRenameWaypointWindow(GetWaypointByTile(tile));

}

static void GetTileDesc_Track(TileIndex tile, TileDesc *td)

		24,

	},

};

#include "table/road_land.h"

	int i;

	// normal level sloped building

	if ((~_valid_tileh_slopes_road[1][tileh] & bits) == 0)

		}

		break;

		if (e->edittext.str[0] != '\0') {

			_cmd_text = e->edittext.str;

			DoCommandP(0, WP(w, buildtrain_d).rename_engine, 0, NULL,

				CMD_RENAME_ENGINE | CMD_MSG(STR_9037_CAN_T_RENAME_ROAD_VEHICLE));

		}

	case WE_RESIZE: {

		if (e->sizing.diff.y == 0)