42#include "table/strings.h"
48 _tile_type_clear_procs,
49 _tile_type_rail_procs,
52 _tile_type_trees_procs,
53 _tile_type_station_procs,
54 _tile_type_water_procs,
55 _tile_type_void_procs,
56 _tile_type_industry_procs,
57 _tile_type_tunnelbridge_procs,
58 _tile_type_object_procs;
66 &_tile_type_clear_procs,
67 &_tile_type_rail_procs,
70 &_tile_type_trees_procs,
71 &_tile_type_station_procs,
72 &_tile_type_water_procs,
73 &_tile_type_void_procs,
74 &_tile_type_industry_procs,
75 &_tile_type_tunnelbridge_procs,
76 &_tile_type_object_procs,
81 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 0,
82 0, 0, 0, 0, 0, 0, 0, 16, 0, 0, 0, 17, 0, 15, 18, 0,
113 if (clamped !=
nullptr) *clamped =
false;
131 if (clamped !=
nullptr) *clamped = (pt.x != old_pt.x) || (pt.y != old_pt.y);
141 for (
int i = 0; i < 5; i++) z =
GetSlopePixelZ(
Clamp(pt.x + std::max(z, 4) - 4, min_coord, max_x),
Clamp(pt.y + std::max(z, 4) - 4, min_coord, max_y)) / 2;
142 for (
int m = 3; m > 0; m--) z =
GetSlopePixelZ(
Clamp(pt.x + std::max(z, m) - m, min_coord, max_x),
Clamp(pt.y + std::max(z, m) - m, min_coord, max_y)) / 2;
143 for (
int i = 0; i < 5; i++) z =
GetSlopePixelZ(
Clamp(pt.x + z, min_coord, max_x),
Clamp(pt.y + z, min_coord, max_y)) / 2;
154 pt.x =
Clamp(pt.x, min_coord, max_x);
155 pt.y =
Clamp(pt.y, min_coord, max_y);
156 if (clamped !=
nullptr) *clamped = *clamped || (pt.x != old_pt.x) || (pt.y != old_pt.y);
195 s = (((highest_corner == CORNER_W) || (highest_corner == CORNER_S)) ?
SLOPE_SW :
SLOPE_NE);
199 s = (((highest_corner == CORNER_S) || (highest_corner == CORNER_E)) ?
SLOPE_SE :
SLOPE_NW);
210 default: NOT_REACHED();
250 default: NOT_REACHED();
259 case SLOPE_E:
return y >= x ? (1 + y - x) >> 1 : 0;
261 case SLOPE_W:
return x >= y ? (x - y) >> 1 : 0;
277 case SLOPE_EW:
return x >= y ? (x - y) >> 1 : (1 + y - x) >> 1;
288 default: NOT_REACHED();
356 static const Slope corners[4][4] = {
366 if (halftile_test == corners[edge][0]) z2 +=
TILE_HEIGHT;
367 if (halftile_test == corners[edge][1]) z1 +=
TILE_HEIGHT;
369 if ((tileh & corners[edge][0]) != 0) z1 +=
TILE_HEIGHT;
370 if ((tileh & corners[edge][1]) != 0) z2 +=
TILE_HEIGHT;
391bool HasFoundationNW(
TileIndex tile,
Slope slope_here, uint z_here)
393 int z_W_here = z_here;
394 int z_N_here = z_here;
402 return (z_N_here > z_N) || (z_W_here > z_W);
406bool HasFoundationNE(
TileIndex tile,
Slope slope_here, uint z_here)
408 int z_E_here = z_here;
409 int z_N_here = z_here;
417 return (z_N_here > z_N) || (z_E_here > z_E);
432 uint sprite_block = 0;
441 if (!HasFoundationNW(ti->
tile, slope, z)) sprite_block += 1;
442 if (!HasFoundationNE(ti->
tile, slope, z)) sprite_block += 2;
445 SpriteID leveled_base = (sprite_block == 0 ? (int)SPR_FOUNDATION_BASE : (SPR_SLOPES_VIRTUAL_BASE + sprite_block * TRKFOUND_BLOCK_SIZE));
446 SpriteID inclined_base = SPR_SLOPES_VIRTUAL_BASE + SLOPES_INCLINED_OFFSET + sprite_block * TRKFOUND_BLOCK_SIZE;
478 int x_bb = (((highest_corner == CORNER_W) || (highest_corner == CORNER_S)) ?
TILE_SIZE / 2 : 0);
479 int y_bb = (((highest_corner == CORNER_S) || (highest_corner == CORNER_E)) ?
TILE_SIZE / 2 : 0);
484 Point pt = {(y_bb - x_bb) * 2, y_bb + x_bb};
495 int x_bb = (((halftile_corner == CORNER_W) || (halftile_corner == CORNER_S)) ?
TILE_SIZE / 2 : 0);
496 int y_bb = (((halftile_corner == CORNER_S) || (halftile_corner == CORNER_E)) ?
TILE_SIZE / 2 : 0);
501 Point pt = {(y_bb - x_bb) * 2, y_bb + x_bb};
538 if (remove) RemoveDockingTile(tile);
646 bool do_clear =
false;
656 return CommandCost(STR_ERROR_CLEARING_LIMIT_REACHED);
663 if (coa !=
nullptr && coa->
first_tile != tile) {
670 return CommandCost(STR_ERROR_CAN_T_BUILD_ON_WATER);
708 bool had_success =
false;
711 int limit = (c ==
nullptr ? INT32_MAX :
GB(c->
clear_limit, 16, 16));
730 if (ret.
GetCost() > 0 && money < 0) {
731 return { cost, ret.
GetCost() };
745 if (ret.
GetCost() != 0 && --limit <= 0)
break;
750 return { had_success ? cost : last_error, 0 };
769 static const uint32_t feedbacks[] = {
770 0xD8F, 0x1296, 0x2496, 0x4357, 0x8679, 0x1030E, 0x206CD, 0x403FE, 0x807B8, 0x1004B2, 0x2006A8, 0x4004B2, 0x800B87
793 tile =
TileIndex{(tile.base() >> 1) ^ (-(int32_t)(tile.base() & 1) & feedback)};
796 _cur_tileloop_tile = tile;
799void InitializeLandscape()
814static const uint8_t _genterrain_tbl_1[5] = { 10, 22, 33, 37, 4 };
815static const uint8_t _genterrain_tbl_2[5] = { 0, 0, 0, 0, 33 };
817static void GenerateTerrain(
int type, uint flag)
822 const Sprite *templ = GetSprite((((r >> 24) * _genterrain_tbl_1[type]) >> 8) + _genterrain_tbl_2[type] + SPR_MAPGEN_BEGIN,
SpriteType::MapGen);
823 if (templ ==
nullptr) UserError(
"Map generator sprites could not be loaded");
831 if (x <= edge_distance || y <= edge_distance)
return;
834 uint w = templ->
width;
839 const uint8_t *p = templ->
data;
841 if ((flag & 4) != 0) {
850 default: NOT_REACHED();
852 if (xw + yw >
Map::Size() - bias)
return;
856 if (yw < xw + bias)
return;
860 if (xw + yw <
Map::Size() + bias)
return;
864 if (xw < yw + bias)
return;
879 default: NOT_REACHED();
884 for (uint w_cur = w; w_cur != 0; --w_cur) {
897 for (uint h_cur = h; h_cur != 0; --h_cur) {
911 for (uint w_cur = w; w_cur != 0; --w_cur) {
925 for (uint h_cur = h; h_cur != 0; --h_cur) {
939static void CreateDesertOrRainForest(uint desert_tropic_line)
943 for (
const auto tile :
Map::Iterate()) {
948 auto allows_desert = [tile, desert_tropic_line](
auto &offset) {
952 if (std::all_of(std::begin(_make_desert_or_rainforest_data), std::end(_make_desert_or_rainforest_data), allows_desert)) {
963 for (
const auto tile :
Map::Iterate()) {
968 auto allows_rainforest = [tile](
auto &offset) {
972 if (std::all_of(std::begin(_make_desert_or_rainforest_data), std::end(_make_desert_or_rainforest_data), allows_rainforest)) {
985 int reference_height;
993 for (
int dx = -1; dx <= 1; dx++) {
994 for (
int dy = -1; dy <= 1; dy++) {
1000 if (num < 4)
return false;
1003 for (
int dx = -16; dx <= 16; dx++) {
1004 for (
int dy = -16; dy <= 16; dy++) {
1021 uint height_lake = *
static_cast<uint *
>(user_data);
1065 bool flat_river_found =
false;
1066 bool sloped_river_found =
false;
1085 desired_slope = other_slope;
1086 sloped_river_found =
true;
1091 if (
IsTileFlat(other_tile)) flat_river_found =
true;
1095 if (!sloped_river_found && !flat_river_found)
return false;
1098 if (!sloped_river_found && flat_river_found) desired_slope =
SLOPE_FLAT;
1125 Slope to_change = cur_slope ^ desired_slope;
1136 to_change = cur_slope ^ desired_slope;
1158 if (!
IsWaterTile(downstream_tile) && !downstream_is_ocean) {
1175 if (cur_slope == desired_slope) {
1201 if (height_end > height_begin)
return false;
1204 if (slope_end == slope_begin && height_end < height_begin)
return true;
1235static void River_GetNeighbours(
AyStar *aystar,
PathNode *current)
1239 aystar->neighbours.clear();
1243 auto &neighbour = aystar->neighbours.emplace_back();
1256 for (
PathNode *path = current->parent; path !=
nullptr; path = path->parent) {
1269 for (
PathNode *path = current->parent; path !=
nullptr; path = path->parent) {
1274 uint radius = std::min(3u, (current_river_length / (long_river_length / 3u)) + 1u);
1293 finder.CalculateG = River_CalculateG;
1294 finder.CalculateH = River_CalculateH;
1295 finder.GetNeighbours = River_GetNeighbours;
1296 finder.EndNodeCheck = River_EndNodeCheck;
1297 finder.FoundEndNode = River_FoundEndNode;
1298 finder.user_target = &end;
1299 finder.user_data = &user_data;
1323 std::set<TileIndex> marks;
1324 marks.insert(begin);
1327 std::list<TileIndex> queue;
1328 queue.push_back(begin);
1334 end = queue.front();
1338 if (
IsTileFlat(end) && (height_end < height_begin || (height_end == height_begin &&
IsWaterTile(end)))) {
1351 }
while (!queue.empty());
1353 bool main_river =
false;
1356 std::tie(found, main_river) =
FlowRiver(spring, end, min_river_length);
1357 }
else if (count > 32) {
1359 std::set<TileIndex>::const_iterator cit = marks.cbegin();
1369 lake_centre != begin &&
1386 if (found)
BuildRiver(begin, end, spring, main_river);
1387 return { found, main_river };
1396 if (amount == 0)
return;
1399 const uint num_short_rivers = wells - std::max(1u, wells / 10);
1403 for (; wells > num_short_rivers; wells--) {
1405 for (
int tries = 0; tries < 512; tries++) {
1413 for (; wells != 0; wells--) {
1415 for (
int tries = 0; tries < 128; tries++) {
1423 ConvertGroundTilesIntoWaterTiles();
1452 std::array<int, MAX_TILE_HEIGHT + 1> histogram = {};
1454 std::array<int, MAX_TILE_HEIGHT + 1> edge_histogram = {};
1461 if (edge_multiplier != 0) {
1466 edge_histogram[h]++;
1473 uint land_tiles =
Map::Size() - histogram[0];
1474 int best_score = land_tiles;
1477 int goal_tiles = land_tiles * coverage / 100;
1483 int current_tiles = 0;
1484 for (; h > 0; h--) {
1485 current_tiles += histogram[h];
1486 int current_score = goal_tiles - current_tiles;
1495 if (edge_multiplier != 0 && h > 1) {
1497 current_score -= edge_histogram[1] * edge_multiplier;
1499 current_score -= edge_histogram[h] * edge_multiplier;
1502 if (std::abs(current_score) < std::abs(best_score)) {
1503 best_score = current_score;
1537 static constexpr uint GLS_HEIGHTMAP = 3;
1538 static constexpr uint GLS_TERRAGENESIS = 5;
1539 static constexpr uint GLS_ORIGINAL = 2;
1540 static constexpr uint GLS_TROPIC = 12;
1541 static constexpr uint GLS_OTHER = 0;
1560 case LandscapeType::Arctic: {
1564 GenerateTerrain(2, 0);
1567 uint flag =
GB(r, 7, 2) | 4;
1569 GenerateTerrain(4, flag);
1574 case LandscapeType::Tropic: {
1578 GenerateTerrain(0, 0);
1581 uint flag =
GB(r, 7, 2) | 4;
1583 GenerateTerrain(0, flag);
1589 GenerateTerrain(3, flag);
1599 for (; i != 0; --i) {
1614 ConvertGroundTilesIntoWaterTiles();
1619 case LandscapeType::Arctic:
1623 case LandscapeType::Tropic: {
1625 CreateDesertOrRainForest(desert_tropic_line);
1639void OnTick_Station();
1640void OnTick_Industry();
1645void CallLandscapeTick()
void DeleteAnimatedTile(TileIndex tile, bool immediate)
Stops animation on the given tile.
This file has the header for AyStar.
AyStarStatus
Return status of AyStar methods.
@ FoundEndNode
An end node was found.
@ Done
Not an end-tile, or wrong direction.
debug_inline static constexpr uint GB(const T x, const uint8_t s, const uint8_t n)
Fetch n bits from x, started at bit s.
void ClearBridgeMiddle(Tile t)
Removes bridges from the given, that is bridges along the X and Y axis.
Common return value for all commands.
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?
static std::unique_ptr< TileIterator > Create(TileIndex corner1, TileIndex corner2, bool diagonal)
Create either an OrthogonalTileIterator or DiagonalTileIterator given the diagonal parameter.
static YearMonthDay ConvertDateToYMD(Date date)
Converts a Date to a Year, Month & Day.
static Date date
Current date in days (day counter).
static TickCounter counter
Monotonic counter, in ticks, since start of game.
Map accessors for 'clear' tiles.
bool IsClearGround(Tile t, ClearGround ct)
Set the type of clear tile.
void MakeClear(Tile t, ClearGround g, uint density)
Make a clear tile.
Functions related to commands.
static const CommandCost CMD_ERROR
Define a default return value for a failed command.
DoCommandFlag
List of flags for a command.
@ DC_AUTO
don't allow building on structures
@ DC_FORCE_CLEAR_TILE
do not only remove the object on the tile, but also clear any water left on it
@ DC_NO_WATER
don't allow building on water
@ DC_BANKRUPT
company bankrupts, skip money check, skip vehicle on tile check in some cases
@ DC_EXEC
execute the given command
Money GetAvailableMoneyForCommand()
This functions returns the money which can be used to execute a command.
CompanyID _current_company
Company currently doing an action.
Functions related to companies.
void DirtyCompanyInfrastructureWindows(CompanyID company)
Redraw all windows with company infrastructure counts.
GUI Functions related to companies.
Owner
Enum for all companies/owners.
DiagDirection ReverseDiagDir(DiagDirection d)
Returns the reverse direction of the given DiagDirection.
DiagDirection ChangeDiagDir(DiagDirection d, DiagDirDiff delta)
Applies a difference on a DiagDirection.
Axis DiagDirToAxis(DiagDirection d)
Convert a DiagDirection to the axis.
DiagDirDiff
Enumeration for the difference between to DiagDirection.
@ DIAGDIRDIFF_END
Used for iterations.
@ DIAGDIRDIFF_90RIGHT
90 degrees right
@ DIAGDIRDIFF_90LEFT
90 degrees left
@ DIAGDIRDIFF_REVERSE
Reverse directions.
@ DIAGDIRDIFF_SAME
Same directions.
@ DIAGDIRDIFF_BEGIN
Used for iterations.
DiagDirection
Enumeration for diagonal directions.
@ DIAGDIR_NE
Northeast, upper right on your monitor.
@ DIAGDIR_END
Used for iterations.
@ DIAGDIR_BEGIN
Used for iterations.
@ EXPENSES_CONSTRUCTION
Construction costs.
EffectVehicle * CreateEffectVehicleAbove(int x, int y, int z, EffectVehicleType type)
Create an effect vehicle above a particular location.
Functions related to effect vehicles.
@ EV_EXPLOSION_SMALL
Various explosions.
@ EV_EXPLOSION_LARGE
Various explosions.
Error reporting related functions.
Declarations for savegames operations.
Types for recording game performance data.
@ PFE_GL_LANDSCAPE
Time spent processing other world features.
Table used to generate deserts and/or rainforests.
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.
@ LG_ORIGINAL
The original landscape generator.
@ LG_TERRAGENESIS
TerraGenesis Perlin landscape generator.
static const uint CUSTOM_SEA_LEVEL_NUMBER_DIFFICULTY
Value for custom sea level in difficulty settings.
@ GWP_LANDSCAPE
Create the landscape.
@ GWP_RIVER
Create the rivers.
void SetGeneratingWorldProgress(GenWorldProgress cls, uint total)
Set the total of a stage of the world generation.
@ GWM_HEIGHTMAP
Generate a newgame from a heightmap.
PauseMode _pause_mode
The current pause mode.
uint32_t SpriteID
The number of a sprite, without mapping bits and colourtables.
@ MapGen
Special sprite for the map generator.
uint8_t LowestSnowLine()
Get the lowest possible snow line height, either variable or static.
uint8_t GetSnowLine()
Get the current snow line, either variable or static.
bool IsSnowLineSet()
Has a snow line table already been loaded.
void ClearSnowLine()
Clear the variable snow line table and free the memory.
static std::unique_ptr< SnowLine > _snow_line
Description of the snow line throughout the year.
void SetSnowLine(std::unique_ptr< SnowLine > &&snow_line)
Set a variable snow line, as loaded from a newgrf file.
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.
bool LoadHeightmap(DetailedFileType dft, const char *filename)
Load a heightmap from file and change the map in its current dimensions to a landscape representing t...
void FixSlopes()
This function takes care of the fact that land in OpenTTD can never differ more than 1 in height.
Functions related to creating heightmaps from files.
uint GetPartialPixelZ(int x, int y, Slope corners)
Determines height at given coordinate of a slope.
static std::tuple< bool, bool > FlowRiver(TileIndex spring, TileIndex begin, uint min_river_length)
Try to flow the river down from a given begin.
int GetSlopePixelZOutsideMap(int x, int y)
Return world z coordinate of a given point of a tile, also for tiles outside the map (virtual "black"...
static bool FlowsDown(TileIndex begin, TileIndex end)
Check whether a river at begin could (logically) flow down to end.
TrackStatus GetTileTrackStatus(TileIndex tile, TransportType mode, uint sub_mode, DiagDirection side)
Returns information about trackdirs and signal states.
static bool RiverMakeWider(TileIndex tile, void *user_data)
Widen a river by expanding into adjacent tiles via circular tile search.
void OnTick_Companies()
Called every tick for updating some company info.
static uint CalculateCoverageLine(uint coverage, uint edge_multiplier)
Calculate what height would be needed to cover N% of the landmass.
static void CalculateSnowLine()
Calculate the line from which snow begins.
static const uint TILE_UPDATE_FREQUENCY_LOG
The logarithm of how many ticks it takes between tile updates (log base 2).
CommandCost CmdLandscapeClear(DoCommandFlag flags, TileIndex tile)
Clear a piece of landscape.
static bool FindSpring(TileIndex tile, void *)
Find the spring of a river.
std::tuple< CommandCost, Money > CmdClearArea(DoCommandFlag flags, TileIndex tile, TileIndex start_tile, bool diagonal)
Clear a big piece of landscape.
void ChangeTileOwner(TileIndex tile, Owner old_owner, Owner new_owner)
Change the owner of a tile.
void RunTileLoop()
Gradually iterate over all tiles on the map, calling their TileLoopProcs once every TILE_UPDATE_FREQU...
static void CreateRivers()
Actually (try to) create some rivers.
void DrawFoundation(TileInfo *ti, Foundation f)
Draw foundation f at tile ti.
int GetSlopeZInCorner(Slope tileh, Corner corner)
Determine the Z height of a corner relative to TileZ.
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,...
static void BuildRiver(TileIndex begin, TileIndex end, TileIndex spring, bool main_river)
Actually build the river between the begin and end tiles using AyStar.
void GetSlopePixelZOnEdge(Slope tileh, DiagDirection edge, int &z1, int &z2)
Determine the Z height of the corners of a specific tile edge.
void OnTick_LinkGraph()
Spawn or join a link graph job or compress a link graph if any link graph is due to do so.
const TileTypeProcs *const _tile_type_procs[16]
Tile callback functions for each type of tile.
Point InverseRemapCoords2(int x, int y, bool clamp_to_map, bool *clamped)
Map 2D viewport or smallmap coordinate to 3D world or tile coordinate.
const TileTypeProcs _tile_type_town_procs
Tile callback functions for a town.
static bool MakeLake(TileIndex tile, void *user_data)
Make a connected lake; fill all tiles in the circular tile search that are connected.
void OnTick_Town()
Iterate through all towns and call their tick handler.
static uint8_t CalculateDesertLine()
Calculate the line (in height) between desert and tropic.
const uint8_t _slope_to_sprite_offset[32]
landscape slope => sprite
const TileTypeProcs _tile_type_road_procs
Tile callback functions for road tiles.
uint ApplyFoundationToSlope(Foundation f, Slope &s)
Applies a foundation to a slope.
bool GenerateLandscape(uint8_t mode)
static const uint TILE_UPDATE_FREQUENCY
How many ticks it takes between tile updates (has to be a power of 2).
int GetSlopePixelZ(int x, int y, bool ground_vehicle)
Return world Z coordinate of a given point of a tile.
Functions related to OTTD's landscape.
std::tuple< Slope, int > GetFoundationPixelSlope(TileIndex tile)
Get slope of a tile on top of a (possible) foundation If a tile does not have a foundation,...
uint ApplyPixelFoundationToSlope(Foundation f, Slope &s)
Applies a foundation to a slope.
Point InverseRemapCoords(int x, int y)
Map 2D viewport or smallmap coordinate to 3D world or tile coordinate.
Command definitions related to landscape (slopes etc.).
Types related to the landscape.
@ Random
Randomise borders.
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.
TileIndex TileAddWrap(TileIndex tile, int addx, int addy)
This function checks if we add addx/addy to tile, if we do wrap around the edges.
uint DistanceManhattan(TileIndex t0, TileIndex t1)
Gets the Manhattan distance between the two given tiles.
TileIndex TileAddXY(TileIndex tile, int x, int y)
Adds a given offset to a tile.
TileIndex AddTileIndexDiffCWrap(TileIndex tile, TileIndexDiffC diff)
Add a TileIndexDiffC to a TileIndex and returns the new one.
static debug_inline TileIndex TileXY(uint x, uint y)
Returns the TileIndex of a coordinate.
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).
TileIndexDiffC TileIndexDiffCByDiagDir(DiagDirection dir)
Returns the TileIndexDiffC offset from a DiagDirection.
#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.
static debug_inline TileIndex TileVirtXY(uint x, uint y)
Get a tile from the virtual XY-coordinate.
static const uint MIN_MAP_SIZE_BITS
Minimal and maximal map width and height.
static const uint MAX_MAP_SIZE_BITS
Maximal size of map is equal to 2 ^ MAX_MAP_SIZE_BITS.
constexpr bool IsInsideBS(const T x, const size_t base, const size_t size)
Checks if a value is between a window started at some base point.
constexpr uint CeilDiv(uint a, uint b)
Computes ceil(a / b) for non-negative a and b.
constexpr T Clamp(const T a, const T min, const T max)
Clamp a value between an interval.
constexpr void Swap(T &a, T &b)
Type safe swap operation.
ClearedObjectArea * FindClearedObject(TileIndex tile)
Find the entry in _cleared_object_areas which occupies a certain tile.
@ PM_UNPAUSED
A normal unpaused game.
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.
A number of safeguards to prevent using unsafe methods.
FileToSaveLoad _file_to_saveload
File to save or load in the openttd loop.
Functions/types related to saving and loading games.
GameSettings _settings_game
Game settings of a running game or the scenario editor.
bool IsSpecialRailFoundation(Foundation f)
Tests if a foundation is a special rail foundation for single horizontal/vertical track.
Slope SlopeWithThreeCornersRaised(Corner corner)
Returns the slope with all except one corner raised.
Corner OppositeCorner(Corner corner)
Returns the opposite corner.
static constexpr Corner GetHalftileSlopeCorner(Slope s)
Returns the leveled halftile of a halftile slope.
static constexpr Slope RemoveHalftileSlope(Slope s)
Removes a halftile slope from a slope.
bool IsSlopeWithOneCornerRaised(Slope s)
Tests if a specific slope has exactly one corner raised.
bool IsNonContinuousFoundation(Foundation f)
Tests if a foundation is a non-continuous foundation, i.e.
Corner GetHighestSlopeCorner(Slope s)
Returns the highest corner of a slope (one corner raised or a steep slope).
Corner GetHalftileFoundationCorner(Foundation f)
Returns the halftile corner of a halftile-foundation.
bool IsLeveledFoundation(Foundation f)
Tests if the foundation is a leveled foundation.
bool IsFoundation(Foundation f)
Tests for FOUNDATION_NONE.
static constexpr bool IsSteepSlope(Slope s)
Checks if a slope is steep.
bool IsSlopeWithThreeCornersRaised(Slope s)
Tests if a specific slope has exactly three corners raised.
bool IsInclinedSlope(Slope s)
Tests if a specific slope is an inclined slope.
Slope SteepSlope(Corner corner)
Returns a specific steep slope.
Corner GetRailFoundationCorner(Foundation f)
Returns the track corner of a special rail foundation.
static constexpr bool IsHalftileSlope(Slope s)
Checks for non-continuous slope on halftile foundations.
static constexpr int GetSlopeMaxPixelZ(Slope s)
Returns the height of the highest corner of a slope relative to TileZ (= minimal height)
DiagDirection GetInclinedSlopeDirection(Slope s)
Returns the direction of an inclined slope.
static constexpr Slope HalftileSlope(Slope s, Corner corner)
Adds a halftile slope to a slope.
Slope ComplementSlope(Slope s)
Return the complement of a slope.
Slope SlopeWithOneCornerRaised(Corner corner)
Returns the slope with a specific corner raised.
bool IsInclinedFoundation(Foundation f)
Tests if the foundation is an inclined foundation.
Corner
Enumeration of tile corners.
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_NS
north and south corner are raised
@ SLOPE_E
the east corner of the tile is raised
@ SLOPE_WSE
west, south and east corner are raised
@ SLOPE_S
the south corner of the tile is raised
@ SLOPE_N
the north corner of the tile is raised
@ SLOPE_SEN
south, east and north corner are raised
@ SLOPE_ENW
east, north and west corner are 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_NWS
north, west and south 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)
@ SLOPE_EW
east and west corner are raised
@ SLOPE_STEEP
indicates the slope is steep
Foundation
Enumeration for Foundations.
@ FOUNDATION_INCLINED_X
The tile has an along X-axis inclined foundation.
@ FOUNDATION_STEEP_BOTH
The tile has a steep slope. The lowest corner is raised by a foundation and the upper halftile is lev...
@ FOUNDATION_INCLINED_Y
The tile has an along Y-axis inclined foundation.
@ FOUNDATION_STEEP_LOWER
The tile has a steep slope. The lowest corner is raised by a foundation to allow building railroad on...
Functions to cache sprites in memory.
This file contains all sprite-related enums and defines.
static const SpriteID SPR_HALFTILE_FOUNDATION_BASE
Halftile foundations.
Functions related to stations.
Definition of base types and functions in a cross-platform compatible way.
#define lengthof(array)
Return the length of an fixed size array.
AyStar search algorithm struct.
AyStarStatus Main()
This is the function you call to run AyStar.
void AddStartNode(AyStarNode *start_node, int g)
Adds a node from where to start an algorithm.
Keeps track of removed objects during execution/testruns of commands.
TileIndex first_tile
The first tile being cleared, which then causes the whole object to be cleared.
uint32_t clear_limit
Amount of tiles we can (still) clear (times 65536).
bool freeform_edges
allow terraforming the tiles at the map edges
uint8_t map_height_limit
the maximum allowed heightlevel
uint8_t terrain_type
the mountainousness of the landscape
uint8_t quantity_sea_lakes
the amount of seas/lakes
DetailedFileType detail_ftype
Concrete file type (PNG, BMP, old save, etc).
std::string name
Name of the file.
uint8_t amount_of_rivers
the amount of rivers
uint8_t min_river_length
the minimum river length
uint8_t snow_coverage
the amount of snow coverage on the map
uint8_t desert_coverage
the amount of desert coverage on the map
LandscapeType landscape
the landscape we're currently in
uint8_t snow_line_height
the configured snow line height (deduced from "snow_coverage")
uint8_t land_generator
the landscape generator
uint8_t river_route_random
the amount of randomicity for the route finding
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)
Size related data of the map.
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 uint SizeY()
Get the size of the map along the Y.
static IterateWrapper Iterate()
Returns an iterable ensemble of all Tiles.
static debug_inline uint SizeX()
Get the size of the map along the X.
static debug_inline uint LogX()
Logarithm of the map size along the X side.
static uint LogY()
Logarithm of the map size along the y side.
static uint MaxY()
Gets the maximum Y coordinate within the map, including MP_VOID.
static debug_inline uint Size()
Get the size of the map.
static debug_inline uint MaxX()
Gets the maximum X coordinate within the map, including MP_VOID.
Coordinates of a point in 2D.
static bool IsValidID(size_t index)
Tests whether given index can be used to get valid (non-nullptr) Titem.
static Titem * GetIfValid(size_t index)
Returns Titem with given index.
static Titem * Get(size_t index)
Returns Titem with given index.
Parameters for river generation to pass as AyStar user data.
TileIndex spring
The current spring during river generation.
bool main_river
Whether the current river is a big river that others flow into.
Data structure describing a sprite.
uint16_t width
Width of the sprite.
uint16_t height
Height of the sprite.
uint8_t data[]
Sprite data.
Tile description for the 'land area information' tool.
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.
GetTileDescProc * get_tile_desc_proc
Get a description of a tile (for the 'land area information' tool)
GetTileTrackStatusProc * get_tile_track_status_proc
Get available tracks and status of a tile.
void GenerateTerrainPerlin()
The main new land generator using Perlin noise.
Functions for the Perlin noise enhanced map generator.
bool MayAnimateTile(TileIndex tile)
Test if a tile may be animated.
bool IsTileFlat(TileIndex tile, int *h)
Check if a given tile is flat.
std::tuple< Slope, int > GetTileSlopeZ(TileIndex tile)
Return the slope of a given tile inside the map.
int GetTileMaxZ(TileIndex t)
Get top height of the tile inside the map.
int GetTileZ(TileIndex tile)
Get bottom height of the tile.
Owner GetTileOwner(Tile tile)
Returns the owner of a 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.
TropicZone GetTropicZone(Tile tile)
Get the tropic zone.
void SetTileHeight(Tile tile, uint height)
Sets the height of a tile.
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.
void SetTropicZone(Tile tile, TropicZone type)
Set the tropic zone.
static debug_inline uint TileHeight(Tile tile)
Returns the height of a tile.
static const uint TILE_PIXELS
Pixel distance between tile columns/rows in ZOOM_BASE.
static const uint TILE_HEIGHT
Height of a height level in world coordinate AND in pixels in ZOOM_BASE.
static const uint TILE_SIZE
Tile size in world coordinates.
static const uint MAX_TILE_HEIGHT
Maximum allowed tile height.
@ TROPICZONE_RAINFOREST
Rainforest tile.
@ TROPICZONE_DESERT
Tile is desert.
@ TROPICZONE_NORMAL
Normal tropiczone.
constexpr TileIndex INVALID_TILE
The very nice invalid tile marker.
@ MP_CLEAR
A tile without any structures, i.e. grass, rocks, farm fields etc.
@ MP_VOID
Invisible tiles at the SW and SE border.
Definition of the game-calendar-timer.
Definition of the tick-based game-timer.
@ INVALID_TRACKDIR
Flag for an invalid trackdir.
TransportType
Available types of transport.
void OffsetGroundSprite(int x, int y)
Called when a foundation has been drawn for the current tile.
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.
Functions related to (drawing on) viewports.
Map accessors for void tiles.
void MakeVoid(Tile t)
Make a nice void tile ;)
Functions related to water (management)
void ClearNeighbourNonFloodingStates(TileIndex tile)
Clear non-flooding state of the tiles around a tile.
void MakeRiverAndModifyDesertZoneAround(TileIndex tile)
Make a river tile and remove desert directly around it.
bool IsTileOnWater(Tile t)
Tests if the tile was built on water.
bool IsRiver(Tile t)
Is it a river water tile?
@ WATER_CLASS_CANAL
Canal.
bool HasTileWaterClass(Tile t)
Checks whether the tile has an waterclass associated.
bool IsCanal(Tile t)
Is it a canal tile?
WaterClass GetWaterClass(Tile t)
Get the water class at a tile.
bool IsCoastTile(Tile t)
Is it a coast tile.
bool IsDockingTile(Tile t)
Checks whether the tile is marked as a dockling tile.
bool IsWaterTile(Tile t)
Is it a water tile with plain water?
void InvalidateWaterRegion(TileIndex tile)
Marks the water region that tile is part of as invalid.
Handles dividing the water in the map into regions to assist pathfinding.