CommandCallback CcCloneVehicle;

/* main_gui.cpp */

CommandCallback CcPlaySound10;

CommandCallback CcPlaceSign;

CommandCallback CcTerraform;

CommandCallback CcGiveMoney;

/* rail_gui.cpp */

CommandCallback CcPlaySound1E;

CommandCallback CcRailDepot;

CommandCallback CcStation;

CommandCallback CcBuildShip;

/* train_gui.cpp */

CommandCallback CcBuildWagon;

CommandCallback CcBuildLoco;

/* group_gui.cpp */

CommandCallback CcCreateGroup;

/* ai/ai_core.cpp */

CommandCallback CcAI;

	/* 0x13 */ CcStation,

	/* 0x14 */ CcTerraform,

	/* 0x15 */ CcAI,

	/* 0x16 */ CcCloneVehicle,

	/* 0x17 */ CcGiveMoney,

	/* 0x18 */ CcCreateGroup,

};

const int _callback_table_count = lengthof(_callback_table);

	{CmdPause,                             CMD_SERVER}, // CMD_PAUSE

	{CmdBuyShareInCompany,                          0}, // CMD_BUY_SHARE_IN_COMPANY

	{CmdSellShareInCompany,                         0}, // CMD_SELL_SHARE_IN_COMPANY

	{CmdBuyCompany,                                 0}, // CMD_BUY_COMANY

	{CmdRenameTown,                        CMD_SERVER}, // CMD_RENAME_TOWN

	{CmdDoTownAction,                               0}, // CMD_DO_TOWN_ACTION

	{CmdSellShip,                                   0}, // CMD_SELL_SHIP

	{CmdBuildShip,                                  0}, // CMD_BUILD_SHIP

	{CmdSendShipToDepot,                            0}, // CMD_SEND_SHIP_TO_DEPOT

uint32 GetWorldPopulation();

void UpdateAllTownVirtCoords();

void InitializeTown();

void ShowTownViewWindow(TownID town);

void ExpandTown(Town *t);

enum TownRatingCheckType {

	ROAD_REMOVE         = 0,

	TUNNELBRIDGE_REMOVE = 1,

	TOWN_RATING_CHECK_TYPE_COUNT,

};

	TACT_FUNDS            = TACT_BUY_RIGHTS | TACT_BRIBE,                                        ///< All possible funding actions.

	TACT_ALL              = TACT_ADVERTISE | TACT_CONSTRUCTION | TACT_FUNDS,                     ///< All possible actions.

};

DECLARE_ENUM_AS_BIT_SET(TownActions);

extern const byte _town_action_costs[TACT_COUNT];

/**

 * Calculate a hash value from a tile position

 *

 * @param x The X coordinate

 * @param y The Y coordinate

#include "table/strings.h"

#include "table/town_land.h"

Town *_cleared_town;

int _cleared_town_rating;

uint32 _cur_town_ctr;     ///< iterator through all towns in OnTick_Town

uint32 _cur_town_iter;    ///< frequency iterator at the same place

/* Initialize the town-pool */

TownPool _town_pool("Town");

	GROWTH_SUCCEED         = -1,

	GROWTH_SEARCH_STOPPED  =  0

//	GROWTH_SEARCH_RUNNING >=  1

};

static bool BuildTownHouse(Town *t, TileIndex tile);

static void TownDrawHouseLift(const TileInfo *ti)

{

	AddChildSpriteScreen(SPR_LIFT, PAL_NONE, 14, 60 - GetLiftPosition(ti->tile));

}

	/* Can only build on clear flat areas, possibly with trees. */

	if ((!IsTileType(tile, MP_CLEAR) && !IsTileType(tile, MP_TREES)) || GetTileSlope(tile, NULL) != SLOPE_FLAT) {

		return_cmd_error(STR_ERROR_SITE_UNSUITABLE);

	}

}

/** Create a new town.

 * This obviously only works in the scenario editor. Function not removed

 * as it might be possible in the future to fund your own town :)

 * @param tile coordinates where town is built

 * @param flags type of operation

 * @param p1  0..1 size of the town (@see TownSize)

 *               2 true iff it should be a city

 *            3..5 town road layout (@see TownLayout)

 * @param p2 town name parts

 * @param text unused

 * @return the cost of this operation or an error

 */

CommandCost CmdFoundTown(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)

{

	if (_game_mode != GM_EDITOR) return CMD_ERROR;

	TownSize size = (TownSize)GB(p1, 0, 2);

	bool city = HasBit(p1, 2);

	TownLayout layout = (TownLayout)GB(p1, 3, 3);

	TownNameParams par(_settings_game.game_creation.town_name);

	uint32 townnameparts = p2;

	if (size > TS_RANDOM) return CMD_ERROR;

	if (layout > TL_RANDOM) return CMD_ERROR;

	if (!VerifyTownName(townnameparts, &par)) return_cmd_error(STR_ERROR_NAME_MUST_BE_UNIQUE);

	/* Allocate town struct */

	if (!Town::CanAllocateItem()) return_cmd_error(STR_ERROR_TOO_MANY_TOWNS);

	/* Create the town */

	if (flags & DC_EXEC) {

		_generating_world = true;

		UpdateNearestTownForRoadTiles(true);

		DoCreateTown(t, tile, townnameparts, size, city, layout);

		UpdateNearestTownForRoadTiles(false);

		_generating_world = false;

	}

}

/**

 * Towns must all be placed on the same grid or when they eventually

 * interpenetrate their road networks will not mesh nicely; this

 * function adjusts a tile so that it aligns properly.

	}

	/* if we get here just give up */

	return INVALID_TILE;

}

{

	if (!Town::CanAllocateItem()) return NULL;

	do {

		/* Generate a tile index not too close from the edge */

		TileIndex tile = AlignTileToGrid(RandomTile(), layout);

			if (tile == INVALID_TILE) continue;

		}

		/* Make sure town can be placed here */

		if (CmdFailed(TownCanBePlacedHere(tile))) continue;

		/* Allocate a town struct */

		Town *t = new Town(tile);

		DoCreateTown(t, tile, townnameparts, size, city, layout);

		/* if the population is still 0 at the point, then the

 */

bool GenerateTowns(TownLayout layout)

{

	uint num = 0;

	uint difficulty = _settings_game.difficulty.number_towns;

	uint n = (difficulty == (uint)CUSTOM_TOWN_NUMBER_DIFFICULTY) ? _settings_game.game_creation.custom_town_number : ScaleByMapSize(_num_initial_towns[difficulty] + (Random() & 7));

	SetGeneratingWorldProgress(GWP_TOWN, n);

	/* First attempt will be made at creating the suggested number of towns.

	 * Note that this is really a suggested value, not a required one.

	 * We would not like the system to lock up just because the user wanted 100 cities on a 64*64 map, would we? */

	do {

		bool city = (_settings_game.economy.larger_towns != 0 && Chance16(1, _settings_game.economy.larger_towns));

		IncreaseGeneratingWorldProgress(GWP_TOWN);

		/* try 20 times to create a random-sized town for the first loop. */

	} while (--n);

	/* If num is still zero at this point, it means that not a single town has been created.

	 * So give it a last try, but now more aggressive */

				extern StringID _switch_mode_errorstr;

				_switch_mode_errorstr = STR_ERROR_COULD_NOT_CREATE_TOWN;

			}

		return false;  // we are still without a town? we failed, simply

	}

/** Returns the bit corresponding to the town zone of the specified tile

 * @param t Town on which town zone is to be found

 * @param tile TileIndex where town zone needs to be found

 * @return the bit position of the given zone, as defined in HouseZones

	if (success) {

		SndPlayTileFx(SND_1F_SPLAT, tile);

		if (!_settings_client.gui.persistent_buildingtools) ResetObjectToPlace();

	}

}

/** Widget numbers of town scenario editor window. */

enum TownScenarioEditorWidgets {

	TSEW_CLOSEBOX,

	TSEW_CAPTION,

	TSEW_STICKYBOX,

	TSEW_BACKGROUND,

			this->SetWidgetLoweredState(i, i == TSEW_LAYOUT_ORIGINAL + this->town_layout);

		}

		this->SetDirty();

	}

	virtual void OnPaint()

	{

		this->DrawWidgets();

	}

	virtual void OnClick(Point pt, int widget)

	{

		switch (widget) {

			case TSEW_NEWTOWN:

				HandlePlacePushButton(this, TSEW_NEWTOWN, SPR_CURSOR_TOWN, HT_RECT, NULL);

				break;

				this->HandleButtonClick(TSEW_RANDOMTOWN);

			case TSEW_MANYRANDOMTOWNS:

				this->HandleButtonClick(TSEW_MANYRANDOMTOWNS);

				_generating_world = true;

				UpdateNearestTownForRoadTiles(true);

		this->RaiseWidget(TSEW_MANYRANDOMTOWNS);

		this->SetDirty();

	}

	virtual void OnPlaceObject(Point pt, TileIndex tile)

	{

	}

	virtual void OnPlaceObjectAbort()

	{

		this->RaiseButtons();

		this->UpdateButtons();