16 #include "viewport_kdtree.h"
61 #include "table/strings.h"
73 void RebuildTownKdtree()
75 std::vector<TownID> townids;
77 townids.push_back(town->index);
79 _town_kdtree.
Build(townids.begin(), townids.end());
121 assert(i->town !=
this);
126 assert(o->town !=
this);
151 for (
auto &psa : this->psa_list) {
154 this->psa_list.clear();
216 void Town::FillCachedName()
const
227 return (_price[PR_CLEAR_HOUSE] * this->
removal_cost) >> 8;
231 static int _grow_town_result;
234 enum TownGrowthResult {
236 GROWTH_SEARCH_STOPPED = 0
243 static void TownDrawHouseLift(
const TileInfo *ti)
248 typedef void TownDrawTileProc(
const TileInfo *ti);
249 static TownDrawTileProc *
const _town_draw_tile_procs[1] = {
275 if (
HouseSpec::Get(house_id)->grf_prop.spritegroup[0] !=
nullptr) {
276 DrawNewHouseTile(ti, house_id);
297 ti->
x + dcts->subtile_x,
298 ti->
y + dcts->subtile_y,
310 int proc = dcts->draw_proc - 1;
312 if (proc >= 0) _town_draw_tile_procs[proc](ti);
316 static int GetSlopePixelZ_Town(
TileIndex tile, uint, uint,
bool)
353 AnimateNewHouseTile(tile);
384 pos += (pos < dest) ? 1 : -1;
403 if (_town_kdtree.
Count() == 0)
return false;
419 STR_VIEWPORT_TOWN_TINY_WHITE);
421 _viewport_sign_kdtree.
Insert(ViewportSignKdtreeItem::MakeTown(this->
index));
430 t->UpdateVirtCoord();
438 t->cached_name.clear();
481 bool covers_area = st->TileIsInCatchment(tile);
482 if (flags & BUILDING_2_TILES_Y) covers_area |= st->TileIsInCatchment(tile +
TileDiffXY(0, 1));
483 if (flags & BUILDING_2_TILES_X) covers_area |= st->TileIsInCatchment(tile +
TileDiffXY(1, 0));
484 if (flags & BUILDING_HAS_4_TILES) covers_area |= st->TileIsInCatchment(tile +
TileDiffXY(1, 1));
506 AnimateNewHouseConstruction(tile);
540 if (amount == 0)
return;
544 amount = (amount + 1) >> 1;
565 uint32_t r = Random();
566 if (
GB(r, 0, 8) < rate) {
568 uint amt = (
GB(r, 0, 8) * cs->town_production_multiplier / TOWN_PRODUCTION_DIVISOR) / 8 + 1;
586 uint32_t r = Random();
589 int genmax = (rate + 7) / 8;
590 uint32_t genmask = (genmax >= 32) ? 0xFFFFFFFF : ((1 << genmax) - 1);
593 uint amt =
CountBits(r & genmask) * cs->town_production_multiplier / TOWN_PRODUCTION_DIVISOR;
629 Town *t = Town::GetByTile(tile);
630 uint32_t r = Random();
635 for (uint i = 0; i < 256; i++) {
643 uint amt =
GB(callback, 0, 8);
644 if (amt == 0)
continue;
676 CanDeleteHouse(tile) &&
684 if (
GB(r, 24, 8) >= 12) {
692 int x =
Clamp(grid_pos.
x, 0, 1);
693 int y =
Clamp(grid_pos.
y, 0, 1);
720 if (!CanDeleteHouse(tile))
return CMD_ERROR;
728 Town *t = Town::GetByTile(tile);
750 Town *t = Town::GetByTile(tile);
753 for (uint i = 0; i < 256; i++) {
766 produced[cs->Index()]++;
771 produced[cs->Index()]++;
787 acceptance[cargo] += amount;
788 SetBit(always_accepted, cargo);
791 static void AddAcceptedCargo_Town(
TileIndex tile,
CargoArray &acceptance, CargoTypes &always_accepted)
797 for (uint8_t i = 0; i <
lengthof(accepts); i++) {
829 for (uint8_t i = 0; i <
lengthof(accepts); i++) {
842 uint16_t callback_res = GetHouseCallback(
CBID_HOUSE_CUSTOM_NAME, house_completed ? 1 : 0, 0, house, Town::GetByTile(tile), tile);
844 if (callback_res > 0x400) {
848 if (new_name != STR_NULL && new_name != STR_UNDEFINED) {
854 if (!house_completed) {
856 td->
str = STR_LAI_TOWN_INDUSTRY_DESCRIPTION_UNDER_CONSTRUCTION;
903 if (_game_mode == GM_EDITOR)
return;
930 const uint16_t assume_max_speed = 50;
933 if (RoadTypeIsTram(rt))
continue;
938 if (rti->
label == 0)
continue;
946 if (best !=
nullptr) {
965 if (RoadTypeIsTram(rt))
continue;
967 if (rti->
label == 0)
continue;
974 if (best ==
nullptr)
return INT32_MAX;
987 if (min_date < INT32_MAX) {
991 ShowErrorMessage(STR_ERROR_NO_TOWN_ROADTYPES_AVAILABLE_AT_ALL, STR_ERROR_NO_TOWN_ROADTYPES_AVAILABLE_AT_ALL_EXPLANATION,
WL_CRITICAL);
1017 dist_multi = (dist_multi + 1) * 4;
1018 for (uint pos = 4; pos < dist_multi; pos++) {
1023 if (pos & 2) cur += tid_lt[2];
1066 if (desired_slope != cur_slope &&
ComplementSlope(desired_slope) != cur_slope) {
1084 static bool TerraformTownTile(
TileIndex tile,
Slope edges,
bool dir)
1089 if (r.
Failed() || r.
GetCost() >= (_price[PR_TERRAFORM] + 2) * 8)
return false;
1094 static void LevelTownLand(
TileIndex tile)
1124 default: NOT_REACHED();
1127 if ((grid_pos.
x % 3) == 0) rcmd |=
ROAD_Y;
1128 if ((grid_pos.
y % 3) == 0) rcmd |=
ROAD_X;
1132 if ((grid_pos.
x % 4) == 0) rcmd |=
ROAD_Y;
1133 if ((grid_pos.
y % 4) == 0) rcmd |=
ROAD_X;
1143 default: rb_template =
ROAD_ALL;
break;
1201 _grow_town_result = GROWTH_SUCCEED;
1222 _grow_town_result = GROWTH_SUCCEED;
1319 uint bridge_length = 0;
1326 const uint TOWN_BRIDGE_LENGTH_CAP = 11;
1327 uint base_bridge_length = 5;
1328 uint max_bridge_length = std::min(t->
cache.
population / 1000 + base_bridge_length, TOWN_BRIDGE_LENGTH_CAP);
1333 if (bridge_length++ >= base_bridge_length) {
1337 bridge_tile += delta;
1341 if (bridge_length++ >= max_bridge_length) {
1345 bridge_tile += delta;
1350 if (bridge_length == 1)
return false;
1360 for (uint8_t times = 0; times <= 22; times++) {
1367 _grow_town_result = GROWTH_SUCCEED;
1398 int max_tunnel_length = 0;
1404 for (uint8_t tiles = 0; tiles < 4; tiles++) {
1408 slope_tile += delta;
1415 max_tunnel_length = 5;
1418 uint8_t tunnel_length = 0;
1423 if (tunnel_length++ >= max_tunnel_length)
return false;
1424 tunnel_tile += delta;
1429 if (tunnel_length == 1)
return false;
1438 _grow_town_result = GROWTH_SUCCEED;
1453 static const TileIndexDiffC tiles[] = { {-1, -1}, {-1, 0}, {-1, 1}, {0, -1}, {0, 1}, {1, -1}, {1, 0}, {1, 1} };
1456 for (
const auto &ptr : tiles) {
1463 RoadType road_rt = GetRoadTypeRoad(cur_tile);
1464 RoadType tram_rt = GetRoadTypeTram(cur_tile);
1484 RoadType rt = GetRoadTypeRoad(tile);
1524 _grow_town_result = GROWTH_SEARCH_STOPPED;
1534 default: NOT_REACHED();
1550 do target_dir =
RandomDiagDir();
while (target_dir == source_dir);
1578 _grow_town_result = GROWTH_SEARCH_STOPPED;
1583 default: NOT_REACHED();
1596 bool allow_house =
true;
1613 if (cur_rb & target_rb) {
1621 if ((cur_rb &
ROAD_X) != target_rb)
return;
1653 default: NOT_REACHED();
1661 allow_house = (rcmd & target_rb) ==
ROAD_NONE;
1683 if (
Chance16(1, 6)) LevelTownLand(house_tile);
1688 _grow_town_result = GROWTH_SUCCEED;
1696 _grow_town_result = GROWTH_SEARCH_STOPPED;
1754 return (target_rb & back_rb) != 0 && (target_rb & ~back_rb) != 0;
1796 if (_grow_town_result == GROWTH_SUCCEED)
return true;
1815 }
while (!(cur_rb & target_bits));
1816 cur_rb &= ~target_bits;
1834 }
while (--_grow_town_result >= 0);
1848 uint32_t r = Random();
1849 uint a =
GB(r, 0, 2);
1850 uint b =
GB(r, 8, 2);
1884 for (
const auto &ptr : _town_coord_mod) {
1897 for (
const auto &ptr : _town_coord_mod) {
1921 static const std::array<std::array<uint32_t, HZB_END>, 23> _town_squared_town_zone_radius_data = {{
1934 { 81, 36, 25, 0, 9},
1935 { 81, 36, 25, 16, 9},
1936 { 81, 49, 0, 25, 9},
1937 { 81, 64, 0, 25, 9},
1938 { 81, 64, 0, 36, 9},
1939 { 81, 64, 0, 36, 16},
1940 {100, 81, 0, 49, 16},
1941 {100, 81, 0, 49, 25},
1942 {121, 81, 0, 49, 25},
1943 {121, 81, 0, 49, 25},
1944 {121, 81, 0, 49, 36},
1947 if (t->
cache.
num_houses < std::size(_town_squared_town_zone_radius_data) * 4) {
2032 t->townnamegrfid = tnp.grfid;
2033 t->townnametype = tnp.type;
2035 t->townnameparts = townnameparts;
2041 int x = (int)size * 16 + 3;
2042 if (size ==
TSZ_RANDOM) x = (Random() & 0xF) + 8;
2097 if (!t->
name.empty() && t->
name == name)
return false;
2126 if (random_location)
return {
CMD_ERROR, 0, INVALID_TOWN };
2147 if (!random_location) {
2149 if (ret.
Failed())
return { ret, 0, INVALID_TOWN };
2152 static const uint8_t price_mult[][
TSZ_RANDOM + 1] = {{ 15, 25, 40, 25 }, { 20, 35, 55, 35 }};
2154 static_assert(
lengthof(price_mult[0]) == 4);
2157 uint8_t mult = price_mult[city][size];
2162 TownID new_town = INVALID_TOWN;
2171 if (random_location) {
2175 DoCreateTown(t, tile, townnameparts, size, city, layout,
true);
2179 old_generating_world.
Restore();
2181 if (t ==
nullptr)
return {
CommandCost(STR_ERROR_NO_SPACE_FOR_TOWN), 0, INVALID_TOWN };
2183 new_town = t->
index;
2185 if (!text.empty()) {
2190 if (_game_mode != GM_EDITOR) {
2192 assert(!random_location);
2199 std::string company_name =
GetString(STR_COMPANY_NAME);
2210 return { cost, 0, new_town };
2227 default:
return tile;
2245 default:
return true;
2357 DoCreateTown(t, tile, townnameparts, size, city, layout,
false);
2373 }
while (--attempts != 0);
2378 static const uint8_t _num_initial_towns[4] = {5, 11, 23, 46};
2388 uint current_number = 0;
2392 uint32_t townnameparts;
2393 TownNames town_names;
2399 town_names.insert(town->GetCachedName());
2421 RebuildTownKdtree();
2423 if (current_number != 0)
return true;
2453 HouseZonesBits smallest = HZB_TOWN_EDGE;
2454 for (HouseZonesBits i = HZB_BEGIN; i < HZB_END; i++) {
2455 if (dist < t->cache.squared_town_zone_radius[i]) smallest = i;
2590 if ((grid_pos.
x % 3) == 0 || (grid_pos.
y % 3) == 0)
return false;
2594 if ((grid_pos.
x % 4) == 0 || (grid_pos.
y % 4) == 0)
return false;
2624 if ((grid_pos.
x != 2 && grid_pos.
x != -1) ||
2625 (grid_pos.
y != 2 && grid_pos.
y != -1))
return false;
2629 if ((grid_pos.
x & 3) < 2 || (grid_pos.
y & 3) < 2)
return false;
2703 uint8_t construction_counter = 0;
2704 uint8_t construction_stage = 0;
2707 uint32_t construction_random = Random();
2715 construction_counter =
GB(construction_random, 2, 2);
2719 MakeTownHouse(tile, t, construction_counter, construction_stage, house, random_bits);
2749 uint bitmask = (1 << rad) + (1 << (land + 12));
2754 static std::vector<std::pair<HouseID, uint>> probs;
2757 uint probability_max = 0;
2765 if (hs.
class_id != HOUSE_NO_CLASS) {
2774 probability_max += cur_prob;
2775 probs.emplace_back(hs.
Index(), cur_prob);
2780 while (probability_max > 0) {
2790 for (i = 0; i < probs.size(); i++) {
2791 if (probs[i].second > r)
break;
2792 r -= probs[i].second;
2795 HouseID house = probs[i].first;
2796 probability_max -= probs[i].second;
2799 probs[i] = probs.back();
2819 if (t->
flags & oneof)
continue;
2823 if (noslope && slope !=
SLOPE_FLAT)
continue;
2835 uint8_t random_bits = Random();
2855 if (_game_mode != GM_EDITOR)
return CMD_ERROR;
2911 DoClearSquare(tile);
2930 }
else if (
HouseSpec::Get(house - 1)->building_flags & BUILDING_2_TILES_Y) {
2933 }
else if (
HouseSpec::Get(house - 2)->building_flags & BUILDING_HAS_4_TILES) {
2936 }
else if (
HouseSpec::Get(house - 3)->building_flags & BUILDING_HAS_4_TILES) {
2997 bool reset = text.empty();
3014 ClearAllStationCachedNames();
3015 ClearAllIndustryCachedNames();
3029 if (cs->town_acceptance_effect == effect)
return cs;
3056 t->
goal[tae] = goal;
3079 if (!text.empty()) t->
text = text;
3101 if (growth_rate == 0) {
3140 int16_t new_rating =
Clamp(rating, RATING_MINIMUM, RATING_MAXIMUM);
3142 t->
ratings[company_id] = new_rating;
3164 if (grow_amount == 0) {
3169 uint n = amount * 10;
3174 for (; grow_amount > 0; grow_amount--) {
3176 for (uint i = 0; i < 25; i++)
if (
GrowTown(t))
break;
3201 if (st->town == t) {
3206 if (ret.
Failed())
return ret;
3227 if (ret.
Failed())
return ret;
3233 bool try_clear =
false;
3270 if (ret.
Failed())
return ret;
3289 2, 4, 9, 35, 48, 53, 117, 175
3349 std::string company_name =
GetString(STR_COMPANY_NAME);
3392 static const int STATUE_NUMBER_INNER_TILES = 25;
3411 if (statue_data->
tile_count <= STATUE_NUMBER_INNER_TILES) {
3507 SetDParam(0, STR_NEWS_EXCLUSIVE_RIGHTS_TITLE);
3562 static TownActionProc *
const _town_action_proc[] = {
3600 if (t->
ratings[cid] >= RATING_BRIBE_MAXIMUM) {
3645 CommandCost ret = _town_action_proc[action](t, flags);
3646 if (ret.
Failed())
return ret;
3655 template <
typename Func>
3656 static void ForAllStationsNearTown(
Town *t, Func func)
3664 if (DistanceSquare(st->xy, t->xy) <= t->cache.squared_town_zone_radius[HZB_TOWN_EDGE]) {
3683 ForAllStationsNearTown(t, [&](
const Station *st) {
3684 if (st->time_since_load <= 20 || st->time_since_unload <= 20) {
3685 if (Company::IsValidID(st->owner)) {
3686 int new_rating = t->ratings[st->owner] + RATING_STATION_UP_STEP;
3687 t->ratings[st->owner] = std::min<int>(new_rating, INT16_MAX);
3691 int new_rating = t->ratings[st->owner] + RATING_STATION_DOWN_STEP;
3692 t->ratings[st->owner] = std::max(new_rating, INT16_MIN);
3730 ForAllStationsNearTown(t, [&](
const Station * st) {
3731 if (st->time_since_load <= 20 || st->time_since_unload <= 20) {
3751 static const uint16_t _grow_count_values[2][6] = {
3752 { 120, 120, 120, 100, 80, 60 },
3753 { 320, 420, 300, 220, 160, 100 }
3761 m >>= growth_multiplier;
3795 for (
int i = TAE_BEGIN; i <
TAE_END; i++) {
3796 switch (t->
goal[i]) {
3879 if (tid == INVALID_TOWN) {
3896 return Town::GetByTile(tile);
3913 static int ref_count = 0;
3915 if (ref_count == 0) {
3920 assert(ref_count > 0);
3962 if (rating < max) rating = max;
3967 if (rating > max) rating = max;
4034 for (
auto &supplied : t->
supplied) supplied.NewMonth();
4035 for (
auto &received : t->
received) received.NewMonth();
4063 bool allow_terraform =
true;
4070 uint16_t res = GetHouseCallback(
CBID_HOUSE_AUTOSLOPE, 0, 0, house, Town::GetByTile(tile), tile);
4084 GetSlopePixelZ_Town,
4086 AddAcceptedCargo_Town,
4088 GetTileTrackStatus_Town,
4092 ChangeTileOwner_Town,
4093 AddProducedCargo_Town,
4099 std::span<const DrawBuildingsTileStruct> GetTownDrawTileData()
Base functions for all AIs.
@ AT_OILRIG
Oilrig airport.
void DeleteAnimatedTile(TileIndex tile)
Removes the given tile from the animated tile table.
void AddAnimatedTile(TileIndex tile, bool mark_dirty)
Add the given tile to the animated tile table (if it does not exist yet).
Functions related to autoslope.
bool AutoslopeEnabled()
Tests if autoslope is enabled for _current_company.
Class for backupping variables and making sure they are restored later.
constexpr debug_inline bool HasBit(const T x, const uint8_t y)
Checks if a bit in a value is set.
constexpr T SetBit(T &x, const uint8_t y)
Set a bit in a variable.
constexpr uint CountBits(T value)
Counts the number of set bits in a variable.
constexpr static debug_inline uint GB(const T x, const uint8_t s, const uint8_t n)
Fetch n bits from x, started at bit s.
constexpr T ClrBit(T &x, const uint8_t y)
Clears a bit in a variable.
static const uint MAX_BRIDGES
Maximal number of available bridge specs.
bool IsBridgeTile(Tile t)
checks if there is a bridge on this tile
bool IsBridgeAbove(Tile t)
checks if a bridge is set above the ground of this tile
Axis GetBridgeAxis(Tile t)
Get the axis of the bridge that goes over the tile.
uint8_t CargoID
Cargo slots to indicate a cargo type within a game.
bool IsValidCargoID(CargoID t)
Test whether cargo type is not INVALID_CARGO.
@ Town
Source/destination is a town.
TownProductionEffect
Town effect when producing cargo.
@ TPE_PASSENGERS
Cargo behaves passenger-like for production.
@ TPE_MAIL
Cargo behaves mail-like for production.
TownAcceptanceEffect
Town growth effect when delivering cargo.
@ TAE_END
End of town effects.
@ TAE_FOOD
Cargo behaves food/fizzy-drinks-like.
@ TAE_WATER
Cargo behaves water-like.
Cheats _cheats
All the cheats.
Types related to cheating.
static void BroadcastNewEvent(ScriptEvent *event, CompanyID skip_company=MAX_COMPANIES)
Broadcast a new event to all active AIs.
Common return value for all commands.
bool Succeeded() const
Did this command succeed?
void AddCost(const Money &cost)
Adds the given cost to the cost of the command.
Money GetCost() const
The costs as made up to this moment.
bool Failed() const
Did this command fail?
void MultiplyCost(int factor)
Multiplies the cost of the command by the given factor.
static void NewEvent(class ScriptEvent *event)
Queue a new event for a Game Script.
An interval timer will fire every interval, and will continue to fire until it is deleted.
K-dimensional tree, specialised for 2-dimensional space.
void Build(It begin, It end)
Clear and rebuild the tree from a new sequence of elements,.
size_t Count() const
Get number of elements stored in tree.
void Insert(const T &element)
Insert a single element in the tree.
void Remove(const T &element)
Remove a single element from the tree, if it exists.
T FindNearest(CoordT x, CoordT y) const
Find the element closest to given coordinate, in Manhattan distance.
RoadTypeLabel label
Unique 32 bit road type identifier.
TimerGameCalendar::Date introduction_date
Introduction date.
RoadTypeFlags flags
Bit mask of road type flags.
uint16_t max_speed
Maximum speed for vehicles travelling on this road type.
Structure contains cached list of stations nearby.
const StationList * GetStations()
Run a tile loop to find stations around a tile, on demand.
static constexpr TimerGameTick::Ticks TOWN_GROWTH_TICKS
Cycle duration for towns trying to grow (this originates from the size of the town array in TTD).
static Date date
Current date in days (day counter).
static Year year
Current year, starting at 0.
static constexpr TimerGame< struct Calendar >::Date MAX_DATE
The date of the last day of the max year.
static bool UsingWallclockUnits(bool newgame=false)
Check if we are using wallclock units.
static TickCounter counter
Monotonic counter, in ticks, since start of game.
Functions related to commands.
static constexpr DoCommandFlag CommandFlagsToDCFlags(CommandFlags cmd_flags)
Extracts the DC flags needed for DoCommand from the flags returned by GetCommandFlags.
static const CommandCost CMD_ERROR
Define a default return value for a failed command.
#define return_cmd_error(errcode)
Returns from a function with a specific StringID as error.
DoCommandFlag
List of flags for a command.
@ DC_NO_TEST_TOWN_RATING
town rating does not disallow you from building
@ DC_AUTO
don't allow building on structures
@ DC_NO_WATER
don't allow building on water
@ DC_NO_MODIFY_TOWN_RATING
do not change town rating
@ DC_EXEC
execute the given command
Definition of stuff that is very close to a company, like the company struct itself.
Money GetAvailableMoneyForCommand()
This functions returns the money which can be used to execute a command.
Money GetAvailableMoney(CompanyID company)
Get the amount of money that a company has available, or INT64_MAX if there is no such valid company.
CompanyID _current_company
Company currently doing an action.
Functions related to companies.
bool IsLocalCompany()
Is the current company the local company?
Owner
Enum for all companies/owners.
@ INVALID_COMPANY
An invalid company.
@ COMPANY_SPECTATOR
The client is spectating.
@ OWNER_DEITY
The object is owned by a superuser / goal script.
@ OWNER_NONE
The tile has no ownership.
@ OWNER_TOWN
A town owns the tile, or a town is expanding.
@ MAX_COMPANIES
Maximum number of companies.
Base for all depots (except hangars)
DiagDirection ReverseDiagDir(DiagDirection d)
Returns the reverse direction of the given DiagDirection.
bool IsValidDiagDirection(DiagDirection d)
Checks if an integer value is a valid DiagDirection.
DiagDirection ChangeDiagDir(DiagDirection d, DiagDirDiff delta)
Applies a difference on a DiagDirection.
Axis DiagDirToAxis(DiagDirection d)
Convert a DiagDirection to the axis.
DiagDirection
Enumeration for diagonal directions.
@ DIAGDIR_END
Used for iterations.
@ DIAGDIR_BEGIN
Used for iterations.
@ DIAGDIRDIFF_90RIGHT
90 degrees right
@ DIAGDIRDIFF_90LEFT
90 degrees left
bool EconomyIsInRecession()
Is the economy in recession?
uint ScaleByCargoScale(uint num, bool town)
Scale a number by the cargo scale setting.
@ EXPENSES_CONSTRUCTION
Construction costs.
@ EXPENSES_OTHER
Other expenses.
Functions related to errors.
void ShowErrorMessage(StringID summary_msg, int x, int y, CommandCost cc)
Display an error message in a window.
@ WL_CRITICAL
Critical errors, the MessageBox is shown in all cases.
@ WL_INFO
Used for DoCommand-like (and some non-fatal AI GUI) errors/information.
Base functions for all Games.
bool _generating_world
Whether we are generating the map or not.
Functions related to world/map generation.
void IncreaseGeneratingWorldProgress(GenWorldProgress cls)
Increases the current stage of the world generation with one.
@ GWP_TOWN
Generate towns.
void SetGeneratingWorldProgress(GenWorldProgress cls, uint total)
Set the total of a stage of the world generation.
uint32_t SpriteID
The number of a sprite, without mapping bits and colourtables.
uint8_t GetSnowLine()
Get the current snow line, either variable or static.
uint8_t HighestSnowLine()
Get the highest possible snow line height, either variable or static.
void MarkWholeScreenDirty()
This function mark the whole screen as dirty.
void MarkTileDirtyByTile(TileIndex tile, int bridge_level_offset, int tile_height_override)
Mark a tile given by its index dirty for repaint.
static const HouseID NEW_HOUSE_OFFSET
Offset for new houses.
static const uint8_t TOWN_HOUSE_COMPLETED
Simple value that indicates the house has reached the final stage of construction.
@ BUILDING_IS_HISTORICAL
this house will only appear during town generation in random games, thus the historical
uint16_t HouseID
OpenTTD ID of house types.
void DrawFoundation(TileInfo *ti, Foundation f)
Draw foundation f at tile ti.
std::tuple< Slope, int > GetFoundationSlope(TileIndex tile)
Get slope of a tile on top of a (possible) foundation If a tile does not have a foundation,...
Functions related to OTTD's landscape.
Point RemapCoords2(int x, int y)
Map 3D world or tile coordinate to equivalent 2D coordinate as used in the viewports and smallmap.
Command definitions related to landscape (slopes etc.).
bool CircularTileSearch(TileIndex *tile, uint size, TestTileOnSearchProc proc, void *user_data)
Function performing a search around a center tile and going outward, thus in circle.
uint DistanceSquare(TileIndex t0, TileIndex t1)
Gets the 'Square' distance between the two given tiles.
uint DistanceFromEdge(TileIndex tile)
Param the minimum distance to an edge.
uint DistanceManhattan(TileIndex t0, TileIndex t1)
Gets the Manhattan distance between the two given tiles.
uint GetClosestWaterDistance(TileIndex tile, bool water)
Finds the distance for the closest tile with water/land given a tile.
TileIndex TileAddXY(TileIndex tile, int x, int y)
Adds a given offset to a tile.
TileIndex TileAddByDir(TileIndex tile, Direction dir)
Adds a Direction to a tile.
static debug_inline TileIndex TileXY(uint x, uint y)
Returns the TileIndex of a coordinate.
TileIndexDiff ToTileIndexDiff(TileIndexDiffC tidc)
Return the offset between two tiles from a TileIndexDiffC struct.
TileIndex TileAddByDiagDir(TileIndex tile, DiagDirection dir)
Adds a DiagDir to a tile.
TileIndexDiff TileDiffXY(int x, int y)
Calculates an offset for the given coordinate(-offset).
constexpr TileIndex TileAdd(TileIndex tile, TileIndexDiff offset)
Adds a given offset to a tile.
#define RandomTile()
Get a valid random tile.
static debug_inline uint TileY(TileIndex tile)
Get the Y component of a tile.
static debug_inline uint TileX(TileIndex tile)
Get the X component of a tile.
TileIndexDiff TileOffsByDiagDir(DiagDirection dir)
Convert a DiagDirection to a TileIndexDiff.
TileIndexDiffC TileIndexToTileIndexDiffC(TileIndex tile_a, TileIndex tile_b)
Returns the diff between two tiles.
int32_t TileIndexDiff
An offset value between two tiles.
constexpr int RoundDivSU(int a, uint b)
Computes round(a / b) for signed a and unsigned b.
constexpr T Clamp(const T a, const T min, const T max)
Clamp a value between an interval.
constexpr bool IsInsideMM(const T x, const size_t min, const size_t max) noexcept
Checks if a value is in an interval.
@ GSF_FAKE_TOWNS
Fake town GrfSpecFeature for NewGRF debugging (parent scope)
@ CBID_HOUSE_DRAW_FOUNDATIONS
Called to determine the type (if any) of foundation to draw for house tile.
@ CBID_HOUSE_CARGO_ACCEPTANCE
Called to decide how much cargo a town building can accept.
@ CBID_HOUSE_AUTOSLOPE
Called to determine if one can alter the ground below a house tile.
@ CBID_HOUSE_CUSTOM_NAME
Called on the Get Tile Description for an house tile.
@ CBID_HOUSE_ALLOW_CONSTRUCTION
Determine whether the house can be built on the specified tile.
@ CBID_HOUSE_ACCEPT_CARGO
Called to determine which cargoes a town building should accept.
@ CBID_HOUSE_PRODUCE_CARGO
Called to determine how much cargo a town building produces.
static const uint CALLBACK_FAILED
Different values for Callback result evaluations.
static const uint CALLBACK_HOUSEPRODCARGO_END
Sentinel indicating that the loop for CBID_HOUSE_PRODUCE_CARGO has ended.
@ CBM_HOUSE_PRODUCE_CARGO
custom cargo production
@ CBM_HOUSE_ALLOW_CONSTRUCTION
decide whether the house can be built on a given tile
@ CBM_HOUSE_CARGO_ACCEPTANCE
decides amount of cargo acceptance
@ CBM_HOUSE_AUTOSLOPE
decides allowance of autosloping
@ CBM_HOUSE_ACCEPT_CARGO
decides accepted types
@ CBM_HOUSE_DRAW_FOUNDATIONS
decides if default foundations need to be drawn
CargoID GetCargoTranslation(uint8_t cargo, const GRFFile *grffile, bool usebit)
Translate a GRF-local cargo slot/bitnum into a CargoID.
Cargo support for NewGRFs.
void ErrorUnknownCallbackResult(uint32_t grfid, uint16_t cbid, uint16_t cb_res)
Record that a NewGRF returned an unknown/invalid callback result.
bool Convert8bitBooleanCallback(const GRFFile *grffile, uint16_t cbid, uint16_t cb_res)
Converts a callback result into a boolean.
bool ConvertBooleanCallback(const GRFFile *grffile, uint16_t cbid, uint16_t cb_res)
Converts a callback result into a boolean.
GRFConfig * GetGRFConfig(uint32_t grfid, uint32_t mask)
Retrieve a NewGRF from the current config by its grfid.
Functions/types related to NewGRF debugging.
void DeleteNewGRFInspectWindow(GrfSpecFeature feature, uint index)
Delete inspect window for a given feature and index.
void DecreaseBuildingCount(Town *t, HouseID house_id)
DecreaseBuildingCount() Decrease the number of a building when it is deleted.
void IncreaseBuildingCount(Town *t, HouseID house_id)
IncreaseBuildingCount() Increase the count of a building when it has been added by a town.
void InitializeBuildingCounts(Town *t)
Initialise building counts for a town.
Functions related to NewGRF houses.
StringID GetGRFStringID(uint32_t grfid, StringID stringid)
Returns the index for this stringid associated with its grfID.
Header of Action 04 "universal holder" structure and functions.
Functions related to news.
void AddNewsItem(StringID string, NewsType type, NewsFlag flags, NewsReferenceType reftype1=NR_NONE, uint32_t ref1=UINT32_MAX, NewsReferenceType reftype2=NR_NONE, uint32_t ref2=UINT32_MAX, const NewsAllocatedData *data=nullptr)
Add a new newsitem to be shown.
@ NT_INDUSTRY_OPEN
Opening of industries.
@ NT_GENERAL
General news (from towns)
@ NR_TOWN
Reference town. Scroll to town when clicking on the news.
@ NR_NONE
Empty reference.
@ NF_COMPANY
Company news item. (Newspaper with face)
@ NF_NORMAL
Normal news item. (Newspaper with text only)
Functions related to objects.
void BuildObject(ObjectType type, TileIndex tile, CompanyID owner=OWNER_NONE, struct Town *town=nullptr, uint8_t view=0)
Actually build the object.
Map accessors for object tiles.
static const ObjectType OBJECT_STATUE
Statue in towns.
Some methods of Pool are placed here in order to reduce compilation time and binary size.
#define INSTANTIATE_POOL_METHODS(name)
Force instantiation of pool methods so we don't get linker errors.
static debug_inline bool IsPlainRailTile(Tile t)
Checks whether the tile is a rail tile or rail tile with signals.
Randomizer _random
Random used in the game state calculations.
Pseudo random number generator.
uint32_t RandomRange(uint32_t limit, const std::source_location location=std::source_location::current())
Pick a random number between 0 and limit - 1, inclusive.
bool Chance16(const uint32_t a, const uint32_t b, const std::source_location location=std::source_location::current())
Flips a coin with given probability.
RoadBits CleanUpRoadBits(const TileIndex tile, RoadBits org_rb)
Clean up unnecessary RoadBits of a planned tile.
const RoadTypeInfo * GetRoadTypeInfo(RoadType roadtype)
Returns a pointer to the Roadtype information for a given roadtype.
@ ROTF_NO_HOUSES
Bit number for setting this roadtype as not house friendly.
@ ROTF_TOWN_BUILD
Bit number for allowing towns to build this roadtype.
void UpdateNearestTownForRoadTiles(bool invalidate)
Updates cached nearest town for all road tiles.
RoadBits DiagDirToRoadBits(DiagDirection d)
Create the road-part which belongs to the given DiagDirection.
Functions used internally by the roads.
RoadBits GetAnyRoadBits(Tile tile, RoadTramType rtt, bool straight_tunnel_bridge_entrance)
Returns the RoadBits on an arbitrary tile Special behaviour:
void SetRoadOwner(Tile t, RoadTramType rtt, Owner o)
Set the owner of a specific road type.
bool HasTownOwnedRoad(Tile t)
Checks if given tile has town owned road.
static debug_inline bool IsNormalRoadTile(Tile t)
Return whether a tile is a normal road tile.
static debug_inline bool IsRoadDepot(Tile t)
Return whether a tile is a road depot.
DisallowedRoadDirections GetDisallowedRoadDirections(Tile t)
Gets the disallowed directions.
bool HasTileRoadType(Tile t, RoadTramType rtt)
Check if a tile has a road or a tram road type.
DiagDirection GetRoadDepotDirection(Tile t)
Get the direction of the exit of a road depot.
static debug_inline bool IsRoadDepotTile(Tile t)
Return whether a tile is a road depot tile.
bool IsRoadOwner(Tile t, RoadTramType rtt, Owner o)
Check if a specific road type is owned by an owner.
RoadBits
Enumeration for the road parts on a tile.
@ ROAD_SW
South-west part.
@ ROAD_ALL
Full 4-way crossing.
@ ROAD_NONE
No road-part is build.
@ ROAD_E
Road at the two eastern edges.
@ ROAD_NE
North-east part.
@ ROAD_N
Road at the two northern edges.
@ ROAD_SE
South-east part.
@ ROAD_Y
Full road along the y-axis (north-west + south-east)
@ ROAD_S
Road at the two southern edges.
@ ROAD_W
Road at the two western edges.
@ ROAD_NW
North-west part.
@ ROAD_X
Full road along the x-axis (south-west + north-east)
RoadType
The different roadtypes we support.
@ INVALID_ROADTYPE
flag for invalid roadtype
@ ROADTYPE_ROAD
Basic road type.
@ ROADTYPE_END
Used for iterations.
@ ROADTYPE_BEGIN
Used for iterations.
@ DRD_NONE
None of the directions are disallowed.
A number of safeguards to prevent using unsafe methods.
GameSettings _settings_game
Game settings of a running game or the scenario editor.
ClientSettings _settings_client
The current settings for this game.
static constexpr int GetSlopeMaxZ(Slope s)
Returns the height of the highest corner of a slope relative to TileZ (= minimal height)
bool IsSlopeWithOneCornerRaised(Slope s)
Tests if a specific slope has exactly one corner raised.
static constexpr bool IsSteepSlope(Slope s)
Checks if a slope is steep.
Foundation FlatteningFoundation(Slope s)
Returns the foundation needed to flatten a slope.
Slope InclinedSlope(DiagDirection dir)
Returns the slope that is inclined in a specific direction.
Slope ComplementSlope(Slope s)
Return the complement of a slope.
Slope
Enumeration for the slope-type.
@ SLOPE_W
the west corner of the tile is raised
@ SLOPE_ELEVATED
bit mask containing all 'simple' slopes
@ SLOPE_E
the east corner of the tile is raised
@ SLOPE_S
the south corner of the tile is raised
@ SLOPE_N
the north corner of the tile is raised
@ SLOPE_SW
south and west corner are raised
@ SLOPE_STEEP_W
a steep slope falling to east (from west)
@ SLOPE_NE
north and east corner are raised
@ SLOPE_STEEP_E
a steep slope falling to west (from east)
@ SLOPE_SE
south and east corner are raised
@ SLOPE_NW
north and west corner are raised
@ SLOPE_STEEP_N
a steep slope falling to south (from north)
@ SLOPE_STEEP_S
a steep slope falling to north (from south)
Foundation
Enumeration for Foundations.
@ FOUNDATION_LEVELED
The tile is leveled up to a flat slope.
@ FOUNDATION_NONE
The tile has no foundation, the slope remains unchanged.
Base classes/functions for stations.
void ForAllStationsAroundTiles(const TileArea &ta, Func func)
Call a function on all stations that have any part of the requested area within their catchment.
void UpdateAllStationVirtCoords()
Update the virtual coords needed to draw the station sign for all stations.
void UpdateAirportsNoise()
Recalculate the noise generated by the airports of each town.
Declarations for accessing the k-d tree of stations.
void ForAllStationsRadius(TileIndex center, uint radius, Func func)
Call a function on all stations whose sign is within a radius of a center tile.
bool IsBayRoadStopTile(Tile t)
Is tile t a bay (non-drive through) road stop station?
bool IsDriveThroughStopTile(Tile t)
Is tile t a drive through road stop station or waypoint?
Axis GetDriveThroughStopAxis(Tile t)
Gets the axis of the drive through stop.
DiagDirection GetBayRoadStopDir(Tile t)
Gets the direction the bay road stop entrance points towards.
bool IsAnyRoadStopTile(Tile t)
Is tile t a road stop station?
@ FACIL_AIRPORT
Station with an airport.
Definition of base types and functions in a cross-platform compatible way.
#define MAX_UVALUE(type)
The largest value that can be entered in a variable.
#define lengthof(array)
Return the length of an fixed size array.
size_t Utf8StringLength(const char *s)
Get the length of an UTF-8 encoded string in number of characters and thus not the number of bytes th...
Functions related to low-level strings.
void SetDParam(size_t n, uint64_t v)
Set a string parameter v at index n in the global string parameter array.
std::string GetString(StringID string)
Resolve the given StringID into a std::string with all the associated DParam lookups and formatting.
void SetDParamStr(size_t n, const char *str)
This function is used to "bind" a C string to a OpenTTD dparam slot.
Functions related to OTTD's strings.
uint32_t StringID
Numeric value that represents a string, independent of the selected language.
static const StringID INVALID_STRING_ID
Constant representing an invalid string (16bit in case it is used in savegames)
Class to backup a specific variable and restore it upon destruction of this object to prevent stack v...
Class to backup a specific variable and restore it later.
void Restore()
Restore the variable.
Owner owner
The owner of this station.
Class for storing amounts of cargo.
static void InvalidateAllFrom(SourceType src_type, SourceID src)
Invalidates (sets source_id to INVALID_SOURCE) all cargo packets from given source.
Specification of a cargo type.
static IterateWrapper Iterate(size_t from=0)
Returns an iterable ensemble of all valid CargoSpec.
static std::array< std::vector< const CargoSpec * >, NUM_TPE > town_production_cargoes
List of cargo specs for each Town Product Effect.
bool value
tells if the bool cheat is active or not
Cheat magic_bulldozer
dynamite industries, objects
GUISettings gui
settings related to the GUI
bool build_on_slopes
allow building on slopes
uint8_t number_towns
the amount of towns
uint8_t town_council_tolerance
minimum required town ratings to be allowed to demolish stuff
This structure is the same for both Industries and Houses.
bool bribe
enable bribing the local authority
TownFounding found_town
town founding.
bool exclusive_rights
allow buying exclusive rights
uint8_t initial_city_size
multiplier for the initial size of the cities compared to towns
TownLayout town_layout
select town layout,
bool allow_town_level_crossings
towns are allowed to build level crossings
uint8_t town_growth_rate
town growth rate
bool allow_town_roads
towns are allowed to build roads (always allowed when generating world / in SE)
bool fund_buildings
allow funding new buildings
bool fund_roads
allow funding local road reconstruction
TownCargoGenMode town_cargogen_mode
algorithm for generating cargo from houses,
uint8_t dist_local_authority
distance for town local authority, default 20
uint8_t larger_towns
the number of cities to build. These start off larger and grow twice as fast
Information about GRF, used in the game and (part of it) in savegames.
const char * GetName() const
Get the name of this grf.
const struct GRFFile * grffile
grf file that introduced this entity
std::array< const struct SpriteGroup *, Tcnt > spritegroup
pointers to the different sprites of the entity
uint16_t override
id of the entity been replaced by
bool population_in_label
show the population of a town in its label?
uint16_t custom_town_number
manually entered number of towns
uint8_t landscape
the landscape we're currently in
uint8_t town_name
the town name generator used for town names
EconomySettings economy
settings to change the economy
ConstructionSettings construction
construction of things in-game
DifficultySettings difficulty
settings related to the difficulty
GameCreationSettings game_creation
settings used during the creation of a game (map)
Stores station stats for a single cargo.
uint8_t rating
Station rating for this cargo.
uint8_t probability
Relative probability of appearing (16 is the standard value)
CargoID accepts_cargo[HOUSE_NUM_ACCEPTS]
input cargo slots
uint8_t removal_cost
cost multiplier for removing it
uint8_t mail_generation
mail generation multiplier (tile based, as the acceptances below)
bool enabled
the house is available to build (true by default, but can be disabled by newgrf)
Money GetRemovalCost() const
Get the cost for removing this house.
static HouseSpec * Get(size_t house_id)
Get the spec for a house ID.
BuildingFlags building_flags
some flags that describe the house (size, stadium etc...)
TimerGameCalendar::Year max_year
last year it can be built
uint16_t remove_rating_decrease
rating decrease if removed
uint8_t population
population (Zero on other tiles in multi tile house.)
HouseExtraFlags extra_flags
some more flags
uint8_t cargo_acceptance[HOUSE_NUM_ACCEPTS]
acceptance level for the cargo slots
HouseID Index() const
Gets the index of this spec.
HouseClassID class_id
defines the class this house has (not grf file based)
StringID building_name
building name
uint8_t minimum_life
The minimum number of years this house will survive before the town rebuilds it.
GRFFileProps grf_prop
Properties related the the grf file.
uint16_t callback_mask
Bitmask of house callbacks that have to be called.
HouseZones building_availability
where can it be built (climates, zones)
static std::vector< HouseSpec > & Specs()
Get a reference to all HouseSpecs.
Defines the internal data of a functional industry.
static Industry * GetByTile(TileIndex tile)
Get the industry of the given tile.
static uint ScaleBySize(uint n)
Scales the given value by the map size, where the given value is for a 256 by 256 map.
static debug_inline uint Size()
Get the size of the map.
An object, such as transmitter, on the map.
ObjectType type
Type of the object.
Town * town
Town the object is built in.
static Object * GetByTile(TileIndex tile)
Get the object associated with a tile.
Represents the covered area of e.g.
void Add(TileIndex to_add)
Add a single tile to a tile area; enlarge if needed.
SpriteID sprite
The 'real' sprite.
PaletteID pal
The palette (use PAL_NONE) if not needed)
Coordinates of a point in 2D.
static size_t GetPoolSize()
Returns first unused index.
Tindex index
Index of this pool item.
static Titem * Get(size_t index)
Returns Titem with given index.
static size_t GetNumItems()
Returns number of valid items in the pool.
static bool CleaningPool()
Returns current state of pool cleaning - yes or no.
static bool IsValidID(size_t index)
Tests whether given index can be used to get valid (non-nullptr) Titem.
static bool CanAllocateItem(size_t n=1)
Helper functions so we can use PoolItem::Function() instead of _poolitem_pool.Function()
static Titem * GetIfValid(size_t index)
Returns Titem with given index.
static Pool::IterateWrapper< Titem > Iterate(size_t from=0)
Returns an iterable ensemble of all valid Titem.
Base class for all pools.
static constexpr size_t MAX_SIZE
Make template parameter accessible from outside.
static Pool::IterateWrapper< Station > Iterate(size_t from=0)
Returns an iterable ensemble of all valid stations of type T.
Used as the user_data for FindFurthestFromWater.
uint max_dist
holds the distance that tile is from the water
TownLayout layout
tells us what kind of town we're building
TileIndex tile
holds the tile that was found
bool CatchmentCoversTown(TownID t) const
Test if the given town ID is covered by our catchment area.
Structure for storing data while searching the best place to build a statue.
int tile_count
Number of tiles tried.
TileIndex best_position
Best position found so far.
Tile description for the 'land area information' tool.
StringID str
Description of the tile.
uint64_t dparam
Parameter of the str string.
const char * grf
newGRF used for the tile contents
Owner owner[4]
Name of the owner(s)
A pair-construct of a TileIndexDiff.
int16_t x
The x value of the coordinate.
int16_t y
The y value of the coordinate.
Tile information, used while rendering the tile.
int x
X position of the tile in unit coordinates.
Slope tileh
Slope of the tile.
TileIndex tile
Tile index.
int y
Y position of the tile in unit coordinates.
Set of callback functions for performing tile operations of a given tile type.
uint32_t population
Current population of people.
uint32_t num_houses
Amount of houses.
std::array< uint32_t, HZB_END > squared_town_zone_radius
UpdateTownRadius updates this given the house count.
TrackedViewportSign sign
Location of name sign, UpdateVirtCoord updates this.
BuildingCounts< uint16_t > building_counts
The number of each type of building in the town.
Struct holding parameters used to generate town name.
bool larger_town
if this is a larger town and should grow more quickly
TransportedCargoStat< uint32_t > supplied[NUM_CARGO]
Cargo statistics about supplied cargo.
CompanyMask statues
which companies have a statue?
uint16_t time_until_rebuild
time until we rebuild a house
std::string cached_name
NOSAVE: Cache of the resolved name of the town, if not using a custom town name.
TileIndex xy
town center tile
uint8_t fund_buildings_months
fund buildings program in action?
int16_t ratings[MAX_COMPANIES]
ratings of each company for this town
TownLayout layout
town specific road layout
TransportedCargoStat< uint16_t > received[NUM_TAE]
Cargo statistics about received cargotypes.
static Town * GetRandom()
Return a random valid town.
std::string name
Custom town name. If empty, the town was not renamed and uses the generated name.
uint16_t grow_counter
counter to count when to grow, value is smaller than or equal to growth_rate
uint8_t flags
See TownFlags.
TownCache cache
Container for all cacheable data.
CompanyID exclusivity
which company has exclusivity
void InitializeLayout(TownLayout layout)
Assign the town layout.
bool show_zone
NOSAVE: mark town to show the local authority zone in the viewports.
uint32_t goal[NUM_TAE]
Amount of cargo required for the town to grow.
uint8_t exclusive_counter
months till the exclusivity expires
void UpdateVirtCoord()
Resize the sign (label) of the town after it changes population.
std::string text
General text with additional information.
CompanyMask have_ratings
which companies have a rating
uint8_t unwanted[MAX_COMPANIES]
how many months companies aren't wanted by towns (bribe)
uint16_t growth_rate
town growth rate
StationList stations_near
NOSAVE: List of nearby stations.
static void PostDestructor(size_t index)
Invalidating of the "nearest town cache" has to be done after removing item from the pool.
uint8_t road_build_months
fund road reconstruction in action?
void UpdatePosition(int center, int top, StringID str, StringID str_small=STR_NULL)
Update the position of the viewport sign.
bool kdtree_valid
Are the sign data valid for use with the _viewport_sign_kdtree?
Tstorage new_max
Maximum amount this month.
Tstorage old_max
Maximum amount last month.
Tstorage old_act
Actually transported last month.
Tstorage new_act
Actually transported this month.
Representation of a waypoint.
void DeleteSubsidyWith(SourceType type, SourceID index)
Delete the subsidies associated with a given cargo source type and id.
Functions related to subsidies.
bool IsTileFlat(TileIndex tile, int *h)
Check if a given tile is flat.
int GetTileMaxZ(TileIndex t)
Get top height of the tile inside the map.
int GetTileZ(TileIndex tile)
Get bottom height of the tile.
uint TileHash(uint x, uint y)
Calculate a hash value from a tile position.
bool IsTileOwner(Tile tile, Owner owner)
Checks if a tile belongs to the given owner.
int GetTileMaxPixelZ(TileIndex tile)
Get top height of the tile.
static debug_inline TileType GetTileType(Tile tile)
Get the tiletype of a given tile.
bool IsValidTile(Tile tile)
Checks if a tile is valid.
uint TileHash2Bit(uint x, uint y)
Get the last two bits of the TileHash from a tile position.
TropicZone GetTropicZone(Tile tile)
Get the tropic zone.
static debug_inline bool IsTileType(Tile tile, TileType type)
Checks if a tile is a given tiletype.
Slope GetTileSlope(TileIndex tile)
Return the slope of a given tile inside the map.
static debug_inline uint TileHeight(Tile tile)
Returns the height of a tile.
@ TROPICZONE_DESERT
Tile is desert.
static const uint TILE_SIZE
Tile size in world coordinates.
constexpr TileIndex INVALID_TILE
The very nice invalid tile marker.
@ MP_TREES
Tile got trees.
@ MP_ROAD
A tile with road (or tram tracks)
@ MP_STATION
A tile of a station.
@ MP_TUNNELBRIDGE
Tunnel entry/exit and bridge heads.
@ MP_CLEAR
A tile without any structures, i.e. grass, rocks, farm fields etc.
@ MP_HOUSE
A house by a town.
@ MP_INDUSTRY
Part of an industry.
@ MP_VOID
Invisible tiles at the SW and SE border.
@ MP_OBJECT
Contains objects such as transmitters and owned land.
OrthogonalTileArea TileArea
Shorthand for the much more common orthogonal tile area.
Definition of Interval and OneShot timers.
Definition of the game-calendar-timer.
Definition of the game-economy-timer.
Definition of the tick-based game-timer.
static const uint TOWN_GROWTH_WINTER
The town only needs this cargo in the winter (any amount)
static const uint TOWN_GROWTH_DESERT
The town needs the cargo for growth when on desert (any amount)
@ TOWN_HAS_CHURCH
There can be only one church by town.
@ TOWN_HAS_STADIUM
There can be only one stadium by town.
@ TOWN_IS_GROWING
Conditions for town growth are met. Grow according to Town::growth_rate.
@ TOWN_CUSTOM_GROWTH
Growth rate is controlled by GS.
TownRatingCheckType
Action types that a company must ask permission for to a town authority.
@ TOWN_RATING_CHECK_TYPE_COUNT
Number of town checking action types.
TownActions
Town actions of a company.
@ TACT_BUILD_STATUE
Build a statue.
@ TACT_ROAD_REBUILD
Rebuild the roads.
@ TACT_BUY_RIGHTS
Buy exclusive transport rights.
@ TACT_BRIBE
Try to bribe the council.
@ TACT_COUNT
Number of available town actions.
@ TACT_FUND_BUILDINGS
Fund new buildings.
@ TACT_NONE
Empty action set.
static const uint CUSTOM_TOWN_NUMBER_DIFFICULTY
value for custom town number in difficulty settings
static const uint16_t TOWN_GROWTH_RATE_NONE
Special value for Town::growth_rate to disable town growth.
static bool RoadTypesAllowHouseHere(TileIndex t)
Checks whether at least one surrounding road allows to build a house here.
static bool CheckFree2x2Area(TileIndex tile, int z, bool noslope)
Checks if a house of size 2x2 can be built at this tile.
static bool TownLayoutAllows2x2HouseHere(Town *t, TileIndex tile)
Checks if the current town layout allows a 2x2 building here.
static void ClearMakeHouseTile(TileIndex tile, Town *t, uint8_t counter, uint8_t stage, HouseID type, uint8_t random_bits)
Clears tile and builds a house or house part.
const CargoSpec * FindFirstCargoWithTownAcceptanceEffect(TownAcceptanceEffect effect)
Determines the first cargo with a certain town effect.
HouseZonesBits GetTownRadiusGroup(const Town *t, TileIndex tile)
Returns the bit corresponding to the town zone of the specified tile.
static bool GrowTownWithExtraHouse(Town *t, TileIndex tile)
Grows the town with an extra house.
static bool SearchTileForStatue(TileIndex tile, void *user_data)
Search callback function for TownActionBuildStatue.
static bool FindNearestEmptyLand(TileIndex tile, void *)
CircularTileSearch callback to find the nearest land tile.
static bool IsTileAlignedToGrid(TileIndex tile, TownLayout layout)
Towns must all be placed on the same grid or when they eventually interpenetrate their road networks ...
static void AddAcceptedCargoSetMask(CargoID cargo, uint amount, CargoArray &acceptance, CargoTypes &always_accepted)
Fill cargo acceptance array and always_accepted mask, if cargo ID is valid.
static CommandCost TownActionBribe(Town *t, DoCommandFlag flags)
Perform the "bribe" town action.
CommandCost CmdRenameTown(DoCommandFlag flags, TownID town_id, const std::string &text)
Rename a town (server-only).
TileIndexDiff GetHouseNorthPart(HouseID &house)
Determines if a given HouseID is part of a multitile house.
static CommandCost TownActionAdvertiseLarge(Town *t, DoCommandFlag flags)
Perform the "large advertising campaign" town action.
static CommandCost TownActionAdvertiseSmall(Town *t, DoCommandFlag flags)
Perform the "small advertising campaign" town action.
static int GetRating(const Town *t)
Get the rating of a town for the _current_company.
void ClearTownHouse(Town *t, TileIndex tile)
Clear a town house.
static uint GetNormalGrowthRate(Town *t)
Calculates town growth rate in normal conditions (custom growth rate not set).
TownActions GetMaskOfTownActions(CompanyID cid, const Town *t)
Get a list of available town authority actions.
static CommandCost ClearTile_Town(TileIndex tile, DoCommandFlag flags)
Callback function to clear a house tile.
static bool GrowTownWithBridge(const Town *t, const TileIndex tile, const DiagDirection bridge_dir)
Grows the town with a bridge.
static TileIndex FindNearestGoodCoastalTownSpot(TileIndex tile, TownLayout layout)
Given a spot on the map (presumed to be a water tile), find a good coastal spot to build a city.
CommandCost CmdTownGrowthRate(DoCommandFlag flags, TownID town_id, uint16_t growth_rate)
Change the growth rate of the town.
static bool IsRoadAllowedHere(Town *t, TileIndex tile, DiagDirection dir)
Check if a Road is allowed on a given tile.
static bool CanRoadContinueIntoNextTile(const Town *t, const TileIndex tile, const DiagDirection road_dir)
Checks if a town road can be continued into the next tile.
CommandCost CmdTownRating(DoCommandFlag flags, TownID town_id, CompanyID company_id, int16_t rating)
Change the rating of a company in a town.
static void UpdateTownGrowCounter(Town *t, uint16_t prev_growth_rate)
Updates town grow counter after growth rate change.
CommandCost CmdTownCargoGoal(DoCommandFlag flags, TownID town_id, TownAcceptanceEffect tae, uint32_t goal)
Change the cargo goal of a town.
static int CountActiveStations(Town *t)
Calculates amount of active stations in the range of town (HZB_TOWN_EDGE).
static CommandCost TownCanBePlacedHere(TileIndex tile)
Check if it's possible to place a town on a given tile.
static bool _generating_town
Set if a town is being generated.
static bool CanFollowRoad(TileIndex tile, DiagDirection dir)
Checks whether a road can be followed or is a dead end, that can not be extended to the next tile.
static bool RedundantBridgeExistsNearby(TileIndex tile, void *user_data)
CircularTileSearch proc which checks for a nearby parallel bridge to avoid building redundant bridges...
static bool TownLayoutAllowsHouseHere(Town *t, TileIndex tile)
Checks if the current town layout allows building here.
static void TileLoop_Town(TileIndex tile)
Tile callback function.
static bool CanBuildHouseHere(TileIndex tile, bool noslope)
Check if a house can be built here, based on slope, whether there's a bridge above,...
static CommandCost TownActionAdvertiseMedium(Town *t, DoCommandFlag flags)
Perform the "medium advertising campaign" town action.
static bool GrowTownWithRoad(const Town *t, TileIndex tile, RoadBits rcmd)
Grows the town with a road piece.
CommandCost CmdDeleteTown(DoCommandFlag flags, TownID town_id)
Delete a town (scenario editor or worldgen only).
static void UpdateTownRating(Town *t)
Monthly callback to update town and station ratings.
static void AdvanceHouseConstruction(TileIndex tile)
Increase the construction stage of a house.
static bool TownCanGrowRoad(TileIndex tile)
Test if town can grow road onto a specific tile.
uint32_t GetWorldPopulation()
Get the total population, the sum of all towns in the world.
static bool GrowTownWithTunnel(const Town *t, const TileIndex tile, const DiagDirection tunnel_dir)
Grows the town with a tunnel.
static std::map< const Town *, int > _town_test_ratings
Map of towns to modified ratings, while in town rating test-mode.
static bool CheckClearTile(TileIndex tile)
Check whether the land can be cleared.
const uint8_t _town_action_costs[TACT_COUNT]
Factor in the cost of each town action.
static CommandCost TownActionRoadRebuild(Town *t, DoCommandFlag flags)
Perform the "local road reconstruction" town action.
static CommandCost TownActionFundBuildings(Town *t, DoCommandFlag flags)
Perform the "fund new buildings" town action.
static void TownGenerateCargoOriginal(Town *t, TownProductionEffect tpe, uint8_t rate, StationFinder &stations)
Generate cargo for a house using the original algorithm.
void UpdateTownMaxPass(Town *t)
Update the maximum amount of montly passengers and mail for a town, based on its population.
static void ChangePopulation(Town *t, int mod)
Change the town's population as recorded in the town cache, town label, and town directory.
static bool CheckTownBuild2x2House(TileIndex *tile, Town *t, int maxz, bool noslope)
Checks if a 1x2 or 2x1 building is allowed here, accounting for road layout and tile heights.
static bool TownAllowedToBuildRoads()
Check if the town is allowed to build roads.
static bool IsNeighborRoadTile(TileIndex tile, const DiagDirection dir, uint dist_multi)
Check for parallel road inside a given distance.
static bool GrowTown(Town *t)
Grow the town.
static DiagDirection RandomDiagDir()
Return a random direction.
static TileIndex AlignTileToGrid(TileIndex tile, TownLayout layout)
Towns must all be placed on the same grid or when they eventually interpenetrate their road networks ...
static Town * CreateRandomTown(uint attempts, uint32_t townnameparts, TownSize size, bool city, TownLayout layout)
Create a random town somewhere in the world.
static void RemoveNearbyStations(Town *t, TileIndex tile, BuildingFlags flags)
Remove stations from nearby station list if a town is no longer in the catchment area of each.
static bool GrowTownAtRoad(Town *t, TileIndex tile)
Try to grow a town at a given road tile.
void ClearAllTownCachedNames()
Clear the cached_name of all towns.
void ChangeTownRating(Town *t, int add, int max, DoCommandFlag flags)
Changes town rating of the current company.
static bool FindFurthestFromWater(TileIndex tile, void *user_data)
CircularTileSearch callback; finds the tile furthest from any water.
static Foundation GetFoundation_Town(TileIndex tile, Slope tileh)
Get the foundation for a house.
static void TownGenerateCargo(Town *t, CargoID ct, uint amount, StationFinder &stations, bool affected_by_recession)
Generate cargo for a house, scaled by the current economy scale.
static TimerGameCalendar::Date GetTownRoadTypeFirstIntroductionDate()
Get the calendar date of the earliest town-buildable road type.
static void AnimateTile_Town(TileIndex tile)
Animate a tile for a town.
CommandCost CmdDoTownAction(DoCommandFlag flags, TownID town_id, uint8_t action)
Do a town action.
const TileTypeProcs _tile_type_town_procs
Tile callback functions for a town.
RoadType GetTownRoadType()
Get the road type that towns should build at this current moment.
static RoadBits GetTownRoadBits(TileIndex tile)
Return the RoadBits of a tile, ignoring depot and bay road stops.
CommandCost CmdExpandTown(DoCommandFlag flags, TownID town_id, uint32_t grow_amount)
Expand a town (scenario editor only).
static CommandCost TownActionBuyRights(Town *t, DoCommandFlag flags)
Perform the "buy exclusive transport rights" town action.
static void DoCreateTown(Town *t, TileIndex tile, uint32_t townnameparts, TownSize size, bool city, TownLayout layout, bool manual)
Actually create a town.
static bool TryBuildTownHouse(Town *t, TileIndex tile)
Tries to build a house at this tile.
static bool TestTownOwnsBridge(TileIndex tile, const Town *t)
Check if a town 'owns' a bridge.
void OnTick_Town()
Iterate through all towns and call their tick handler.
bool CheckTownRoadTypes()
Check if towns are able to build road.
bool GenerateTowns(TownLayout layout)
Generate a number of towns with a given layout.
CommandCost CheckIfAuthorityAllowsNewStation(TileIndex tile, DoCommandFlag flags)
Checks whether the local authority allows construction of a new station (rail, road,...
CommandCost CheckforTownRating(DoCommandFlag flags, Town *t, TownRatingCheckType type)
Does the town authority allow the (destructive) action of the current company?
static bool CheckTownBuild2House(TileIndex *tile, Town *t, int maxz, bool noslope, DiagDirection second)
Checks if a 1x2 or 2x1 building is allowed here, accounting for road layout and tile heights.
static void UpdateTownGrowthRate(Town *t)
Updates town growth rate.
static RoadBits GetTownRoadGridElement(Town *t, TileIndex tile, DiagDirection dir)
Generate the RoadBits of a grid tile.
static void AdvanceSingleHouseConstruction(TileIndex tile)
Helper function for house construction stage progression.
static void TownTickHandler(Town *t)
Handle the town tick for a single town, by growing the town if desired.
Town * CalcClosestTownFromTile(TileIndex tile, uint threshold)
Return the town closest to the given tile within threshold.
static void MakeTownHouse(TileIndex tile, Town *t, uint8_t counter, uint8_t stage, HouseID type, uint8_t random_bits)
Write house information into the map.
void SetTownRatingTestMode(bool mode)
Switch the town rating to test-mode, to allow commands to be tested without affecting current ratings...
static CommandCost TownActionBuildStatue(Town *t, DoCommandFlag flags)
Perform a 9x9 tiles circular search from the center of the town in order to find a free tile to place...
static bool _town_rating_test
If true, town rating is in test-mode.
void UpdateTownRadius(Town *t)
Update the cached town zone radii of a town, based on the number of houses.
static void BuildTownHouse(Town *t, TileIndex tile, const HouseSpec *hs, HouseID house, uint8_t random_bits)
Build a house at this tile.
CommandCost CmdTownSetText(DoCommandFlag flags, TownID town_id, const std::string &text)
Set a custom text in the Town window.
static bool IsCloseToTown(TileIndex tile, uint dist)
Determines if a town is close to a tile.
static void UpdateTownGrowth(Town *t)
Updates town growth state (whether it is growing or not).
static void DoClearTownHouseHelper(TileIndex tile, Town *t, HouseID house)
Update data structures when a house is removed.
Town * ClosestTownFromTile(TileIndex tile, uint threshold)
Return the town closest (in distance or ownership) to a given tile, within a given threshold.
static RoadBits GenRandomRoadBits()
Generate a random road block.
static bool CheckBuildHouseSameZ(TileIndex tile, int z, bool noslope)
Check if a tile where we want to build a multi-tile house has an appropriate max Z.
static void TownGenerateCargoBinominal(Town *t, TownProductionEffect tpe, uint8_t rate, StationFinder &stations)
Generate cargo for a house using the binominal algorithm.
std::tuple< CommandCost, Money, TownID > CmdFoundTown(DoCommandFlag flags, TileIndex tile, TownSize size, bool city, TownLayout layout, bool random_location, uint32_t townnameparts, const std::string &text)
Create a new town.
static bool IsUniqueTownName(const std::string &name)
Verifies this custom name is unique.
static void DrawTile_Town(TileInfo *ti)
Draw a house and its tile.
void UpdateAllTownVirtCoords()
Update the virtual coords needed to draw the town sign for all towns.
static void GrowTownInTile(TileIndex *tile_ptr, RoadBits cur_rb, DiagDirection target_dir, Town *t1)
Grows the given town.
Command definitions related to towns.
Declarations for accessing the k-d tree of towns.
Sprites to use and how to display them for town tiles.
static const DrawBuildingsTileStruct _town_draw_tile_data[]
structure of houses graphics
void IncrementHouseAge(Tile t)
Increments the age of the house.
void HaltLift(Tile t)
Stop the lift of this animated house from moving.
HouseID GetHouseType(Tile t)
Get the type of this house, which is an index into the house spec array.
void ResetHouseAge(Tile t)
Sets the age of the house to zero.
void IncHouseConstructionTick(Tile t)
Sets the increment stage of a house It is working with the whole counter + stage 5 bits,...
uint8_t GetLiftPosition(Tile t)
Get the position of the lift on this animated house.
void SetLiftDestination(Tile t, uint8_t dest)
Set the new destination of the lift for this animated house, and activate the LiftHasDestination bit.
TimerGameCalendar::Year GetHouseAge(Tile t)
Get the age of the house.
void SetLiftPosition(Tile t, uint8_t pos)
Set the position of the lift on this animated house.
uint8_t GetLiftDestination(Tile t)
Get the current destination for this lift.
uint8_t GetHouseBuildingStage(Tile t)
House Construction Scheme.
TownID GetTownIndex(Tile t)
Get the index of which town this house/street is attached to.
void SetTownIndex(Tile t, TownID index)
Set the town index for a road or house tile.
bool LiftHasDestination(Tile t)
Check if the lift of this animated house has a destination.
bool IsHouseCompleted(Tile t)
Get the completion of this house.
void MakeHouseTile(Tile t, TownID tid, uint8_t counter, uint8_t stage, HouseID type, uint8_t random_bits)
Make the tile a house.
uint8_t GetHouseConstructionTick(Tile t)
Gets the construction stage of a house.
static constexpr int RATING_GROWTH_UP_STEP
when a town grows, all companies have rating increased a bit ...
static constexpr int RATING_INITIAL
initial rating
static constexpr int RATING_ROAD_NEEDED_HOSTILE
"Hostile"
@ TCGM_BITCOUNT
Bit-counted algorithm (normal distribution from individual house population)
@ TCGM_ORIGINAL
Original algorithm (quadratic cargo by population)
static constexpr int RATING_ROAD_NEEDED_NEUTRAL
"Neutral"
@ TL_3X3_GRID
Geometric 3x3 grid algorithm.
@ TL_ORIGINAL
Original algorithm (min. 1 distance between roads)
@ TL_2X2_GRID
Geometric 2x2 grid algorithm.
@ TL_RANDOM
Random town layout.
@ TL_BETTER_ROADS
Extended original algorithm (min. 2 distance between roads)
@ NUM_TLS
Number of town layouts.
static constexpr int RATING_TUNNEL_BRIDGE_NEEDED_LENIENT
rating needed, "Lenient" difficulty settings
@ TF_CUSTOM_LAYOUT
Allowed, with custom town layout.
static constexpr int RATING_TUNNEL_BRIDGE_NEEDED_HOSTILE
"Hostile"
static constexpr int RATING_TUNNEL_BRIDGE_NEEDED_PERMISSIVE
"Permissive" (local authority disabled)
static constexpr int RATING_TUNNEL_BRIDGE_NEEDED_NEUTRAL
"Neutral"
static constexpr int RATING_ROAD_NEEDED_LENIENT
rating needed, "Lenient" difficulty settings
TownSize
Supported initial town sizes.
@ TSZ_RANDOM
Random size, bigger than small, smaller than large.
@ TSZ_END
Number of available town sizes.
static const uint MAX_LENGTH_TOWN_NAME_CHARS
The maximum length of a town name in characters including '\0'.
static constexpr int RATING_ROAD_NEEDED_PERMISSIVE
"Permissive" (local authority disabled)
static constexpr int RATING_GROWTH_MAXIMUM
... up to RATING_MEDIOCRE
bool VerifyTownName(uint32_t r, const TownNameParams *par, TownNames *town_names)
Verifies the town name is valid and unique.
bool GenerateTownName(Randomizer &randomizer, uint32_t *townnameparts, TownNames *town_names)
Generates valid town name.
static void GetTownName(StringBuilder &builder, const TownNameParams *par, uint32_t townnameparts)
Fills builder with specified town name.
Town name generator stuff.
@ TO_HOUSES
town buildings
bool IsTransparencySet(TransparencyOption to)
Check if the transparency option bit is set and if we aren't in the game menu (there's never transpar...
bool IsInvisibilitySet(TransparencyOption to)
Check if the invisibility option bit is set and if we aren't in the game menu (there's never transpar...
TransportType
Available types of transport.
@ TRANSPORT_ROAD
Transport by road vehicle.
Command definitions related to tunnels and bridges.
Functions that have tunnels and bridges in common.
DiagDirection GetTunnelBridgeDirection(Tile t)
Get the direction pointing to the other end.
TransportType GetTunnelBridgeTransportType(Tile t)
Tunnel: Get the transport type of the tunnel (road or rail) Bridge: Get the transport type of the bri...
TileIndex GetOtherTunnelBridgeEnd(Tile t)
Determines type of the wormhole and returns its other end.
void AddSortableSpriteToDraw(SpriteID image, PaletteID pal, int x, int y, int w, int h, int dz, int z, bool transparent, int bb_offset_x, int bb_offset_y, int bb_offset_z, const SubSprite *sub)
Draw a (transparent) sprite at given coordinates with a given bounding box.
void AddChildSpriteScreen(SpriteID image, PaletteID pal, int x, int y, bool transparent, const SubSprite *sub, bool scale, bool relative)
Add a child sprite to a parent sprite.
void DrawGroundSprite(SpriteID image, PaletteID pal, const SubSprite *sub, int extra_offs_x, int extra_offs_y)
Draws a ground sprite for the current tile.
Functions related to (drawing on) viewports.
bool HasTileWaterGround(Tile t)
Checks whether the tile has water at the ground.
bool IsWaterTile(Tile t)
Is it a water tile with plain water?
bool IsSea(Tile t)
Is it a sea water tile?
void CloseWindowById(WindowClass cls, WindowNumber number, bool force, int data)
Close a window by its class and window number (if it is open).
void SetWindowClassesDirty(WindowClass cls)
Mark all windows of a particular class as dirty (in need of repainting)
void InvalidateWindowData(WindowClass cls, WindowNumber number, int data, bool gui_scope)
Mark window data of the window of a given class and specific window number as invalid (in need of re-...
void SetWindowDirty(WindowClass cls, WindowNumber number)
Mark window as dirty (in need of repainting)
Window functions not directly related to making/drawing windows.
@ WC_TOWN_AUTHORITY
Town authority; Window numbers:
@ WC_STATION_VIEW
Station view; Window numbers:
@ WC_TOWN_VIEW
Town view; Window numbers:
@ WC_TOWN_DIRECTORY
Town directory; Window numbers: