OpenTTD Source
20240915-master-g3784a3d3d6
|
Go to the documentation of this file.
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;
379 _game_mode != GM_EDITOR) {
406 if (is_new_owner) owner = company;
414 if (ret.
Failed())
return ret;
417 if (terraform_cost_north.
Failed() || (terraform_cost_north.
GetCost() != 0 && !allow_on_slopes))
return_cmd_error(STR_ERROR_LAND_SLOPED_IN_WRONG_DIRECTION);
418 cost.
AddCost(terraform_cost_north);
422 if (ret.
Failed())
return ret;
426 if (terraform_cost_south.
Failed() || (terraform_cost_south.
GetCost() != 0 && !allow_on_slopes))
return_cmd_error(STR_ERROR_LAND_SLOPED_IN_WRONG_DIRECTION);
427 cost.
AddCost(terraform_cost_south);
429 const TileIndex heads[] = {tile_start, tile_end};
430 for (
int i = 0; i < 2; i++) {
443 for (
TileIndex tile = tile_start + delta; tile != tile_end; tile += delta) {
494 if (ret.
Failed())
return ret;
514 if (RoadTypeIsRoad(roadtype)) road_rt = roadtype;
515 if (RoadTypeIsTram(roadtype)) tram_rt = roadtype;
523 switch (transport_type) {
552 MakeRoadBridgeRamp(tile_start, owner, owner_road, owner_tram, bridge_type, dir, road_rt, tram_rt);
586 switch (transport_type) {
603 cost.
AddCost((int64_t)bridge_len * _price[PR_BUILD_BRIDGE] *
GetBridgeSpec(bridge_type)->price >> 8);
606 cost.
AddCost((int64_t)bridge_len * _price[PR_BUILD_AQUEDUCT]);
630 switch (transport_type) {
632 railtype = (
RailType)road_rail_type;
637 roadtype = (
RoadType)road_rail_type;
663 if (ret.
Failed())
return ret;
695 if (start_z == end_z)
break;
702 if (tiles == tiles_bump) {
707 cost.
AddCost(_price[PR_BUILD_TUNNEL]);
712 cost.
AddCost(_price[PR_BUILD_TUNNEL]);
732 if (coa ==
nullptr) {
750 assert(coa >= begin && coa < begin + _cleared_object_areas.size());
751 size_t coa_index = coa - begin;
752 assert(coa_index < UINT_MAX);
756 _cleared_object_areas[(uint)coa_index].first_tile = old_first_tile;
760 cost.
AddCost(_price[PR_BUILD_TUNNEL]);
763 switch (transport_type) {
766 default: NOT_REACHED();
804 RoadType road_rt = GetRoadTypeRoad(tile);
805 RoadType tram_rt = GetRoadTypeTram(tile);
835 default: NOT_REACHED();
848 if (ret.
Failed())
return ret;
853 if (ret.
Failed())
return ret;
864 if (ret.
Failed())
return ret;
895 DoClearSquare(endtile);
911 DoClearSquare(endtile);
928 if (ret.
Failed())
return ret;
933 if (ret.
Failed())
return ret;
945 if (ret.
Failed())
return ret;
982 DoClearSquare(endtile);
984 for (
TileIndex c = tile + delta; c != endtile; c += delta) {
1040 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);
1057 for (cur_z = z_top; cur_z >= z_bottom; cur_z -=
TILE_HEIGHT) {
1058 DrawPillar(psid, x, y, cur_z, w, h,
nullptr);
1076 static const int bounding_box_size[2] = {16, 2};
1077 static const int back_pillar_offset[2] = { 0, 9};
1079 static const int INF = 1000;
1080 static const SubSprite half_pillar_sub_sprite[2][2] = {
1081 { { -14, -INF, INF, INF }, { -INF, -INF, -15, INF } },
1082 { { -INF, -INF, 15, INF }, { 16, -INF, INF, INF } },
1085 if (psid->
sprite == 0)
return;
1089 int z_front_north = ti->
z;
1090 int z_back_north = ti->
z;
1091 int z_front_south = ti->
z;
1092 int z_back_south = ti->
z;
1097 int z_front = std::max(z_front_north, z_front_south);
1098 int z_back = std::max(z_back_north, z_back_south);
1101 int w = bounding_box_size[axis];
1102 int h = bounding_box_size[
OtherAxis(axis)];
1104 int x_back = x - back_pillar_offset[axis];
1105 int y_back = y - back_pillar_offset[
OtherAxis(axis)];
1109 if (z_front_north < z_front)
DrawPillar(psid, x, y, bottom_z, w, h, &half_pillar_sub_sprite[axis][0]);
1110 if (z_front_south < z_front)
DrawPillar(psid, x, y, bottom_z, w, h, &half_pillar_sub_sprite[axis][1]);
1113 int z_bridge_back = z_bridge - 2 * (int)
TILE_HEIGHT;
1114 if (drawfarpillar && (z_back_north <= z_bridge_back || z_back_south <= z_bridge_back)) {
1115 bottom_z =
DrawPillarColumn(z_back, z_bridge_back, psid, x_back, y_back, w, h);
1116 if (z_back_north < z_back)
DrawPillar(psid, x_back, y_back, bottom_z, w, h, &half_pillar_sub_sprite[axis][0]);
1117 if (z_back_south < z_back)
DrawPillar(psid, x_back, y_back, bottom_z, w, h, &half_pillar_sub_sprite[axis][1]);
1132 static const SpriteID back_offsets[6] = { 95, 96, 99, 102, 100, 101 };
1133 static const SpriteID front_offsets[6] = { 97, 98, 103, 106, 104, 105 };
1138 if (spr_back == 0 && spr_front == 0) {
1142 if (spr_back != 0) spr_back += 23 + offset;
1143 if (spr_front != 0) spr_front += 23 + offset;
1158 RoadType road_rt = GetRoadTypeRoad(head_tile);
1159 RoadType tram_rt = GetRoadTypeTram(head_tile);
1164 bool trans_back[4] = {
false };
1166 bool trans_front[4] = {
false };
1168 static const SpriteID overlay_offsets[6] = { 0, 1, 11, 12, 13, 14 };
1172 if (road_rti !=
nullptr) {
1173 if (road_rti->UsesOverlay()) {
1176 }
else if (tram_rti !=
nullptr) {
1177 if (tram_rti->UsesOverlay()) {
1180 seq_back[0] = SPR_TRAMWAY_BRIDGE + offset;
1186 if (road_rti !=
nullptr) {
1187 if (road_rti->UsesOverlay()) {
1189 if (seq_back[1] != 0) seq_back[1] += overlay_offsets[offset];
1195 if (tram_rti !=
nullptr) {
1196 if (tram_rti->UsesOverlay()) {
1198 if (seq_back[2] != 0) seq_back[2] += overlay_offsets[offset];
1199 }
else if (road_rti !=
nullptr) {
1200 seq_back[2] = SPR_TRAMWAY_OVERLAY + overlay_offsets[offset];
1214 static const uint size_x[6] = { 1, 16, 16, 1, 16, 1 };
1215 static const uint size_y[6] = { 16, 1, 1, 16, 1, 16 };
1216 static const uint front_bb_offset_x[6] = { 15, 0, 0, 15, 0, 15 };
1217 static const uint front_bb_offset_y[6] = { 0, 15, 15, 0, 15, 0 };
1221 for (uint i = 0; i <
lengthof(seq_back); ++i) {
1222 if (seq_back[i] != 0) {
1224 x, y, size_x[offset], size_y[offset], 0x28, z,
1233 for (uint i = 0; i <
lengthof(seq_front); ++i) {
1234 if (seq_front[i] != 0) {
1236 x, y, size_x[offset] + front_bb_offset_x[offset], size_y[offset] + front_bb_offset_y[offset], 0x28, z,
1238 front_bb_offset_x[offset], front_bb_offset_y[offset]);
1271 static const int _tunnel_BB[4][12] = {
1274 { 1, 0, -15, -14, 0, 15, 16, 1, 0, 1, 16, 15 },
1275 { 0, 1, -14, -15, 15, 0, 1, 16, 1, 0, 15, 16 },
1276 { 1, 0, -15, -14, 0, 15, 16, 1, 0, 1, 16, 15 },
1277 { 0, 1, -14, -15, 15, 0, 1, 16, 1, 0, 15, 16 },
1279 const int *BB_data = _tunnel_BB[tunnelbridge_direction];
1281 bool catenary =
false;
1288 if (rti->UsesOverlay()) {
1294 image = SPR_TUNNEL_ENTRY_REAR_ROAD;
1299 image += tunnelbridge_direction * 2;
1308 bool draw_underlay =
true;
1311 if (road_rti !=
nullptr) {
1312 if (road_rti->UsesOverlay()) {
1316 draw_underlay =
false;
1320 if (tram_rti->UsesOverlay()) {
1324 draw_underlay =
false;
1329 DrawRoadOverlays(ti, PAL_NONE, road_rti, tram_rti, sprite_offset, sprite_offset, draw_underlay);
1335 if (catenary_sprite_base == 0) {
1336 catenary_sprite_base = SPR_TRAMWAY_TUNNEL_WIRES;
1338 catenary_sprite_base += 19;
1342 if (catenary_sprite_base == 0) {
1343 catenary_sprite_base = SPR_TRAMWAY_TUNNEL_WIRES;
1345 catenary_sprite_base += 19;
1349 if (catenary_sprite_base != 0) {
1352 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);
1356 if (rti->UsesOverlay()) {
1358 if (surface != 0)
DrawGroundSprite(surface + tunnelbridge_direction, PAL_NONE);
1363 if (rti->UsesOverlay()) {
1384 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);
1386 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);
1402 assert(base_offset != 8);
1408 assert( (base_offset & 0x07) == 0x00);
1413 base_offset += (6 - tunnelbridge_direction) % 4;
1418 psid = &GetBridgeSpriteTable(
GetBridgeType(ti->
tile), BRIDGE_PIECE_HEAD)[base_offset];
1420 psid = _aqueduct_sprites + base_offset;
1426 DrawShoreTile(ti->
tileh);
1428 DrawClearLandTile(ti, 3);
1446 uint offset = tunnelbridge_direction;
1449 offset = (offset + 1) & 1;
1461 if (rti->UsesOverlay()) {
1477 if (rti->UsesOverlay()) {
1525 return BRIDGE_PIECE_NORTH;
1526 }
else if (south == 1) {
1527 return BRIDGE_PIECE_SOUTH;
1528 }
else if (north < south) {
1529 return north & 1 ? BRIDGE_PIECE_INNER_SOUTH : BRIDGE_PIECE_INNER_NORTH;
1530 }
else if (north > south) {
1531 return south & 1 ? BRIDGE_PIECE_INNER_NORTH : BRIDGE_PIECE_INNER_SOUTH;
1533 return north & 1 ? BRIDGE_PIECE_MIDDLE_EVEN : BRIDGE_PIECE_MIDDLE_ODD;
1584 psid = base_offset + GetBridgeSpriteTable(type, piece);
1586 drawfarpillar =
true;
1587 psid = _aqueduct_sprites;
1590 if (axis !=
AXIS_X) psid += 4;
1606 AddSortableSpriteToDraw(psid->
sprite, psid->
pal, x, y, 16, 1, 0x28, z,
IsTransparencySet(
TO_BRIDGES), 0, 0,
BRIDGE_Z_START);
1608 AddSortableSpriteToDraw(psid->
sprite, psid->
pal, x, y, 1, 16, 0x28, z,
IsTransparencySet(
TO_BRIDGES), 0, 0,
BRIDGE_Z_START);
1627 if (rti->UsesOverlay()) {
1646 if (psid->
sprite &
SPRITE_MASK)
AddSortableSpriteToDraw(psid->
sprite, psid->
pal, x, y, 16, 4, 0x28, z,
IsTransparencySet(
TO_BRIDGES), 0, 3,
BRIDGE_Z_START);
1649 if (psid->
sprite &
SPRITE_MASK)
AddSortableSpriteToDraw(psid->
sprite, psid->
pal, x, y, 4, 16, 0x28, z,
IsTransparencySet(
TO_BRIDGES), 3, 0,
BRIDGE_Z_START);
1664 static int GetSlopePixelZ_TunnelBridge(
TileIndex tile, uint x, uint y,
bool ground_vehicle)
1673 if (ground_vehicle)
return z;
1679 if (ground_vehicle) {
1683 default: NOT_REACHED();
1705 td->
str = (tt ==
TRANSPORT_RAIL) ? STR_LAI_TUNNEL_DESCRIPTION_RAILROAD : STR_LAI_TUNNEL_DESCRIPTION_ROAD;
1713 RoadType road_rt = GetRoadTypeRoad(tile);
1714 RoadType tram_rt = GetRoadTypeTram(tile);
1733 td->
owner_type[i] = STR_LAND_AREA_INFORMATION_ROAD_OWNER;
1734 td->
owner[i] = road_owner;
1738 td->
owner_type[i] = STR_LAND_AREA_INFORMATION_TRAM_OWNER;
1739 td->
owner[i] = tram_owner;
1751 if (spd == UINT16_MAX) spd = 0;
1752 if (td->
rail_speed == 0 || spd < td->rail_speed) {
1759 if (spd == UINT16_MAX) spd = 0;
1766 static void TileLoop_TunnelBridge(
TileIndex tile)
1804 static void ChangeTileOwner_TunnelBridge(
TileIndex tile,
Owner old_owner,
Owner new_owner)
1811 for (RoadTramType rtt : _roadtramtypes) {
1814 RoadType rt = GetRoadType(tile, rtt);
1818 Company::Get(old_owner)->infrastructure.road[rt] -= num_pieces * 2;
1867 template <
typename T>
1943 assert(frame == rv->frame + 1);
1994 default: NOT_REACHED();
2028 default: NOT_REACHED();
2059 extern const TileTypeProcs _tile_type_tunnelbridge_procs = {
2061 GetSlopePixelZ_TunnelBridge,
2064 GetTileDesc_TunnelBridge,
2065 GetTileTrackStatus_TunnelBridge,
2068 TileLoop_TunnelBridge,
2069 ChangeTileOwner_TunnelBridge,
2071 VehicleEnter_TunnelBridge,
2072 GetFoundation_TunnelBridge,
2073 TerraformTile_TunnelBridge,
@ INVALID_RAILTYPE
Flag for invalid railtype.
static const int BRIDGE_Z_START
Z position of the bridge sprites relative to bridge height (downwards)
Buses, trucks and trams belong to this class.
static CommandCost DoClearTunnel(TileIndex tile, DoCommandFlag flags)
Remove a tunnel from the game, update town rating, etc.
@ SLOPE_SE
south and east corner are raised
static debug_inline uint TileY(TileIndex tile)
Get the Y component of a tile.
@ MP_CLEAR
A tile without any structures, i.e. grass, rocks, farm fields etc.
debug_inline bool IsFrontEngine() const
Check if the vehicle is a front engine.
@ SPRITE_MASK
The mask to for the main sprite.
bool is_ai
If true, the company is (also) controlled by the computer (a NoAI program).
@ OWNER_DEITY
The object is owned by a superuser / goal script.
@ VETSB_CANNOT_ENTER
The vehicle cannot enter the tile.
@ TROPICZONE_DESERT
Tile is desert.
@ DIAGDIR_NE
Northeast, upper right on your monitor.
Cheat crossing_tunnels
allow tunnels that cross each other
Cheat magic_bulldozer
dynamite industries, objects
static Titem * Get(size_t index)
Returns Titem with given index.
TileIndex GetOtherBridgeEnd(TileIndex tile)
Starting at one bridge end finds the other bridge end.
int GetTileMaxZ(TileIndex t)
Get top height of the tile inside the map.
void ResetBridges()
Reset the data been eventually changed by the grf loaded.
@ ROADSIDE_TREES
Road with trees on paved sidewalks.
static const uint BB_Z_SEPARATOR
Separates the bridge/tunnel from the things under/above it.
bool ValParamRailType(const RailType rail)
Validate functions for rail building.
@ VSE_TUNNEL
Train entering a tunnel.
Allow incrementing of ObjectClassID variables.
void YapfNotifyTrackLayoutChange(TileIndex tile, Track track)
Use this function to notify YAPF that track layout (or signal configuration) has change.
uint GetTunnelBridgeLength(TileIndex begin, TileIndex end)
Calculates the length of a tunnel or a bridge (without end tiles)
constexpr void Swap(T &a, T &b)
Type safe swap operation.
static Titem * GetIfValid(size_t index)
Returns Titem with given index.
static const CommandCost CMD_ERROR
Define a default return value for a failed command.
Foundation FlatteningFoundation(Slope s)
Returns the foundation needed to flatten a slope.
const RailTypeInfo * GetRailTypeInfo(RailType railtype)
Returns a pointer to the Railtype information for a given railtype.
Town * ClosestTownFromTile(TileIndex tile, uint threshold)
Return the town closest (in distance or ownership) to a given tile, within a given threshold.
Tile information, used while rendering the tile.
@ RATING_TUNNEL_BRIDGE_MINIMUM
minimum rating after removing tunnel or bridge
WaterClass GetWaterClass(Tile t)
Get the water class at a tile.
StringID railtype
Type of rail on the tile.
static debug_inline uint MaxX()
Gets the maximum X coordinate within the map, including MP_VOID.
SpriteID tunnel
tunnel sprites base
bool HasBridgeFlatRamp(Slope tileh, Axis axis)
Determines if the track on a bridge ramp is flat or goes up/down.
Money RailClearCost(RailType railtype)
Returns the 'cost' of clearing the specified railtype.
Owner owner[4]
Name of the owner(s)
@ SLOPE_NE
north and east corner are raised
@ TRANSPORT_WATER
Transport over water.
static debug_inline bool IsPlainRail(Tile t)
Returns whether this is plain rails, with or without signals.
@ INVALID_OWNER
An invalid owner.
SpriteID bridge_offset
Bridge offset.
@ SND_05_TRAIN_THROUGH_TUNNEL
3 == 0x03 Train enters tunnel: steam engine
Roadside GetRoadside(Tile tile)
Get the decorations of a road.
Price
Enumeration of all base prices for use with Prices.
Foundation InclinedFoundation(Axis axis)
Returns the along a specific axis inclined foundation.
static void DrawPillar(const PalSpriteID *psid, int x, int y, int z, int w, int h, const SubSprite *subsprite)
Draw a single pillar sprite.
uint16_t road_speed
Speed limit of road (bridges and track)
void SetTunnelBridgeReservation(Tile t, bool b)
Set the reservation state of the rail tunnel/bridge.
@ OBJECT_FLAG_ALLOW_UNDER_BRIDGE
Object can built under a bridge.
bool AutoslopeEnabled()
Tests if autoslope is enabled for _current_company.
Owner
Enum for all companies/owners.
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...
RailType
Enumeration for all possible railtypes.
Tindex index
Index of this pool item.
PalSpriteID ** sprite_table
table of sprites for drawing the bridge
Axis DiagDirToAxis(DiagDirection d)
Convert a DiagDirection to the axis.
@ VEH_TRAIN
Train vehicle type.
SpriteID sprite
The 'real' sprite.
int GetBridgeHeight(TileIndex t)
Get the height ('z') of a bridge.
bool HasTunnelBridgeReservation(Tile t)
Get the reservation state of the rail tunnel/bridge.
int GetTileZ(TileIndex tile)
Get bottom height of the tile.
constexpr TileIndex INVALID_TILE
The very nice invalid tile marker.
This struct contains all the info that is needed to draw and construct tracks.
@ VETSB_CONTINUE
Bit sets of the above specified bits.
bool IsTunnelInWayDir(TileIndex tile, int z, DiagDirection dir)
Is there a tunnel in the way in the given direction?
static const uint8_t TUNNEL_SOUND_FRAME
Frame when the 'enter tunnel' sound should be played.
uint8_t height
The height of this structure, in heightlevels; max MAX_TILE_HEIGHT.
static const uint BB_HEIGHT_UNDER_BRIDGE
Some values for constructing bounding boxes (BB).
uint GetPartialPixelZ(int x, int y, Slope corners)
Determines height at given coordinate of a slope.
@ VEH_ROAD
Road vehicle type.
static const uint TILE_SIZE
Tile size in world coordinates.
DiagDirection
Enumeration for diagonal directions.
void ClearBridgeMiddle(Tile t)
Removes bridges from the given, that is bridges along the X and Y axis.
@ SLOPE_NW
north and west corner are raised
ClientSettings _settings_client
The current settings for this game.
TileIndex xy
town center tile
void DrawRailCatenaryOnBridge(const TileInfo *ti)
Draws wires on a tunnel tile.
int y
Y position of the tile in unit coordinates.
uint16_t speed
maximum travel speed (1 unit = 1/1.6 mph = 1 km-ish/h)
CompanyInfrastructure infrastructure
NOSAVE: Counts of company owned infrastructure.
void DrawBridgeMiddle(const TileInfo *ti)
Draw the middle bits of a bridge.
static CommandCost CheckAllowRemoveTunnelBridge(TileIndex tile)
Are we allowed to remove the tunnel or bridge at tile?
uint16_t max_tunnel_length
maximum length of tunnels
struct RailTypeInfo::@26 strings
Strings associated with the rail type.
RailType GetRailType(Tile t)
Gets the rail type of the given tile.
uint16_t max_bridge_length
maximum length of bridges
@ DC_EXEC
execute the given command
int GetSlopePixelZ(int x, int y, bool ground_vehicle)
Return world Z coordinate of a given point of a tile.
Used to only draw a part of the sprite.
CommandCost CheckforTownRating(DoCommandFlag flags, Town *t, TownRatingCheckType type)
Does the town authority allow the (destructive) action of the current company?
uint8_t landscape
the landscape we're currently in
@ MP_ROAD
A tile with road (or tram tracks)
Tile description for the 'land area information' tool.
DoCommandFlag
List of flags for a command.
Foundation
Enumeration for Foundations.
bool Succeeded() const
Did this command succeed?
GameCreationSettings game_creation
settings used during the creation of a game (map)
@ TRANSPORT_ROAD
Transport by road vehicle.
bool IsCoast(Tile t)
Is it a coast tile?
TrackBits DiagDirToDiagTrackBits(DiagDirection diagdir)
Maps a (4-way) direction to the diagonal track bits incidating with that diagdir.
Slope ComplementSlope(Slope s)
Return the complement of a slope.
Slope tileh
Slope of the tile.
@ GVF_GOINGDOWN_BIT
Vehicle is currently going downhill. (Cached track information for acceleration)
static debug_inline TileType GetTileType(Tile tile)
Get the tiletype of a given tile.
@ RTO_SLOPE_NE
Piece of rail on slope with north-east raised.
void MakeRailBridgeRamp(Tile t, Owner o, BridgeType bridgetype, DiagDirection d, RailType rt)
Make a bridge ramp for rails.
Struct containing information about a single bridge type.
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).
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...
Money RoadBuildCost(RoadType roadtype)
Returns the cost of building the specified roadtype.
StringID name
Name of this rail type.
SpriteID GetCustomRoadSprite(const RoadTypeInfo *rti, TileIndex tile, RoadTypeSpriteGroup rtsg, TileContext context, uint *num_results)
Get the sprite to draw for the given tile.
void SetBridgeMiddle(Tile t, Axis a)
Set that there is a bridge over the given axis.
TransportType
Available types of transport.
@ RTBO_Y
Piece of rail in Y direction.
void CheckForDockingTile(TileIndex t)
Mark the supplied tile as a docking tile if it is suitable for docking.
@ VS_HIDDEN
Vehicle is not visible.
EngineClass engclass
Class of engine for this vehicle.
static const uint TILE_UNIT_MASK
For masking in/out the inner-tile world coordinate units.
CommandCost CheckOwnership(Owner owner, TileIndex tile)
Check whether the current owner owns something.
#define return_cmd_error(errcode)
Returns from a function with a specific StringID as error.
TrackdirBits TrackBitsToTrackdirBits(TrackBits bits)
Converts TrackBits to TrackdirBits while allowing both directions.
bool HasRoadCatenaryDrawn(RoadType roadtype)
Test if we should draw road catenary.
Common return value for all commands.
bool IsBridge(Tile t)
Checks if this is a bridge, instead of a tunnel.
const BridgeSpec * GetBridgeSpec(BridgeType i)
Get the specification of a bridge type.
uint ApplyPixelFoundationToSlope(Foundation f, Slope &s)
Applies a foundation to a slope.
bool IsWater(Tile t)
Is it a plain water tile?
@ OWNER_NONE
The tile has no ownership.
static const uint MAX_BRIDGES
Maximal number of available bridge specs.
@ RTSG_BRIDGE
Bridge surface images.
CommandCost CmdBuildBridge(DoCommandFlag flags, TileIndex tile_end, TileIndex tile_start, TransportType transport_type, BridgeType bridge_type, uint8_t road_rail_type)
Build a Bridge.
@ INVALID_DIAGDIR
Flag for an invalid DiagDirection.
void DirtyCompanyInfrastructureWindows(CompanyID company)
Redraw all windows with company infrastructure counts.
BridgeSpec _bridge[MAX_BRIDGES]
The specification of all bridges.
Town * CalcClosestTownFromTile(TileIndex tile, uint threshold=UINT_MAX)
Return the town closest to the given tile within threshold.
@ GVF_GOINGUP_BIT
Vehicle is currently going uphill. (Cached track information for acceleration)
std::tuple< Slope, int > GetTilePixelSlope(TileIndex tile)
Return the slope of a given tile.
bool HasTunnelBridgeSnowOrDesert(Tile t)
Tunnel: Is this tunnel entrance in a snowy or desert area? Bridge: Does the bridge ramp lie in a snow...
TileIndex tile
Current tile index.
void MakeRoadTunnel(Tile t, Owner o, DiagDirection d, RoadType road_rt, RoadType tram_rt)
Makes a road tunnel entrance.
void free(const void *ptr)
Version of the standard free that accepts const pointers.
EngineID engine_type
The type of engine used for this vehicle.
StringID roadtype
Type of road on the tile.
@ MP_OBJECT
Contains objects such as transmitters and owned land.
bool IsTunnel(Tile t)
Is this a tunnel (entrance)?
Cheats _cheats
All the cheats.
TileIndex first_tile
The first tile being cleared, which then causes the whole object to be cleared.
@ TRACKDIR_BIT_NONE
No track build.
DiagDirection ReverseDiagDir(DiagDirection d)
Returns the reverse direction of the given DiagDirection.
bool Failed() const
Did this command fail?
@ VEH_SHIP
Ship vehicle type.
const uint8_t _tunnel_visibility_frame[DIAGDIR_END]
Frame when a vehicle should be hidden in a tunnel with a certain direction.
void SetRoadside(Tile tile, Roadside s)
Set the decorations of a road.
TileIndex GetNorthernBridgeEnd(TileIndex t)
Finds the northern end of a bridge starting at a middle tile.
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.
DiagDirection AxisToDiagDir(Axis a)
Converts an Axis to a DiagDirection.
void EndSpriteCombine()
Terminates a block of sprites started by StartSpriteCombine.
static const uint TUNNELBRIDGE_TRACKBIT_FACTOR
Multiplier for how many regular track bits a tunnel/bridge counts.
uint16_t cur_speed
current speed
TileIndexDiff TileDiffXY(int x, int y)
Calculates an offset for the given coordinate(-offset).
GameSettings _settings_game
Game settings of a running game or the scenario editor.
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.
bool IsBridgeTile(Tile t)
checks if there is a bridge on this tile
RoadType
The different roadtypes we support.
void MakeRailTunnel(Tile t, Owner o, DiagDirection d, RailType r)
Makes a rail tunnel entrance.
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.
CompanyID _local_company
Company controlled by the human player at this client. Can also be COMPANY_SPECTATOR.
#define lengthof(array)
Return the length of an fixed size array.
static debug_inline bool IsNormalRoadTile(Tile t)
Return whether a tile is a normal road tile.
'Train' is either a loco or a wagon.
void FreeTrainTrackReservation(const Train *v)
Free the reserved path in front of a vehicle.
bool HasTileRoadType(Tile t, RoadTramType rtt)
Check if a tile has a road or a tram road type.
Money GetCost() const
The costs as made up to this moment.
DiagDirection DirToDiagDir(Direction dir)
Convert a Direction to a DiagDirection.
bool HasSlopeHighestCorner(Slope s)
Tests if a slope has a highest corner (i.e.
@ TCX_NORMAL
Nothing special.
@ ROTSG_BRIDGE
Required: Bridge surface images.
Owner GetTileOwner(Tile tile)
Returns the owner of a tile.
void StartSpriteCombine()
Starts a block of sprites, which are "combined" into a single bounding box.
@ MP_TUNNELBRIDGE
Tunnel entry/exit and bridge heads.
@ INVALID_ROADTYPE
flag for invalid roadtype
int32_t TileIndexDiff
An offset value between two tiles.
@ FOUNDATION_NONE
The tile has no foundation, the slope remains unchanged.
StringID name
Name of this rail type.
bool ValParamRoadType(RoadType roadtype)
Validate functions for rail building.
TileIndex GetSouthernBridgeEnd(TileIndex t)
Finds the southern end of a bridge starting at a middle tile.
@ RTBO_SLOPE
Sloped rail pieces, in order NE, SE, SW, NW.
TrackStatus CombineTrackStatus(TrackdirBits trackdirbits, TrackdirBits red_signals)
Builds a TrackStatus.
static void PrepareToEnterBridge(T *gv)
Helper to prepare the ground vehicle when entering a bridge.
void AddCost(const Money &cost)
Adds the given cost to the cost of the command.
bool show_track_reservation
highlight reserved tracks.
uint BridgeType
Bridge spec number.
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.
Set of callback functions for performing tile operations of a given tile type.
bool extra_dynamite
extra dynamite
Foundation GetBridgeFoundation(Slope tileh, Axis axis)
Get the foundation for a bridge.
void SetTileOwner(Tile tile, Owner owner)
Sets the owner of a tile.
int CalcBridgeLenCostFactor(int length)
Calculate the price factor for building a long bridge.
uint32_t SpriteID
The number of a sprite, without mapping bits and colourtables.
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.
static const SpriteID SPR_RAILTYPE_TUNNEL_BASE
Tunnel sprites with grass only for custom railtype tunnel.
bool value
tells if the bool cheat is active or not
@ DC_BANKRUPT
company bankrupts, skip money check, skip vehicle on tile check in some cases
std::array< uint32_t, RAILTYPE_END > rail
Count of company owned track bits for each rail type.
@ RTSG_OVERLAY
Images for overlaying track.
static CommandCost DoClearBridge(TileIndex tile, DoCommandFlag flags)
Remove a bridge from the game, update town rating, etc.
@ OWNER_TOWN
A town owns the tile, or a town is expanding.
Money RoadClearCost(RoadType roadtype)
Returns the cost of clearing the specified roadtype.
bool HasTileWaterClass(Tile t)
Checks whether the tile has an waterclass associated.
void ChangeTownRating(Town *t, int add, int max, DoCommandFlag flags)
Changes town rating of the current company.
int32_t z_pos
z coordinate.
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.
SpriteID single_sloped
single piece of rail for slopes
bool IsValidTile(Tile tile)
Checks if a tile is valid.
@ TRACK_BIT_WORMHOLE
Bitflag for a wormhole (used for tunnels)
Direction direction
facing
uint16_t max_speed
Maximum speed for vehicles travelling on this rail type.
TileIndexDiff TileOffsByDiagDir(DiagDirection dir)
Convert a DiagDirection to a TileIndexDiff.
SpriteID single_x
single piece of rail in X direction, without ground
const RoadTypeInfo * GetRoadTypeInfo(RoadType roadtype)
Returns a pointer to the Roadtype information for a given roadtype.
void DrawFoundation(TileInfo *ti, Foundation f)
Draw foundation f at tile ti.
uint DistanceSquare(TileIndex t0, TileIndex t1)
Gets the 'Square' distance between the two given tiles.
@ RTSG_TUNNEL
Main group of ground images for snow or desert.
uint16_t tram_speed
Speed limit of tram (bridges and track)
All ships have this type.
CompanyID _current_company
Company currently doing an action.
Track
These are used to specify a single track.
static const PaletteID PALETTE_CRASH
Recolour sprite greying of crashed vehicles.
@ RTBO_X
Piece of rail in X direction.
Vehicle * First() const
Get the first vehicle of this vehicle chain.
ClearedObjectArea * FindClearedObject(TileIndex tile)
Find the entry in _cleared_object_areas which occupies a certain tile.
static CommandCost ClearTile_TunnelBridge(TileIndex tile, DoCommandFlag flags)
Remove a tunnel or a bridge from the game.
CommandCost CmdBuildTunnel(DoCommandFlag flags, TileIndex start_tile, TransportType transport_type, uint8_t road_rail_type)
Build Tunnel.
Slope
Enumeration for the slope-type.
bool TryPathReserve(Train *v, bool mark_as_stuck=false, bool first_tile_okay=false)
Try to reserve a path to a safe position.
static Train * From(Vehicle *v)
Converts a Vehicle to SpecializedVehicle with type checking.
Axis
Allow incrementing of DiagDirDiff variables.
constexpr T abs(const T a)
Returns the absolute value of (scalar) variable.
@ TRANSPORT_RAIL
Transport by train.
void SetDParam(size_t n, uint64_t v)
Set a string parameter v at index n in the global string parameter array.
@ TCX_ON_BRIDGE
Querying information about stuff on the bridge (via some bridgehead).
bool build_on_slopes
allow building on slopes
@ ROTSG_OVERLAY
Optional: Images for overlaying track.
@ RTO_X
Piece of rail in X direction.
@ OWNER_WATER
The tile/execution is done by "water".
@ SLOPE_SW
south and west corner are raised
void MarkTileDirtyByTile(TileIndex tile, int bridge_level_offset, int tile_height_override)
Mark a tile given by its index dirty for repaint.
static const ObjectSpec * GetByTile(TileIndex tile)
Get the specification associated with a tile.
void AddSideToSignalBuffer(TileIndex tile, DiagDirection side, Owner owner)
Add side of tile to signal update buffer.
std::array< uint32_t, ROADTYPE_END > road
Count of company owned track bits for each road type.
TrackBits state
The "track" the ship is following.
Owner GetRoadOwner(Tile t, RoadTramType rtt)
Get the owner of a specific road type.
@ ROTSG_CATENARY_FRONT
Optional: Catenary front.
TownCache cache
Container for all cacheable data.
void UpdateCompanyRoadInfrastructure(RoadType rt, Owner o, int count)
Update road infrastructure counts for a company.
bool HasRailCatenaryDrawn(RailType rt)
Test if we should draw rail catenary.
TransportType GetTunnelBridgeTransportType(Tile t)
Tunnel: Get the transport type of the tunnel (road or rail) Bridge: Get the transport type of the bri...
@ DIAGDIR_END
Used for iterations.
bool IsBridgeAbove(Tile t)
checks if a bridge is set above the ground of this tile
StringID str
Description of the tile.
@ DC_AUTO
don't allow building on structures
Combination of a palette sprite and a 'real' sprite.
Track DiagDirToDiagTrack(DiagDirection diagdir)
Maps a (4-way) direction to the diagonal track incidating with that diagdir.
struct RoadTypeInfo::@29 strings
Strings associated with the rail type.
void SetRoadOwner(Tile t, RoadTramType rtt, Owner o)
Set the owner of a specific road type.
TileIndex GetOtherTunnelBridgeEnd(Tile t)
Determines type of the wormhole and returns its other end.
Track AxisToTrack(Axis a)
Convert an Axis to the corresponding Track AXIS_X -> TRACK_X AXIS_Y -> TRACK_Y Uses the fact that the...
@ ROTSG_TUNNEL
Optional: Ground images for tunnels.
TileIndex GetOtherTunnelEnd(TileIndex tile)
Gets the other end of the tunnel.
bool PlayVehicleSound(const Vehicle *v, VehicleSoundEvent event, bool force)
Checks whether a NewGRF wants to play a different vehicle sound effect.
OrthogonalTileArea TileArea
Shorthand for the much more common orthogonal tile area.
void DrawRailCatenaryOnTunnel(const TileInfo *ti)
Draws wires on a tunnel tile.
void MarkBridgeDirty(TileIndex begin, TileIndex end, DiagDirection direction, uint bridge_height)
Mark bridge tiles dirty.
static BridgePieces CalcBridgePiece(uint north, uint south)
Compute bridge piece.
CommandCost CheckTileOwnership(TileIndex tile)
Check whether the current owner owns the stuff on the given tile.
uint8_t max_bridge_height
maximum height of bridges
uint8_t min_length
the minimum length (not counting start and end tile)
uint16_t max_speed
Maximum speed for vehicles travelling on this road type.
@ RVSB_WORMHOLE
The vehicle is in a tunnel and/or bridge.
uint SlopeToSpriteOffset(Slope s)
Returns the Sprite offset for a given Slope.
TimerGameCalendar::Year avail_year
the year where it becomes available
static debug_inline uint TileHeight(Tile tile)
Returns the height of a tile.
std::array< uint32_t, HZB_END > squared_town_zone_radius
UpdateTownRadius updates this given the house count.
struct RailTypeInfo::@23 base_sprites
Struct containing the main sprites.
static const uint TILE_HEIGHT
Height of a height level in world coordinate AND in pixels in #ZOOM_BASE.
static void DrawTile_TunnelBridge(TileInfo *ti)
Draws a tunnel of bridge tile.
void DrawRailCatenary(const TileInfo *ti)
Draws overhead wires and pylons for electric railways.
CommandCost CheckBridgeAvailability(BridgeType bridge_type, uint bridge_len, DoCommandFlag flags)
Is a bridge of the specified type and length available?
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.
StringID owner_type[4]
Type of each owner.
int x
X position of the tile in unit coordinates.
PaletteID pal
The palette (use PAL_NONE) if not needed)
TileIndex tile
Tile index.
ConstructionSettings construction
construction of things in-game
@ ROADSIDE_PAVED
Road with paved sidewalks.
uint16_t rail_speed
Speed limit of rail (bridges and track)
uint8_t GetSnowLine()
Get the current snow line, either variable or static.
static bool IsValidID(size_t index)
Tests whether given index can be used to get valid (non-nullptr) Titem.
VehicleType type
Type of vehicle.
void MakeAqueductBridgeRamp(Tile t, Owner o, DiagDirection d)
Make a bridge ramp for aqueducts.
static debug_inline uint TileX(TileIndex tile)
Get the X component of a tile.
StringID tramtype
Type of tram on the tile.
@ DC_QUERY_COST
query cost only, don't build.
int GetBridgePixelHeight(TileIndex tile)
Get the height ('z') of a bridge in pixels.
@ TUNNELBRIDGE_REMOVE
Removal of a tunnel or bridge owned by the towb.
Keeps track of removed objects during execution/testruns of commands.
static Money TunnelBridgeClearCost(TileIndex tile, Price base_price)
Calculate the base cost of clearing a tunnel/bridge per tile.
Axis GetBridgeAxis(Tile t)
Get the axis of the bridge that goes over the tile.
BridgePieces
This enum is related to the definition of bridge pieces, which is used to determine the proper sprite...
constexpr T ClrBit(T &x, const uint8_t y)
Clears a bit in a variable.
bool IsTileOwner(Tile tile, Owner owner)
Checks if a tile belongs to the given owner.
Trackdir DiagDirToDiagTrackdir(DiagDirection diagdir)
Maps a (4-way) direction to the diagonal trackdir that runs in that direction.
TropicZone GetTropicZone(Tile tile)
Get the tropic zone.
Axis OtherAxis(Axis a)
Select the other axis as provided.
@ ROTSG_CATENARY_BACK
Optional: Catenary back.
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.
DiagDirection GetInclinedSlopeDirection(Slope s)
Returns the direction of an inclined slope.
bool HasTileWaterGround(Tile t)
Checks whether the tile has water at the ground.
uint32_t water
Count of company owned track bits for canals.
std::tuple< Slope, int > GetTileSlopeZ(TileIndex tile)
Return the slope of a given tile inside the map.
static debug_inline bool IsRoadDepot(Tile t)
Return whether a tile is a road depot.
@ RATING_TUNNEL_BRIDGE_DOWN_STEP
penalty for removing town owned tunnel or bridge
SpriteID single_y
single piece of rail in Y direction, without ground
VehicleEnterTileStatus
The returned bits of VehicleEnterTile.
CommandCost TunnelBridgeIsFree(TileIndex tile, TileIndex endtile, const Vehicle *ignore)
Finds vehicle in tunnel / bridge.
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.
TileIndex _build_tunnel_endtile
The end of a tunnel; as hidden return from the tunnel build command for GUI purposes.
BridgeType GetBridgeType(Tile t)
Determines the type of bridge on a tile.
Money RailBuildCost(RailType railtype)
Returns the cost of building the specified railtype.
GUISettings gui
settings related to the GUI
Train * GetTrainForReservation(TileIndex tile, Track track)
Find the train which has reserved a specific path.
uint16_t max_length
the maximum length (not counting start and end tile)
SpriteID GetCustomRailSprite(const RailTypeInfo *rti, TileIndex tile, RailTypeSpriteGroup rtsg, TileContext context, uint *num_results)
Get the sprite to draw for the given tile.
static const SpriteID SPR_TRAMWAY_BASE
Tramway sprites.
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.
@ VETSB_ENTERED_WORMHOLE
The vehicle either entered a bridge, tunnel or depot tile (this includes the last tile of the bridge/...
DiagDirection GetTunnelBridgeDirection(Tile t)
Get the direction pointing to the other end.
static Year year
Current year, starting at 0.
ObjectFlags flags
Flags/settings related to the object.
@ EXPENSES_CONSTRUCTION
Construction costs.
@ RTSG_TUNNEL_PORTAL
Tunnel portal overlay.
constexpr debug_inline bool HasBit(const T x, const uint8_t y)
Checks if a bit in a value is set.