47 #include "table/strings.h"
70 for (
TileIndex t = begin; t != end; t += delta) {
90 if (
_bridge[i].sprite_table !=
nullptr) {
99 memcpy(&
_bridge, &_orig_bridge,
sizeof(_orig_bridge));
110 if (length < 2)
return length;
114 for (
int delta = 1;; delta++) {
115 for (
int count = 0; count < delta; count++) {
116 if (length == 0)
return sum;
155 assert(table < BRIDGE_PIECE_INVALID);
157 return _bridge_sprite_table[index][table];
175 assert(bridge_piece == BRIDGE_PIECE_NORTH || bridge_piece == BRIDGE_PIECE_SOUTH);
180 Slope valid_inclined;
181 if (bridge_piece == BRIDGE_PIECE_NORTH) {
226 Money base_cost = _price[base_price];
231 RoadType road_rt = GetRoadTypeRoad(tile);
232 RoadType tram_rt = GetRoadTypeTram(tile);
271 switch (transport_type) {
273 roadtype = (
RoadType)road_rail_type;
278 railtype = (
RailType)road_rail_type;
302 if (tile_start == tile_end) {
309 }
else if (
TileY(tile_start) ==
TileY(tile_end)) {
315 if (tile_end < tile_start)
Swap(tile_start, tile_end);
321 if (ret.
Failed())
return ret;
329 bool pbs_reservation =
false;
336 if (z_start != z_end)
return_cmd_error(STR_ERROR_BRIDGEHEADS_NOT_SAME_HEIGHT);
348 switch (transport_type) {
356 road_rt = GetRoadTypeRoad(tile_start);
357 tram_rt = GetRoadTypeTram(tile_start);
370 RoadType existing_rt = RoadTypeIsRoad(roadtype) ? road_rt : tram_rt;
378 if ((bridge_type ==
GetBridgeType(tile_start)) && (transport_type !=
TRANSPORT_ROAD || road_rt == roadtype || tram_rt == roadtype)) {
407 if (is_new_owner) owner = company;
415 if (ret.
Failed())
return ret;
418 if (terraform_cost_north.
Failed() || (terraform_cost_north.
GetCost() != 0 && !allow_on_slopes))
return_cmd_error(STR_ERROR_LAND_SLOPED_IN_WRONG_DIRECTION);
419 cost.
AddCost(terraform_cost_north);
423 if (ret.
Failed())
return ret;
427 if (terraform_cost_south.
Failed() || (terraform_cost_south.
GetCost() != 0 && !allow_on_slopes))
return_cmd_error(STR_ERROR_LAND_SLOPED_IN_WRONG_DIRECTION);
428 cost.
AddCost(terraform_cost_south);
430 const TileIndex heads[] = {tile_start, tile_end};
431 for (
int i = 0; i < 2; i++) {
444 for (
TileIndex tile = tile_start + delta; tile != tile_end; tile += delta) {
495 if (ret.
Failed())
return ret;
515 if (RoadTypeIsRoad(roadtype)) road_rt = roadtype;
516 if (RoadTypeIsTram(roadtype)) tram_rt = roadtype;
524 switch (transport_type) {
553 MakeRoadBridgeRamp(tile_start, owner, owner_road, owner_tram, bridge_type, dir, road_rt, tram_rt);
587 switch (transport_type) {
604 cost.
AddCost((int64_t)bridge_len * _price[PR_BUILD_BRIDGE] *
GetBridgeSpec(bridge_type)->price >> 8);
607 cost.
AddCost((int64_t)bridge_len * _price[PR_BUILD_AQUEDUCT]);
631 switch (transport_type) {
633 railtype = (
RailType)road_rail_type;
638 roadtype = (
RoadType)road_rail_type;
664 if (ret.
Failed())
return ret;
696 if (start_z == end_z)
break;
703 if (tiles == tiles_bump) {
708 cost.
AddCost(_price[PR_BUILD_TUNNEL]);
713 cost.
AddCost(_price[PR_BUILD_TUNNEL]);
733 if (coa ==
nullptr) {
751 assert(coa >= begin && coa < begin + _cleared_object_areas.size());
752 size_t coa_index = coa - begin;
753 assert(coa_index < UINT_MAX);
757 _cleared_object_areas[(uint)coa_index].first_tile = old_first_tile;
761 cost.
AddCost(_price[PR_BUILD_TUNNEL]);
764 switch (transport_type) {
767 default: NOT_REACHED();
805 RoadType road_rt = GetRoadTypeRoad(tile);
806 RoadType tram_rt = GetRoadTypeTram(tile);
836 default: NOT_REACHED();
849 if (ret.
Failed())
return ret;
854 if (ret.
Failed())
return ret;
865 if (ret.
Failed())
return ret;
896 DoClearSquare(endtile);
912 DoClearSquare(endtile);
929 if (ret.
Failed())
return ret;
934 if (ret.
Failed())
return ret;
946 if (ret.
Failed())
return ret;
983 DoClearSquare(endtile);
985 for (
TileIndex c = tile + delta; c != endtile; c += delta) {
1041 AddSortableSpriteToDraw(psid->
sprite, psid->
pal, x, y, w, h,
BB_HEIGHT_UNDER_BRIDGE - PILLAR_Z_OFFSET, z,
IsTransparencySet(
TO_BRIDGES), 0, 0, -PILLAR_Z_OFFSET, subsprite);
1058 for (cur_z = z_top; cur_z >= z_bottom; cur_z -=
TILE_HEIGHT) {
1059 DrawPillar(psid, x, y, cur_z, w, h,
nullptr);
1077 static const int bounding_box_size[2] = {16, 2};
1078 static const int back_pillar_offset[2] = { 0, 9};
1080 static const int INF = 1000;
1081 static const SubSprite half_pillar_sub_sprite[2][2] = {
1082 { { -14, -INF, INF, INF }, { -INF, -INF, -15, INF } },
1083 { { -INF, -INF, 15, INF }, { 16, -INF, INF, INF } },
1086 if (psid->
sprite == 0)
return;
1090 int z_front_north = ti->
z;
1091 int z_back_north = ti->
z;
1092 int z_front_south = ti->
z;
1093 int z_back_south = ti->
z;
1098 int z_front = std::max(z_front_north, z_front_south);
1099 int z_back = std::max(z_back_north, z_back_south);
1102 int w = bounding_box_size[axis];
1103 int h = bounding_box_size[
OtherAxis(axis)];
1105 int x_back = x - back_pillar_offset[axis];
1106 int y_back = y - back_pillar_offset[
OtherAxis(axis)];
1110 if (z_front_north < z_front)
DrawPillar(psid, x, y, bottom_z, w, h, &half_pillar_sub_sprite[axis][0]);
1111 if (z_front_south < z_front)
DrawPillar(psid, x, y, bottom_z, w, h, &half_pillar_sub_sprite[axis][1]);
1114 int z_bridge_back = z_bridge - 2 * (int)
TILE_HEIGHT;
1115 if (drawfarpillar && (z_back_north <= z_bridge_back || z_back_south <= z_bridge_back)) {
1116 bottom_z =
DrawPillarColumn(z_back, z_bridge_back, psid, x_back, y_back, w, h);
1117 if (z_back_north < z_back)
DrawPillar(psid, x_back, y_back, bottom_z, w, h, &half_pillar_sub_sprite[axis][0]);
1118 if (z_back_south < z_back)
DrawPillar(psid, x_back, y_back, bottom_z, w, h, &half_pillar_sub_sprite[axis][1]);
1133 static const SpriteID back_offsets[6] = { 95, 96, 99, 102, 100, 101 };
1134 static const SpriteID front_offsets[6] = { 97, 98, 103, 106, 104, 105 };
1139 if (spr_back == 0 && spr_front == 0) {
1143 if (spr_back != 0) spr_back += 23 + offset;
1144 if (spr_front != 0) spr_front += 23 + offset;
1159 RoadType road_rt = GetRoadTypeRoad(head_tile);
1160 RoadType tram_rt = GetRoadTypeTram(head_tile);
1165 bool trans_back[4] = {
false };
1167 bool trans_front[4] = {
false };
1169 static const SpriteID overlay_offsets[6] = { 0, 1, 11, 12, 13, 14 };
1173 if (road_rti !=
nullptr) {
1174 if (road_rti->UsesOverlay()) {
1177 }
else if (tram_rti !=
nullptr) {
1178 if (tram_rti->UsesOverlay()) {
1181 seq_back[0] = SPR_TRAMWAY_BRIDGE + offset;
1187 if (road_rti !=
nullptr) {
1188 if (road_rti->UsesOverlay()) {
1190 if (seq_back[1] != 0) seq_back[1] += overlay_offsets[offset];
1196 if (tram_rti !=
nullptr) {
1197 if (tram_rti->UsesOverlay()) {
1199 if (seq_back[2] != 0) seq_back[2] += overlay_offsets[offset];
1200 }
else if (road_rti !=
nullptr) {
1201 seq_back[2] = SPR_TRAMWAY_OVERLAY + overlay_offsets[offset];
1215 static const uint size_x[6] = { 1, 16, 16, 1, 16, 1 };
1216 static const uint size_y[6] = { 16, 1, 1, 16, 1, 16 };
1217 static const uint front_bb_offset_x[6] = { 15, 0, 0, 15, 0, 15 };
1218 static const uint front_bb_offset_y[6] = { 0, 15, 15, 0, 15, 0 };
1222 for (uint i = 0; i <
lengthof(seq_back); ++i) {
1223 if (seq_back[i] != 0) {
1225 x, y, size_x[offset], size_y[offset], 0x28, z,
1234 for (uint i = 0; i <
lengthof(seq_front); ++i) {
1235 if (seq_front[i] != 0) {
1237 x, y, size_x[offset] + front_bb_offset_x[offset], size_y[offset] + front_bb_offset_y[offset], 0x28, z,
1239 front_bb_offset_x[offset], front_bb_offset_y[offset]);
1272 static const int _tunnel_BB[4][12] = {
1275 { 1, 0, -15, -14, 0, 15, 16, 1, 0, 1, 16, 15 },
1276 { 0, 1, -14, -15, 15, 0, 1, 16, 1, 0, 15, 16 },
1277 { 1, 0, -15, -14, 0, 15, 16, 1, 0, 1, 16, 15 },
1278 { 0, 1, -14, -15, 15, 0, 1, 16, 1, 0, 15, 16 },
1280 const int *BB_data = _tunnel_BB[tunnelbridge_direction];
1282 bool catenary =
false;
1289 if (rti->UsesOverlay()) {
1295 image = SPR_TUNNEL_ENTRY_REAR_ROAD;
1300 image += tunnelbridge_direction * 2;
1309 bool draw_underlay =
true;
1312 if (road_rti !=
nullptr) {
1313 if (road_rti->UsesOverlay()) {
1317 draw_underlay =
false;
1321 if (tram_rti->UsesOverlay()) {
1325 draw_underlay =
false;
1330 DrawRoadOverlays(ti, PAL_NONE, road_rti, tram_rti, sprite_offset, sprite_offset, draw_underlay);
1336 if (catenary_sprite_base == 0) {
1337 catenary_sprite_base = SPR_TRAMWAY_TUNNEL_WIRES;
1339 catenary_sprite_base += 19;
1343 if (catenary_sprite_base == 0) {
1344 catenary_sprite_base = SPR_TRAMWAY_TUNNEL_WIRES;
1346 catenary_sprite_base += 19;
1350 if (catenary_sprite_base != 0) {
1353 AddSortableSpriteToDraw(catenary_sprite_base + tunnelbridge_direction, PAL_NONE, ti->
x, ti->
y, BB_data[10], BB_data[11],
TILE_HEIGHT, ti->
z,
IsTransparencySet(
TO_CATENARY), BB_data[8], BB_data[9],
BB_Z_SEPARATOR);
1357 if (rti->UsesOverlay()) {
1359 if (surface != 0)
DrawGroundSprite(surface + tunnelbridge_direction, PAL_NONE);
1364 if (rti->UsesOverlay()) {
1385 AddSortableSpriteToDraw(image + 1, PAL_NONE, ti->
x +
TILE_SIZE - 1, ti->
y +
TILE_SIZE - 1, BB_data[0], BB_data[1],
TILE_HEIGHT, ti->
z,
false, BB_data[2], BB_data[3],
BB_Z_SEPARATOR);
1387 if (railtype_overlay != 0)
AddSortableSpriteToDraw(railtype_overlay + tunnelbridge_direction, PAL_NONE, ti->
x +
TILE_SIZE - 1, ti->
y +
TILE_SIZE - 1, BB_data[0], BB_data[1],
TILE_HEIGHT, ti->
z,
false, BB_data[2], BB_data[3],
BB_Z_SEPARATOR);
1403 assert(base_offset != 8);
1409 assert( (base_offset & 0x07) == 0x00);
1414 base_offset += (6 - tunnelbridge_direction) % 4;
1419 psid = &GetBridgeSpriteTable(
GetBridgeType(ti->
tile), BRIDGE_PIECE_HEAD)[base_offset];
1421 psid = _aqueduct_sprites + base_offset;
1427 DrawShoreTile(ti->
tileh);
1429 DrawClearLandTile(ti, 3);
1447 uint offset = tunnelbridge_direction;
1450 offset = (offset + 1) & 1;
1462 if (rti->UsesOverlay()) {
1478 if (rti->UsesOverlay()) {
1526 return BRIDGE_PIECE_NORTH;
1527 }
else if (south == 1) {
1528 return BRIDGE_PIECE_SOUTH;
1529 }
else if (north < south) {
1530 return north & 1 ? BRIDGE_PIECE_INNER_SOUTH : BRIDGE_PIECE_INNER_NORTH;
1531 }
else if (north > south) {
1532 return south & 1 ? BRIDGE_PIECE_INNER_NORTH : BRIDGE_PIECE_INNER_SOUTH;
1534 return north & 1 ? BRIDGE_PIECE_MIDDLE_EVEN : BRIDGE_PIECE_MIDDLE_ODD;
1585 psid = base_offset + GetBridgeSpriteTable(type, piece);
1587 drawfarpillar =
true;
1588 psid = _aqueduct_sprites;
1591 if (axis !=
AXIS_X) psid += 4;
1607 AddSortableSpriteToDraw(psid->
sprite, psid->
pal, x, y, 16, 1, 0x28, z,
IsTransparencySet(
TO_BRIDGES), 0, 0,
BRIDGE_Z_START);
1609 AddSortableSpriteToDraw(psid->
sprite, psid->
pal, x, y, 1, 16, 0x28, z,
IsTransparencySet(
TO_BRIDGES), 0, 0,
BRIDGE_Z_START);
1628 if (rti->UsesOverlay()) {
1647 if (psid->
sprite &
SPRITE_MASK)
AddSortableSpriteToDraw(psid->
sprite, psid->
pal, x, y, 16, 4, 0x28, z,
IsTransparencySet(
TO_BRIDGES), 0, 3,
BRIDGE_Z_START);
1650 if (psid->
sprite &
SPRITE_MASK)
AddSortableSpriteToDraw(psid->
sprite, psid->
pal, x, y, 4, 16, 0x28, z,
IsTransparencySet(
TO_BRIDGES), 3, 0,
BRIDGE_Z_START);
1665 static int GetSlopePixelZ_TunnelBridge(
TileIndex tile, uint x, uint y,
bool ground_vehicle)
1674 if (ground_vehicle)
return z;
1680 if (ground_vehicle) {
1684 default: NOT_REACHED();
1706 td->
str = (tt ==
TRANSPORT_RAIL) ? STR_LAI_TUNNEL_DESCRIPTION_RAILROAD : STR_LAI_TUNNEL_DESCRIPTION_ROAD;
1714 RoadType road_rt = GetRoadTypeRoad(tile);
1715 RoadType tram_rt = GetRoadTypeTram(tile);
1734 td->
owner_type[i] = STR_LAND_AREA_INFORMATION_ROAD_OWNER;
1735 td->
owner[i] = road_owner;
1739 td->
owner_type[i] = STR_LAND_AREA_INFORMATION_TRAM_OWNER;
1740 td->
owner[i] = tram_owner;
1752 if (spd == UINT16_MAX) spd = 0;
1753 if (td->
rail_speed == 0 || spd < td->rail_speed) {
1760 if (spd == UINT16_MAX) spd = 0;
1767 static void TileLoop_TunnelBridge(
TileIndex tile)
1805 static void ChangeTileOwner_TunnelBridge(
TileIndex tile,
Owner old_owner,
Owner new_owner)
1812 for (RoadTramType rtt : _roadtramtypes) {
1815 RoadType rt = GetRoadType(tile, rtt);
1819 Company::Get(old_owner)->infrastructure.road[rt] -= num_pieces * 2;
1868 template <
typename T>
1944 assert(frame == rv->frame + 1);
1995 default: NOT_REACHED();
2029 default: NOT_REACHED();
2060 extern const TileTypeProcs _tile_type_tunnelbridge_procs = {
2062 GetSlopePixelZ_TunnelBridge,
2065 GetTileDesc_TunnelBridge,
2066 GetTileTrackStatus_TunnelBridge,
2069 TileLoop_TunnelBridge,
2070 ChangeTileOwner_TunnelBridge,
2072 VehicleEnter_TunnelBridge,
2073 GetFoundation_TunnelBridge,
2074 TerraformTile_TunnelBridge,
Functions related to autoslope.
bool AutoslopeEnabled()
Tests if autoslope is enabled for _current_company.
constexpr debug_inline bool HasBit(const T x, const uint8_t y)
Checks if a bit in a value is set.
constexpr T ClrBit(T &x, const uint8_t y)
Clears a bit in a variable.
BridgePieces
This enum is related to the definition of bridge pieces, which is used to determine the proper sprite...
uint BridgeType
Bridge spec number.
static const uint MAX_BRIDGES
Maximal number of available bridge specs.
const BridgeSpec * GetBridgeSpec(BridgeType i)
Get the specification of a bridge type.
This file contains all the sprites for bridges It consists of a number of arrays.
TileIndex GetSouthernBridgeEnd(TileIndex t)
Finds the southern end of a bridge starting at a middle tile.
TileIndex GetOtherBridgeEnd(TileIndex tile)
Starting at one bridge end finds the other bridge end.
TileIndex GetNorthernBridgeEnd(TileIndex t)
Finds the northern end of a bridge starting at a middle tile.
int GetBridgeHeight(TileIndex t)
Get the height ('z') of a bridge.
void SetBridgeMiddle(Tile t, Axis a)
Set that there is a bridge over the given axis.
void MakeAqueductBridgeRamp(Tile t, Owner o, DiagDirection d)
Make a bridge ramp for aqueducts.
bool IsBridgeTile(Tile t)
checks if there is a bridge on this tile
void MakeRailBridgeRamp(Tile t, Owner o, BridgeType bridgetype, DiagDirection d, RailType rt)
Make a bridge ramp for rails.
int GetBridgePixelHeight(TileIndex tile)
Get the height ('z') of a bridge in pixels.
void ClearBridgeMiddle(Tile t)
Removes bridges from the given, that is bridges along the X and Y axis.
void MakeRoadBridgeRamp(Tile t, Owner o, Owner owner_road, Owner owner_tram, BridgeType bridgetype, DiagDirection d, RoadType road_rt, RoadType tram_rt)
Make a bridge ramp for roads.
BridgeType GetBridgeType(Tile t)
Determines the type of bridge on a 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.
bool IsBridge(Tile t)
Checks if this is a bridge, instead of a tunnel.
Cheats _cheats
All the cheats.
Types related to cheating.
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?
This struct contains all the info that is needed to draw and construct tracks.
SpriteID single_x
single piece of rail in X direction, without ground
SpriteID bridge_offset
Bridge offset.
uint16_t max_speed
Maximum speed for vehicles travelling on this rail type.
struct RailTypeInfo::@23 base_sprites
Struct containing the main sprites.
struct RailTypeInfo::@26 strings
Strings associated with the rail type.
SpriteID single_y
single piece of rail in Y direction, without ground
StringID name
Name of this rail type.
SpriteID tunnel
tunnel sprites base
SpriteID single_sloped
single piece of rail for slopes
struct RoadTypeInfo::@29 strings
Strings associated with the rail type.
uint16_t max_speed
Maximum speed for vehicles travelling on this road type.
StringID name
Name of this rail type.
static Year year
Current year, starting at 0.
Functions related to clear (MP_CLEAR) land.
Functions related to commands.
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_AUTO
don't allow building on structures
@ DC_BANKRUPT
company bankrupts, skip money check, skip vehicle on tile check in some cases
@ DC_QUERY_COST
query cost only, don't build.
@ DC_EXEC
execute the given command
Definition of stuff that is very close to a company, like the company struct itself.
CommandCost CheckTileOwnership(TileIndex tile)
Check whether the current owner owns the stuff on the given tile.
CommandCost CheckOwnership(Owner owner, TileIndex tile)
Check whether the current owner owns something.
CompanyID _local_company
Company controlled by the human player at this client. Can also be COMPANY_SPECTATOR.
CompanyID _current_company
Company currently doing an action.
void DirtyCompanyInfrastructureWindows(CompanyID company)
Redraw all windows with company infrastructure counts.
GUI Functions related to companies.
Owner
Enum for all companies/owners.
@ INVALID_OWNER
An invalid owner.
@ OWNER_DEITY
The object is owned by a superuser / goal script.
@ OWNER_NONE
The tile has no ownership.
@ OWNER_WATER
The tile/execution is done by "water".
@ OWNER_TOWN
A town owns the tile, or a town is expanding.
DiagDirection ReverseDiagDir(DiagDirection d)
Returns the reverse direction of the given DiagDirection.
DiagDirection AxisToDiagDir(Axis a)
Converts an Axis to a DiagDirection.
Axis OtherAxis(Axis a)
Select the other axis as provided.
Axis DiagDirToAxis(DiagDirection d)
Convert a DiagDirection to the axis.
DiagDirection DirToDiagDir(Direction dir)
Convert a Direction to a DiagDirection.
Axis
Allow incrementing of DiagDirDiff variables.
DiagDirection
Enumeration for diagonal directions.
@ DIAGDIR_NE
Northeast, upper right on your monitor.
@ DIAGDIR_END
Used for iterations.
@ INVALID_DIAGDIR
Flag for an invalid DiagDirection.
@ EXPENSES_CONSTRUCTION
Construction costs.
static const uint TUNNELBRIDGE_TRACKBIT_FACTOR
Multiplier for how many regular track bits a tunnel/bridge counts.
Price
Enumeration of all base prices for use with Prices.
void DrawRailCatenaryOnBridge(const TileInfo *ti)
Draws wires on a tunnel tile.
void DrawRailCatenaryOnTunnel(const TileInfo *ti)
Draws wires on a tunnel tile.
void DrawRailCatenary(const TileInfo *ti)
Draws overhead wires and pylons for electric railways.
header file for electrified rail specific functions
bool HasRailCatenaryDrawn(RailType rt)
Test if we should draw rail catenary.
uint32_t SpriteID
The number of a sprite, without mapping bits and colourtables.
@ GVF_GOINGDOWN_BIT
Vehicle is currently going downhill. (Cached track information for acceleration)
@ GVF_GOINGUP_BIT
Vehicle is currently going uphill. (Cached track information for acceleration)
uint8_t GetSnowLine()
Get the current snow line, either variable or static.
void MarkTileDirtyByTile(TileIndex tile, int bridge_level_offset, int tile_height_override)
Mark a tile given by its index dirty for repaint.
uint GetPartialPixelZ(int x, int y, Slope corners)
Determines height at given coordinate of a slope.
void DrawFoundation(TileInfo *ti, Foundation f)
Draw foundation f at tile ti.
void GetSlopePixelZOnEdge(Slope tileh, DiagDirection edge, int &z1, int &z2)
Determine the Z height of the corners of a specific tile edge.
uint ApplyFoundationToSlope(Foundation f, Slope &s)
Applies a foundation to a slope.
int GetSlopePixelZ(int x, int y, bool ground_vehicle)
Return world Z coordinate of a given point of a tile.
uint ApplyPixelFoundationToSlope(Foundation f, Slope &s)
Applies a foundation to a slope.
Command definitions related to landscape (slopes etc.).
uint DistanceSquare(TileIndex t0, TileIndex t1)
Gets the 'Square' distance between the two given tiles.
TileIndexDiff TileOffsByAxis(Axis axis)
Convert an Axis to a TileIndexDiff.
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.
int32_t TileIndexDiff
An offset value between two tiles.
constexpr T abs(const T a)
Returns the absolute value of (scalar) variable.
constexpr void Swap(T &a, T &b)
Type safe swap operation.
@ TCX_ON_BRIDGE
Querying information about stuff on the bridge (via some bridgehead).
@ TCX_NORMAL
Nothing special.
Functions related to NewGRF objects.
@ OBJECT_FLAG_ALLOW_UNDER_BRIDGE
Object can built under a bridge.
SpriteID GetCustomRailSprite(const RailTypeInfo *rti, TileIndex tile, RailTypeSpriteGroup rtsg, TileContext context, uint *num_results)
Get the sprite to draw for the given tile.
NewGRF handling of rail types.
SpriteID GetCustomRoadSprite(const RoadTypeInfo *rti, TileIndex tile, RoadTypeSpriteGroup rtsg, TileContext context, uint *num_results)
Get the sprite to draw for the given tile.
NewGRF handling of road types.
bool PlayVehicleSound(const Vehicle *v, VehicleSoundEvent event, bool force)
Checks whether a NewGRF wants to play a different vehicle sound effect.
Functions related to NewGRF provided sounds.
@ VSE_TUNNEL
Train entering a tunnel.
ClearedObjectArea * FindClearedObject(TileIndex tile)
Find the entry in _cleared_object_areas which occupies a certain tile.
Train * GetTrainForReservation(TileIndex tile, Track track)
Find the train which has reserved a specific path.
bool ValParamRailType(const RailType rail)
Validate functions for rail building.
@ RTSG_TUNNEL
Main group of ground images for snow or desert.
@ RTSG_OVERLAY
Images for overlaying track.
@ RTSG_BRIDGE
Bridge surface images.
@ RTSG_TUNNEL_PORTAL
Tunnel portal overlay.
@ RTBO_Y
Piece of rail in Y direction.
@ RTBO_X
Piece of rail in X direction.
@ RTBO_SLOPE
Sloped rail pieces, in order NE, SE, SW, NW.
Money RailClearCost(RailType railtype)
Returns the 'cost' of clearing the specified railtype.
Money RailBuildCost(RailType railtype)
Returns the cost of building the specified railtype.
const RailTypeInfo * GetRailTypeInfo(RailType railtype)
Returns a pointer to the Railtype information for a given railtype.
@ RTO_SLOPE_NE
Piece of rail on slope with north-east raised.
@ RTO_X
Piece of rail in X direction.
RailType GetRailType(Tile t)
Gets the rail type of the given tile.
static debug_inline bool IsPlainRail(Tile t)
Returns whether this is plain rails, with or without signals.
RailType
Enumeration for all possible railtypes.
@ INVALID_RAILTYPE
Flag for invalid railtype.
bool ValParamRoadType(RoadType roadtype)
Validate functions for rail building.
const RoadTypeInfo * GetRoadTypeInfo(RoadType roadtype)
Returns a pointer to the Roadtype information for a given roadtype.
Money RoadClearCost(RoadType roadtype)
Returns the cost of clearing the specified roadtype.
@ ROTSG_OVERLAY
Optional: Images for overlaying track.
@ ROTSG_CATENARY_BACK
Optional: Catenary back.
@ ROTSG_BRIDGE
Required: Bridge surface images.
@ ROTSG_CATENARY_FRONT
Optional: Catenary front.
@ ROTSG_TUNNEL
Optional: Ground images for tunnels.
Money RoadBuildCost(RoadType roadtype)
Returns the cost of building the specified roadtype.
void UpdateCompanyRoadInfrastructure(RoadType rt, Owner o, int count)
Update road infrastructure counts for a company.
void DrawRoadOverlays(const TileInfo *ti, PaletteID pal, const RoadTypeInfo *road_rti, const RoadTypeInfo *tram_rti, uint road_offset, uint tram_offset, bool draw_underlay)
Draw road underlay and overlay sprites.
bool HasRoadCatenaryDrawn(RoadType roadtype)
Test if we should draw road catenary.
void SetRoadOwner(Tile t, RoadTramType rtt, Owner o)
Set the owner of a specific road type.
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.
bool HasTileRoadType(Tile t, RoadTramType rtt)
Check if a tile has a road or a tram road type.
Roadside GetRoadside(Tile tile)
Get the decorations of a road.
Owner GetRoadOwner(Tile t, RoadTramType rtt)
Get the owner of a specific road type.
void SetRoadside(Tile tile, Roadside s)
Set the decorations of a road.
@ ROADSIDE_PAVED
Road with paved sidewalks.
@ ROADSIDE_TREES
Road with trees on paved sidewalks.
RoadType
The different roadtypes we support.
@ INVALID_ROADTYPE
flag for invalid roadtype
@ RVSB_WORMHOLE
The vehicle is in a tunnel and/or bridge.
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.
void AddSideToSignalBuffer(TileIndex tile, DiagDirection side, Owner owner)
Add side of tile to signal update buffer.
uint SlopeToSpriteOffset(Slope s)
Returns the Sprite offset for a given Slope.
bool HasSlopeHighestCorner(Slope s)
Tests if a slope has a highest corner (i.e.
Foundation FlatteningFoundation(Slope s)
Returns the foundation needed to flatten a slope.
DiagDirection GetInclinedSlopeDirection(Slope s)
Returns the direction of an inclined slope.
Foundation InclinedFoundation(Axis axis)
Returns the along a specific axis inclined foundation.
Slope ComplementSlope(Slope s)
Return the complement of a slope.
Slope
Enumeration for the slope-type.
@ SLOPE_SW
south and west corner are raised
@ SLOPE_NE
north and east corner are raised
@ SLOPE_SE
south and east corner are raised
@ SLOPE_NW
north and west corner are raised
Foundation
Enumeration for Foundations.
@ FOUNDATION_NONE
The tile has no foundation, the slope remains unchanged.
Functions related to sound.
@ SND_05_TRAIN_THROUGH_TUNNEL
3 == 0x03 Train enters tunnel: steam engine
static constexpr uint32_t SPRITE_MASK
The mask to for the main sprite.
static const PaletteID PALETTE_CRASH
Recolour sprite greying of crashed vehicles.
static const SpriteID SPR_RAILTYPE_TUNNEL_BASE
Tunnel sprites with grass only for custom railtype tunnel.
static const SpriteID SPR_TRAMWAY_BASE
Tramway sprites.
Functions related to stations.
Definition of base types and functions in a cross-platform compatible way.
void free(const void *ptr)
Version of the standard free that accepts const pointers.
#define lengthof(array)
Return the length of an fixed size array.
void SetDParam(size_t n, uint64_t v)
Set a string parameter v at index n in the global string parameter array.
Functions related to OTTD's strings.
VehicleType type
Type of vehicle.
Struct containing information about a single bridge type.
uint8_t min_length
the minimum length (not counting start and end tile)
TimerGameCalendar::Year avail_year
the year where it becomes available
PalSpriteID ** sprite_table
table of sprites for drawing the bridge
uint16_t speed
maximum travel speed (1 unit = 1/1.6 mph = 1 km-ish/h)
uint16_t max_length
the maximum length (not counting start and end tile)
bool value
tells if the bool cheat is active or not
Cheat crossing_tunnels
allow tunnels that cross each other
Cheat magic_bulldozer
dynamite industries, objects
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.
GUISettings gui
settings related to the GUI
std::array< uint32_t, ROADTYPE_END > road
Count of company owned track bits for each road type.
std::array< uint32_t, RAILTYPE_END > rail
Count of company owned track bits for each rail type.
uint32_t water
Count of company owned track bits for canals.
bool is_ai
If true, the company is (also) controlled by the computer (a NoAI program).
CompanyInfrastructure infrastructure
NOSAVE: Counts of company owned infrastructure.
uint8_t max_bridge_height
maximum height of bridges
bool build_on_slopes
allow building on slopes
bool extra_dynamite
extra dynamite
uint16_t max_bridge_length
maximum length of bridges
uint16_t max_tunnel_length
maximum length of tunnels
bool show_track_reservation
highlight reserved tracks.
uint8_t landscape
the landscape we're currently in
ConstructionSettings construction
construction of things in-game
GameCreationSettings game_creation
settings used during the creation of a game (map)
static debug_inline uint MaxX()
Gets the maximum X coordinate within the map, including MP_VOID.
Allow incrementing of ObjectClassID variables.
static const ObjectSpec * GetByTile(TileIndex tile)
Get the specification associated with a tile.
ObjectFlags flags
Flags/settings related to the object.
uint8_t height
The height of this structure, in heightlevels; max MAX_TILE_HEIGHT.
Combination of a palette sprite and a 'real' sprite.
SpriteID sprite
The 'real' sprite.
PaletteID pal
The palette (use PAL_NONE) if not needed)
Tindex index
Index of this pool item.
static Titem * Get(size_t index)
Returns Titem with given index.
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.
EngineClass engclass
Class of engine for this vehicle.
Buses, trucks and trams belong to this class.
All ships have this type.
TrackBits state
The "track" the ship is following.
static T * From(Vehicle *v)
Converts a Vehicle to SpecializedVehicle with type checking.
Used to only draw a part of the sprite.
Tile description for the 'land area information' tool.
uint16_t rail_speed
Speed limit of rail (bridges and track)
StringID str
Description of the tile.
uint16_t tram_speed
Speed limit of tram (bridges and track)
StringID roadtype
Type of road on the tile.
StringID tramtype
Type of tram on the tile.
StringID railtype
Type of rail on the tile.
uint16_t road_speed
Speed limit of road (bridges and track)
Owner owner[4]
Name of the owner(s)
StringID owner_type[4]
Type of each owner.
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.
std::array< uint32_t, HZB_END > squared_town_zone_radius
UpdateTownRadius updates this given the house count.
TileIndex xy
town center tile
TownCache cache
Container for all cacheable data.
'Train' is either a loco or a wagon.
EngineID engine_type
The type of engine used for this vehicle.
int32_t z_pos
z coordinate.
Direction direction
facing
Vehicle * First() const
Get the first vehicle of this vehicle chain.
debug_inline bool IsFrontEngine() const
Check if the vehicle is a front engine.
uint16_t cur_speed
current speed
TileIndex tile
Current tile index.
VehicleEnterTileStatus
The returned bits of VehicleEnterTile.
@ VETSB_ENTERED_WORMHOLE
The vehicle either entered a bridge, tunnel or depot tile (this includes the last tile of the bridge/...
@ VETSB_CANNOT_ENTER
The vehicle cannot enter the tile.
@ VETSB_CONTINUE
Bit sets of the above specified bits.
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.
bool IsTileOwner(Tile tile, Owner owner)
Checks if a tile belongs to the given owner.
Owner GetTileOwner(Tile tile)
Returns the owner of a tile.
void SetTileOwner(Tile tile, Owner owner)
Sets 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.
std::tuple< Slope, int > GetTilePixelSlope(TileIndex tile)
Return the slope of a given tile.
static debug_inline uint TileHeight(Tile tile)
Returns the height of a tile.
@ TROPICZONE_DESERT
Tile is desert.
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 TILE_UNIT_MASK
For masking in/out the inner-tile world coordinate units.
constexpr TileIndex INVALID_TILE
The very nice invalid tile marker.
@ MP_ROAD
A tile with road (or tram tracks)
@ MP_TUNNELBRIDGE
Tunnel entry/exit and bridge heads.
@ MP_CLEAR
A tile without any structures, i.e. grass, rocks, farm fields etc.
@ MP_OBJECT
Contains objects such as transmitters and owned land.
OrthogonalTileArea TileArea
Shorthand for the much more common orthogonal tile area.
Definition of the game-calendar-timer.
@ TUNNELBRIDGE_REMOVE
Removal of a tunnel or bridge owned by the towb.
Town * CalcClosestTownFromTile(TileIndex tile, uint threshold=UINT_MAX)
Return the town closest to the given tile within threshold.
void ChangeTownRating(Town *t, int add, int max, DoCommandFlag flags)
Changes town rating of the current company.
CommandCost CheckforTownRating(DoCommandFlag flags, Town *t, TownRatingCheckType type)
Does the town authority allow the (destructive) action of the current company?
Town * ClosestTownFromTile(TileIndex tile, uint threshold)
Return the town closest (in distance or ownership) to a given tile, within a given threshold.
static constexpr int RATING_TUNNEL_BRIDGE_UP_STEP
rating increase for improving a town-owned bridge
static constexpr int RATING_TUNNEL_BRIDGE_MINIMUM
minimum rating after removing tunnel or bridge
static constexpr int RATING_TUNNEL_BRIDGE_DOWN_STEP
penalty for removing town owned tunnel or bridge
TrackdirBits TrackBitsToTrackdirBits(TrackBits bits)
Converts TrackBits to TrackdirBits while allowing both directions.
TrackStatus CombineTrackStatus(TrackdirBits trackdirbits, TrackdirBits red_signals)
Builds a TrackStatus.
TrackBits DiagDirToDiagTrackBits(DiagDirection diagdir)
Maps a (4-way) direction to the diagonal track bits incidating with that diagdir.
Trackdir DiagDirToDiagTrackdir(DiagDirection diagdir)
Maps a (4-way) direction to the diagonal trackdir that runs in that direction.
Track AxisToTrack(Axis a)
Convert an Axis to the corresponding Track AXIS_X -> TRACK_X AXIS_Y -> TRACK_Y Uses the fact that the...
Track DiagDirToDiagTrack(DiagDirection diagdir)
Maps a (4-way) direction to the diagonal track incidating with that diagdir.
@ TRACK_BIT_WORMHOLE
Bitflag for a wormhole (used for tunnels)
@ TRACKDIR_BIT_NONE
No track build.
Track
These are used to specify a single track.
Base for the train class.
bool TryPathReserve(Train *v, bool mark_as_stuck=false, bool first_tile_okay=false)
Try to reserve a path to a safe position.
void FreeTrainTrackReservation(const Train *v)
Free the reserved path in front of a vehicle.
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_RAIL
Transport by train.
@ TRANSPORT_ROAD
Transport by road vehicle.
@ TRANSPORT_WATER
Transport over water.
bool IsTunnelInWayDir(TileIndex tile, int z, DiagDirection dir)
Is there a tunnel in the way in the given direction?
TileIndex GetOtherTunnelEnd(TileIndex tile)
Gets the other end of the tunnel.
void MakeRailTunnel(Tile t, Owner o, DiagDirection d, RailType r)
Makes a rail tunnel entrance.
bool IsTunnel(Tile t)
Is this a tunnel (entrance)?
void MakeRoadTunnel(Tile t, Owner o, DiagDirection d, RoadType road_rt, RoadType tram_rt)
Makes a road tunnel entrance.
Header file for things common for tunnels and bridges.
uint GetTunnelBridgeLength(TileIndex begin, TileIndex end)
Calculates the length of a tunnel or a bridge (without end tiles)
CommandCost CmdBuildTunnel(DoCommandFlag flags, TileIndex start_tile, TransportType transport_type, uint8_t road_rail_type)
Build Tunnel.
static BridgePieces CalcBridgePiece(uint north, uint south)
Compute bridge piece.
static CommandCost CheckAllowRemoveTunnelBridge(TileIndex tile)
Are we allowed to remove the tunnel or bridge at tile?
static CommandCost DoClearBridge(TileIndex tile, DoCommandFlag flags)
Remove a bridge from the game, update town rating, etc.
static Money TunnelBridgeClearCost(TileIndex tile, Price base_price)
Calculate the base cost of clearing a tunnel/bridge per tile.
void DrawBridgeMiddle(const TileInfo *ti)
Draw the middle bits of a bridge.
Foundation GetBridgeFoundation(Slope tileh, Axis axis)
Get the foundation for a bridge.
static void DrawBridgeRoadBits(TileIndex head_tile, int x, int y, int z, int offset, bool head)
Draws the road and trambits over an already drawn (lower end) of a bridge.
const uint8_t _tunnel_visibility_frame[DIAGDIR_END]
Frame when a vehicle should be hidden in a tunnel with a certain direction.
static int DrawPillarColumn(int z_bottom, int z_top, const PalSpriteID *psid, int x, int y, int w, int h)
Draw two bridge pillars (north and south).
void MarkBridgeDirty(TileIndex begin, TileIndex end, DiagDirection direction, uint bridge_height)
Mark bridge tiles dirty.
CommandCost CheckBridgeAvailability(BridgeType bridge_type, uint bridge_len, DoCommandFlag flags)
Is a bridge of the specified type and length available?
bool HasBridgeFlatRamp(Slope tileh, Axis axis)
Determines if the track on a bridge ramp is flat or goes up/down.
CommandCost CmdBuildBridge(DoCommandFlag flags, TileIndex tile_end, TileIndex tile_start, TransportType transport_type, BridgeType bridge_type, uint8_t road_rail_type)
Build a Bridge.
static void DrawTile_TunnelBridge(TileInfo *ti)
Draws a tunnel of bridge tile.
static CommandCost ClearTile_TunnelBridge(TileIndex tile, DoCommandFlag flags)
Remove a tunnel or a bridge from the game.
static const int BRIDGE_Z_START
Z position of the bridge sprites relative to bridge height (downwards)
static CommandCost DoClearTunnel(TileIndex tile, DoCommandFlag flags)
Remove a tunnel from the game, update town rating, etc.
TileIndex _build_tunnel_endtile
The end of a tunnel; as hidden return from the tunnel build command for GUI purposes.
BridgeSpec _bridge[MAX_BRIDGES]
The specification of all bridges.
static void GetBridgeRoadCatenary(const RoadTypeInfo *rti, TileIndex head_tile, int offset, bool head, SpriteID &spr_back, SpriteID &spr_front)
Retrieve the sprites required for catenary on a road/tram bridge.
int CalcBridgeLenCostFactor(int length)
Calculate the price factor for building a long bridge.
static void PrepareToEnterBridge(T *gv)
Helper to prepare the ground vehicle when entering a bridge.
static void DrawPillar(const PalSpriteID *psid, int x, int y, int z, int w, int h, const SubSprite *subsprite)
Draw a single pillar sprite.
void ResetBridges()
Reset the data been eventually changed by the grf loaded.
static void DrawBridgePillars(const PalSpriteID *psid, const TileInfo *ti, Axis axis, bool drawfarpillar, int x, int y, int z_bridge)
Draws the pillars under high bridges.
static CommandCost CheckBridgeSlope(BridgePieces bridge_piece, Axis axis, Slope &tileh, int &z)
Determines the foundation for the bridge head, and tests if the resulting slope is valid.
static const uint8_t TUNNEL_SOUND_FRAME
Frame when the 'enter tunnel' sound should be played.
Command definitions related to tunnels and bridges.
Functions that have tunnels and bridges in common.
void SetTunnelBridgeSnowOrDesert(Tile t, bool snow_or_desert)
Tunnel: Places this tunnel entrance in a snowy or desert area, or takes it out of there.
DiagDirection GetTunnelBridgeDirection(Tile t)
Get the direction pointing to the other end.
bool HasTunnelBridgeSnowOrDesert(Tile t)
Tunnel: Is this tunnel entrance in a snowy or desert area? Bridge: Does the bridge ramp lie in a snow...
bool HasTunnelBridgeReservation(Tile t)
Get the reservation state of the rail tunnel/bridge.
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 SetTunnelBridgeReservation(Tile t, bool b)
Set the reservation state of the rail tunnel/bridge.
CommandCost TunnelBridgeIsFree(TileIndex tile, TileIndex endtile, const Vehicle *ignore)
Finds vehicle in tunnel / bridge.
@ VS_HIDDEN
Vehicle is not visible.
Functions related to vehicles.
@ VEH_ROAD
Road vehicle type.
@ VEH_SHIP
Ship vehicle type.
@ VEH_TRAIN
Train vehicle type.
void StartSpriteCombine()
Starts a block of sprites, which are "combined" into a single bounding box.
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 EndSpriteCombine()
Terminates a block of sprites started by StartSpriteCombine.
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.
static const uint BB_HEIGHT_UNDER_BRIDGE
Some values for constructing bounding boxes (BB).
static const uint BB_Z_SEPARATOR
Separates the bridge/tunnel from the things under/above it.
Functions related to water (management)
void CheckForDockingTile(TileIndex t)
Mark the supplied tile as a docking tile if it is suitable for docking.
bool HasTileWaterGround(Tile t)
Checks whether the tile has water at the ground.
bool HasTileWaterClass(Tile t)
Checks whether the tile has an waterclass associated.
bool IsCoast(Tile t)
Is it a coast tile?
WaterClass GetWaterClass(Tile t)
Get the water class at a tile.
bool IsWater(Tile t)
Is it a plain water tile?
Handles dividing the water in the map into regions to assist pathfinding.
Entry point for OpenTTD to YAPF's cache.
void YapfNotifyTrackLayoutChange(TileIndex tile, Track track)
Use this function to notify YAPF that track layout (or signal configuration) has change.