From 2feba80fd727d22994248294d5e21b879cbce28e Mon Sep 17 00:00:00 2001 From: Peter Nelson Date: Wed, 7 May 2025 07:49:05 +0100 Subject: [PATCH] Codechange: Codestyle fixes for elrail code. --- src/elrail.cpp | 109 +++++++++++++++++++--------------------- src/table/elrail_data.h | 36 ++++++------- 2 files changed, 71 insertions(+), 74 deletions(-) diff --git a/src/elrail.cpp b/src/elrail.cpp index 5bcadc0cbf..ca19cbc1f7 100644 --- a/src/elrail.cpp +++ b/src/elrail.cpp @@ -213,10 +213,10 @@ static void AdjustTileh(TileIndex tile, Slope *tileh) * Returns the Z position of a Pylon Control Point. * * @param tile The tile the pylon should stand on. - * @param PCPpos The PCP of the tile. + * @param pcp_pos The PCP of the tile. * @return The Z position of the PCP. */ -static int GetPCPElevation(TileIndex tile, DiagDirection PCPpos) +static int GetPCPElevation(TileIndex tile, DiagDirection pcp_pos) { /* The elevation of the "pylon"-sprite should be the elevation at the PCP. * PCPs are always on a tile edge. @@ -232,8 +232,8 @@ static int GetPCPElevation(TileIndex tile, DiagDirection PCPpos) * Also note that the result of GetSlopePixelZ() is very special on bridge-ramps. */ - int z = GetSlopePixelZ(TileX(tile) * TILE_SIZE + std::min(x_pcp_offsets[PCPpos], TILE_SIZE - 1), - TileY(tile) * TILE_SIZE + std::min(y_pcp_offsets[PCPpos], TILE_SIZE - 1), true); + int z = GetSlopePixelZ(TileX(tile) * TILE_SIZE + std::min(_x_pcp_offsets[pcp_pos], TILE_SIZE - 1), + TileY(tile) * TILE_SIZE + std::min(_y_pcp_offsets[pcp_pos], TILE_SIZE - 1), true); /* Round the Z to the nearest half tile height. */ static const uint HALF_TILE_HEIGHT = TILE_HEIGHT / 2; return (z + HALF_TILE_HEIGHT / 2) / HALF_TILE_HEIGHT * HALF_TILE_HEIGHT; @@ -249,7 +249,7 @@ static int GetPCPElevation(TileIndex tile, DiagDirection PCPpos) void DrawRailCatenaryOnTunnel(const TileInfo *ti) { /* xmin, ymin, xmax + 1, ymax + 1 of BB */ - static const int _tunnel_wire_BB[4][4] = { + static const int tunnel_wire_bb[4][4] = { { 0, 1, 16, 15 }, // NE { 1, 0, 15, 16 }, // SE { 0, 1, 16, 15 }, // SW @@ -260,14 +260,14 @@ void DrawRailCatenaryOnTunnel(const TileInfo *ti) SpriteID wire_base = GetWireBase(ti->tile); - const SortableSpriteStruct *sss = &RailCatenarySpriteData_Tunnel[dir]; - const int *BB_data = _tunnel_wire_BB[dir]; + const SortableSpriteStruct *sss = &_rail_catenary_sprite_data_tunnel[dir]; + const int *bb_data = tunnel_wire_bb[dir]; AddSortableSpriteToDraw( wire_base + sss->image_offset, PAL_NONE, ti->x + sss->x_offset, ti->y + sss->y_offset, - BB_data[2] - sss->x_offset, BB_data[3] - sss->y_offset, BB_Z_SEPARATOR - sss->z_offset + 1, + bb_data[2] - sss->x_offset, bb_data[3] - sss->y_offset, BB_Z_SEPARATOR - sss->z_offset + 1, GetTilePixelZ(ti->tile) + sss->z_offset, IsTransparencySet(TO_CATENARY), - BB_data[0] - sss->x_offset, BB_data[1] - sss->y_offset, BB_Z_SEPARATOR - sss->z_offset + bb_data[0] - sss->x_offset, bb_data[1] - sss->y_offset, BB_Z_SEPARATOR - sss->z_offset ); } @@ -280,9 +280,9 @@ static void DrawRailCatenaryRailway(const TileInfo *ti) /* Pylons are placed on a tile edge, so we need to take into account * the track configuration of 2 adjacent tiles. trackconfig[0] stores the * current tile (home tile) while [1] holds the neighbour */ - TrackBits trackconfig[TS_END]; - TrackBits wireconfig[TS_END]; - bool isflat[TS_END]; + TrackBits track_config[TS_END]; + TrackBits wire_config[TS_END]; + bool is_flat[TS_END]; /* Note that ti->tileh has already been adjusted for Foundations */ Slope tileh[TS_END] = { ti->tileh, SLOPE_FLAT }; @@ -306,10 +306,10 @@ static void DrawRailCatenaryRailway(const TileInfo *ti) * 2) on the "far" end of a bridge head (the one that connects to bridge middle), * because that one is drawn on the bridge. Exception is for length 0 bridges * which have no middle tiles */ - trackconfig[TS_HOME] = GetRailTrackBitsUniversal(ti->tile, &override_pcp); - wireconfig[TS_HOME] = MaskWireBits(ti->tile, trackconfig[TS_HOME]); + track_config[TS_HOME] = GetRailTrackBitsUniversal(ti->tile, &override_pcp); + wire_config[TS_HOME] = MaskWireBits(ti->tile, track_config[TS_HOME]); /* If a track bit is present that is not in the main direction, the track is level */ - isflat[TS_HOME] = ((trackconfig[TS_HOME] & (TRACK_BIT_HORZ | TRACK_BIT_VERT)) != 0); + is_flat[TS_HOME] = ((track_config[TS_HOME] & (TRACK_BIT_HORZ | TRACK_BIT_VERT)) != 0); AdjustTileh(ti->tile, &tileh[TS_HOME]); @@ -330,27 +330,27 @@ static void DrawRailCatenaryRailway(const TileInfo *ti) /* Here's one of the main headaches. GetTileSlope does not correct for possibly * existing foundataions, so we do have to do that manually later on.*/ tileh[TS_NEIGHBOUR] = GetTileSlope(neighbour); - trackconfig[TS_NEIGHBOUR] = GetRailTrackBitsUniversal(neighbour, nullptr); - wireconfig[TS_NEIGHBOUR] = MaskWireBits(neighbour, trackconfig[TS_NEIGHBOUR]); - if (IsTunnelTile(neighbour) && i != GetTunnelBridgeDirection(neighbour)) wireconfig[TS_NEIGHBOUR] = trackconfig[TS_NEIGHBOUR] = TRACK_BIT_NONE; + track_config[TS_NEIGHBOUR] = GetRailTrackBitsUniversal(neighbour, nullptr); + wire_config[TS_NEIGHBOUR] = MaskWireBits(neighbour, track_config[TS_NEIGHBOUR]); + if (IsTunnelTile(neighbour) && i != GetTunnelBridgeDirection(neighbour)) wire_config[TS_NEIGHBOUR] = track_config[TS_NEIGHBOUR] = TRACK_BIT_NONE; /* Ignore station tiles that allow neither wires nor pylons. */ - if (IsRailStationTile(neighbour) && !CanStationTileHavePylons(neighbour) && !CanStationTileHaveWires(neighbour)) wireconfig[TS_NEIGHBOUR] = trackconfig[TS_NEIGHBOUR] = TRACK_BIT_NONE; + if (IsRailStationTile(neighbour) && !CanStationTileHavePylons(neighbour) && !CanStationTileHaveWires(neighbour)) wire_config[TS_NEIGHBOUR] = track_config[TS_NEIGHBOUR] = TRACK_BIT_NONE; /* If the neighboured tile does not smoothly connect to the current tile (because of a foundation), * we have to draw all pillars on the current tile. */ - if (elevation != GetPCPElevation(neighbour, ReverseDiagDir(i))) wireconfig[TS_NEIGHBOUR] = trackconfig[TS_NEIGHBOUR] = TRACK_BIT_NONE; + if (elevation != GetPCPElevation(neighbour, ReverseDiagDir(i))) wire_config[TS_NEIGHBOUR] = track_config[TS_NEIGHBOUR] = TRACK_BIT_NONE; - isflat[TS_NEIGHBOUR] = ((trackconfig[TS_NEIGHBOUR] & (TRACK_BIT_HORZ | TRACK_BIT_VERT)) != 0); + is_flat[TS_NEIGHBOUR] = ((track_config[TS_NEIGHBOUR] & (TRACK_BIT_HORZ | TRACK_BIT_VERT)) != 0); ppp_preferred[i] = DIRECTIONS_ALL; // We start with preferring everything (end-of-line in any direction) - ppp_allowed[i] = AllowedPPPonPCP[i]; + ppp_allowed[i] = _allowed_ppp_on_pcp[i]; /* We cycle through all the existing tracks at a PCP and see what * PPPs we want to have, or may not have at all */ for (uint k = 0; k < NUM_TRACKS_AT_PCP; k++) { /* Next to us, we have a bridge head, don't worry about that one, if it shows away from us */ - if (TrackSourceTile[i][k] == TS_NEIGHBOUR && + if (_track_source_tile[i][k] == TS_NEIGHBOUR && IsBridgeTile(neighbour) && GetTunnelBridgeDirection(neighbour) == ReverseDiagDir(i)) { continue; @@ -359,16 +359,16 @@ static void DrawRailCatenaryRailway(const TileInfo *ti) /* We check whether the track in question (k) is present in the tile * (TrackSourceTile) */ DiagDirection pcp_pos = i; - if (HasBit(wireconfig[TrackSourceTile[i][k]], TracksAtPCP[i][k])) { + if (HasBit(wire_config[_track_source_tile[i][k]], _tracks_at_pcp[i][k])) { /* track found, if track is in the neighbour tile, adjust the number * of the PCP for preferred/allowed determination*/ - pcp_pos = (TrackSourceTile[i][k] == TS_HOME) ? i : ReverseDiagDir(i); + pcp_pos = (_track_source_tile[i][k] == TS_HOME) ? i : ReverseDiagDir(i); pcp_status.Set(i); // This PCP is in use - ppp_preferred[i] &= PreferredPPPofTrackAtPCP[TracksAtPCP[i][k]][pcp_pos]; + ppp_preferred[i] &= _preferred_ppp_of_track_at_pcp[_tracks_at_pcp[i][k]][pcp_pos]; } - if (HasBit(trackconfig[TrackSourceTile[i][k]], TracksAtPCP[i][k])) { - ppp_allowed[i].Reset(DisallowedPPPofTrackAtPCP[TracksAtPCP[i][k]][pcp_pos]); + if (HasBit(track_config[_track_source_tile[i][k]], _tracks_at_pcp[i][k])) { + ppp_allowed[i].Reset(_disallowed_ppp_of_track_at_pcp[_tracks_at_pcp[i][k]][pcp_pos]); } } @@ -384,7 +384,7 @@ static void DrawRailCatenaryRailway(const TileInfo *ti) if (IsTileType(neighbour, MP_STATION) || IsTileType(neighbour, MP_ROAD)) tileh[TS_NEIGHBOUR] = SLOPE_FLAT; /* Read the foundations if they are present, and adjust the tileh */ - if (trackconfig[TS_NEIGHBOUR] != TRACK_BIT_NONE && IsTileType(neighbour, MP_RAILWAY) && HasRailCatenary(GetRailType(neighbour))) foundation = GetRailFoundation(tileh[TS_NEIGHBOUR], trackconfig[TS_NEIGHBOUR]); + if (track_config[TS_NEIGHBOUR] != TRACK_BIT_NONE && IsTileType(neighbour, MP_RAILWAY) && HasRailCatenary(GetRailType(neighbour))) foundation = GetRailFoundation(tileh[TS_NEIGHBOUR], track_config[TS_NEIGHBOUR]); if (IsBridgeTile(neighbour)) { foundation = GetBridgeFoundation(tileh[TS_NEIGHBOUR], DiagDirToAxis(GetTunnelBridgeDirection(neighbour))); } @@ -400,9 +400,9 @@ static void DrawRailCatenaryRailway(const TileInfo *ti) /* If we have a straight (and level) track, we want a pylon only every 2 tiles * Delete the PCP if this is the case. * Level means that the slope is the same, or the track is flat */ - if (tileh[TS_HOME] == tileh[TS_NEIGHBOUR] || (isflat[TS_HOME] && isflat[TS_NEIGHBOUR])) { + if (tileh[TS_HOME] == tileh[TS_NEIGHBOUR] || (is_flat[TS_HOME] && is_flat[TS_NEIGHBOUR])) { for (uint k = 0; k < NUM_IGNORE_GROUPS; k++) { - if (ppp_preferred[i] == IgnoredPCP[k][tlg][i]) pcp_status.Reset(i); + if (ppp_preferred[i] == _ignored_pcp[k][tlg][i]) pcp_status.Reset(i); } } @@ -417,7 +417,7 @@ static void DrawRailCatenaryRailway(const TileInfo *ti) int height = GetBridgeHeight(GetNorthernBridgeEnd(ti->tile)); if ((height <= GetTileMaxZ(ti->tile) + 1) && - (i == PCPpositions[bridgetrack][0] || i == PCPpositions[bridgetrack][1])) { + (i == _pcp_positions[bridgetrack][0] || i == _pcp_positions[bridgetrack][1])) { override_pcp.Set(i); } } @@ -425,22 +425,22 @@ static void DrawRailCatenaryRailway(const TileInfo *ti) if (ppp_allowed[i].Any() && pcp_status.Test(i) && !override_pcp.Test(i) && (!IsRailStationTile(ti->tile) || CanStationTileHavePylons(ti->tile))) { - const auto &ppp_orders = PPPorder[i][GetTileLocationGroup(ti->tile)]; + const auto &ppp_orders = _ppp_order[i][GetTileLocationGroup(ti->tile)]; for (Direction k = DIR_BEGIN; k < DIR_END; k++) { Direction temp = ppp_orders[k]; if (ppp_allowed[i].Test(temp)) { - uint x = ti->x + x_pcp_offsets[i] + x_ppp_offsets[temp]; - uint y = ti->y + y_pcp_offsets[i] + y_ppp_offsets[temp]; + uint x = ti->x + _x_pcp_offsets[i] + _x_ppp_offsets[temp]; + uint y = ti->y + _y_pcp_offsets[i] + _y_ppp_offsets[temp]; /* Don't build the pylon if it would be outside the tile */ - if (!OwnedPPPonPCP[i].Test(temp)) { + if (!_owned_ppp_on_pcp[i].Test(temp)) { /* We have a neighbour that will draw it, bail out */ - if (trackconfig[TS_NEIGHBOUR] != TRACK_BIT_NONE) break; + if (track_config[TS_NEIGHBOUR] != TRACK_BIT_NONE) break; continue; // No neighbour, go looking for a better position } - AddSortableSpriteToDraw(pylon_base + pylon_sprites[temp], PAL_NONE, x, y, 1, 1, BB_HEIGHT_UNDER_BRIDGE, + AddSortableSpriteToDraw(pylon_base + _pylon_sprites[temp], PAL_NONE, x, y, 1, 1, BB_HEIGHT_UNDER_BRIDGE, elevation, IsTransparencySet(TO_CATENARY), -1, -1); break; // We already have drawn a pylon, bail out @@ -474,17 +474,15 @@ static void DrawRailCatenaryRailway(const TileInfo *ti) } /* Drawing of pylons is finished, now draw the wires */ - for (Track t : SetTrackBitIterator(wireconfig[TS_HOME])) { + for (Track t : SetTrackBitIterator(wire_config[TS_HOME])) { SpriteID wire_base = (t == halftile_track) ? wire_halftile : wire_normal; - uint8_t pcp_config = pcp_status.Test(PCPpositions[t][0]) + - (pcp_status.Test(PCPpositions[t][1]) << 1); - - const SortableSpriteStruct *sss; + uint8_t pcp_config = pcp_status.Test(_pcp_positions[t][0]) + + (pcp_status.Test(_pcp_positions[t][1]) << 1); int tileh_selector = !(tileh[TS_HOME] % 3) * tileh[TS_HOME] / 3; // tileh for the slopes, 0 otherwise assert(pcp_config != 0); // We have a pylon on neither end of the wire, that doesn't work (since we have no sprites for that) assert(!IsSteepSlope(tileh[TS_HOME])); - sss = &RailCatenarySpriteData[Wires[tileh_selector][t][pcp_config]]; + const SortableSpriteStruct *sss = &_rail_catenary_sprite_data[_rail_wires[tileh_selector][t][pcp_config]]; /* * The "wire"-sprite position is inside the tile, i.e. 0 <= sss->?_offset < TILE_SIZE. @@ -512,24 +510,23 @@ void DrawRailCatenaryOnBridge(const TileInfo *ti) uint length = GetTunnelBridgeLength(start, end); uint num = GetTunnelBridgeLength(ti->tile, start) + 1; - uint height; - const SortableSpriteStruct *sss; Axis axis = GetBridgeAxis(ti->tile); TileLocationGroup tlg = GetTileLocationGroup(ti->tile); RailCatenarySprite offset = (RailCatenarySprite)(axis == AXIS_X ? 0 : WIRE_Y_FLAT_BOTH - WIRE_X_FLAT_BOTH); + const SortableSpriteStruct *sss; if ((length % 2) && num == length) { /* Draw the "short" wire on the southern end of the bridge * only needed if the length of the bridge is odd */ - sss = &RailCatenarySpriteData[WIRE_X_FLAT_BOTH + offset]; + sss = &_rail_catenary_sprite_data[WIRE_X_FLAT_BOTH + offset]; } else { /* Draw "long" wires on all other tiles of the bridge (one pylon every two tiles) */ - sss = &RailCatenarySpriteData[WIRE_X_FLAT_SW + (num % 2) + offset]; + sss = &_rail_catenary_sprite_data[WIRE_X_FLAT_SW + (num % 2) + offset]; } - height = GetBridgePixelHeight(end); + uint height = GetBridgePixelHeight(end); SpriteID wire_base = GetWireBase(end, TCX_ON_BRIDGE); @@ -546,9 +543,9 @@ void DrawRailCatenaryOnBridge(const TileInfo *ti) DiagDirection pcp_pos = (axis == AXIS_X ? DIAGDIR_NE : DIAGDIR_NW); Direction ppp_pos = (axis == AXIS_X ? DIR_NW : DIR_NE); if (HasBit(tlg, (axis == AXIS_X ? 0 : 1))) ppp_pos = ReverseDir(ppp_pos); - uint x = ti->x + x_pcp_offsets[pcp_pos] + x_ppp_offsets[ppp_pos]; - uint y = ti->y + y_pcp_offsets[pcp_pos] + y_ppp_offsets[ppp_pos]; - AddSortableSpriteToDraw(pylon_base + pylon_sprites[ppp_pos], PAL_NONE, x, y, 1, 1, BB_HEIGHT_UNDER_BRIDGE, height, IsTransparencySet(TO_CATENARY), -1, -1); + uint x = ti->x + _x_pcp_offsets[pcp_pos] + _x_ppp_offsets[ppp_pos]; + uint y = ti->y + _y_pcp_offsets[pcp_pos] + _y_ppp_offsets[ppp_pos]; + AddSortableSpriteToDraw(pylon_base + _pylon_sprites[ppp_pos], PAL_NONE, x, y, 1, 1, BB_HEIGHT_UNDER_BRIDGE, height, IsTransparencySet(TO_CATENARY), -1, -1); } /* need a pylon on the southern end of the bridge */ @@ -556,9 +553,9 @@ void DrawRailCatenaryOnBridge(const TileInfo *ti) DiagDirection pcp_pos = (axis == AXIS_X ? DIAGDIR_SW : DIAGDIR_SE); Direction ppp_pos = (axis == AXIS_X ? DIR_NW : DIR_NE); if (HasBit(tlg, (axis == AXIS_X ? 0 : 1))) ppp_pos = ReverseDir(ppp_pos); - uint x = ti->x + x_pcp_offsets[pcp_pos] + x_ppp_offsets[ppp_pos]; - uint y = ti->y + y_pcp_offsets[pcp_pos] + y_ppp_offsets[ppp_pos]; - AddSortableSpriteToDraw(pylon_base + pylon_sprites[ppp_pos], PAL_NONE, x, y, 1, 1, BB_HEIGHT_UNDER_BRIDGE, height, IsTransparencySet(TO_CATENARY), -1, -1); + uint x = ti->x + _x_pcp_offsets[pcp_pos] + _x_ppp_offsets[ppp_pos]; + uint y = ti->y + _y_pcp_offsets[pcp_pos] + _y_ppp_offsets[ppp_pos]; + AddSortableSpriteToDraw(pylon_base + _pylon_sprites[ppp_pos], PAL_NONE, x, y, 1, 1, BB_HEIGHT_UNDER_BRIDGE, height, IsTransparencySet(TO_CATENARY), -1, -1); } } @@ -572,7 +569,7 @@ void DrawRailCatenary(const TileInfo *ti) switch (GetTileType(ti->tile)) { case MP_RAILWAY: if (IsRailDepot(ti->tile)) { - const SortableSpriteStruct *sss = &RailCatenarySpriteData_Depot[GetRailDepotDirection(ti->tile)]; + const SortableSpriteStruct *sss = &_rail_catenary_sprite_data_depot[GetRailDepotDirection(ti->tile)]; SpriteID wire_base = GetWireBase(ti->tile); diff --git a/src/table/elrail_data.h b/src/table/elrail_data.h index efea4019ec..5be264f008 100644 --- a/src/table/elrail_data.h +++ b/src/table/elrail_data.h @@ -40,7 +40,7 @@ enum TileSource : uint8_t { static const uint NUM_TRACKS_AT_PCP = 6; /** Which PPPs are possible at all on a given PCP */ -static const Directions AllowedPPPonPCP[DIAGDIR_END] = { +static const Directions _allowed_ppp_on_pcp[DIAGDIR_END] = { {DIR_N, DIR_E, DIR_SE, DIR_S, DIR_W, DIR_NW}, {DIR_N, DIR_NE, DIR_E, DIR_S, DIR_SW, DIR_W}, {DIR_N, DIR_E, DIR_SE, DIR_S, DIR_W, DIR_NW}, @@ -52,7 +52,7 @@ static const Directions AllowedPPPonPCP[DIAGDIR_END] = { * the following system is used: if you rotate the PCP so that it is in the * north, the eastern PPP belongs to the tile. */ -static const Directions OwnedPPPonPCP[DIAGDIR_END] = { +static const Directions _owned_ppp_on_pcp[DIAGDIR_END] = { {DIR_SE, DIR_S, DIR_SW, DIR_W}, {DIR_N, DIR_SW, DIR_W, DIR_NW}, {DIR_N, DIR_NE, DIR_E, DIR_NW}, @@ -60,7 +60,7 @@ static const Directions OwnedPPPonPCP[DIAGDIR_END] = { }; /** Maps a track bit onto two PCP positions */ -static const DiagDirection PCPpositions[TRACK_END][2] = { +static const DiagDirection _pcp_positions[TRACK_END][2] = { {DIAGDIR_NE, DIAGDIR_SW}, // X {DIAGDIR_SE, DIAGDIR_NW}, // Y {DIAGDIR_NW, DIAGDIR_NE}, // UPPER @@ -75,7 +75,7 @@ static const DiagDirection PCPpositions[TRACK_END][2] = { * which are not on either end of the track are fully preferred. * @see PCPpositions */ -static const Directions PreferredPPPofTrackAtPCP[TRACK_END][DIAGDIR_END] = { +static const Directions _preferred_ppp_of_track_at_pcp[TRACK_END][DIAGDIR_END] = { { // X {DIR_NE, DIR_SE, DIR_NW}, // NE DIRECTIONS_ALL, // SE @@ -120,7 +120,7 @@ static const Directions PreferredPPPofTrackAtPCP[TRACK_END][DIAGDIR_END] = { * so there are certain tiles which we ignore. A straight line is found if * we have exactly two PPPs. */ -static const Directions IgnoredPCP[NUM_IGNORE_GROUPS][TLG_END][DIAGDIR_END] = { +static const Directions _ignored_pcp[NUM_IGNORE_GROUPS][TLG_END][DIAGDIR_END] = { { // Ignore group 1, X and Y tracks { // X even, Y even DIRECTIONS_ALL, @@ -193,7 +193,7 @@ static const Directions IgnoredPCP[NUM_IGNORE_GROUPS][TLG_END][DIAGDIR_END] = { }; /** Which pylons can definitely NOT be built */ -static const Directions DisallowedPPPofTrackAtPCP[TRACK_END][DIAGDIR_END] = { +static const Directions _disallowed_ppp_of_track_at_pcp[TRACK_END][DIAGDIR_END] = { {{DIR_SW, DIR_NE}, {}, {DIR_SW, DIR_NE}, {} }, // X {{}, {DIR_NW, DIR_SE}, {}, {DIR_NW, DIR_SE}}, // Y {{DIR_W, DIR_E}, {}, {}, {DIR_W, DIR_E} }, // UPPER @@ -203,7 +203,7 @@ static const Directions DisallowedPPPofTrackAtPCP[TRACK_END][DIAGDIR_END] = { }; /* This array stores which track bits can meet at a tile edge */ -static const Track TracksAtPCP[DIAGDIR_END][NUM_TRACKS_AT_PCP] = { +static const Track _tracks_at_pcp[DIAGDIR_END][NUM_TRACKS_AT_PCP] = { {TRACK_X, TRACK_X, TRACK_UPPER, TRACK_LOWER, TRACK_LEFT, TRACK_RIGHT}, {TRACK_Y, TRACK_Y, TRACK_UPPER, TRACK_LOWER, TRACK_LEFT, TRACK_RIGHT}, {TRACK_X, TRACK_X, TRACK_UPPER, TRACK_LOWER, TRACK_LEFT, TRACK_RIGHT}, @@ -212,7 +212,7 @@ static const Track TracksAtPCP[DIAGDIR_END][NUM_TRACKS_AT_PCP] = { /* takes each of the 6 track bits from the array above and * assigns it to the home tile or neighbour tile */ -static const TileSource TrackSourceTile[DIAGDIR_END][NUM_TRACKS_AT_PCP] = { +static const TileSource _track_source_tile[DIAGDIR_END][NUM_TRACKS_AT_PCP] = { {TS_HOME, TS_NEIGHBOUR, TS_HOME , TS_NEIGHBOUR, TS_NEIGHBOUR, TS_HOME }, {TS_HOME, TS_NEIGHBOUR, TS_NEIGHBOUR, TS_HOME , TS_NEIGHBOUR, TS_HOME }, {TS_HOME, TS_NEIGHBOUR, TS_NEIGHBOUR, TS_HOME , TS_HOME , TS_NEIGHBOUR}, @@ -220,7 +220,7 @@ static const TileSource TrackSourceTile[DIAGDIR_END][NUM_TRACKS_AT_PCP] = { }; /* Several PPPs maybe exist, here they are sorted in order of preference. */ -static const Direction PPPorder[DIAGDIR_END][TLG_END][DIR_END] = { // X - Y +static const Direction _ppp_order[DIAGDIR_END][TLG_END][DIR_END] = { // X - Y { // PCP 0 {DIR_NE, DIR_NW, DIR_SE, DIR_SW, DIR_N, DIR_E, DIR_S, DIR_W}, // evn - evn {DIR_NE, DIR_SE, DIR_SW, DIR_NW, DIR_S, DIR_W, DIR_N, DIR_E}, // evn - odd @@ -244,11 +244,11 @@ static const Direction PPPorder[DIAGDIR_END][TLG_END][DIR_END] = { // X - } }; /* Geometric placement of the PCP relative to the tile origin */ -static const int8_t x_pcp_offsets[DIAGDIR_END] = {0, 8, 16, 8}; -static const int8_t y_pcp_offsets[DIAGDIR_END] = {8, 16, 8, 0}; +static const int8_t _x_pcp_offsets[DIAGDIR_END] = {0, 8, 16, 8}; +static const int8_t _y_pcp_offsets[DIAGDIR_END] = {8, 16, 8, 0}; /* Geometric placement of the PPP relative to the PCP*/ -static const int8_t x_ppp_offsets[DIR_END] = {-2, -4, -2, 0, 2, 4, 2, 0}; -static const int8_t y_ppp_offsets[DIR_END] = {-2, 0, 2, 4, 2, 0, -2, -4}; +static const int8_t _x_ppp_offsets[DIR_END] = {-2, -4, -2, 0, 2, 4, 2, 0}; +static const int8_t _y_ppp_offsets[DIR_END] = {-2, 0, 2, 4, 2, 0, -2, -4}; /** * Offset for pylon sprites from the base pylon sprite. @@ -265,7 +265,7 @@ enum PylonSpriteOffset : uint8_t { }; /* The type of pylon to draw at each PPP */ -static const uint8_t pylon_sprites[] = { +static const uint8_t _pylon_sprites[] = { PSO_EW_N, PSO_Y_NE, PSO_NS_E, @@ -330,7 +330,7 @@ static const uint ELRAIL_ELEVRAISE = ELRAIL_ELEVATION + TILE_HEIGHT + 1; /** Wires that a draw one level lower than the north corner. */ static const uint ELRAIL_ELEVLOWER = ELRAIL_ELEVATION - 1; -static const SortableSpriteStruct RailCatenarySpriteData[] = { +static const SortableSpriteStruct _rail_catenary_sprite_data[] = { /* X direction * Flat tiles: * Wires */ @@ -391,14 +391,14 @@ static const SortableSpriteStruct RailCatenarySpriteData[] = { { WSO_EW_E, 15, 8, 3, 3, 1, ELRAIL_ELEVATION } //!33: LOWER trackbit wire, pylon on both ends }; -static const SortableSpriteStruct RailCatenarySpriteData_Depot[] = { +static const SortableSpriteStruct _rail_catenary_sprite_data_depot[] = { { WSO_ENTRANCE_NE, 0, 7, 15, 1, 1, ELRAIL_ELEVATION }, //! Wire for NE depot exit { WSO_ENTRANCE_SE, 7, 0, 1, 15, 1, ELRAIL_ELEVATION }, //! Wire for SE depot exit { WSO_ENTRANCE_SW, 0, 7, 15, 1, 1, ELRAIL_ELEVATION }, //! Wire for SW depot exit { WSO_ENTRANCE_NW, 7, 0, 1, 15, 1, ELRAIL_ELEVATION } //! Wire for NW depot exit }; -static const SortableSpriteStruct RailCatenarySpriteData_Tunnel[] = { +static const SortableSpriteStruct _rail_catenary_sprite_data_tunnel[] = { { WSO_ENTRANCE_SW, 0, 7, 15, 1, 1, ELRAIL_ELEVATION }, //! Wire for NE tunnel (SW facing exit) { WSO_ENTRANCE_NW, 7, 0, 1, 15, 1, ELRAIL_ELEVATION }, //! Wire for SE tunnel (NW facing exit) { WSO_ENTRANCE_NE, 0, 7, 15, 1, 1, ELRAIL_ELEVATION }, //! Wire for SW tunnel (NE facing exit) @@ -470,7 +470,7 @@ enum RailCatenarySprite : uint8_t { * c) the second * d) both * PCP exists.*/ -static const RailCatenarySprite Wires[5][TRACK_END][4] = { +static const RailCatenarySprite _rail_wires[5][TRACK_END][4] = { { // Tileh == 0 {INVALID_CATENARY, WIRE_X_FLAT_NE, WIRE_X_FLAT_SW, WIRE_X_FLAT_BOTH}, {INVALID_CATENARY, WIRE_Y_FLAT_SE, WIRE_Y_FLAT_NW, WIRE_Y_FLAT_BOTH},