*/

static CommandCost CheckIfIndustryIsAllowed(TileIndex tile, int type, const Town *t)

{

		return_cmd_error(STR_ERROR_CAN_ONLY_BE_BUILT_IN_TOWNS_WITH_POPULATION_OF_1200);

	}

void InitializeBuildingCounts()

{

	memset(&_building_counts, 0, sizeof(_building_counts));

}

/**

	if (!_loaded_newgrf_features.has_newhouses) return;

	_building_counts.id_count[house_id]++;

	if (class_id == HOUSE_NO_CLASS) return;

	_building_counts.class_count[class_id]++;

}

	if (!_loaded_newgrf_features.has_newhouses) return;

	if (class_id == HOUSE_NO_CLASS) return;

}

static uint32 HouseGetRandomBits(const ResolverObject *object)

	map_id_count     = ClampU(_building_counts.id_count[house_id], 0, 255);

	map_class_count  = ClampU(_building_counts.class_count[class_id], 0, 255);

	return map_class_count << 24 | town_class_count << 16 | map_id_count << 8 | town_id_count;

}

		/* Town properties */

		case 0x80: return t->xy;

		case 0x81: return GB(t->xy, 8, 8);

		case 0x8A: return t->grow_counter;

		case 0x92: return t->flags;  // In original game, 0x92 and 0x93 are really one word. Since flags is a byte, this is to adjust

		case 0x93: return 0;

		case 0x9E: return t->ratings[0];

		case 0x9F: return GB(t->ratings[0], 8, 8);

		case 0xA0: return t->ratings[1];

		case 0xAD: return GB(t->ratings[7], 8, 8);

		case 0xAE: return t->have_ratings;

		case 0xB2: return t->statues;

		case 0xB9: return t->growth_rate & (~TOWN_GROW_RATE_CUSTOM);

		case 0xBA: return ClampToU16(t->supplied[CT_PASSENGERS].new_max);

		case 0xBB: return GB(ClampToU16(t->supplied[CT_PASSENGERS].new_max), 8, 8);

			company = OWNER_TOWN;

			/* If we are not within a town, we are not owned by the town */

				company = OWNER_NONE;

			}

		}

	/* Reset town population and num_houses */

	FOR_ALL_TOWNS(town) {

	}

	for (TileIndex t = 0; t < MapSize(); t++) {

		HouseID house_id = GetCleanHouseType(t);

		town = Town::GetByTile(t);

		IncreaseBuildingCount(town, house_id);

		/* Increase the number of houses for every house, but only once. */

	}

	/* Update the population and num_house dependant values */

{

	if (!IsValidTown(town_id)) return -1;

	const Town *t = ::Town::Get(town_id);

}

/* static */ int32 ScriptTown::GetHouseCount(TownID town_id)

{

	if (!IsValidTown(town_id)) return -1;

	const Town *t = ::Town::Get(town_id);

}

/* static */ TileIndex ScriptTown::GetLocation(TownID town_id)

	switch (t->goal[towneffect_id]) {

		case TOWN_GROWTH_WINTER:

			return 0;

		case TOWN_GROWTH_DESERT:

			return 0;

		default: return t->goal[towneffect_id];

	if (!IsValidTown(town_id)) return false;

	const Town *t = ::Town::Get(town_id);

}

/* static */ bool ScriptTown::HasStatue(TownID town_id)

		FOR_ALL_TOWNS(t) {

			/* Remap the town coordinate */

			Point pt = this->RemapTile(TileX(t->xy), TileY(t->xy));

			int y = pt.y;

			/* Check if the town sign is within bounds */

					x < dpi->left + dpi->width &&

					y + FONT_HEIGHT_SMALL > dpi->top &&

					y < dpi->top + dpi->height) {

				/* And draw it. */

				SetDParam(0, t->index);

			}

		}

	}

{

	switch (type) {

		case ST_INDUSTRY: Industry::Get(index)->part_of_subsidy |= flag; return;

		default: NOT_REACHED();

	}

}

void RebuildSubsidisedSourceAndDestinationCache()

{

	Town *t;

	Industry *i;

	FOR_ALL_INDUSTRIES(i) i->part_of_subsidy = POS_NONE;

	if (!Subsidy::CanAllocateItem()) return false;

	const Town *src = Town::GetRandom();

			src->GetPercentTransported(CT_PASSENGERS) > SUBSIDY_MAX_PCT_TRANSPORTED) {

		return false;

	}

	const Town *dst = Town::GetRandom();

		return false;

	}

			if (!(Industry::Get(src)->part_of_subsidy & POS_SRC)) return false;

			break;

		case ST_TOWN:

			break;

		default: return false;

	}

					TileIndex tile = TileXY(x, y);

					if (!IsTileType(tile, MP_HOUSE)) continue;

					const Town *t = Town::GetByTile(tile);

				}

			}

			break;

				case ST_TOWN:

					for (const Town * const *tp = towns_near.Begin(); tp != towns_near.End(); tp++) {

						if (s->dst == (*tp)->index) {

							subsidised = true;

							if (!s->IsAwarded()) s->AwardTo(company);

						}

typedef Pool<Town, TownID, 64, 64000> TownPool;

extern TownPool _town_pool;

/** Town data structure. */

struct Town : TownPool::PoolItem<&_town_pool> {

	TileIndex xy;                  ///< town center tile

	/* Town name */

	uint32 townnamegrfid;

	uint32 townnameparts;

	char *name;

	/* Makes sure we don't build certain house types twice.

	 * bit 0 = Building funds received

	 * bit 1 = CHURCH

	std::list<PersistentStorage *> psa_list;

	/**

	 * Creates a new town.

	 * @param tile center tile of the town

	 */

	inline uint16 MaxTownNoise() const

	{

		/* 3 is added (the noise of the lowest airport), so the  user can at least build a small airfield. */

	}

	void UpdateVirtCoord();

{

	Point pt = RemapCoords2(TileX(this->xy) * TILE_SIZE, TileY(this->xy) * TILE_SIZE);

	SetDParam(0, this->index);

		_settings_client.gui.population_in_label ? STR_VIEWPORT_TOWN_POP : STR_VIEWPORT_TOWN);

	SetWindowDirty(WC_TOWN_VIEW, this->index);

 */

static void ChangePopulation(Town *t, int mod)

{

	InvalidateWindowData(WC_TOWN_VIEW, t->index); // Cargo requirements may appear/vanish for small populations

	t->UpdateVirtCoord();

	uint32 pop = 0;

	const Town *t;

	return pop;

}

	 * them a little handicap. */

	switch (t->layout) {

		case TL_BETTER_ROADS:

			break;

		case TL_3X3_GRID:

		case TL_2X2_GRID:

			break;

		default:

			break;

	}

		{121, 81,  0, 49, 36}, // 88

	};

	} else {

		/* Actually we are proportional to sqrt() but that's right because we are covering an area.

		 * The offsets are to make sure the radii do not decrease in size when going from the table

		 * to the calculated value.*/

	}

}

void UpdateTownMaxPass(Town *t)

{

}

/**

static void DoCreateTown(Town *t, TileIndex tile, uint32 townnameparts, TownSize size, bool city, TownLayout layout, bool manual)

{

	t->xy = tile;

	t->time_until_rebuild = 10;

	UpdateTownRadius(t);

	t->flags = 0;

	t->grow_counter = 0;

	t->growth_rate = 250;

	/* Don't create huge cities when founding town in-game */

	if (city && (!manual || _game_mode == GM_EDITOR)) x *= _settings_game.economy.initial_city_size;

	UpdateTownRadius(t);

	int i = x * 4;

		GrowTown(t);

	} while (--i);

	UpdateTownRadius(t);

	UpdateTownMaxPass(t);

	UpdateAirportsNoise();

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

		 * placement is so bad it couldn't grow at all */

		CommandCost rc = DoCommand(t->xy, t->index, 0, DC_EXEC, CMD_DELETE_TOWN);

		assert(rc.Succeeded());

	HouseZonesBits smallest = HZB_TOWN_EDGE;

	for (HouseZonesBits i = HZB_BEGIN; i < HZB_END; i++) {

	}

	return smallest;

		/* Don't let these counters overflow. Global counters are 32bit, there will never be that many houses. */

		if (hs->class_id != HOUSE_NO_CLASS) {

			/* id_count is always <= class_count, so it doesn't need to be checked */

		} else {

			/* If the house has no class, check id_count instead */

		}

		/* Without NewHouses, all houses have probability '1' */

		}

		/* build the house */

		/* Special houses that there can be only one of. */

		t->flags |= oneof;

		ChangePopulation(t, -hs->population);

	}

	/* Clear flags for houses that only may exist once/town. */

	if (hs->building_flags & BUILDING_IS_CHURCH) {

	if (flags & DC_EXEC) {

		/* The more houses, the faster we grow */

		if (p2 == 0) {

			UpdateTownRadius(t);

			uint n = amount * 10;

			do GrowTown(t); while (--n);

		} else {

			for (; p2 > 0; p2--) {

				/* Try several times to grow, as we are really suppose to grow */

	const Station *st;

	FOR_ALL_STATIONS(st) {

			if (st->time_since_load <= 20 || st->time_since_unload <= 20) {

				if (Company::IsValidID(st->owner)) {

					int new_rating = t->ratings[st->owner] + RATING_STATION_UP_STEP;

		for (int i = TE_BEGIN; i < TE_END; i++) {

			switch (t->goal[i]) {

				case TOWN_GROWTH_WINTER:

					break;

				case TOWN_GROWTH_DESERT:

					break;

				default:

					if (t->goal[i] > t->received[i].old_act) return;

	const Station *st;

	FOR_ALL_STATIONS(st) {

			if (st->time_since_load <= 20 || st->time_since_unload <= 20) {

				n++;

			}

	m >>= growth_multiplier;

	if (t->larger_town) m /= 2;

	if (m <= t->grow_counter) {

		t->grow_counter = m;

	}

		uint y = r.top + WD_FRAMERECT_TOP;

		DrawString(r.left + WD_FRAMERECT_LEFT, r.right - WD_FRAMERECT_LEFT, y, STR_TOWN_VIEW_POPULATION_HOUSES);

		SetDParam(0, this->town->supplied[CT_PASSENGERS].old_act);

		bool first = true;

		for (int i = TE_BEGIN; i < TE_END; i++) {

			if (this->town->goal[i] == 0) continue;

			if (first) {

				DrawString(r.left + WD_FRAMERECT_LEFT, r.right - WD_FRAMERECT_LEFT, y += FONT_HEIGHT_NORMAL, STR_TOWN_VIEW_CARGO_FOR_TOWNGROWTH);

		bool first = true;

		for (int i = TE_BEGIN; i < TE_END; i++) {

			if (this->town->goal[i] == 0) continue;

			if (first) {

				aimed_height += FONT_HEIGHT_NORMAL;

	/** Sort by population */

	static int CDECL TownPopulationSorter(const Town * const *a, const Town * const *b)

	{

	}

public:

					}

					SetDParam(0, t->index);

					DrawString(text_left, text_right, y + (this->resize.step_height - FONT_HEIGHT_NORMAL) / 2, STR_TOWN_DIRECTORY_TOWN);

					y += this->resize.step_height;

		company = OWNER_TOWN;

		/* If we are not within a town, we are not owned by the town */

			company = OWNER_NONE;

		}

	}

		company = OWNER_TOWN;

		/* If we are not within a town, we are not owned by the town */

			company = OWNER_NONE;

		}

	}

	const Town *t;

	FOR_ALL_TOWNS(t) {

				_settings_client.gui.population_in_label ? STR_VIEWPORT_TOWN_POP : STR_VIEWPORT_TOWN,

				STR_VIEWPORT_TOWN_TINY_WHITE, STR_VIEWPORT_TOWN_TINY_BLACK,

	}

}

	const Town *t;

	FOR_ALL_TOWNS(t) {

			ShowTownViewWindow(t->index);

			return true;

		}