mirror of
https://github.com/JGRennison/OpenTTD-patches.git
synced 2024-11-17 21:25:40 +00:00
b618b75c9b
-Feature: Bridges can now be placed above: Any railway track combination (excluding depots and waypoints) Any road combination (excluding depots) Clear tiles (duh), including fields Tunnel entrances Bridge heads Thanks to Tron for idea and implementation, KUDr for the yapf synchronization and many others for hours of testing There are still a number of visual problems remaining, especially when electric railways are on or under the bridge. DO NOT REPORT THOSE BUGS FOR THE TIME BEING please.
2003 lines
49 KiB
C
2003 lines
49 KiB
C
/* $Id$ */
|
|
|
|
#include "stdafx.h"
|
|
#include "openttd.h"
|
|
#include "functions.h"
|
|
#include "strings.h"
|
|
#include "road_map.h"
|
|
#include "table/strings.h"
|
|
#include "table/sprites.h"
|
|
#include "map.h"
|
|
#include "tile.h"
|
|
#include "town_map.h"
|
|
#include "tunnel_map.h"
|
|
#include "viewport.h"
|
|
#include "town.h"
|
|
#include "command.h"
|
|
#include "gfx.h"
|
|
#include "industry.h"
|
|
#include "station.h"
|
|
#include "player.h"
|
|
#include "news.h"
|
|
#include "saveload.h"
|
|
#include "economy.h"
|
|
#include "gui.h"
|
|
#include "unmovable_map.h"
|
|
#include "water_map.h"
|
|
#include "variables.h"
|
|
#include "bridge.h"
|
|
#include "bridge_map.h"
|
|
#include "table/town_land.h"
|
|
|
|
enum {
|
|
/* Max towns: 64000 (8 * 8000) */
|
|
TOWN_POOL_BLOCK_SIZE_BITS = 3, /* In bits, so (1 << 3) == 8 */
|
|
TOWN_POOL_MAX_BLOCKS = 8000,
|
|
};
|
|
|
|
/**
|
|
* Called if a new block is added to the town-pool
|
|
*/
|
|
static void TownPoolNewBlock(uint start_item)
|
|
{
|
|
Town *t;
|
|
|
|
FOR_ALL_TOWNS_FROM(t, start_item)
|
|
t->index = start_item++;
|
|
}
|
|
|
|
/* Initialize the town-pool */
|
|
MemoryPool _town_pool = { "Towns", TOWN_POOL_MAX_BLOCKS, TOWN_POOL_BLOCK_SIZE_BITS, sizeof(Town), &TownPoolNewBlock, NULL, 0, 0, NULL };
|
|
|
|
// Local
|
|
static int _grow_town_result;
|
|
|
|
static bool BuildTownHouse(Town *t, TileIndex tile);
|
|
static void ClearTownHouse(Town *t, TileIndex tile);
|
|
static void DoBuildTownHouse(Town *t, TileIndex tile);
|
|
|
|
static void TownDrawHouseLift(const TileInfo *ti)
|
|
{
|
|
AddChildSpriteScreen(SPR_LIFT, 14, 60 - GetLiftPosition(ti->tile));
|
|
}
|
|
|
|
typedef void TownDrawTileProc(const TileInfo *ti);
|
|
static TownDrawTileProc * const _town_draw_tile_procs[1] = {
|
|
TownDrawHouseLift
|
|
};
|
|
|
|
|
|
static void DrawTile_Town(TileInfo *ti)
|
|
{
|
|
const DrawBuildingsTileStruct *dcts;
|
|
byte z;
|
|
uint32 image;
|
|
|
|
/* Retrieve pointer to the draw town tile struct */
|
|
{
|
|
/* this "randomizes" on the (up to) 4 variants of a building */
|
|
uint variant;
|
|
variant = ti->x >> 4;
|
|
variant ^= ti->x >> 6;
|
|
variant ^= ti->y >> 4;
|
|
variant -= ti->y >> 6;
|
|
variant &= 3;
|
|
dcts = &_town_draw_tile_data[GetHouseType(ti->tile) << 4 | variant << 2 | GetHouseBuildingStage(ti->tile)];
|
|
}
|
|
|
|
z = ti->z;
|
|
|
|
/* Add bricks below the house? */
|
|
if (ti->tileh != SLOPE_FLAT) {
|
|
AddSortableSpriteToDraw(SPR_FOUNDATION_BASE + ti->tileh, ti->x, ti->y, 16, 16, 7, z);
|
|
AddChildSpriteScreen(dcts->ground, 31, 1);
|
|
z += TILE_HEIGHT;
|
|
} else {
|
|
/* Else draw regular ground */
|
|
DrawGroundSprite(dcts->ground);
|
|
}
|
|
|
|
/* Add a house on top of the ground? */
|
|
image = dcts->building;
|
|
if (image != 0) {
|
|
if (_display_opt & DO_TRANS_BUILDINGS) MAKE_TRANSPARENT(image);
|
|
|
|
AddSortableSpriteToDraw(image,
|
|
ti->x + dcts->subtile_x,
|
|
ti->y + dcts->subtile_y,
|
|
dcts->width + 1,
|
|
dcts->height + 1,
|
|
dcts->dz,
|
|
z);
|
|
|
|
if (_display_opt & DO_TRANS_BUILDINGS) return;
|
|
}
|
|
|
|
{
|
|
int proc = dcts->draw_proc - 1;
|
|
|
|
if (proc >= 0) _town_draw_tile_procs[proc](ti);
|
|
}
|
|
}
|
|
|
|
static uint GetSlopeZ_Town(const TileInfo* ti)
|
|
{
|
|
return ti->z + (ti->tileh == SLOPE_FLAT ? 0 : TILE_HEIGHT);
|
|
}
|
|
|
|
static Slope GetSlopeTileh_Town(TileIndex tile, Slope tileh)
|
|
{
|
|
return SLOPE_FLAT;
|
|
}
|
|
|
|
static void AnimateTile_Town(TileIndex tile)
|
|
{
|
|
int pos, dest;
|
|
|
|
if (_tick_counter & 3) return;
|
|
|
|
// If the house is not one with a lift anymore, then stop this animating.
|
|
// Not exactly sure when this happens, but probably when a house changes.
|
|
// Before this was just a return...so it'd leak animated tiles..
|
|
// That bug seems to have been here since day 1??
|
|
if (!(_housetype_extra_flags[GetHouseType(tile)] & 0x20)) {
|
|
DeleteAnimatedTile(tile);
|
|
return;
|
|
}
|
|
|
|
if (!IsLiftMoving(tile)) {
|
|
int i;
|
|
|
|
/** Building has 6 floors, number 0 .. 6, where 1 is illegal.
|
|
* This is due to the fact that the first floor is, in the graphics,
|
|
* the height of 2 'normal' floors.
|
|
* Furthermore, there are 6 lift positions from floor N (incl) to floor N + 1 (excl) */
|
|
do {
|
|
i = (Random() & 7) - 1;
|
|
} while (i < 0 || i == 1 || i * 6 == GetLiftPosition(tile));
|
|
|
|
SetLiftDestination(tile, i);
|
|
}
|
|
|
|
pos = GetLiftPosition(tile);
|
|
dest = GetLiftDestination(tile) * 6;
|
|
pos += (pos < dest) ? 1 : -1;
|
|
SetLiftPosition(tile, pos);
|
|
|
|
if (pos == dest) HaltLift(tile);
|
|
|
|
MarkTileDirtyByTile(tile);
|
|
}
|
|
|
|
static void UpdateTownRadius(Town *t);
|
|
|
|
static bool IsCloseToTown(TileIndex tile, uint dist)
|
|
{
|
|
const Town* t;
|
|
|
|
FOR_ALL_TOWNS(t) {
|
|
if (t->xy != 0 && DistanceManhattan(tile, t->xy) < dist) return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static void MarkTownSignDirty(Town *t)
|
|
{
|
|
MarkAllViewportsDirty(
|
|
t->sign.left-6,
|
|
t->sign.top-3,
|
|
t->sign.left+t->sign.width_1*4+12,
|
|
t->sign.top + 45
|
|
);
|
|
}
|
|
|
|
void UpdateTownVirtCoord(Town *t)
|
|
{
|
|
Point pt;
|
|
|
|
MarkTownSignDirty(t);
|
|
pt = RemapCoords2(TileX(t->xy) * TILE_SIZE, TileY(t->xy) * TILE_SIZE);
|
|
SetDParam(0, t->index);
|
|
SetDParam(1, t->population);
|
|
UpdateViewportSignPos(&t->sign, pt.x, pt.y - 24,
|
|
_patches.population_in_label ? STR_TOWN_LABEL_POP : STR_TOWN_LABEL);
|
|
MarkTownSignDirty(t);
|
|
}
|
|
|
|
static void ChangePopulation(Town *t, int mod)
|
|
{
|
|
t->population += mod;
|
|
InvalidateWindow(WC_TOWN_VIEW, t->index);
|
|
UpdateTownVirtCoord(t);
|
|
|
|
if (_town_sort_order & 2) _town_sort_dirty = true;
|
|
}
|
|
|
|
uint32 GetWorldPopulation(void)
|
|
{
|
|
uint32 pop;
|
|
const Town* t;
|
|
|
|
pop = 0;
|
|
FOR_ALL_TOWNS(t) pop += t->population;
|
|
return pop;
|
|
}
|
|
|
|
static void MakeSingleHouseBigger(TileIndex tile)
|
|
{
|
|
assert(IsTileType(tile, MP_HOUSE));
|
|
|
|
if (LiftHasDestination(tile)) return;
|
|
|
|
IncHouseConstructionTick(tile);
|
|
if (GetHouseConstructionTick(tile) != 0) return;
|
|
|
|
IncHouseBuildingStage(tile); /*increase construction stage of one more step*/
|
|
|
|
if (GetHouseBuildingStage(tile) == TOWN_HOUSE_COMPLETED){
|
|
/*Now, construction is completed. Can add population of building to the town*/
|
|
ChangePopulation(GetTownByTile(tile), _housetype_population[GetHouseType(tile)]);
|
|
}
|
|
MarkTileDirtyByTile(tile);
|
|
}
|
|
|
|
static void MakeTownHouseBigger(TileIndex tile)
|
|
{
|
|
uint flags = _house_more_flags[GetHouseType(tile)];
|
|
if (flags & 8) MakeSingleHouseBigger(TILE_ADDXY(tile, 0, 0));
|
|
if (flags & 4) MakeSingleHouseBigger(TILE_ADDXY(tile, 0, 1));
|
|
if (flags & 2) MakeSingleHouseBigger(TILE_ADDXY(tile, 1, 0));
|
|
if (flags & 1) MakeSingleHouseBigger(TILE_ADDXY(tile, 1, 1));
|
|
}
|
|
|
|
static void TileLoop_Town(TileIndex tile)
|
|
{
|
|
int house;
|
|
Town *t;
|
|
uint32 r;
|
|
|
|
if (GetHouseBuildingStage(tile) != TOWN_HOUSE_COMPLETED) {
|
|
/*Construction is not completed. See if we can go further in construction*/
|
|
MakeTownHouseBigger(tile);
|
|
return;
|
|
}
|
|
|
|
house = GetHouseType(tile);
|
|
if ((_housetype_extra_flags[house] & 0x20) && !LiftHasDestination(tile) && CHANCE16(1, 2) && AddAnimatedTile(tile)) BeginLiftMovement(tile);
|
|
|
|
t = GetTownByTile(tile);
|
|
|
|
r = Random();
|
|
|
|
if (GB(r, 0, 8) < _housetype_population[house]) {
|
|
uint amt = GB(r, 0, 8) / 8 + 1;
|
|
uint moved;
|
|
|
|
if (_economy.fluct <= 0) amt = (amt + 1) >> 1;
|
|
t->new_max_pass += amt;
|
|
moved = MoveGoodsToStation(tile, 1, 1, CT_PASSENGERS, amt);
|
|
t->new_act_pass += moved;
|
|
}
|
|
|
|
if (GB(r, 8, 8) < _housetype_mailamount[house] ) {
|
|
uint amt = GB(r, 8, 8) / 8 + 1;
|
|
uint moved;
|
|
|
|
if (_economy.fluct <= 0) amt = (amt + 1) >> 1;
|
|
t->new_max_mail += amt;
|
|
moved = MoveGoodsToStation(tile, 1, 1, CT_MAIL, amt);
|
|
t->new_act_mail += moved;
|
|
}
|
|
|
|
if (_house_more_flags[house] & 8 && HASBIT(t->flags12, TOWN_IS_FUNDED) && --t->time_until_rebuild == 0) {
|
|
t->time_until_rebuild = GB(r, 16, 6) + 130;
|
|
|
|
_current_player = OWNER_TOWN;
|
|
|
|
ClearTownHouse(t, tile);
|
|
|
|
// rebuild with another house?
|
|
if (GB(r, 24, 8) >= 12) DoBuildTownHouse(t, tile);
|
|
|
|
_current_player = OWNER_NONE;
|
|
}
|
|
}
|
|
|
|
static void ClickTile_Town(TileIndex tile)
|
|
{
|
|
/* not used */
|
|
}
|
|
|
|
static int32 ClearTile_Town(TileIndex tile, byte flags)
|
|
{
|
|
int house, rating;
|
|
int32 cost;
|
|
Town *t;
|
|
|
|
// safety checks
|
|
if (!EnsureNoVehicle(tile)) return CMD_ERROR;
|
|
if (flags&DC_AUTO && !(flags&DC_AI_BUILDING)) return_cmd_error(STR_2004_BUILDING_MUST_BE_DEMOLISHED);
|
|
|
|
house = GetHouseType(tile);
|
|
cost = _price.remove_house * _housetype_remove_cost[house] >> 8;
|
|
|
|
rating = _housetype_remove_ratingmod[house];
|
|
_cleared_town_rating += rating;
|
|
_cleared_town = t = GetTownByTile(tile);
|
|
|
|
if (_current_player < MAX_PLAYERS) {
|
|
if (rating > t->ratings[_current_player] && !(flags & DC_NO_TOWN_RATING) && !_cheats.magic_bulldozer.value) {
|
|
SetDParam(0, t->index);
|
|
return_cmd_error(STR_2009_LOCAL_AUTHORITY_REFUSES);
|
|
}
|
|
}
|
|
|
|
if (flags & DC_EXEC) {
|
|
ChangeTownRating(t, -rating, RATING_HOUSE_MINIMUM);
|
|
ClearTownHouse(t, tile);
|
|
}
|
|
|
|
return cost;
|
|
}
|
|
|
|
static void GetAcceptedCargo_Town(TileIndex tile, AcceptedCargo ac)
|
|
{
|
|
byte type = GetHouseType(tile);
|
|
|
|
ac[CT_PASSENGERS] = _housetype_cargo_passengers[type];
|
|
ac[CT_MAIL] = _housetype_cargo_mail[type];
|
|
ac[CT_GOODS] = _housetype_cargo_goods[type];
|
|
ac[CT_FOOD] = _housetype_cargo_food[type];
|
|
}
|
|
|
|
static void GetTileDesc_Town(TileIndex tile, TileDesc *td)
|
|
{
|
|
td->str = _town_tile_names[GetHouseType(tile)];
|
|
if (GetHouseBuildingStage(tile) != TOWN_HOUSE_COMPLETED) {
|
|
SetDParamX(td->dparam, 0, td->str);
|
|
td->str = STR_2058_UNDER_CONSTRUCTION;
|
|
}
|
|
|
|
td->owner = OWNER_TOWN;
|
|
}
|
|
|
|
static uint32 GetTileTrackStatus_Town(TileIndex tile, TransportType mode)
|
|
{
|
|
/* not used */
|
|
return 0;
|
|
}
|
|
|
|
static void ChangeTileOwner_Town(TileIndex tile, PlayerID old_player, PlayerID new_player)
|
|
{
|
|
/* not used */
|
|
}
|
|
|
|
|
|
static const TileIndexDiffC _roadblock_tileadd[] = {
|
|
{ 0, -1},
|
|
{ 1, 0},
|
|
{ 0, 1},
|
|
{-1, 0},
|
|
|
|
// Store the first 3 elements again.
|
|
// Lets us rotate without using &3.
|
|
{ 0, -1},
|
|
{ 1, 0},
|
|
{ 0, 1}
|
|
};
|
|
|
|
|
|
static bool GrowTown(Town *t);
|
|
|
|
static void TownTickHandler(Town *t)
|
|
{
|
|
if (HASBIT(t->flags12, TOWN_IS_FUNDED)) {
|
|
int i = t->grow_counter - 1;
|
|
if (i < 0) {
|
|
if (GrowTown(t)) {
|
|
i = t->growth_rate;
|
|
} else {
|
|
i = 0;
|
|
}
|
|
}
|
|
t->grow_counter = i;
|
|
}
|
|
|
|
UpdateTownRadius(t);
|
|
}
|
|
|
|
void OnTick_Town(void)
|
|
{
|
|
if (_game_mode == GM_EDITOR) return;
|
|
|
|
/* Make sure each town's tickhandler invocation frequency is about the
|
|
* same - TOWN_GROWTH_FREQUENCY - independent on the number of towns. */
|
|
for (_cur_town_iter += GetTownPoolSize();
|
|
_cur_town_iter >= TOWN_GROWTH_FREQUENCY;
|
|
_cur_town_iter -= TOWN_GROWTH_FREQUENCY) {
|
|
uint32 i = _cur_town_ctr;
|
|
Town *t;
|
|
|
|
if (++_cur_town_ctr >= GetTownPoolSize())
|
|
_cur_town_ctr = 0;
|
|
|
|
t = GetTown(i);
|
|
|
|
if (t->xy != 0) TownTickHandler(t);
|
|
}
|
|
}
|
|
|
|
static RoadBits GetTownRoadMask(TileIndex tile)
|
|
{
|
|
TrackBits b = GetAnyRoadTrackBits(tile);
|
|
RoadBits r = 0;
|
|
|
|
if (b & TRACK_BIT_X) r |= ROAD_X;
|
|
if (b & TRACK_BIT_Y) r |= ROAD_Y;
|
|
if (b & TRACK_BIT_UPPER) r |= ROAD_NE | ROAD_NW;
|
|
if (b & TRACK_BIT_LOWER) r |= ROAD_SE | ROAD_SW;
|
|
if (b & TRACK_BIT_LEFT) r |= ROAD_NW | ROAD_SW;
|
|
if (b & TRACK_BIT_RIGHT) r |= ROAD_NE | ROAD_SE;
|
|
return r;
|
|
}
|
|
|
|
static bool IsRoadAllowedHere(TileIndex tile, int dir)
|
|
{
|
|
Slope k;
|
|
Slope slope;
|
|
|
|
// If this assertion fails, it might be because the world contains
|
|
// land at the edges. This is not ok.
|
|
TILE_ASSERT(tile);
|
|
|
|
for (;;) {
|
|
// Check if there already is a road at this point?
|
|
if (GetAnyRoadTrackBits(tile) == 0) {
|
|
// No, try to build one in the direction.
|
|
// if that fails clear the land, and if that fails exit.
|
|
// This is to make sure that we can build a road here later.
|
|
if (CmdFailed(DoCommand(tile, (dir & 1 ? ROAD_X : ROAD_Y), 0, DC_AUTO, CMD_BUILD_ROAD)) &&
|
|
CmdFailed(DoCommand(tile, 0, 0, DC_AUTO, CMD_LANDSCAPE_CLEAR)))
|
|
return false;
|
|
}
|
|
|
|
slope = GetTileSlope(tile, NULL);
|
|
if (slope == SLOPE_FLAT) {
|
|
no_slope:
|
|
// Tile has no slope
|
|
// Disallow the road if any neighboring tile has a road.
|
|
if (HASBIT(GetTownRoadMask(TILE_ADD(tile, ToTileIndexDiff(_roadblock_tileadd[dir+1]))), dir^2) ||
|
|
HASBIT(GetTownRoadMask(TILE_ADD(tile, ToTileIndexDiff(_roadblock_tileadd[dir+3]))), dir^2) ||
|
|
HASBIT(GetTownRoadMask(TILE_ADD(tile, ToTileIndexDiff(_roadblock_tileadd[dir+1]) + ToTileIndexDiff(_roadblock_tileadd[dir+2]))), dir) ||
|
|
HASBIT(GetTownRoadMask(TILE_ADD(tile, ToTileIndexDiff(_roadblock_tileadd[dir+3]) + ToTileIndexDiff(_roadblock_tileadd[dir+2]))), dir))
|
|
return false;
|
|
|
|
// Otherwise allow
|
|
return true;
|
|
}
|
|
|
|
// If the tile is not a slope in the right direction, then
|
|
// maybe terraform some.
|
|
k = (dir & 1) ? SLOPE_NE : SLOPE_NW;
|
|
if (k != slope && ComplementSlope(k) != slope) {
|
|
uint32 r = Random();
|
|
|
|
if (CHANCE16I(1, 8, r) && !_generating_world) {
|
|
int32 res;
|
|
|
|
if (CHANCE16I(1, 16, r)) {
|
|
res = DoCommand(tile, slope, 0, DC_EXEC | DC_AUTO | DC_NO_WATER,
|
|
CMD_TERRAFORM_LAND);
|
|
} else {
|
|
res = DoCommand(tile, slope ^ 0xF, 1, DC_EXEC | DC_AUTO | DC_NO_WATER,
|
|
CMD_TERRAFORM_LAND);
|
|
}
|
|
if (CmdFailed(res) && CHANCE16I(1, 3, r)) {
|
|
// We can consider building on the slope, though.
|
|
goto no_slope;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
|
|
static bool TerraformTownTile(TileIndex tile, int edges, int dir)
|
|
{
|
|
int32 r;
|
|
|
|
TILE_ASSERT(tile);
|
|
|
|
r = DoCommand(tile, edges, dir, DC_AUTO | DC_NO_WATER, CMD_TERRAFORM_LAND);
|
|
if (CmdFailed(r) || r >= 126 * 16) return false;
|
|
DoCommand(tile, edges, dir, DC_AUTO | DC_NO_WATER | DC_EXEC, CMD_TERRAFORM_LAND);
|
|
return true;
|
|
}
|
|
|
|
static void LevelTownLand(TileIndex tile)
|
|
{
|
|
Slope tileh;
|
|
|
|
TILE_ASSERT(tile);
|
|
|
|
// Don't terraform if land is plain or if there's a house there.
|
|
if (IsTileType(tile, MP_HOUSE)) return;
|
|
tileh = GetTileSlope(tile, NULL);
|
|
if (tileh == SLOPE_FLAT) return;
|
|
|
|
// First try up, then down
|
|
if (!TerraformTownTile(tile, ~tileh & 0xF, 1)) {
|
|
TerraformTownTile(tile, tileh & 0xF, 0);
|
|
}
|
|
}
|
|
|
|
static void GrowTownInTile(TileIndex* tile_ptr, RoadBits mask, int block, Town* t1)
|
|
{
|
|
RoadBits rcmd;
|
|
TileIndex tmptile;
|
|
DiagDirection i;
|
|
int j;
|
|
TileIndex tile = *tile_ptr;
|
|
|
|
TILE_ASSERT(tile);
|
|
|
|
if (mask == 0) {
|
|
int a;
|
|
int b;
|
|
|
|
// Tile has no road. First reset the status counter
|
|
// to say that this is the last iteration.
|
|
_grow_town_result = 0;
|
|
|
|
// Remove hills etc
|
|
LevelTownLand(tile);
|
|
|
|
// Is a road allowed here?
|
|
if (!IsRoadAllowedHere(tile, block)) return;
|
|
|
|
// Randomize new road block numbers
|
|
a = block;
|
|
b = block ^ 2;
|
|
if (CHANCE16(1, 4)) {
|
|
do {
|
|
a = GB(Random(), 0, 2);
|
|
} while (a == b);
|
|
}
|
|
|
|
if (!IsRoadAllowedHere(TILE_ADD(tile, ToTileIndexDiff(_roadblock_tileadd[a])), a)) {
|
|
// A road is not allowed to continue the randomized road,
|
|
// return if the road we're trying to build is curved.
|
|
if (a != (b ^ 2)) return;
|
|
|
|
// Return if neither side of the new road is a house
|
|
if (!IsTileType(TILE_ADD(tile, ToTileIndexDiff(_roadblock_tileadd[a + 1])), MP_HOUSE) &&
|
|
!IsTileType(TILE_ADD(tile, ToTileIndexDiff(_roadblock_tileadd[a + 3])), MP_HOUSE))
|
|
return;
|
|
|
|
// That means that the road is only allowed if there is a house
|
|
// at any side of the new road.
|
|
}
|
|
rcmd = (1 << a) + (1 << b);
|
|
|
|
} else if (block < 5 && !HASBIT(mask,block^2)) {
|
|
// Continue building on a partial road.
|
|
// Always OK.
|
|
_grow_town_result = 0;
|
|
rcmd = 1 << (block ^ 2);
|
|
} else {
|
|
int i;
|
|
|
|
// Reached a tunnel? Then continue at the other side of it.
|
|
if (IsTunnelTile(tile) && GetTunnelTransportType(tile) == TRANSPORT_ROAD) {
|
|
*tile_ptr = GetOtherTunnelEnd(tile);
|
|
return;
|
|
}
|
|
|
|
// For any other kind of tunnel/bridge, bail out.
|
|
if (IsTileType(tile, MP_TUNNELBRIDGE)) return;
|
|
|
|
// Possibly extend the road in a direction.
|
|
// Randomize a direction and if it has a road, bail out.
|
|
i = GB(Random(), 0, 2);
|
|
if (HASBIT(mask, i)) return;
|
|
|
|
// This is the tile we will reach if we extend to this direction.
|
|
tmptile = TILE_ADD(tile, ToTileIndexDiff(_roadblock_tileadd[i]));
|
|
|
|
// Don't do it if it reaches to water.
|
|
if (IsClearWaterTile(tmptile)) return;
|
|
|
|
// Build a house at the edge. 60% chance or
|
|
// always ok if no road allowed.
|
|
if (!IsRoadAllowedHere(tmptile, i) || CHANCE16(6, 10)) {
|
|
// But not if there already is a house there.
|
|
if (!IsTileType(tmptile, MP_HOUSE)) {
|
|
// Level the land if possible
|
|
LevelTownLand(tmptile);
|
|
|
|
// And build a house.
|
|
// Set result to -1 if we managed to build it.
|
|
if (BuildTownHouse(t1, tmptile)) _grow_town_result = -1;
|
|
}
|
|
return;
|
|
}
|
|
|
|
_grow_town_result = 0;
|
|
rcmd = 1 << i;
|
|
}
|
|
|
|
// Return if a water tile
|
|
if (IsClearWaterTile(tile)) return;
|
|
|
|
// Determine direction of slope,
|
|
// and build a road if not a special slope.
|
|
switch (GetTileSlope(tile, NULL)) {
|
|
case SLOPE_SW: i = DIAGDIR_NE; break;
|
|
case SLOPE_SE: i = DIAGDIR_NW; break;
|
|
case SLOPE_NW: i = DIAGDIR_SE; break;
|
|
case SLOPE_NE: i = DIAGDIR_SW; break;
|
|
|
|
default:
|
|
build_road_and_exit:
|
|
if (!CmdFailed(DoCommand(tile, rcmd, t1->index, DC_EXEC | DC_AUTO | DC_NO_WATER, CMD_BUILD_ROAD))) {
|
|
_grow_town_result = -1;
|
|
}
|
|
return;
|
|
}
|
|
|
|
tmptile = tile;
|
|
|
|
// Now it contains the direction of the slope
|
|
j = -11; // max 11 tile long bridges
|
|
do {
|
|
if (++j == 0)
|
|
goto build_road_and_exit;
|
|
tmptile = TILE_MASK(tmptile + TileOffsByDir(i));
|
|
} while (IsClearWaterTile(tmptile));
|
|
|
|
// no water tiles in between?
|
|
if (j == -10)
|
|
goto build_road_and_exit;
|
|
|
|
// Quit if it selecting an appropiate bridge type fails a large number of times.
|
|
j = 22;
|
|
{
|
|
int32 bridge_len = GetBridgeLength(tile, tmptile);
|
|
do {
|
|
byte bridge_type = RandomRange(MAX_BRIDGES - 1);
|
|
if (CheckBridge_Stuff(bridge_type, bridge_len)) {
|
|
if (!CmdFailed(DoCommand(tile, tmptile, 0x8000 + bridge_type, DC_EXEC | DC_AUTO, CMD_BUILD_BRIDGE)))
|
|
_grow_town_result = -1;
|
|
|
|
// obviously, if building any bridge would fail, there is no need to try other bridge-types
|
|
return;
|
|
}
|
|
} while (--j != 0);
|
|
}
|
|
}
|
|
|
|
// Returns true if a house was built, or no if the build failed.
|
|
static int GrowTownAtRoad(Town *t, TileIndex tile)
|
|
{
|
|
int block = 5; // special case
|
|
|
|
TILE_ASSERT(tile);
|
|
|
|
// Number of times to search.
|
|
_grow_town_result = 10 + t->num_houses * 4 / 9;
|
|
|
|
do {
|
|
// Get a bitmask of the road blocks on a tile
|
|
RoadBits mask = GetTownRoadMask(tile);
|
|
|
|
// Try to grow the town from this point
|
|
GrowTownInTile(&tile,mask,block,t);
|
|
|
|
// Exclude the source position from the bitmask
|
|
// and return if no more road blocks available
|
|
CLRBIT(mask, (block ^ 2));
|
|
if (mask == 0)
|
|
return _grow_town_result;
|
|
|
|
// Select a random bit from the blockmask, walk a step
|
|
// and continue the search from there.
|
|
do block = Random() & 3; while (!HASBIT(mask,block));
|
|
tile += ToTileIndexDiff(_roadblock_tileadd[block]);
|
|
|
|
if (IsTileType(tile, MP_STREET)) {
|
|
/* Don't allow building over roads of other cities */
|
|
if (IsTileOwner(tile, OWNER_TOWN) && GetTownByTile(tile) != t)
|
|
_grow_town_result = -1;
|
|
else if (_game_mode == GM_EDITOR) {
|
|
/* If we are in the SE, and this road-piece has no town owner yet, it just found an
|
|
* owner :) (happy happy happy road now) */
|
|
SetTileOwner(tile, OWNER_TOWN);
|
|
SetTownIndex(tile, t->index);
|
|
}
|
|
}
|
|
|
|
// Max number of times is checked.
|
|
} while (--_grow_town_result >= 0);
|
|
|
|
return (_grow_town_result == -2);
|
|
}
|
|
|
|
// Generate a random road block
|
|
// The probability of a straight road
|
|
// is somewhat higher than a curved.
|
|
static RoadBits GenRandomRoadBits(void)
|
|
{
|
|
uint32 r = Random();
|
|
uint a = GB(r, 0, 2);
|
|
uint b = GB(r, 8, 2);
|
|
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.
|
|
static bool GrowTown(Town *t)
|
|
{
|
|
TileIndex tile;
|
|
const TileIndexDiffC *ptr;
|
|
PlayerID old_player;
|
|
|
|
static const TileIndexDiffC _town_coord_mod[] = {
|
|
{-1, 0},
|
|
{ 1, 1},
|
|
{ 1, -1},
|
|
{-1, -1},
|
|
{-1, 0},
|
|
{ 0, 2},
|
|
{ 2, 0},
|
|
{ 0, -2},
|
|
{-1, -1},
|
|
{-2, 2},
|
|
{ 2, 2},
|
|
{ 2, -2},
|
|
{ 0, 0}
|
|
};
|
|
|
|
// Current player is a town
|
|
old_player = _current_player;
|
|
_current_player = OWNER_TOWN;
|
|
|
|
// Find a road that we can base the construction on.
|
|
tile = t->xy;
|
|
for (ptr = _town_coord_mod; ptr != endof(_town_coord_mod); ++ptr) {
|
|
if (GetAnyRoadTrackBits(tile) != 0) {
|
|
int r = GrowTownAtRoad(t, tile);
|
|
_current_player = old_player;
|
|
return r;
|
|
}
|
|
tile = TILE_ADD(tile, ToTileIndexDiff(*ptr));
|
|
}
|
|
|
|
// No road available, try to build a random road block by
|
|
// clearing some land and then building a road there.
|
|
tile = t->xy;
|
|
for (ptr = _town_coord_mod; ptr != endof(_town_coord_mod); ++ptr) {
|
|
// Only work with plain land that not already has a house with GetHouseConstructionTick=0
|
|
if ((!IsTileType(tile, MP_HOUSE) || GetHouseConstructionTick(tile) != 0) &&
|
|
GetTileSlope(tile, NULL) == SLOPE_FLAT) {
|
|
if (!CmdFailed(DoCommand(tile, 0, 0, DC_AUTO, CMD_LANDSCAPE_CLEAR))) {
|
|
DoCommand(tile, GenRandomRoadBits(), t->index, DC_EXEC | DC_AUTO, CMD_BUILD_ROAD);
|
|
_current_player = old_player;
|
|
return true;
|
|
}
|
|
}
|
|
tile = TILE_ADD(tile, ToTileIndexDiff(*ptr));
|
|
}
|
|
|
|
_current_player = old_player;
|
|
return false;
|
|
}
|
|
|
|
static void UpdateTownRadius(Town *t)
|
|
{
|
|
static const uint16 _town_radius_data[23][5] = {
|
|
{ 4, 0, 0, 0, 0}, // 0
|
|
{16, 0, 0, 0, 0},
|
|
{25, 0, 0, 0, 0},
|
|
{36, 0, 0, 0, 0},
|
|
{49, 0, 4, 0, 0},
|
|
{64, 0, 4, 0, 0}, // 20
|
|
{64, 0, 9, 0, 1},
|
|
{64, 0, 9, 0, 4},
|
|
{64, 0, 16, 0, 4},
|
|
{81, 0, 16, 0, 4},
|
|
{81, 0, 16, 0, 4}, // 40
|
|
{81, 0, 25, 0, 9},
|
|
{81, 36, 25, 0, 9},
|
|
{81, 36, 25, 16, 9},
|
|
{81, 49, 0, 25, 9},
|
|
{81, 64, 0, 25, 9}, // 60
|
|
{81, 64, 0, 36, 9},
|
|
{81, 64, 0, 36, 16},
|
|
{100, 81, 0, 49, 16},
|
|
{100, 81, 0, 49, 25},
|
|
{121, 81, 0, 49, 25}, // 80
|
|
{121, 81, 0, 49, 25},
|
|
{121, 81, 0, 49, 36}, // 88
|
|
};
|
|
|
|
if (t->num_houses < 92) {
|
|
memcpy(t->radius, _town_radius_data[t->num_houses / 4], sizeof(t->radius));
|
|
} else {
|
|
int mass = t->num_houses / 8;
|
|
// At least very roughly extrapolate. Empirical numbers dancing between
|
|
// overwhelming by cottages and skyscrapers outskirts.
|
|
t->radius[0] = mass * mass;
|
|
// Actually we are proportional to sqrt() but that's right because
|
|
// we are covering an area.
|
|
t->radius[1] = mass * 7;
|
|
t->radius[2] = 0;
|
|
t->radius[3] = mass * 4;
|
|
t->radius[4] = mass * 3;
|
|
//debug("%d (->%d): %d %d %d %d\n", t->num_houses, mass, t->radius[0], t->radius[1], t->radius[3], t->radius[4]);
|
|
}
|
|
}
|
|
|
|
static bool CreateTownName(uint32 *townnameparts)
|
|
{
|
|
Town *t2;
|
|
char buf1[64];
|
|
char buf2[64];
|
|
uint32 r;
|
|
/* Do not set too low tries, since when we run out of names, we loop
|
|
* for #tries only one time anyway - then we stop generating more
|
|
* towns. Do not show it too high neither, since looping through all
|
|
* the other towns may take considerable amount of time (10000 is
|
|
* too much). */
|
|
int tries = 1000;
|
|
uint16 townnametype = SPECSTR_TOWNNAME_START + _opt.town_name;
|
|
|
|
assert(townnameparts);
|
|
|
|
for (;;) {
|
|
restart:
|
|
r = Random();
|
|
|
|
SetDParam(0, r);
|
|
GetString(buf1, townnametype);
|
|
|
|
// Check size and width
|
|
if (strlen(buf1) >= 31 || GetStringWidth(buf1) > 130) continue;
|
|
|
|
FOR_ALL_TOWNS(t2) {
|
|
if (t2->xy != 0) {
|
|
// We can't just compare the numbers since
|
|
// several numbers may map to a single name.
|
|
SetDParam(0, t2->index);
|
|
GetString(buf2, STR_TOWN);
|
|
if (strcmp(buf1, buf2) == 0) {
|
|
if (tries-- < 0) return false;
|
|
goto restart;
|
|
}
|
|
}
|
|
}
|
|
*townnameparts = r;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
void UpdateTownMaxPass(Town *t)
|
|
{
|
|
t->max_pass = t->population >> 3;
|
|
t->max_mail = t->population >> 4;
|
|
}
|
|
|
|
static void DoCreateTown(Town *t, TileIndex tile, uint32 townnameparts, uint size_mode)
|
|
{
|
|
int x, i;
|
|
|
|
// clear the town struct
|
|
i = t->index;
|
|
memset(t, 0, sizeof(Town));
|
|
t->index = i;
|
|
|
|
t->xy = tile;
|
|
t->num_houses = 0;
|
|
t->time_until_rebuild = 10;
|
|
UpdateTownRadius(t);
|
|
t->flags12 = 0;
|
|
t->population = 0;
|
|
t->grow_counter = 0;
|
|
t->growth_rate = 250;
|
|
t->new_max_pass = 0;
|
|
t->new_max_mail = 0;
|
|
t->new_act_pass = 0;
|
|
t->new_act_mail = 0;
|
|
t->max_pass = 0;
|
|
t->max_mail = 0;
|
|
t->act_pass = 0;
|
|
t->act_mail = 0;
|
|
|
|
t->pct_pass_transported = 0;
|
|
t->pct_mail_transported = 0;
|
|
t->fund_buildings_months = 0;
|
|
t->new_act_food = 0;
|
|
t->new_act_water = 0;
|
|
t->act_food = 0;
|
|
t->act_water = 0;
|
|
|
|
for (i = 0; i != MAX_PLAYERS; i++)
|
|
t->ratings[i] = 500;
|
|
|
|
t->have_ratings = 0;
|
|
t->exclusivity = (byte)-1;
|
|
t->exclusive_counter = 0;
|
|
t->statues = 0;
|
|
|
|
t->townnametype = SPECSTR_TOWNNAME_START + _opt.town_name;
|
|
t->townnameparts = townnameparts;
|
|
|
|
UpdateTownVirtCoord(t);
|
|
_town_sort_dirty = true;
|
|
|
|
if (size_mode == 0) {
|
|
x = (Random() & 0xF) + 8;
|
|
} else {
|
|
x = (size_mode - 1) * 16 + 3;
|
|
}
|
|
|
|
t->num_houses += x;
|
|
UpdateTownRadius(t);
|
|
|
|
i = x * 4;
|
|
do {
|
|
GrowTown(t);
|
|
} while (--i);
|
|
|
|
t->num_houses -= x;
|
|
UpdateTownRadius(t);
|
|
UpdateTownMaxPass(t);
|
|
}
|
|
|
|
static Town *AllocateTown(void)
|
|
{
|
|
Town *t;
|
|
FOR_ALL_TOWNS(t) {
|
|
if (t->xy == 0) {
|
|
uint index = t->index;
|
|
|
|
if (t->index > _total_towns)
|
|
_total_towns = t->index;
|
|
|
|
memset(t, 0, sizeof(Town));
|
|
t->index = index;
|
|
|
|
return t;
|
|
}
|
|
}
|
|
|
|
/* Check if we can add a block to the pool */
|
|
if (AddBlockToPool(&_town_pool))
|
|
return AllocateTown();
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/** 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 p1 size of the town (1 = small, 2 = medium, 3 = large)
|
|
* @param p2 unused
|
|
*/
|
|
int32 CmdBuildTown(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
|
|
{
|
|
Town *t;
|
|
uint32 townnameparts;
|
|
|
|
/* Only in the scenario editor */
|
|
if (_game_mode != GM_EDITOR) return CMD_ERROR;
|
|
|
|
SET_EXPENSES_TYPE(EXPENSES_OTHER);
|
|
|
|
// Check if too close to the edge of map
|
|
if (DistanceFromEdge(tile) < 12)
|
|
return_cmd_error(STR_0237_TOO_CLOSE_TO_EDGE_OF_MAP);
|
|
|
|
// Can only build on clear flat areas.
|
|
if (!IsTileType(tile, MP_CLEAR) || GetTileSlope(tile, NULL) != SLOPE_FLAT) {
|
|
return_cmd_error(STR_0239_SITE_UNSUITABLE);
|
|
}
|
|
|
|
// Check distance to all other towns.
|
|
if (IsCloseToTown(tile, 20))
|
|
return_cmd_error(STR_0238_TOO_CLOSE_TO_ANOTHER_TOWN);
|
|
|
|
// Get a unique name for the town.
|
|
if (!CreateTownName(&townnameparts))
|
|
return_cmd_error(STR_023A_TOO_MANY_TOWNS);
|
|
|
|
// Allocate town struct
|
|
t = AllocateTown();
|
|
if (t == NULL) return_cmd_error(STR_023A_TOO_MANY_TOWNS);
|
|
|
|
// Create the town
|
|
if (flags & DC_EXEC) {
|
|
_generating_world = true;
|
|
DoCreateTown(t, tile, townnameparts, p1);
|
|
_generating_world = false;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
Town *CreateRandomTown(uint attempts, uint size_mode)
|
|
{
|
|
TileIndex tile;
|
|
Town *t;
|
|
uint32 townnameparts;
|
|
|
|
do {
|
|
// Generate a tile index not too close from the edge
|
|
tile = RandomTile();
|
|
if (DistanceFromEdge(tile) < 20) continue;
|
|
|
|
// Make sure the tile is plain
|
|
if (!IsTileType(tile, MP_CLEAR) || GetTileSlope(tile, NULL) != SLOPE_FLAT) continue;
|
|
|
|
// Check not too close to a town
|
|
if (IsCloseToTown(tile, 20)) continue;
|
|
|
|
// Get a unique name for the town.
|
|
if (!CreateTownName(&townnameparts)) break;
|
|
|
|
// Allocate a town struct
|
|
t = AllocateTown();
|
|
if (t == NULL) break;
|
|
|
|
DoCreateTown(t, tile, townnameparts, size_mode);
|
|
return t;
|
|
} while (--attempts);
|
|
return NULL;
|
|
}
|
|
|
|
static const byte _num_initial_towns[3] = {11, 23, 46};
|
|
|
|
bool GenerateTowns(void)
|
|
{
|
|
uint num = 0;
|
|
uint n = ScaleByMapSize(_num_initial_towns[_opt.diff.number_towns] + (Random() & 7));
|
|
|
|
do {
|
|
if (CreateRandomTown(20, 0) != NULL) //try 20 times to create a random-sized town for the first loop.
|
|
num++;
|
|
} while (--n);
|
|
|
|
// give it a last try, but now more aggressive
|
|
if (num == 0 && CreateRandomTown(10000, 0) == NULL) {
|
|
Town *t;
|
|
FOR_ALL_TOWNS(t) { if (IsValidTown(t)) {num = 1; break;}}
|
|
|
|
//XXX can we handle that more gracefully?
|
|
if (num == 0 && _game_mode != GM_EDITOR) error("Could not generate any town");
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
static bool CheckBuildHouseMode(TileIndex tile, Slope tileh, int mode)
|
|
{
|
|
int b;
|
|
Slope slope;
|
|
|
|
static const byte _masks[8] = {
|
|
0xC,0x3,0x9,0x6,
|
|
0x3,0xC,0x6,0x9,
|
|
};
|
|
|
|
slope = GetTileSlope(tile, NULL);
|
|
if (IsSteepSlope(slope)) return false;
|
|
|
|
if (MayHaveBridgeAbove(tile) && IsBridgeAbove(tile)) return false;
|
|
|
|
b = 0;
|
|
if ((slope != SLOPE_FLAT && ~slope & _masks[mode])) b = ~b;
|
|
if ((tileh != SLOPE_FLAT && ~tileh & _masks[mode+4])) b = ~b;
|
|
if (b)
|
|
return false;
|
|
|
|
return !CmdFailed(DoCommand(tile, 0, 0, DC_EXEC | DC_AUTO | DC_NO_WATER, CMD_LANDSCAPE_CLEAR));
|
|
}
|
|
|
|
int GetTownRadiusGroup(const Town *t, TileIndex tile)
|
|
{
|
|
uint dist;
|
|
int i,smallest;
|
|
|
|
dist = DistanceSquare(tile, t->xy);
|
|
if (t->fund_buildings_months && dist <= 25)
|
|
return 4;
|
|
|
|
smallest = 0;
|
|
for (i = 0; i != lengthof(t->radius); i++) {
|
|
if (dist < t->radius[i])
|
|
smallest = i;
|
|
}
|
|
|
|
return smallest;
|
|
}
|
|
|
|
static bool CheckFree2x2Area(TileIndex tile)
|
|
{
|
|
int i;
|
|
|
|
static const TileIndexDiffC _tile_add[] = {
|
|
{0 , 0 },
|
|
{0 - 0, 1 - 0},
|
|
{1 - 0, 0 - 1},
|
|
{1 - 1, 1 - 0}
|
|
};
|
|
|
|
for (i = 0; i != 4; i++) {
|
|
tile += ToTileIndexDiff(_tile_add[i]);
|
|
|
|
if (GetTileSlope(tile, NULL) != SLOPE_FLAT) return false;
|
|
|
|
if (MayHaveBridgeAbove(tile) && IsBridgeAbove(tile)) return false;
|
|
|
|
if (CmdFailed(DoCommand(tile, 0, 0, DC_EXEC | DC_AUTO | DC_NO_WATER | DC_FORCETEST, CMD_LANDSCAPE_CLEAR)))
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
static void DoBuildTownHouse(Town *t, TileIndex tile)
|
|
{
|
|
int i;
|
|
uint bitmask;
|
|
int house;
|
|
Slope slope;
|
|
uint z;
|
|
uint oneof = 0;
|
|
|
|
// Above snow?
|
|
slope = GetTileSlope(tile, &z);
|
|
|
|
// Get the town zone type
|
|
{
|
|
uint rad = GetTownRadiusGroup(t, tile);
|
|
|
|
int land = _opt.landscape;
|
|
if (land == LT_HILLY && z >= _opt.snow_line)
|
|
land = -1;
|
|
|
|
bitmask = (1 << rad) + (1 << (land + 12));
|
|
}
|
|
|
|
// bits 0-4 are used
|
|
// bits 11-15 are used
|
|
// bits 5-10 are not used.
|
|
{
|
|
byte houses[lengthof(_housetype_flags)];
|
|
int num = 0;
|
|
|
|
// Generate a list of all possible houses that can be built.
|
|
for (i=0; i!=lengthof(_housetype_flags); i++) {
|
|
if ((~_housetype_flags[i] & bitmask) == 0)
|
|
houses[num++] = (byte)i;
|
|
}
|
|
|
|
for (;;) {
|
|
house = houses[RandomRange(num)];
|
|
|
|
if (_cur_year < _housetype_years[house].min || _cur_year > _housetype_years[house].max)
|
|
continue;
|
|
|
|
// Special houses that there can be only one of.
|
|
switch (house) {
|
|
case HOUSE_TEMP_CHURCH:
|
|
case HOUSE_ARCT_CHURCH:
|
|
case HOUSE_SNOW_CHURCH:
|
|
case HOUSE_TROP_CHURCH:
|
|
case HOUSE_TOY_CHURCH:
|
|
SETBIT(oneof, TOWN_HAS_CHURCH);
|
|
break;
|
|
case HOUSE_STADIUM:
|
|
case HOUSE_MODERN_STADIUM:
|
|
SETBIT(oneof, TOWN_HAS_STADIUM);
|
|
break;
|
|
default:
|
|
oneof = 0;
|
|
break;
|
|
}
|
|
|
|
if (HASBITS(t->flags12 , oneof)) continue;
|
|
|
|
// Make sure there is no slope?
|
|
if (_housetype_extra_flags[house] & 0x12 && slope != SLOPE_FLAT) continue;
|
|
|
|
if (_housetype_extra_flags[house] & 0x10) {
|
|
if (CheckFree2x2Area(tile) ||
|
|
CheckFree2x2Area(tile += TileDiffXY(-1, 0)) ||
|
|
CheckFree2x2Area(tile += TileDiffXY( 0, -1)) ||
|
|
CheckFree2x2Area(tile += TileDiffXY( 1, 0))) {
|
|
break;
|
|
}
|
|
tile += TileDiffXY(0, 1);
|
|
} else if (_housetype_extra_flags[house] & 4) {
|
|
if (CheckBuildHouseMode(tile + TileDiffXY(1, 0), slope, 0)) break;
|
|
|
|
if (CheckBuildHouseMode(tile + TileDiffXY(-1, 0), slope, 1)) {
|
|
tile += TileDiffXY(-1, 0);
|
|
break;
|
|
}
|
|
} else if (_housetype_extra_flags[house] & 8) {
|
|
if (CheckBuildHouseMode(tile + TileDiffXY(0, 1), slope, 2)) break;
|
|
|
|
if (CheckBuildHouseMode(tile + TileDiffXY(0, -1), slope, 3)) {
|
|
tile += TileDiffXY(0, -1);
|
|
break;
|
|
}
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
t->num_houses++;
|
|
|
|
// Special houses that there can be only one of.
|
|
t->flags12 |= oneof;
|
|
|
|
{
|
|
byte construction_counter = 0, construction_stage = 0, size_flags;
|
|
|
|
if (_generating_world) {
|
|
uint32 r = Random();
|
|
|
|
construction_stage = TOWN_HOUSE_COMPLETED;
|
|
if (CHANCE16(1, 7)) construction_stage = GB(r, 0, 2);
|
|
|
|
if (construction_stage == TOWN_HOUSE_COMPLETED) {
|
|
ChangePopulation(t, _housetype_population[house]);
|
|
} else {
|
|
construction_counter = GB(r, 2, 2);
|
|
}
|
|
}
|
|
size_flags = GB(_housetype_extra_flags[house], 2, 3);
|
|
MakeTownHouse(tile, t->index, construction_counter, construction_stage, size_flags, house);
|
|
}
|
|
|
|
// ENDING
|
|
}
|
|
|
|
static bool BuildTownHouse(Town *t, TileIndex tile)
|
|
{
|
|
int32 r;
|
|
|
|
// make sure it's possible
|
|
if (!EnsureNoVehicle(tile)) return false;
|
|
if (IsSteepSlope(GetTileSlope(tile, NULL))) return false;
|
|
if (MayHaveBridgeAbove(tile) && IsBridgeAbove(tile)) return false;
|
|
|
|
r = DoCommand(tile, 0, 0, DC_EXEC | DC_AUTO | DC_NO_WATER, CMD_LANDSCAPE_CLEAR);
|
|
if (CmdFailed(r)) return false;
|
|
|
|
DoBuildTownHouse(t, tile);
|
|
return true;
|
|
}
|
|
|
|
|
|
static void DoClearTownHouseHelper(TileIndex tile)
|
|
{
|
|
assert(IsTileType(tile, MP_HOUSE));
|
|
DoClearSquare(tile);
|
|
DeleteAnimatedTile(tile);
|
|
}
|
|
|
|
static void ClearTownHouse(Town *t, TileIndex tile)
|
|
{
|
|
uint house = GetHouseType(tile);
|
|
uint eflags;
|
|
|
|
assert(IsTileType(tile, MP_HOUSE));
|
|
|
|
// need to align the tile to point to the upper left corner of the house
|
|
if (house >= 3) { // house id 0,1,2 MUST be single tile houses, or this code breaks.
|
|
if (_housetype_extra_flags[house-1] & 0x04) {
|
|
house--;
|
|
tile += TileDiffXY(-1, 0);
|
|
} else if (_housetype_extra_flags[house-1] & 0x18) {
|
|
house--;
|
|
tile += TileDiffXY(0, -1);
|
|
} else if (_housetype_extra_flags[house-2] & 0x10) {
|
|
house-=2;
|
|
tile += TileDiffXY(-1, 0);
|
|
} else if (_housetype_extra_flags[house-3] & 0x10) {
|
|
house-=3;
|
|
tile += TileDiffXY(-1, -1);
|
|
}
|
|
}
|
|
|
|
// Remove population from the town if the house is finished.
|
|
if (GetHouseBuildingStage(tile) == TOWN_HOUSE_COMPLETED) {
|
|
ChangePopulation(t, -_housetype_population[house]);
|
|
}
|
|
|
|
t->num_houses--;
|
|
|
|
// Clear flags for houses that only may exist once/town.
|
|
switch (house) {
|
|
case HOUSE_TEMP_CHURCH:
|
|
case HOUSE_ARCT_CHURCH:
|
|
case HOUSE_SNOW_CHURCH:
|
|
case HOUSE_TROP_CHURCH:
|
|
case HOUSE_TOY_CHURCH:
|
|
CLRBIT(t->flags12, TOWN_HAS_CHURCH);
|
|
break;
|
|
case HOUSE_STADIUM:
|
|
case HOUSE_MODERN_STADIUM:
|
|
CLRBIT(t->flags12, TOWN_HAS_STADIUM);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
// Do the actual clearing of tiles
|
|
eflags = _housetype_extra_flags[house];
|
|
DoClearTownHouseHelper(tile);
|
|
if (eflags & 0x14) DoClearTownHouseHelper(tile + TileDiffXY(1, 0));
|
|
if (eflags & 0x18) DoClearTownHouseHelper(tile + TileDiffXY(0, 1));
|
|
if (eflags & 0x10) DoClearTownHouseHelper(tile + TileDiffXY(1, 1));
|
|
}
|
|
|
|
/** Rename a town (server-only).
|
|
* @param tile unused
|
|
* @param p1 town ID to rename
|
|
* @param p2 unused
|
|
*/
|
|
int32 CmdRenameTown(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
|
|
{
|
|
StringID str;
|
|
Town *t;
|
|
|
|
if (!IsTownIndex(p1) || _cmd_text[0] == '\0') return CMD_ERROR;
|
|
|
|
t = GetTown(p1);
|
|
|
|
str = AllocateNameUnique(_cmd_text, 4);
|
|
if (str == 0) return CMD_ERROR;
|
|
|
|
if (flags & DC_EXEC) {
|
|
DeleteName(t->townnametype);
|
|
t->townnametype = str;
|
|
|
|
UpdateTownVirtCoord(t);
|
|
_town_sort_dirty = true;
|
|
UpdateAllStationVirtCoord();
|
|
MarkWholeScreenDirty();
|
|
} else {
|
|
DeleteName(str);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
// Called from GUI
|
|
void DeleteTown(Town *t)
|
|
{
|
|
Industry *i;
|
|
TileIndex tile;
|
|
|
|
// Delete town authority window
|
|
// and remove from list of sorted towns
|
|
DeleteWindowById(WC_TOWN_VIEW, t->index);
|
|
_town_sort_dirty = true;
|
|
|
|
// Delete all industries belonging to the town
|
|
FOR_ALL_INDUSTRIES(i) {
|
|
if (i->xy && i->town == t)
|
|
DeleteIndustry(i);
|
|
}
|
|
|
|
// Go through all tiles and delete those belonging to the town
|
|
for (tile = 0; tile < MapSize(); ++tile) {
|
|
switch (GetTileType(tile)) {
|
|
case MP_HOUSE:
|
|
if (GetTownByTile(tile) == t)
|
|
DoCommand(tile, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR);
|
|
break;
|
|
|
|
case MP_STREET:
|
|
case MP_TUNNELBRIDGE:
|
|
if (IsTileOwner(tile, OWNER_TOWN) &&
|
|
ClosestTownFromTile(tile, (uint)-1) == t)
|
|
DoCommand(tile, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
t->xy = 0;
|
|
DeleteName(t->townnametype);
|
|
|
|
MarkWholeScreenDirty();
|
|
}
|
|
|
|
// Called from GUI
|
|
void ExpandTown(Town *t)
|
|
{
|
|
int amount, n;
|
|
|
|
_generating_world = true;
|
|
|
|
/* The more houses, the faster we grow */
|
|
amount = RandomRange(t->num_houses / 10) + 3;
|
|
t->num_houses += amount;
|
|
UpdateTownRadius(t);
|
|
|
|
n = amount * 10;
|
|
do GrowTown(t); while (--n);
|
|
|
|
t->num_houses -= amount;
|
|
UpdateTownRadius(t);
|
|
|
|
UpdateTownMaxPass(t);
|
|
_generating_world = false;
|
|
}
|
|
|
|
const byte _town_action_costs[8] = {
|
|
2, 4, 9, 35, 48, 53, 117, 175
|
|
};
|
|
|
|
static void TownActionAdvertiseSmall(Town* t)
|
|
{
|
|
ModifyStationRatingAround(t->xy, _current_player, 0x40, 10);
|
|
}
|
|
|
|
static void TownActionAdvertiseMedium(Town* t)
|
|
{
|
|
ModifyStationRatingAround(t->xy, _current_player, 0x70, 15);
|
|
}
|
|
|
|
static void TownActionAdvertiseLarge(Town* t)
|
|
{
|
|
ModifyStationRatingAround(t->xy, _current_player, 0xA0, 20);
|
|
}
|
|
|
|
static void TownActionRoadRebuild(Town* t)
|
|
{
|
|
const Player* p;
|
|
|
|
t->road_build_months = 6;
|
|
|
|
SetDParam(0, t->index);
|
|
|
|
p = GetPlayer(_current_player);
|
|
SetDParam(1, p->name_1);
|
|
SetDParam(2, p->name_2);
|
|
|
|
AddNewsItem(STR_2055_TRAFFIC_CHAOS_IN_ROAD_REBUILDING,
|
|
NEWS_FLAGS(NM_NORMAL, NF_TILE, NT_GENERAL, 0), t->xy, 0);
|
|
}
|
|
|
|
static bool DoBuildStatueOfCompany(TileIndex tile)
|
|
{
|
|
PlayerID old;
|
|
int32 r;
|
|
|
|
if (GetTileSlope(tile, NULL) != SLOPE_FLAT) return false;
|
|
|
|
if (!IsTileType(tile, MP_HOUSE) &&
|
|
!IsTileType(tile, MP_CLEAR) &&
|
|
!IsTileType(tile, MP_TREES)) {
|
|
return false;
|
|
}
|
|
|
|
old = _current_player;
|
|
_current_player = OWNER_NONE;
|
|
r = DoCommand(tile, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR);
|
|
_current_player = old;
|
|
|
|
if (CmdFailed(r)) return false;
|
|
|
|
MakeStatue(tile, _current_player);
|
|
MarkTileDirtyByTile(tile);
|
|
|
|
return true;
|
|
}
|
|
|
|
static void TownActionBuildStatue(Town* t)
|
|
{
|
|
// Layouted as an outward spiral
|
|
static const TileIndexDiffC _statue_tiles[] = {
|
|
{-1, 0},
|
|
{ 0, 1},
|
|
{ 1, 0}, { 1, 0},
|
|
{ 0,-1}, { 0,-1},
|
|
{-1, 0}, {-1, 0}, {-1, 0},
|
|
{ 0, 1}, { 0, 1}, { 0, 1},
|
|
{ 1, 0}, { 1, 0}, { 1, 0}, { 1, 0},
|
|
{ 0,-1}, { 0,-1}, { 0,-1}, { 0,-1},
|
|
{-1, 0}, {-1, 0}, {-1, 0}, {-1, 0}, {-1, 0},
|
|
{ 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1},
|
|
{ 1, 0}, { 1, 0}, { 1, 0}, { 1, 0}, { 1, 0}, { 1, 0},
|
|
{ 0,-1}, { 0,-1}, { 0,-1}, { 0,-1}, { 0,-1}, { 0,-1},
|
|
{-1, 0}, {-1, 0}, {-1, 0}, {-1, 0}, {-1, 0}, {-1, 0}, {-1, 0},
|
|
{ 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1},
|
|
{ 1, 0}, { 1, 0}, { 1, 0}, { 1, 0}, { 1, 0}, { 1, 0}, { 1, 0}, { 1, 0},
|
|
{ 0,-1}, { 0,-1}, { 0,-1}, { 0,-1}, { 0,-1}, { 0,-1}, { 0,-1}, { 0,-1},
|
|
{-1, 0}, {-1, 0}, {-1, 0}, {-1, 0}, {-1, 0}, {-1, 0}, {-1, 0}, {-1, 0},
|
|
{ 0, 0}
|
|
};
|
|
TileIndex tile = t->xy;
|
|
const TileIndexDiffC *p;
|
|
|
|
SETBIT(t->statues, _current_player);
|
|
|
|
for (p = _statue_tiles; p != endof(_statue_tiles); ++p) {
|
|
if (DoBuildStatueOfCompany(tile)) return;
|
|
tile = TILE_ADD(tile, ToTileIndexDiff(*p));
|
|
}
|
|
}
|
|
|
|
static void TownActionFundBuildings(Town* t)
|
|
{
|
|
// Build next tick
|
|
t->grow_counter = 1;
|
|
// If we were not already growing
|
|
SETBIT(t->flags12, TOWN_IS_FUNDED);
|
|
// And grow for 3 months
|
|
t->fund_buildings_months = 3;
|
|
}
|
|
|
|
static void TownActionBuyRights(Town* t)
|
|
{
|
|
t->exclusive_counter = 12;
|
|
t->exclusivity = _current_player;
|
|
|
|
ModifyStationRatingAround(t->xy, _current_player, 130, 17);
|
|
}
|
|
|
|
static void TownActionBribe(Town* t)
|
|
{
|
|
if (!RandomRange(15)) {
|
|
Station *st;
|
|
|
|
// set as unwanted for 6 months
|
|
t->unwanted[_current_player] = 6;
|
|
|
|
// set all close by station ratings to 0
|
|
FOR_ALL_STATIONS(st) {
|
|
if (st->town == t && st->owner == _current_player) {
|
|
uint i;
|
|
|
|
for (i = 0; i != NUM_CARGO; i++) st->goods[i].rating = 0;
|
|
}
|
|
}
|
|
|
|
// only show errormessage to the executing player. All errors are handled command.c
|
|
// but this is special, because it can only 'fail' on a DC_EXEC
|
|
if (IsLocalPlayer()) ShowErrorMessage(STR_BRIBE_FAILED_2, STR_BRIBE_FAILED, 0, 0);
|
|
|
|
/* decrease by a lot!
|
|
* ChangeTownRating is only for stuff in demolishing. Bribe failure should
|
|
* be independent of any cheat settings
|
|
*/
|
|
if (t->ratings[_current_player] > RATING_BRIBE_DOWN_TO) {
|
|
t->ratings[_current_player] = RATING_BRIBE_DOWN_TO;
|
|
}
|
|
} else {
|
|
ChangeTownRating(t, RATING_BRIBE_UP_STEP, RATING_BRIBE_MAXIMUM);
|
|
}
|
|
}
|
|
|
|
typedef void TownActionProc(Town* t);
|
|
static TownActionProc * const _town_action_proc[] = {
|
|
TownActionAdvertiseSmall,
|
|
TownActionAdvertiseMedium,
|
|
TownActionAdvertiseLarge,
|
|
TownActionRoadRebuild,
|
|
TownActionBuildStatue,
|
|
TownActionFundBuildings,
|
|
TownActionBuyRights,
|
|
TownActionBribe
|
|
};
|
|
|
|
extern uint GetMaskOfTownActions(int *nump, PlayerID pid, const Town *t);
|
|
|
|
/** Do a town action.
|
|
* This performs an action such as advertising, building a statue, funding buildings,
|
|
* but also bribing the town-council
|
|
* @param tile unused
|
|
* @param p1 town to do the action at
|
|
* @param p2 action to perform, @see _town_action_proc for the list of available actions
|
|
*/
|
|
int32 CmdDoTownAction(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
|
|
{
|
|
int32 cost;
|
|
Town *t;
|
|
|
|
if (!IsTownIndex(p1) || p2 > lengthof(_town_action_proc)) return CMD_ERROR;
|
|
|
|
t = GetTown(p1);
|
|
|
|
if (!HASBIT(GetMaskOfTownActions(NULL, _current_player, t), p2)) return CMD_ERROR;
|
|
|
|
SET_EXPENSES_TYPE(EXPENSES_OTHER);
|
|
|
|
cost = (_price.build_industry >> 8) * _town_action_costs[p2];
|
|
|
|
if (flags & DC_EXEC) {
|
|
_town_action_proc[p2](t);
|
|
InvalidateWindow(WC_TOWN_AUTHORITY, p1);
|
|
}
|
|
|
|
return cost;
|
|
}
|
|
|
|
static void UpdateTownGrowRate(Town *t)
|
|
{
|
|
int n;
|
|
Station *st;
|
|
byte m;
|
|
Player *p;
|
|
|
|
// Reset player ratings if they're low
|
|
FOR_ALL_PLAYERS(p) {
|
|
if (p->is_active && t->ratings[p->index] <= 200) {
|
|
t->ratings[p->index] += 5;
|
|
}
|
|
}
|
|
|
|
n = 0;
|
|
FOR_ALL_STATIONS(st) {
|
|
if (DistanceSquare(st->xy, t->xy) <= t->radius[0]) {
|
|
if (st->time_since_load <= 20 || st->time_since_unload <= 20) {
|
|
n++;
|
|
if (st->owner < MAX_PLAYERS && t->ratings[st->owner] <= 1000-12)
|
|
t->ratings[st->owner] += 12;
|
|
} else {
|
|
if (st->owner < MAX_PLAYERS && t->ratings[st->owner] >= -1000+15)
|
|
t->ratings[st->owner] -= 15;
|
|
}
|
|
}
|
|
}
|
|
|
|
CLRBIT(t->flags12, TOWN_IS_FUNDED);
|
|
|
|
if (t->fund_buildings_months != 0) {
|
|
static const byte _grow_count_values[6] = {
|
|
60, 60, 60, 50, 40, 30
|
|
};
|
|
m = _grow_count_values[min(n, 5)];
|
|
t->fund_buildings_months--;
|
|
} else if (n == 0) {
|
|
m = 160;
|
|
if (!CHANCE16(1, 12))
|
|
return;
|
|
} else {
|
|
static const byte _grow_count_values[5] = {
|
|
210, 150, 110, 80, 50
|
|
};
|
|
m = _grow_count_values[min(n, 5) - 1];
|
|
}
|
|
|
|
if (_opt.landscape == LT_HILLY) {
|
|
if (TilePixelHeight(t->xy) >= _opt.snow_line && t->act_food == 0 && t->population > 90)
|
|
return;
|
|
} else if (_opt.landscape == LT_DESERT) {
|
|
if (GetTropicZone(t->xy) == TROPICZONE_DESERT && (t->act_food==0 || t->act_water==0) && t->population > 60)
|
|
return;
|
|
}
|
|
|
|
t->growth_rate = m / (t->num_houses / 50 + 1);
|
|
if (m <= t->grow_counter)
|
|
t->grow_counter = m;
|
|
|
|
SETBIT(t->flags12, TOWN_IS_FUNDED);
|
|
}
|
|
|
|
static void UpdateTownAmounts(Town *t)
|
|
{
|
|
// Using +1 here to prevent overflow and division by zero
|
|
t->pct_pass_transported = t->new_act_pass * 256 / (t->new_max_pass + 1);
|
|
|
|
t->max_pass = t->new_max_pass; t->new_max_pass = 0;
|
|
t->act_pass = t->new_act_pass; t->new_act_pass = 0;
|
|
t->act_food = t->new_act_food; t->new_act_food = 0;
|
|
t->act_water = t->new_act_water; t->new_act_water = 0;
|
|
|
|
// Using +1 here to prevent overflow and division by zero
|
|
t->pct_mail_transported = t->new_act_mail * 256 / (t->new_max_mail + 1);
|
|
t->max_mail = t->new_max_mail; t->new_max_mail = 0;
|
|
t->act_mail = t->new_act_mail; t->new_act_mail = 0;
|
|
|
|
InvalidateWindow(WC_TOWN_VIEW, t->index);
|
|
}
|
|
|
|
static void UpdateTownUnwanted(Town *t)
|
|
{
|
|
Player *p;
|
|
|
|
FOR_ALL_PLAYERS(p) {
|
|
if (t->unwanted[p->index] > 0)
|
|
t->unwanted[p->index]--;
|
|
}
|
|
}
|
|
|
|
bool CheckIfAuthorityAllows(TileIndex tile)
|
|
{
|
|
Town *t;
|
|
|
|
if (_current_player >= MAX_PLAYERS)
|
|
return true;
|
|
|
|
t = ClosestTownFromTile(tile, _patches.dist_local_authority);
|
|
if (t == NULL)
|
|
return true;
|
|
|
|
if (t->ratings[_current_player] > -200)
|
|
return true;
|
|
|
|
_error_message = STR_2009_LOCAL_AUTHORITY_REFUSES;
|
|
SetDParam(0, t->index);
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
Town *ClosestTownFromTile(TileIndex tile, uint threshold)
|
|
{
|
|
Town *t;
|
|
uint dist, best = threshold;
|
|
Town *best_town = NULL;
|
|
|
|
if (IsTileType(tile, MP_HOUSE) || (
|
|
IsTileType(tile, MP_STREET) &&
|
|
(IsLevelCrossing(tile) ? GetCrossingRoadOwner(tile) : GetTileOwner(tile)) == OWNER_TOWN
|
|
))
|
|
return GetTownByTile(tile);
|
|
|
|
FOR_ALL_TOWNS(t) {
|
|
if (t->xy != 0) {
|
|
dist = DistanceManhattan(tile, t->xy);
|
|
if (dist < best) {
|
|
best = dist;
|
|
best_town = t;
|
|
}
|
|
}
|
|
}
|
|
|
|
return best_town;
|
|
}
|
|
|
|
void ChangeTownRating(Town *t, int add, int max)
|
|
{
|
|
int rating;
|
|
|
|
// if magic_bulldozer cheat is active, town doesn't penaltize for removing stuff
|
|
if (t == NULL ||
|
|
_current_player >= MAX_PLAYERS ||
|
|
(_cheats.magic_bulldozer.value && add < 0)) {
|
|
return;
|
|
}
|
|
|
|
SETBIT(t->have_ratings, _current_player);
|
|
|
|
rating = t->ratings[_current_player];
|
|
|
|
if (add < 0) {
|
|
if (rating > max) {
|
|
rating += add;
|
|
if (rating < max) rating = max;
|
|
}
|
|
} else {
|
|
if (rating < max) {
|
|
rating += add;
|
|
if (rating > max) rating = max;
|
|
}
|
|
}
|
|
t->ratings[_current_player] = rating;
|
|
}
|
|
|
|
/* penalty for removing town-owned stuff */
|
|
static const int _default_rating_settings [3][3] = {
|
|
// ROAD_REMOVE, TUNNELBRIDGE_REMOVE, INDUSTRY_REMOVE
|
|
{ 0, 128, 384}, // Permissive
|
|
{ 48, 192, 480}, // Neutral
|
|
{ 96, 384, 768}, // Hostile
|
|
};
|
|
|
|
bool CheckforTownRating(uint32 flags, Town *t, byte type)
|
|
{
|
|
int modemod;
|
|
|
|
// if magic_bulldozer cheat is active, town doesn't restrict your destructive actions
|
|
if (t == NULL || _current_player >= MAX_PLAYERS || _cheats.magic_bulldozer.value)
|
|
return true;
|
|
|
|
/* check if you're allowed to remove the street/bridge/tunnel/industry
|
|
* owned by a town no removal if rating is lower than ... depends now on
|
|
* difficulty setting. Minimum town rating selected by difficulty level
|
|
*/
|
|
modemod = _default_rating_settings[_opt.diff.town_council_tolerance][type];
|
|
|
|
if (t->ratings[_current_player] < 16 + modemod && !(flags & DC_NO_TOWN_RATING)) {
|
|
SetDParam(0, t->index);
|
|
_error_message = STR_2009_LOCAL_AUTHORITY_REFUSES;
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void TownsMonthlyLoop(void)
|
|
{
|
|
Town *t;
|
|
|
|
FOR_ALL_TOWNS(t) if (t->xy != 0) {
|
|
if (t->road_build_months != 0)
|
|
t->road_build_months--;
|
|
|
|
if (t->exclusive_counter != 0)
|
|
if (--t->exclusive_counter == 0)
|
|
t->exclusivity = (byte)-1;
|
|
|
|
UpdateTownGrowRate(t);
|
|
UpdateTownAmounts(t);
|
|
UpdateTownUnwanted(t);
|
|
}
|
|
}
|
|
|
|
void InitializeTowns(void)
|
|
{
|
|
Subsidy *s;
|
|
|
|
/* Clean the town pool and create 1 block in it */
|
|
CleanPool(&_town_pool);
|
|
AddBlockToPool(&_town_pool);
|
|
|
|
memset(_subsidies, 0, sizeof(_subsidies));
|
|
for (s=_subsidies; s != endof(_subsidies); s++)
|
|
s->cargo_type = CT_INVALID;
|
|
|
|
_cur_town_ctr = 0;
|
|
_cur_town_iter = 0;
|
|
_total_towns = 0;
|
|
_town_sort_dirty = true;
|
|
}
|
|
|
|
const TileTypeProcs _tile_type_town_procs = {
|
|
DrawTile_Town, /* draw_tile_proc */
|
|
GetSlopeZ_Town, /* get_slope_z_proc */
|
|
ClearTile_Town, /* clear_tile_proc */
|
|
GetAcceptedCargo_Town, /* get_accepted_cargo_proc */
|
|
GetTileDesc_Town, /* get_tile_desc_proc */
|
|
GetTileTrackStatus_Town, /* get_tile_track_status_proc */
|
|
ClickTile_Town, /* click_tile_proc */
|
|
AnimateTile_Town, /* animate_tile_proc */
|
|
TileLoop_Town, /* tile_loop_clear */
|
|
ChangeTileOwner_Town, /* change_tile_owner_clear */
|
|
NULL, /* get_produced_cargo_proc */
|
|
NULL, /* vehicle_enter_tile_proc */
|
|
GetSlopeTileh_Town, /* get_slope_tileh_proc */
|
|
};
|
|
|
|
|
|
// Save and load of towns.
|
|
static const SaveLoad _town_desc[] = {
|
|
SLE_CONDVAR(Town, xy, SLE_FILE_U16 | SLE_VAR_U32, 0, 5),
|
|
SLE_CONDVAR(Town, xy, SLE_UINT32, 6, SL_MAX_VERSION),
|
|
|
|
SLE_CONDVAR(Town,population, SLE_FILE_U16 | SLE_VAR_U32, 0, 2),
|
|
SLE_CONDVAR(Town,population, SLE_UINT32, 3, SL_MAX_VERSION),
|
|
|
|
|
|
SLE_VAR(Town,num_houses, SLE_UINT16),
|
|
SLE_VAR(Town,townnametype,SLE_UINT16),
|
|
SLE_VAR(Town,townnameparts,SLE_UINT32),
|
|
|
|
SLE_VAR(Town,flags12, SLE_UINT8),
|
|
SLE_VAR(Town,statues, SLE_UINT8),
|
|
|
|
// sort_index_obsolete was stored here in savegame format 0 - 1
|
|
SLE_CONDNULL(1, 0, 1),
|
|
|
|
SLE_VAR(Town,have_ratings,SLE_UINT8),
|
|
SLE_ARR(Town,ratings, SLE_INT16, 8),
|
|
// failed bribe attempts are stored since savegame format 4
|
|
SLE_CONDARR(Town,unwanted, SLE_INT8, 8, 4,SL_MAX_VERSION),
|
|
|
|
SLE_CONDVAR(Town,max_pass, SLE_FILE_U16 | SLE_VAR_U32, 0, 8),
|
|
SLE_CONDVAR(Town,max_mail, SLE_FILE_U16 | SLE_VAR_U32, 0, 8),
|
|
SLE_CONDVAR(Town,new_max_pass,SLE_FILE_U16 | SLE_VAR_U32, 0, 8),
|
|
SLE_CONDVAR(Town,new_max_mail,SLE_FILE_U16 | SLE_VAR_U32, 0, 8),
|
|
SLE_CONDVAR(Town,act_pass, SLE_FILE_U16 | SLE_VAR_U32, 0, 8),
|
|
SLE_CONDVAR(Town,act_mail, SLE_FILE_U16 | SLE_VAR_U32, 0, 8),
|
|
SLE_CONDVAR(Town,new_act_pass,SLE_FILE_U16 | SLE_VAR_U32, 0, 8),
|
|
SLE_CONDVAR(Town,new_act_mail,SLE_FILE_U16 | SLE_VAR_U32, 0, 8),
|
|
|
|
SLE_CONDVAR(Town,max_pass, SLE_UINT32, 9, SL_MAX_VERSION),
|
|
SLE_CONDVAR(Town,max_mail, SLE_UINT32, 9, SL_MAX_VERSION),
|
|
SLE_CONDVAR(Town,new_max_pass,SLE_UINT32, 9, SL_MAX_VERSION),
|
|
SLE_CONDVAR(Town,new_max_mail,SLE_UINT32, 9, SL_MAX_VERSION),
|
|
SLE_CONDVAR(Town,act_pass, SLE_UINT32, 9, SL_MAX_VERSION),
|
|
SLE_CONDVAR(Town,act_mail, SLE_UINT32, 9, SL_MAX_VERSION),
|
|
SLE_CONDVAR(Town,new_act_pass,SLE_UINT32, 9, SL_MAX_VERSION),
|
|
SLE_CONDVAR(Town,new_act_mail,SLE_UINT32, 9, SL_MAX_VERSION),
|
|
|
|
SLE_VAR(Town,pct_pass_transported,SLE_UINT8),
|
|
SLE_VAR(Town,pct_mail_transported,SLE_UINT8),
|
|
|
|
SLE_VAR(Town,act_food, SLE_UINT16),
|
|
SLE_VAR(Town,act_water, SLE_UINT16),
|
|
SLE_VAR(Town,new_act_food,SLE_UINT16),
|
|
SLE_VAR(Town,new_act_water,SLE_UINT16),
|
|
|
|
SLE_VAR(Town,time_until_rebuild, SLE_UINT8),
|
|
SLE_VAR(Town,grow_counter, SLE_UINT8),
|
|
SLE_VAR(Town,growth_rate, SLE_UINT8),
|
|
SLE_VAR(Town,fund_buildings_months, SLE_UINT8),
|
|
SLE_VAR(Town,road_build_months, SLE_UINT8),
|
|
|
|
SLE_VAR(Town,exclusivity, SLE_UINT8),
|
|
SLE_VAR(Town,exclusive_counter, SLE_UINT8),
|
|
// reserve extra space in savegame here. (currently 30 bytes)
|
|
SLE_CONDNULL(30, 2, SL_MAX_VERSION),
|
|
|
|
SLE_END()
|
|
};
|
|
|
|
static void Save_TOWN(void)
|
|
{
|
|
Town *t;
|
|
|
|
FOR_ALL_TOWNS(t) {
|
|
if (t->xy != 0) {
|
|
SlSetArrayIndex(t->index);
|
|
SlObject(t, _town_desc);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void Load_TOWN(void)
|
|
{
|
|
int index;
|
|
|
|
_total_towns = 0;
|
|
|
|
while ((index = SlIterateArray()) != -1) {
|
|
Town *t;
|
|
|
|
if (!AddBlockIfNeeded(&_town_pool, index))
|
|
error("Towns: failed loading savegame: too many towns");
|
|
|
|
t = GetTown(index);
|
|
SlObject(t, _town_desc);
|
|
|
|
if ((uint)index > _total_towns)
|
|
_total_towns = index;
|
|
}
|
|
|
|
/* This is to ensure all pointers are within the limits of
|
|
* the size of the TownPool */
|
|
if (_cur_town_ctr >= GetTownPoolSize())
|
|
_cur_town_ctr = 0;
|
|
}
|
|
|
|
void AfterLoadTown(void)
|
|
{
|
|
Town *t;
|
|
FOR_ALL_TOWNS(t) {
|
|
if (t->xy != 0) {
|
|
UpdateTownRadius(t);
|
|
UpdateTownVirtCoord(t);
|
|
}
|
|
}
|
|
_town_sort_dirty = true;
|
|
}
|
|
|
|
|
|
const ChunkHandler _town_chunk_handlers[] = {
|
|
{ 'CITY', Save_TOWN, Load_TOWN, CH_ARRAY | CH_LAST},
|
|
};
|