miguel.horta/openttd-cmclient
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Codechange: Use enum class for water-related enums. (#14804)

Browse Source
This commit is contained in:
Peter Nelson
2025-11-19 20:35:11 +00:00
committed by dP
parent eb976cc523
commit c2f269dab2
21 changed files with 190 additions and 190 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/clear_cmd.cpp
View File

@@ -226,7 +226,7 @@ static inline bool NeighbourIsNormal(TileIndex tile)
TileIndex t = tile + TileOffsByDiagDir(dir);
if (!IsValidTile(t)) continue;
if (GetTropicZone(t) != TROPICZONE_DESERT) return true;
if (HasTileWaterClass(t) && GetWaterClass(t) == WATER_CLASS_SEA) return true;
if (HasTileWaterClass(t) && GetWaterClass(t) == WaterClass::Sea) return true;
}
return false;
}

10
src/dock_gui.cpp
View File

@@ -264,13 +264,13 @@ struct BuildDocksToolbarWindow : Window {
break;
case DDSP_CREATE_WATER:
if (_game_mode == GM_EDITOR) {
Command<CMD_BUILD_CANAL>::Post(STR_ERROR_CAN_T_BUILD_CANALS, CcPlaySound_CONSTRUCTION_WATER, end_tile, start_tile, _ctrl_pressed ? WATER_CLASS_SEA : WATER_CLASS_CANAL, false);
Command<CMD_BUILD_CANAL>::Post(STR_ERROR_CAN_T_BUILD_CANALS, CcPlaySound_CONSTRUCTION_WATER, end_tile, start_tile, _ctrl_pressed ? WaterClass::Sea : WaterClass::Canal, false);
} else {
Command<CMD_BUILD_CANAL>::Post(STR_ERROR_CAN_T_BUILD_CANALS, CcPlaySound_CONSTRUCTION_WATER, end_tile, start_tile, WATER_CLASS_CANAL, _ctrl_pressed);
Command<CMD_BUILD_CANAL>::Post(STR_ERROR_CAN_T_BUILD_CANALS, CcPlaySound_CONSTRUCTION_WATER, end_tile, start_tile, WaterClass::Canal, _ctrl_pressed);
}
break;
case DDSP_CREATE_RIVER:
Command<CMD_BUILD_CANAL>::Post(STR_ERROR_CAN_T_PLACE_RIVERS, CcPlaySound_CONSTRUCTION_WATER, end_tile, start_tile, WATER_CLASS_RIVER, _ctrl_pressed);
Command<CMD_BUILD_CANAL>::Post(STR_ERROR_CAN_T_PLACE_RIVERS, CcPlaySound_CONSTRUCTION_WATER, end_tile, start_tile, WaterClass::River, _ctrl_pressed);
break;
default: break;
@@ -560,8 +560,8 @@ public:
int y = (ir.Height() - ScaleSpriteTrad(64)) / 2;
int x1 = ScaleSpriteTrad(63);
int x2 = ScaleSpriteTrad(31);
DrawShipDepotSprite(x + (axis == AXIS_X ? x1 : x2), y + ScaleSpriteTrad(17), axis, DEPOT_PART_NORTH);
DrawShipDepotSprite(x + (axis == AXIS_X ? x2 : x1), y + ScaleSpriteTrad(33), axis, DEPOT_PART_SOUTH);
DrawShipDepotSprite(x + (axis == AXIS_X ? x1 : x2), y + ScaleSpriteTrad(17), axis, DepotPart::North);
DrawShipDepotSprite(x + (axis == AXIS_X ? x2 : x1), y + ScaleSpriteTrad(33), axis, DepotPart::South);
}
break;
}

2
src/industry_cmd.cpp
View File

@@ -1938,7 +1938,7 @@ static void DoCreateNewIndustry(Industry *i, TileIndex tile, IndustryType type,
if (it.gfx != GFX_WATERTILE_SPECIALCHECK) {
i->location.Add(cur_tile);
WaterClass wc = (IsWaterTile(cur_tile) ? GetWaterClass(cur_tile) : WATER_CLASS_INVALID);
WaterClass wc = (IsWaterTile(cur_tile) ? GetWaterClass(cur_tile) : WaterClass::Invalid);
Command<CMD_LANDSCAPE_CLEAR>::Do({DoCommandFlag::Execute, DoCommandFlag::NoTestTownRating, DoCommandFlag::NoModifyTownRating}, cur_tile);

4
src/landscape.cpp
View File

@@ -681,9 +681,9 @@ CommandCost CmdLandscapeClear(DoCommandFlags flags, TileIndex tile)
bool do_clear = false;
/* Test for stuff which results in water when cleared. Then add the cost to also clear the water. */
if (flags.Test(DoCommandFlag::ForceClearTile) && HasTileWaterClass(tile) && IsTileOnWater(tile) && !IsWaterTile(tile) && !IsCoastTile(tile)) {
if (flags.Test(DoCommandFlag::Auto) && GetWaterClass(tile) == WATER_CLASS_CANAL) return CommandCost(STR_ERROR_MUST_DEMOLISH_CANAL_FIRST);
if (flags.Test(DoCommandFlag::Auto) && GetWaterClass(tile) == WaterClass::Canal) return CommandCost(STR_ERROR_MUST_DEMOLISH_CANAL_FIRST);
do_clear = true;
cost.AddCost(GetWaterClass(tile) == WATER_CLASS_CANAL ? _price[PR_CLEAR_CANAL] : _price[PR_CLEAR_WATER]);
cost.AddCost(GetWaterClass(tile) == WaterClass::Canal ? _price[PR_CLEAR_CANAL] : _price[PR_CLEAR_WATER]);
}
Company *c = flags.Any({DoCommandFlag::Auto, DoCommandFlag::Bankrupt}) ? nullptr : Company::GetIfValid(_current_company);

2
src/newgrf_canal.cpp
View File

@@ -65,7 +65,7 @@ struct CanalResolverObject : public ResolverObject {
case 0x80: {
int z = GetTileZ(this->tile);
/* Return consistent height within locks */
if (IsTileType(this->tile, MP_WATER) && IsLock(this->tile) && GetLockPart(this->tile) == LOCK_PART_UPPER) z--;
if (IsTileType(this->tile, MP_WATER) && IsLock(this->tile) && GetLockPart(this->tile) == LockPart::Upper) z--;
return z;
}

2
src/newgrf_commons.cpp
View File

@@ -443,7 +443,7 @@ uint32_t GetNearbyTileInformation(TileIndex tile, bool grf_version8)
auto [tileh, z] = GetTilePixelSlope(tile);
/* Return 0 if the tile is a land tile */
uint8_t terrain_type = (HasTileWaterClass(tile) ? (GetWaterClass(tile) + 1) & 3 : 0) << 5 | GetTerrainType(tile) << 2 | (tile_type == MP_WATER ? 1 : 0) << 1;
uint8_t terrain_type = (HasTileWaterClass(tile) ? (to_underlying(GetWaterClass(tile)) + 1) & 3 : 0) << 5 | GetTerrainType(tile) << 2 | (tile_type == MP_WATER ? 1 : 0) << 1;
if (grf_version8) z /= TILE_HEIGHT;
return tile_type << 24 | ClampTo<uint8_t>(z) << 16 | terrain_type << 8 | tileh;
}

2
src/newgrf_generic.cpp
View File

@@ -248,7 +248,7 @@ void AmbientSoundEffectCallback(TileIndex tile)
object.generic_scope.feature = GSF_SOUNDFX;
uint32_t param1_v7 = GetTileType(tile) << 28 | Clamp(TileHeight(tile), 0, 15) << 24 | GB(r, 16, 8) << 16 | GetTerrainType(tile);
uint32_t param1_v8 = GetTileType(tile) << 24 | GetTileZ(tile) << 16 | GB(r, 16, 8) << 8 | (HasTileWaterClass(tile) ? GetWaterClass(tile) : 0) << 3 | GetTerrainType(tile);
uint32_t param1_v8 = GetTileType(tile) << 24 | GetTileZ(tile) << 16 | GB(r, 16, 8) << 8 | (HasTileWaterClass(tile) ? to_underlying(GetWaterClass(tile)) : 0) << 3 | GetTerrainType(tile);
/* Run callback. */
auto callback = GetGenericCallbackResult(GSF_SOUNDFX, object, param1_v7, param1_v8);

8
src/object_cmd.cpp
View File

@@ -116,9 +116,9 @@ void BuildObject(ObjectType type, TileIndex tile, CompanyID owner, Town *town, u
for (TileIndex t : ta) {
if (IsWaterTile(t)) ClearNeighbourNonFloodingStates(t);
if (HasTileWaterGround(t)) InvalidateWaterRegion(t);
WaterClass wc = (IsWaterTile(t) ? GetWaterClass(t) : WATER_CLASS_INVALID);
WaterClass wc = (IsWaterTile(t) ? GetWaterClass(t) : WaterClass::Invalid);
/* Update company infrastructure counts for objects build on canals owned by nobody. */
if (wc == WATER_CLASS_CANAL && owner != OWNER_NONE && (IsTileOwner(t, OWNER_NONE) || IsTileOwner(t, OWNER_WATER))) {
if (wc == WaterClass::Canal && owner != OWNER_NONE && (IsTileOwner(t, OWNER_NONE) || IsTileOwner(t, OWNER_WATER))) {
Company::Get(owner)->infrastructure.water++;
DirtyCompanyInfrastructureWindows(owner);
}
@@ -769,7 +769,7 @@ static bool TryBuildLightHouse()
}
/* Only build lighthouses at tiles where the border is sea. */
if (!IsTileType(tile, MP_WATER) || GetWaterClass(tile) != WATER_CLASS_SEA) return false;
if (!IsTileType(tile, MP_WATER) || GetWaterClass(tile) != WaterClass::Sea) return false;
for (int j = 0; j < 19; j++) {
int h;
@@ -873,7 +873,7 @@ static void ChangeTileOwner_Object(TileIndex tile, Owner old_owner, Owner new_ow
ObjectType type = GetObjectType(tile);
if ((type == OBJECT_OWNED_LAND || type >= NEW_OBJECT_OFFSET) && new_owner != INVALID_OWNER) {
SetTileOwner(tile, new_owner);
if (GetWaterClass(tile) == WATER_CLASS_CANAL) {
if (GetWaterClass(tile) == WaterClass::Canal) {
Company::Get(old_owner)->infrastructure.water--;
Company::Get(new_owner)->infrastructure.water++;
}

4
src/pathfinder/yapf/yapf_ship.cpp
View File

@@ -385,11 +385,11 @@ public:
/* Ocean/canal speed penalty. */
const ShipVehicleInfo *svi = ShipVehInfo(Yapf().GetVehicle()->engine_type);
uint8_t speed_frac = (GetEffectiveWaterClass(n.GetTile()) == WATER_CLASS_SEA) ? svi->ocean_speed_frac : svi->canal_speed_frac;
uint8_t speed_frac = (GetEffectiveWaterClass(n.GetTile()) == WaterClass::Sea) ? svi->ocean_speed_frac : svi->canal_speed_frac;
if (speed_frac > 0) c += YAPF_TILE_LENGTH * (1 + follower->tiles_skipped) * speed_frac / (256 - speed_frac);
/* Lock penalty. */
if (IsTileType(n.GetTile(), MP_WATER) && IsLock(n.GetTile()) && GetLockPart(n.GetTile()) == LOCK_PART_MIDDLE) {
if (IsTileType(n.GetTile(), MP_WATER) && IsLock(n.GetTile()) && GetLockPart(n.GetTile()) == LockPart::Middle) {
const uint canal_speed = svi->ApplyWaterClassSpeedFrac(svi->max_speed, false);
/* Cost is proportional to the vehicle's speed as the vehicle stops in the lock. */
c += (TILE_HEIGHT * YAPF_TILE_LENGTH * canal_speed) / 128;

52
src/saveload/afterload.cpp
View File

@@ -86,7 +86,7 @@ extern void ClearOldOrders();
* This as for example docks and shipdepots do not store
* whether the tile used to be canal or 'normal' water.
* @param t the tile to change.
* @param include_invalid_water_class Also consider WATER_CLASS_INVALID, i.e. industry tiles on land
* @param include_invalid_water_class Also consider WaterClass::Invalid, i.e. industry tiles on land
*/
void SetWaterClassDependingOnSurroundings(Tile t, bool include_invalid_water_class)
{
@@ -94,7 +94,7 @@ void SetWaterClassDependingOnSurroundings(Tile t, bool include_invalid_water_cla
* Note: Wrt. autosloping under industry tiles this is the most fool-proof behaviour. */
if (!IsTileFlat(t)) {
if (include_invalid_water_class) {
SetWaterClass(t, WATER_CLASS_INVALID);
SetWaterClass(t, WaterClass::Invalid);
return;
} else {
SlErrorCorrupt("Invalid water class for dry tile");
@@ -105,8 +105,8 @@ void SetWaterClassDependingOnSurroundings(Tile t, bool include_invalid_water_cla
MarkTileDirtyByTile(t);
if (TileX(t) == 0 || TileY(t) == 0 || TileX(t) == Map::MaxX() - 1 || TileY(t) == Map::MaxY() - 1) {
/* tiles at map borders are always WATER_CLASS_SEA */
SetWaterClass(t, WATER_CLASS_SEA);
/* tiles at map borders are always WaterClass::Sea */
SetWaterClass(t, WaterClass::Sea);
return;
}
@@ -123,9 +123,9 @@ void SetWaterClassDependingOnSurroundings(Tile t, bool include_invalid_water_cla
has_water = true;
} else if (!IsLock(neighbour)) {
switch (GetWaterClass(neighbour)) {
case WATER_CLASS_SEA: has_water = true; break;
case WATER_CLASS_CANAL: has_canal = true; break;
case WATER_CLASS_RIVER: has_river = true; break;
case WaterClass::Sea: has_water = true; break;
case WaterClass::Canal: has_canal = true; break;
case WaterClass::River: has_river = true; break;
default: SlErrorCorrupt("Invalid water class for tile");
}
}
@@ -146,16 +146,16 @@ void SetWaterClassDependingOnSurroundings(Tile t, bool include_invalid_water_cla
}
if (!has_water && !has_canal && !has_river && include_invalid_water_class) {
SetWaterClass(t, WATER_CLASS_INVALID);
SetWaterClass(t, WaterClass::Invalid);
return;
}
if (has_river && !has_canal) {
SetWaterClass(t, WATER_CLASS_RIVER);
SetWaterClass(t, WaterClass::River);
} else if (has_canal || !has_water) {
SetWaterClass(t, WATER_CLASS_CANAL);
SetWaterClass(t, WaterClass::Canal);
} else {
SetWaterClass(t, WATER_CLASS_SEA);
SetWaterClass(t, WaterClass::Sea);
}
}
@@ -853,12 +853,12 @@ bool AfterLoadGame()
switch (GB(t.m5(), 4, 4)) {
case 0x0: /* Previously WBL_TYPE_NORMAL, Clear water or coast. */
SetWaterTileType(t, HasBit(t.m5(), WBL_COAST_FLAG) ? WATER_TILE_COAST : WATER_TILE_CLEAR);
SetWaterTileType(t, HasBit(t.m5(), WBL_COAST_FLAG) ? WaterTileType::Coast : WaterTileType::Clear);
break;
case 0x1: SetWaterTileType(t, WATER_TILE_LOCK); break; /* Previously WBL_TYPE_LOCK */
case 0x8: SetWaterTileType(t, WATER_TILE_DEPOT); break; /* Previously WBL_TYPE_DEPOT */
default: SetWaterTileType(t, WATER_TILE_CLEAR); break; /* Shouldn't happen... */
case 0x1: SetWaterTileType(t, WaterTileType::Lock); break; /* Previously WBL_TYPE_LOCK */
case 0x8: SetWaterTileType(t, WaterTileType::Depot); break; /* Previously WBL_TYPE_DEPOT */
default: SetWaterTileType(t, WaterTileType::Clear); break; /* Shouldn't happen... */
}
}
}
@@ -870,7 +870,7 @@ bool AfterLoadGame()
default: break;
case MP_WATER:
if (GetWaterTileType(t) == WATER_TILE_LOCK && GetTileOwner(t) == OWNER_WATER) SetTileOwner(t, OWNER_NONE);
if (GetWaterTileType(t) == WaterTileType::Lock && GetTileOwner(t) == OWNER_WATER) SetTileOwner(t, OWNER_NONE);
break;
case MP_STATION: {
@@ -1740,7 +1740,7 @@ bool AfterLoadGame()
if (IsSavegameVersionBefore(SLV_82)) {
for (const auto t : Map::Iterate()) {
if (IsTileType(t, MP_WATER) &&
GetWaterTileType(t) == WATER_TILE_CLEAR &&
GetWaterTileType(t) == WaterTileType::Clear &&
GetTileOwner(t) == OWNER_WATER &&
TileHeight(t) != 0) {
SetTileOwner(t, OWNER_NONE);
@@ -1872,7 +1872,7 @@ bool AfterLoadGame()
break;
default:
SetWaterClass(t, WATER_CLASS_INVALID);
SetWaterClass(t, WaterClass::Invalid);
break;
}
break;
@@ -1883,7 +1883,7 @@ bool AfterLoadGame()
break;
case MP_OBJECT:
SetWaterClass(t, WATER_CLASS_INVALID);
SetWaterClass(t, WaterClass::Invalid);
break;
default:
@@ -1897,7 +1897,7 @@ bool AfterLoadGame()
for (auto t : Map::Iterate()) {
/* Move river flag and update canals to use water class */
if (IsTileType(t, MP_WATER)) {
if (GetWaterClass(t) != WATER_CLASS_RIVER) {
if (GetWaterClass(t) != WaterClass::River) {
if (IsWater(t)) {
Owner o = GetTileOwner(t);
if (o == OWNER_WATER) {
@@ -1907,7 +1907,7 @@ bool AfterLoadGame()
}
} else if (IsShipDepot(t)) {
Owner o = (Owner)t.m4(); // Original water owner
SetWaterClass(t, o == OWNER_WATER ? WATER_CLASS_SEA : WATER_CLASS_CANAL);
SetWaterClass(t, o == OWNER_WATER ? WaterClass::Sea : WaterClass::Canal);
}
}
}
@@ -1931,7 +1931,7 @@ bool AfterLoadGame()
(TileX(t) == 0 || TileY(t) == 0 || TileX(t) == Map::MaxX() - 1 || TileY(t) == Map::MaxY() - 1)) {
/* Some version 86 savegames have wrong water class at map borders (under buoy, or after removing buoy).
* This conversion has to be done before buoys with invalid owner are removed. */
SetWaterClass(t, WATER_CLASS_SEA);
SetWaterClass(t, WaterClass::Sea);
}
if (IsBuoyTile(t) || IsDriveThroughStopTile(t) || IsTileType(t, MP_WATER)) {
@@ -2003,7 +2003,7 @@ bool AfterLoadGame()
if (GetIndustrySpec(GetIndustryType(t))->behaviour.Test(IndustryBehaviour::BuiltOnWater)) {
SetWaterClassDependingOnSurroundings(t, true);
} else {
SetWaterClass(t, WATER_CLASS_INVALID);
SetWaterClass(t, WaterClass::Invalid);
}
}
@@ -2594,7 +2594,7 @@ bool AfterLoadGame()
for (const auto t : Map::Iterate()) {
if (!IsTileType(t, MP_STATION)) continue;
if (!IsBuoy(t) && !IsOilRig(t) && !(IsDock(t) && IsTileFlat(t))) {
SetWaterClass(t, WATER_CLASS_INVALID);
SetWaterClass(t, WaterClass::Invalid);
}
}
@@ -3149,7 +3149,7 @@ bool AfterLoadGame()
/* Move ships from lock slope to upper or lower position. */
for (Ship *s : Ship::Iterate()) {
/* Suitable tile? */
if (!IsTileType(s->tile, MP_WATER) || !IsLock(s->tile) || GetLockPart(s->tile) != LOCK_PART_MIDDLE) continue;
if (!IsTileType(s->tile, MP_WATER) || !IsLock(s->tile) || GetLockPart(s->tile) != LockPart::Middle) continue;
/* We don't need to adjust position when at the tile centre */
int x = s->x_pos & 0xF;
@@ -3205,7 +3205,7 @@ bool AfterLoadGame()
if (IsSavegameVersionBefore(SLV_TREES_WATER_CLASS)) {
/* Update water class for trees. */
for (const auto t : Map::Iterate()) {
if (IsTileType(t, MP_TREES)) SetWaterClass(t, GetTreeGround(t) == TREE_GROUND_SHORE ? WATER_CLASS_SEA : WATER_CLASS_INVALID);
if (IsTileType(t, MP_TREES)) SetWaterClass(t, GetTreeGround(t) == TREE_GROUND_SHORE ? WaterClass::Sea : WaterClass::Invalid);
}
}

6
src/saveload/company_sl.cpp
View File

@@ -197,7 +197,7 @@ void AfterLoadCompanyStats()
case StationType::Dock:
case StationType::Buoy:
if (GetWaterClass(tile) == WATER_CLASS_CANAL) {
if (GetWaterClass(tile) == WaterClass::Canal) {
if (c != nullptr) c->infrastructure.water++;
}
break;
@@ -212,7 +212,7 @@ void AfterLoadCompanyStats()
c = Company::GetIfValid(GetTileOwner(tile));
if (c != nullptr) {
if (IsShipDepot(tile)) c->infrastructure.water += LOCK_DEPOT_TILE_FACTOR;
if (IsLock(tile) && GetLockPart(tile) == LOCK_PART_MIDDLE) {
if (IsLock(tile) && GetLockPart(tile) == LockPart::Middle) {
/* The middle tile specifies the owner of the lock. */
c->infrastructure.water += 3 * LOCK_DEPOT_TILE_FACTOR; // the middle tile specifies the owner of the
break; // do not count the middle tile as canal
@@ -222,7 +222,7 @@ void AfterLoadCompanyStats()
[[fallthrough]];
case MP_OBJECT:
if (GetWaterClass(tile) == WATER_CLASS_CANAL) {
if (GetWaterClass(tile) == WaterClass::Canal) {
c = Company::GetIfValid(GetTileOwner(tile));
if (c != nullptr) c->infrastructure.water++;
}

2
src/saveload/oldloader_sl.cpp
View File

@@ -84,7 +84,7 @@ static void FixTTDMapArray()
SetTileType(tile, MP_WATER);
SetTileOwner(tile, OWNER_WATER);
tile.m2() = 0;
tile.m3() = 2; // WATER_CLASS_RIVER
tile.m3() = 2; // WaterClass::River
tile.m4() = Random();
tile.m5() = 0;
}

6
src/script/api/script_marine.cpp
View File

@@ -25,7 +25,7 @@
{
if (!::IsValidTile(tile)) return false;
return ::IsTileType(tile, MP_WATER) && ::GetWaterTileType(tile) == WATER_TILE_DEPOT;
return ::IsTileType(tile, MP_WATER) && ::GetWaterTileType(tile) == WaterTileType::Depot;
}
/* static */ bool ScriptMarine::IsDockTile(TileIndex tile)
@@ -46,7 +46,7 @@
{
if (!::IsValidTile(tile)) return false;
return ::IsTileType(tile, MP_WATER) && ::GetWaterTileType(tile) == WATER_TILE_LOCK;
return ::IsTileType(tile, MP_WATER) && ::GetWaterTileType(tile) == WaterTileType::Lock;
}
/* static */ bool ScriptMarine::IsCanalTile(TileIndex tile)
@@ -116,7 +116,7 @@
EnforceCompanyModeValid(false);
EnforcePrecondition(false, ::IsValidTile(tile));
return ScriptObject::Command<CMD_BUILD_CANAL>::Do(tile, tile, WATER_CLASS_CANAL, false);
return ScriptObject::Command<CMD_BUILD_CANAL>::Do(tile, tile, WaterClass::Canal, false);
}
/* static */ bool ScriptMarine::RemoveWaterDepot(TileIndex tile)

8
src/ship_cmd.cpp
View File

@@ -55,11 +55,11 @@ WaterClass GetEffectiveWaterClass(TileIndex tile)
if (HasTileWaterClass(tile)) return GetWaterClass(tile);
if (IsTileType(tile, MP_TUNNELBRIDGE)) {
assert(GetTunnelBridgeTransportType(tile) == TRANSPORT_WATER);
return WATER_CLASS_CANAL;
return WaterClass::Canal;
}
if (IsTileType(tile, MP_RAILWAY)) {
assert(GetRailGroundType(tile) == RailGroundType::HalfTileWater);
return WATER_CLASS_SEA;
return WaterClass::Sea;
}
NOT_REACHED();
}
@@ -233,7 +233,7 @@ void Ship::UpdateCache()
const ShipVehicleInfo *svi = ShipVehInfo(this->engine_type);
/* Get speed fraction for the current water type. Aqueducts are always canals. */
bool is_ocean = GetEffectiveWaterClass(this->tile) == WATER_CLASS_SEA;
bool is_ocean = GetEffectiveWaterClass(this->tile) == WaterClass::Sea;
uint raw_speed = GetVehicleProperty(this, PROP_SHIP_SPEED, svi->max_speed);
this->vcache.cached_max_speed = svi->ApplyWaterClassSpeedFrac(raw_speed, is_ocean);
@@ -566,7 +566,7 @@ static const ShipSubcoordData _ship_subcoord[DIAGDIR_END][TRACK_END] = {
static int ShipTestUpDownOnLock(const Ship *v)
{
/* Suitable tile? */
if (!IsTileType(v->tile, MP_WATER) || !IsLock(v->tile) || GetLockPart(v->tile) != LOCK_PART_MIDDLE) return 0;
if (!IsTileType(v->tile, MP_WATER) || !IsLock(v->tile) || GetLockPart(v->tile) != LockPart::Middle) return 0;
/* Must be at the centre of the lock */
if ((v->x_pos & 0xF) != 8 || (v->y_pos & 0xF) != 8) return 0;

10
src/station_cmd.cpp
View File

@@ -2702,7 +2702,7 @@ CommandCost CmdBuildAirport(DoCommandFlags flags, TileIndex tile, uint8_t airpor
for (AirportTileTableIterator iter(as->layouts[layout].tiles, tile); iter != INVALID_TILE; ++iter) {
Tile t(iter);
MakeAirport(t, st->owner, st->index, iter.GetStationGfx(), WATER_CLASS_INVALID);
MakeAirport(t, st->owner, st->index, iter.GetStationGfx(), WaterClass::Invalid);
SetStationTileRandomBits(t, GB(Random(), 0, 4));
st->airport.Add(iter);
@@ -2946,7 +2946,7 @@ CommandCost CmdBuildDock(DoCommandFlags flags, TileIndex tile, StationID station
* This is needed as we've cleared that tile before.
* Clearing object tiles may result in water tiles which are already accounted for in the water infrastructure total.
* See: MakeWaterKeepingClass() */
if (wc == WATER_CLASS_CANAL && !(HasTileWaterClass(flat_tile) && GetWaterClass(flat_tile) == WATER_CLASS_CANAL && IsTileOwner(flat_tile, _current_company))) {
if (wc == WaterClass::Canal && !(HasTileWaterClass(flat_tile) && GetWaterClass(flat_tile) == WaterClass::Canal && IsTileOwner(flat_tile, _current_company))) {
Company::Get(st->owner)->infrastructure.water++;
}
Company::Get(st->owner)->infrastructure.station += 2;
@@ -3357,8 +3357,8 @@ static void DrawTile_Station(TileInfo *ti)
} else {
assert(IsDock(ti->tile));
TileIndex water_tile = ti->tile + TileOffsByDiagDir(GetDockDirection(ti->tile));
WaterClass wc = HasTileWaterClass(water_tile) ? GetWaterClass(water_tile) : WATER_CLASS_INVALID;
if (wc == WATER_CLASS_SEA) {
WaterClass wc = HasTileWaterClass(water_tile) ? GetWaterClass(water_tile) : WaterClass::Invalid;
if (wc == WaterClass::Sea) {
DrawShoreTile(ti->tileh);
} else {
DrawClearLandTile(ti, 3);
@@ -4748,7 +4748,7 @@ static void ChangeTileOwner_Station(TileIndex tile, Owner old_owner, Owner new_o
case StationType::Buoy:
case StationType::Dock:
if (GetWaterClass(tile) == WATER_CLASS_CANAL) {
if (GetWaterClass(tile) == WaterClass::Canal) {
old_company->infrastructure.water--;
new_company->infrastructure.water++;
}

2
src/station_map.h
View File

@@ -714,7 +714,7 @@ inline uint8_t GetStationTileRandomBits(Tile t)
* @param section the StationGfx to be used for this tile
* @param wc The water class of the station
*/
inline void MakeStation(Tile t, Owner o, StationID sid, StationType st, uint8_t section, WaterClass wc = WATER_CLASS_INVALID)
inline void MakeStation(Tile t, Owner o, StationID sid, StationType st, uint8_t section, WaterClass wc = WaterClass::Invalid)
{
SetTileType(t, MP_STATION);
SetTileOwner(t, o);

16
src/table/water_land.h
View File

@@ -44,14 +44,14 @@ static const DrawTileSeqStruct _shipdepot_display_se_seq[] = {
TILE_SEQ_LINE( 15, 0, 0, 1, 16, 0x14, 0xFE7 | (1 << PALETTE_MODIFIER_COLOUR))
};
static const DrawTileSpriteSpan _shipdepot_display_data[][DEPOT_PART_END] = {
static const DrawTileSpriteSpan _shipdepot_display_data[][to_underlying(DepotPart::End)] = {
{ // AXIS_X
TILE_SPRITE_LINE(0xFDD, _shipdepot_display_ne_seq) // DEPOT_PART_NORTH
TILE_SPRITE_LINE(0xFDD, _shipdepot_display_sw_seq) // DEPOT_PART_SOUTH
TILE_SPRITE_LINE(0xFDD, _shipdepot_display_ne_seq) // DepotPart::North
TILE_SPRITE_LINE(0xFDD, _shipdepot_display_sw_seq) // DepotPart::South
},
{ // AXIS_Y
TILE_SPRITE_LINE(0xFDD, _shipdepot_display_nw_seq) // DEPOT_PART_NORTH
TILE_SPRITE_LINE(0xFDD, _shipdepot_display_se_seq) // DEPOT_PART_SOUTH
TILE_SPRITE_LINE(0xFDD, _shipdepot_display_nw_seq) // DepotPart::North
TILE_SPRITE_LINE(0xFDD, _shipdepot_display_se_seq) // DepotPart::South
},
};
@@ -123,21 +123,21 @@ static const DrawTileSeqStruct _lock_display_upper_nw_seq[] = {
};
static const DrawTileSpriteSpan _lock_display_data[][DIAGDIR_END] = {
{ // LOCK_PART_MIDDLE
{ // LockPart::Middle
TILE_SPRITE_LINE(1, _lock_display_middle_ne_seq) // NE
TILE_SPRITE_LINE(0, _lock_display_middle_se_seq) // SE
TILE_SPRITE_LINE(2, _lock_display_middle_sw_seq) // SW
TILE_SPRITE_LINE(3, _lock_display_middle_nw_seq) // NW
},
{ // LOCK_PART_LOWER
{ // LockPart::Lower
TILE_SPRITE_LINE(0xFDD, _lock_display_lower_ne_seq) // NE
TILE_SPRITE_LINE(0xFDD, _lock_display_lower_se_seq) // SE
TILE_SPRITE_LINE(0xFDD, _lock_display_lower_sw_seq) // SW
TILE_SPRITE_LINE(0xFDD, _lock_display_lower_nw_seq) // NW
},
{ // LOCK_PART_UPPER
{ // LockPart::Upper
TILE_SPRITE_LINE(0xFDD, _lock_display_upper_ne_seq) // NE
TILE_SPRITE_LINE(0xFDD, _lock_display_upper_se_seq) // SE
TILE_SPRITE_LINE(0xFDD, _lock_display_upper_sw_seq) // SW

4
src/tree_map.h
View File

@@ -146,7 +146,7 @@ inline void SetTreeGroundDensity(Tile t, TreeGround g, uint d)
assert(IsTileType(t, MP_TREES)); // XXX incomplete
SB(t.m2(), 4, 2, d);
SB(t.m2(), 6, 3, g);
SetWaterClass(t, g == TREE_GROUND_SHORE ? WATER_CLASS_SEA : WATER_CLASS_INVALID);
SetWaterClass(t, g == TREE_GROUND_SHORE ? WaterClass::Sea : WaterClass::Invalid);
}
/**
@@ -245,7 +245,7 @@ inline void MakeTree(Tile t, TreeType type, uint count, TreeGrowthStage growth,
{
SetTileType(t, MP_TREES);
SetTileOwner(t, OWNER_NONE);
SetWaterClass(t, ground == TREE_GROUND_SHORE ? WATER_CLASS_SEA : WATER_CLASS_INVALID);
SetWaterClass(t, ground == TREE_GROUND_SHORE ? WaterClass::Sea : WaterClass::Invalid);
t.m2() = ground << 6 | density << 4 | 0;
t.m3() = type;
t.m4() = 0 << 5 | 0 << 2;

2
src/tunnelbridge_cmd.cpp
View File

@@ -1462,7 +1462,7 @@ static void DrawTile_TunnelBridge(TileInfo *ti)
if (!HasTunnelBridgeSnowOrDesert(ti->tile)) {
TileIndex next = ti->tile + TileOffsByDiagDir(tunnelbridge_direction);
if (ti->tileh != SLOPE_FLAT && ti->z == 0 && HasTileWaterClass(next) && GetWaterClass(next) == WATER_CLASS_SEA) {
if (ti->tileh != SLOPE_FLAT && ti->z == 0 && HasTileWaterClass(next) && GetWaterClass(next) == WaterClass::Sea) {
DrawShoreTile(ti->tileh);
} else {
DrawClearLandTile(ti, 3);

138
src/water_cmd.cpp
View File

@@ -151,14 +151,14 @@ CommandCost CmdBuildShipDepot(DoCommandFlags flags, TileIndex tile, Axis axis)
/* Update infrastructure counts after the tile clears earlier.
* Clearing object tiles may result in water tiles which are already accounted for in the water infrastructure total.
* See: MakeWaterKeepingClass() */
if (wc1 == WATER_CLASS_CANAL && !(HasTileWaterClass(tile) && GetWaterClass(tile) == WATER_CLASS_CANAL && IsTileOwner(tile, _current_company))) new_water_infra++;
if (wc2 == WATER_CLASS_CANAL && !(HasTileWaterClass(tile2) && GetWaterClass(tile2) == WATER_CLASS_CANAL && IsTileOwner(tile2, _current_company))) new_water_infra++;
if (wc1 == WaterClass::Canal && !(HasTileWaterClass(tile) && GetWaterClass(tile) == WaterClass::Canal && IsTileOwner(tile, _current_company))) new_water_infra++;
if (wc2 == WaterClass::Canal && !(HasTileWaterClass(tile2) && GetWaterClass(tile2) == WaterClass::Canal && IsTileOwner(tile2, _current_company))) new_water_infra++;
Company::Get(_current_company)->infrastructure.water += new_water_infra;
DirtyCompanyInfrastructureWindows(_current_company);
MakeShipDepot(tile, _current_company, depot->index, DEPOT_PART_NORTH, axis, wc1);
MakeShipDepot(tile2, _current_company, depot->index, DEPOT_PART_SOUTH, axis, wc2);
MakeShipDepot(tile, _current_company, depot->index, DepotPart::North, axis, wc1);
MakeShipDepot(tile2, _current_company, depot->index, DepotPart::South, axis, wc2);
CheckForDockingTile(tile);
CheckForDockingTile(tile2);
MarkTileDirtyByTile(tile);
@@ -174,7 +174,7 @@ bool IsPossibleDockingTile(Tile t)
assert(IsValidTile(t));
switch (GetTileType(t)) {
case MP_WATER:
if (IsLock(t) && GetLockPart(t) == LOCK_PART_MIDDLE) return false;
if (IsLock(t) && GetLockPart(t) == LockPart::Middle) return false;
[[fallthrough]];
case MP_RAILWAY:
case MP_STATION:
@@ -223,7 +223,7 @@ void MakeWaterKeepingClass(TileIndex tile, Owner o)
auto [slope, z] = GetTileSlopeZ(tile);
if (slope != SLOPE_FLAT) {
if (wc == WATER_CLASS_CANAL) {
if (wc == WaterClass::Canal) {
/* If we clear the canal, we have to remove it from the infrastructure count as well. */
Company *c = Company::GetIfValid(o);
if (c != nullptr) {
@@ -231,16 +231,16 @@ void MakeWaterKeepingClass(TileIndex tile, Owner o)
DirtyCompanyInfrastructureWindows(c->index);
}
/* Sloped canals are locks and no natural water remains whatever the slope direction */
wc = WATER_CLASS_INVALID;
wc = WaterClass::Invalid;
}
/* Only river water should be restored on appropriate slopes. Other water would be invalid on slopes */
if (wc != WATER_CLASS_RIVER || GetInclinedSlopeDirection(slope) == INVALID_DIAGDIR) {
wc = WATER_CLASS_INVALID;
if (wc != WaterClass::River || GetInclinedSlopeDirection(slope) == INVALID_DIAGDIR) {
wc = WaterClass::Invalid;
}
}
if (wc == WATER_CLASS_SEA && z > 0) {
if (wc == WaterClass::Sea && z > 0) {
/* Update company infrastructure count. */
Company *c = Company::GetIfValid(o);
if (c != nullptr) {
@@ -248,7 +248,7 @@ void MakeWaterKeepingClass(TileIndex tile, Owner o)
DirtyCompanyInfrastructureWindows(c->index);
}
wc = WATER_CLASS_CANAL;
wc = WaterClass::Canal;
}
/* Zero map array and terminate animation */
@@ -256,13 +256,13 @@ void MakeWaterKeepingClass(TileIndex tile, Owner o)
/* Maybe change to water */
switch (wc) {
case WATER_CLASS_SEA: MakeSea(tile); break;
case WATER_CLASS_CANAL: MakeCanal(tile, o, Random()); break;
case WATER_CLASS_RIVER: MakeRiver(tile, Random()); break;
case WaterClass::Sea: MakeSea(tile); break;
case WaterClass::Canal: MakeCanal(tile, o, Random()); break;
case WaterClass::River: MakeRiver(tile, Random()); break;
default: break;
}
if (wc != WATER_CLASS_INVALID) CheckForDockingTile(tile);
if (wc != WaterClass::Invalid) CheckForDockingTile(tile);
MarkTileDirtyByTile(tile);
}
@@ -290,7 +290,7 @@ static CommandCost RemoveShipDepot(TileIndex tile, DoCommandFlags flags)
Company *c = Company::GetIfValid(GetTileOwner(tile));
if (c != nullptr) {
c->infrastructure.water -= 2 * LOCK_DEPOT_TILE_FACTOR;
if (do_clear && GetWaterClass(tile) == WATER_CLASS_CANAL) c->infrastructure.water--;
if (do_clear && GetWaterClass(tile) == WaterClass::Canal) c->infrastructure.water--;
DirtyCompanyInfrastructureWindows(c->index);
}
@@ -308,10 +308,10 @@ static CommandCost RemoveShipDepot(TileIndex tile, DoCommandFlags flags)
*/
static uint8_t GetLockPartMinimalBridgeHeight(LockPart lock_part)
{
static constexpr uint8_t MINIMAL_BRIDGE_HEIGHT[LOCK_PART_END] = {
2, // LOCK_PART_MIDDLE
3, // LOCK_PART_LOWER
2, // LOCK_PART_UPPER
static constexpr uint8_t MINIMAL_BRIDGE_HEIGHT[to_underlying(LockPart::End)] = {
2, // LockPart::Middle
3, // LockPart::Lower
2, // LockPart::Upper
};
return MINIMAL_BRIDGE_HEIGHT[to_underlying(lock_part)];
}
@@ -334,7 +334,7 @@ static CommandCost DoBuildLock(TileIndex tile, DiagDirection dir, DoCommandFlags
if (ret.Failed()) return ret;
/* middle tile */
WaterClass wc_middle = HasTileWaterGround(tile) ? GetWaterClass(tile) : WATER_CLASS_CANAL;
WaterClass wc_middle = HasTileWaterGround(tile) ? GetWaterClass(tile) : WaterClass::Canal;
ret = Command<CMD_LANDSCAPE_CLEAR>::Do(flags, tile);
if (ret.Failed()) return ret;
cost.AddCost(ret.GetCost());
@@ -349,7 +349,7 @@ static CommandCost DoBuildLock(TileIndex tile, DiagDirection dir, DoCommandFlags
if (!IsTileFlat(tile - delta)) {
return CommandCost(STR_ERROR_LAND_SLOPED_IN_WRONG_DIRECTION);
}
WaterClass wc_lower = IsWaterTile(tile - delta) ? GetWaterClass(tile - delta) : WATER_CLASS_CANAL;
WaterClass wc_lower = IsWaterTile(tile - delta) ? GetWaterClass(tile - delta) : WaterClass::Canal;
/* upper tile */
if (!IsWaterTile(tile + delta)) {
@@ -361,9 +361,9 @@ static CommandCost DoBuildLock(TileIndex tile, DiagDirection dir, DoCommandFlags
if (!IsTileFlat(tile + delta)) {
return CommandCost(STR_ERROR_LAND_SLOPED_IN_WRONG_DIRECTION);
}
WaterClass wc_upper = IsWaterTile(tile + delta) ? GetWaterClass(tile + delta) : WATER_CLASS_CANAL;
WaterClass wc_upper = IsWaterTile(tile + delta) ? GetWaterClass(tile + delta) : WaterClass::Canal;
for (LockPart lock_part = LOCK_PART_MIDDLE; TileIndex t : {tile, tile - delta, tile + delta}) {
for (LockPart lock_part = LockPart::Middle; TileIndex t : {tile, tile - delta, tile + delta}) {
if (IsBridgeAbove(t) && GetBridgeHeight(GetSouthernBridgeEnd(t)) < GetTileMaxZ(t) + GetLockPartMinimalBridgeHeight(lock_part)) {
int height_diff = (GetTileMaxZ(tile) + GetLockPartMinimalBridgeHeight(lock_part) - GetBridgeHeight(GetSouthernBridgeEnd(t))) * TILE_HEIGHT_STEP;
return CommandCostWithParam(STR_ERROR_BRIDGE_TOO_LOW_FOR_LOCK, height_diff);
@@ -428,7 +428,7 @@ static CommandCost RemoveLock(TileIndex tile, DoCommandFlags flags)
DirtyCompanyInfrastructureWindows(c->index);
}
if (GetWaterClass(tile) == WATER_CLASS_RIVER) {
if (GetWaterClass(tile) == WaterClass::River) {
MakeRiver(tile, Random());
} else {
DoClearSquare(tile);
@@ -494,7 +494,7 @@ CommandCost CmdBuildCanal(DoCommandFlags flags, TileIndex tile, TileIndex start_
if (start_tile >= Map::Size() || !IsValidWaterClass(wc)) return CMD_ERROR;
/* Outside of the editor you can only build canals, not oceans */
if (wc != WATER_CLASS_CANAL && _game_mode != GM_EDITOR) return CMD_ERROR;
if (wc != WaterClass::Canal && _game_mode != GM_EDITOR) return CMD_ERROR;
CommandCost cost(EXPENSES_CONSTRUCTION);
@@ -504,7 +504,7 @@ CommandCost CmdBuildCanal(DoCommandFlags flags, TileIndex tile, TileIndex start_
CommandCost ret;
Slope slope = GetTileSlope(current_tile);
if (slope != SLOPE_FLAT && (wc != WATER_CLASS_RIVER || !IsInclinedSlope(slope))) {
if (slope != SLOPE_FLAT && (wc != WaterClass::River || !IsInclinedSlope(slope))) {
return CommandCost(STR_ERROR_FLAT_LAND_REQUIRED);
}
@@ -528,7 +528,7 @@ CommandCost CmdBuildCanal(DoCommandFlags flags, TileIndex tile, TileIndex start_
}
switch (wc) {
case WATER_CLASS_RIVER:
case WaterClass::River:
MakeRiver(current_tile, Random());
if (_game_mode == GM_EDITOR) {
/* Remove desert directly around the river tile. */
@@ -538,7 +538,7 @@ CommandCost CmdBuildCanal(DoCommandFlags flags, TileIndex tile, TileIndex start_
}
break;
case WATER_CLASS_SEA:
case WaterClass::Sea:
if (TileHeight(current_tile) == 0) {
MakeSea(current_tile);
break;
@@ -572,7 +572,7 @@ CommandCost CmdBuildCanal(DoCommandFlags flags, TileIndex tile, TileIndex start_
static CommandCost ClearTile_Water(TileIndex tile, DoCommandFlags flags)
{
switch (GetWaterTileType(tile)) {
case WATER_TILE_CLEAR: {
case WaterTileType::Clear: {
if (flags.Test(DoCommandFlag::NoWater)) return CommandCost(STR_ERROR_CAN_T_BUILD_ON_WATER);
Money base_cost = IsCanal(tile) ? _price[PR_CLEAR_CANAL] : _price[PR_CLEAR_WATER];
@@ -605,7 +605,7 @@ static CommandCost ClearTile_Water(TileIndex tile, DoCommandFlags flags)
return CommandCost(EXPENSES_CONSTRUCTION, base_cost);
}
case WATER_TILE_COAST: {
case WaterTileType::Coast: {
Slope slope = GetTileSlope(tile);
/* Make sure no vehicle is on the tile */
@@ -624,21 +624,21 @@ static CommandCost ClearTile_Water(TileIndex tile, DoCommandFlags flags)
}
}
case WATER_TILE_LOCK: {
static const TileIndexDiffC _lock_tomiddle_offs[][DIAGDIR_END] = {
case WaterTileType::Lock: {
static const TileIndexDiffC _lock_tomiddle_offs[to_underlying(LockPart::End)][DIAGDIR_END] = {
/* NE SE SW NW */
{ { 0, 0}, {0, 0}, { 0, 0}, {0, 0} }, // LOCK_PART_MIDDLE
{ {-1, 0}, {0, 1}, { 1, 0}, {0, -1} }, // LOCK_PART_LOWER
{ { 1, 0}, {0, -1}, {-1, 0}, {0, 1} }, // LOCK_PART_UPPER
{ { 0, 0}, {0, 0}, { 0, 0}, {0, 0} }, // LockPart::Middle
{ {-1, 0}, {0, 1}, { 1, 0}, {0, -1} }, // LockPart::Lower
{ { 1, 0}, {0, -1}, {-1, 0}, {0, 1} }, // LockPart::Upper
};
if (flags.Test(DoCommandFlag::Auto)) return CommandCost(STR_ERROR_BUILDING_MUST_BE_DEMOLISHED);
if (_current_company == OWNER_WATER) return CMD_ERROR;
/* move to the middle tile.. */
return RemoveLock(tile + ToTileIndexDiff(_lock_tomiddle_offs[GetLockPart(tile)][GetLockDirection(tile)]), flags);
return RemoveLock(tile + ToTileIndexDiff(_lock_tomiddle_offs[to_underlying(GetLockPart(tile))][GetLockDirection(tile)]), flags);
}
case WATER_TILE_DEPOT:
case WaterTileType::Depot:
if (flags.Test(DoCommandFlag::Auto)) return CommandCost(STR_ERROR_BUILDING_MUST_BE_DEMOLISHED);
return RemoveShipDepot(tile, flags);
@@ -661,10 +661,10 @@ bool IsWateredTile(TileIndex tile, Direction from)
case MP_WATER:
switch (GetWaterTileType(tile)) {
default: NOT_REACHED();
case WATER_TILE_DEPOT: case WATER_TILE_CLEAR: return true;
case WATER_TILE_LOCK: return DiagDirToAxis(GetLockDirection(tile)) == DiagDirToAxis(DirToDiagDir(from));
case WaterTileType::Depot: case WaterTileType::Clear: return true;
case WaterTileType::Lock: return DiagDirToAxis(GetLockDirection(tile)) == DiagDirToAxis(DirToDiagDir(from));
case WATER_TILE_COAST:
case WaterTileType::Coast:
switch (GetTileSlope(tile)) {
case SLOPE_W: return (from == DIR_SE) || (from == DIR_E) || (from == DIR_NE);
case SLOPE_S: return (from == DIR_NE) || (from == DIR_N) || (from == DIR_NW);
@@ -839,8 +839,8 @@ static void DrawWaterTileStruct(const TileInfo *ti, std::span<const DrawTileSeqS
/** Draw a lock tile. */
static void DrawWaterLock(const TileInfo *ti)
{
int part = GetLockPart(ti->tile);
const DrawTileSprites &dts = _lock_display_data[part][GetLockDirection(ti->tile)];
LockPart part = GetLockPart(ti->tile);
const DrawTileSprites &dts = _lock_display_data[to_underlying(part)][GetLockDirection(ti->tile)];
/* Draw ground sprite. */
SpriteID image = dts.ground.sprite;
@@ -868,7 +868,7 @@ static void DrawWaterLock(const TileInfo *ti)
if (base == 0) {
/* If no custom graphics, use defaults. */
base = SPR_LOCK_BASE;
uint8_t z_threshold = part == LOCK_PART_UPPER ? 8 : 0;
uint8_t z_threshold = part == LockPart::Upper ? 8 : 0;
zoffs = ti->z > z_threshold ? 24 : 0;
}
@@ -879,7 +879,7 @@ static void DrawWaterLock(const TileInfo *ti)
static void DrawWaterDepot(const TileInfo *ti)
{
DrawWaterClassGround(ti);
DrawWaterTileStruct(ti, _shipdepot_display_data[GetShipDepotAxis(ti->tile)][GetShipDepotPart(ti->tile)].seq, 0, 0, GetCompanyPalette(GetTileOwner(ti->tile)), CF_END);
DrawWaterTileStruct(ti, _shipdepot_display_data[GetShipDepotAxis(ti->tile)][to_underlying(GetShipDepotPart(ti->tile))].seq, 0, 0, GetCompanyPalette(GetTileOwner(ti->tile)), CF_END);
}
static void DrawRiverWater(const TileInfo *ti)
@@ -940,9 +940,9 @@ void DrawShoreTile(Slope tileh)
void DrawWaterClassGround(const TileInfo *ti)
{
switch (GetWaterClass(ti->tile)) {
case WATER_CLASS_SEA: DrawSeaWater(ti->tile); break;
case WATER_CLASS_CANAL: DrawCanalWater(ti->tile); break;
case WATER_CLASS_RIVER: DrawRiverWater(ti); break;
case WaterClass::Sea: DrawSeaWater(ti->tile); break;
case WaterClass::Canal: DrawCanalWater(ti->tile); break;
case WaterClass::River: DrawRiverWater(ti); break;
default: NOT_REACHED();
}
}
@@ -950,27 +950,27 @@ void DrawWaterClassGround(const TileInfo *ti)
static void DrawTile_Water(TileInfo *ti)
{
switch (GetWaterTileType(ti->tile)) {
case WATER_TILE_CLEAR:
case WaterTileType::Clear:
DrawWaterClassGround(ti);
/* A plain water tile can be traversed in any direction, so setting blocked pillars here would mean all bridges
* with edges would have no pillars above water. Instead prefer current behaviour of ships passing through. */
DrawBridgeMiddle(ti, {});
break;
case WATER_TILE_COAST: {
case WaterTileType::Coast: {
DrawShoreTile(ti->tileh);
DrawBridgeMiddle(ti, {});
break;
}
case WATER_TILE_LOCK:
case WaterTileType::Lock:
DrawWaterLock(ti);
DrawBridgeMiddle(ti, DiagDirToAxis(GetLockDirection(ti->tile)) == AXIS_X
? BridgePillarFlags{BridgePillarFlag::EdgeNE, BridgePillarFlag::EdgeSW}
: BridgePillarFlags{BridgePillarFlag::EdgeNW, BridgePillarFlag::EdgeSE});
break;
case WATER_TILE_DEPOT:
case WaterTileType::Depot:
DrawWaterDepot(ti);
break;
}
@@ -978,7 +978,7 @@ static void DrawTile_Water(TileInfo *ti)
void DrawShipDepotSprite(int x, int y, Axis axis, DepotPart part)
{
const DrawTileSprites &dts = _shipdepot_display_data[axis][part];
const DrawTileSprites &dts = _shipdepot_display_data[axis][to_underlying(part)];
DrawSprite(dts.ground.sprite, dts.ground.pal, x, y);
DrawOrigTileSeqInGUI(x, y, &dts, GetCompanyPalette(_local_company));
@@ -1000,17 +1000,17 @@ static Foundation GetFoundation_Water(TileIndex, Slope)
static void GetTileDesc_Water(TileIndex tile, TileDesc &td)
{
switch (GetWaterTileType(tile)) {
case WATER_TILE_CLEAR:
case WaterTileType::Clear:
switch (GetWaterClass(tile)) {
case WATER_CLASS_SEA: td.str = STR_LAI_WATER_DESCRIPTION_WATER; break;
case WATER_CLASS_CANAL: td.str = STR_LAI_WATER_DESCRIPTION_CANAL; break;
case WATER_CLASS_RIVER: td.str = STR_LAI_WATER_DESCRIPTION_RIVER; break;
case WaterClass::Sea: td.str = STR_LAI_WATER_DESCRIPTION_WATER; break;
case WaterClass::Canal: td.str = STR_LAI_WATER_DESCRIPTION_CANAL; break;
case WaterClass::River: td.str = STR_LAI_WATER_DESCRIPTION_RIVER; break;
default: NOT_REACHED();
}
break;
case WATER_TILE_COAST: td.str = STR_LAI_WATER_DESCRIPTION_COAST_OR_RIVERBANK; break;
case WATER_TILE_LOCK : td.str = STR_LAI_WATER_DESCRIPTION_LOCK; break;
case WATER_TILE_DEPOT:
case WaterTileType::Coast: td.str = STR_LAI_WATER_DESCRIPTION_COAST_OR_RIVERBANK; break;
case WaterTileType::Lock : td.str = STR_LAI_WATER_DESCRIPTION_LOCK; break;
case WaterTileType::Depot:
td.str = STR_LAI_WATER_DESCRIPTION_SHIP_DEPOT;
td.build_date = Depot::GetByTile(tile)->build_date;
break;
@@ -1129,7 +1129,7 @@ FloodingBehaviour GetFloodingBehaviour(TileIndex tile)
case MP_STATION:
case MP_INDUSTRY:
case MP_OBJECT:
return (GetWaterClass(tile) == WATER_CLASS_SEA) ? FLOOD_ACTIVE : FLOOD_NONE;
return (GetWaterClass(tile) == WaterClass::Sea) ? FLOOD_ACTIVE : FLOOD_NONE;
case MP_RAILWAY:
if (GetRailGroundType(tile) == RailGroundType::HalfTileWater) {
@@ -1366,10 +1366,10 @@ static TrackStatus GetTileTrackStatus_Water(TileIndex tile, TransportType mode,
if (mode != TRANSPORT_WATER) return 0;
switch (GetWaterTileType(tile)) {
case WATER_TILE_CLEAR: ts = IsTileFlat(tile) ? TRACK_BIT_ALL : TRACK_BIT_NONE; break;
case WATER_TILE_COAST: ts = coast_tracks[GetTileSlope(tile) & 0xF]; break;
case WATER_TILE_LOCK: ts = DiagDirToDiagTrackBits(GetLockDirection(tile)); break;
case WATER_TILE_DEPOT: ts = AxisToTrackBits(GetShipDepotAxis(tile)); break;
case WaterTileType::Clear: ts = IsTileFlat(tile) ? TRACK_BIT_ALL : TRACK_BIT_NONE; break;
case WaterTileType::Coast: ts = coast_tracks[GetTileSlope(tile) & 0xF]; break;
case WaterTileType::Lock: ts = DiagDirToDiagTrackBits(GetLockDirection(tile)); break;
case WaterTileType::Depot: ts = AxisToTrackBits(GetShipDepotAxis(tile)); break;
default: return 0;
}
if (TileX(tile) == 0) {
@@ -1385,7 +1385,7 @@ static TrackStatus GetTileTrackStatus_Water(TileIndex tile, TransportType mode,
static bool ClickTile_Water(TileIndex tile)
{
if (GetWaterTileType(tile) == WATER_TILE_DEPOT) {
if (GetWaterTileType(tile) == WaterTileType::Depot) {
ShowDepotWindow(GetShipDepotNorthTile(tile), VEH_SHIP);
return true;
}
@@ -1396,7 +1396,7 @@ static void ChangeTileOwner_Water(TileIndex tile, Owner old_owner, Owner new_own
{
if (!IsTileOwner(tile, old_owner)) return;
bool is_lock_middle = IsLock(tile) && GetLockPart(tile) == LOCK_PART_MIDDLE;
bool is_lock_middle = IsLock(tile) && GetLockPart(tile) == LockPart::Middle;
/* No need to dirty company windows here, we'll redraw the whole screen anyway. */
if (is_lock_middle) Company::Get(old_owner)->infrastructure.water -= 3 * LOCK_DEPOT_TILE_FACTOR; // Lock has three parts.
@@ -1404,7 +1404,7 @@ static void ChangeTileOwner_Water(TileIndex tile, Owner old_owner, Owner new_own
if (is_lock_middle) Company::Get(new_owner)->infrastructure.water += 3 * LOCK_DEPOT_TILE_FACTOR; // Lock has three parts.
/* Only subtract from the old owner here if the new owner is valid,
* otherwise we clear ship depots and canal water below. */
if (GetWaterClass(tile) == WATER_CLASS_CANAL && !is_lock_middle) {
if (GetWaterClass(tile) == WaterClass::Canal && !is_lock_middle) {
Company::Get(old_owner)->infrastructure.water--;
Company::Get(new_owner)->infrastructure.water++;
}
@@ -1423,7 +1423,7 @@ static void ChangeTileOwner_Water(TileIndex tile, Owner old_owner, Owner new_own
/* Set owner of canals and locks ... and also canal under dock there was before.
* Check if the new owner after removing depot isn't OWNER_WATER. */
if (IsTileOwner(tile, old_owner)) {
if (GetWaterClass(tile) == WATER_CLASS_CANAL && !is_lock_middle) Company::Get(old_owner)->infrastructure.water--;
if (GetWaterClass(tile) == WaterClass::Canal && !is_lock_middle) Company::Get(old_owner)->infrastructure.water--;
SetTileOwner(tile, OWNER_NONE);
}
}

98
src/water_map.h
View File

@@ -28,19 +28,19 @@ static constexpr uint8_t WBL_DEPOT_PART = 0; ///< Depot part flag.
static constexpr uint8_t WBL_DEPOT_AXIS = 1; ///< Depot axis flag.
/** Available water tile types. */
enum WaterTileType : uint8_t {
WATER_TILE_CLEAR, ///< Plain water.
WATER_TILE_COAST, ///< Coast.
WATER_TILE_LOCK, ///< Water lock.
WATER_TILE_DEPOT, ///< Water Depot.
enum class WaterTileType : uint8_t {
Clear = 0, ///< Plain water.
Coast = 1, ///< Coast.
Lock = 2, ///< Water lock.
Depot = 3, ///< Water Depot.
};
/** classes of water (for #WATER_TILE_CLEAR water tile type). */
enum WaterClass : uint8_t {
WATER_CLASS_SEA, ///< Sea.
WATER_CLASS_CANAL, ///< Canal.
WATER_CLASS_RIVER, ///< River.
WATER_CLASS_INVALID, ///< Used for industry tiles on land (also for oilrig if newgrf says so).
/** classes of water (for #WaterTileType::Clear water tile type). */
enum class WaterClass : uint8_t {
Sea = 0, ///< Sea.
Canal = 1, ///< Canal.
River = 2, ///< River.
Invalid = 3, ///< Used for industry tiles on land (also for oilrig if newgrf says so).
};
/**
@@ -51,22 +51,22 @@ enum WaterClass : uint8_t {
*/
inline bool IsValidWaterClass(WaterClass wc)
{
return wc < WATER_CLASS_INVALID;
return wc < WaterClass::Invalid;
}
/** Sections of the water depot. */
enum DepotPart : uint8_t {
DEPOT_PART_NORTH = 0, ///< Northern part of a depot.
DEPOT_PART_SOUTH = 1, ///< Southern part of a depot.
DEPOT_PART_END
enum class DepotPart : uint8_t {
North = 0, ///< Northern part of a depot.
South = 1, ///< Southern part of a depot.
End,
};
/** Sections of the water lock. */
enum LockPart : uint8_t {
LOCK_PART_MIDDLE = 0, ///< Middle part of a lock.
LOCK_PART_LOWER = 1, ///< Lower part of a lock.
LOCK_PART_UPPER = 2, ///< Upper part of a lock.
LOCK_PART_END,
enum class LockPart : uint8_t {
Middle = 0, ///< Middle part of a lock.
Lower = 1, ///< Lower part of a lock.
Upper = 2, ///< Upper part of a lock.
End,
};
DECLARE_INCREMENT_DECREMENT_OPERATORS(LockPart);
@@ -114,7 +114,7 @@ inline bool HasTileWaterClass(Tile t)
inline WaterClass GetWaterClass(Tile t)
{
assert(HasTileWaterClass(t));
return (WaterClass)GB(t.m1(), 5, 2);
return static_cast<WaterClass>(GB(t.m1(), 5, 2));
}
/**
@@ -126,7 +126,7 @@ inline WaterClass GetWaterClass(Tile t)
inline void SetWaterClass(Tile t, WaterClass wc)
{
assert(HasTileWaterClass(t));
SB(t.m1(), 5, 2, wc);
SB(t.m1(), 5, 2, to_underlying(wc));
}
/**
@@ -137,7 +137,7 @@ inline void SetWaterClass(Tile t, WaterClass wc)
*/
inline bool IsTileOnWater(Tile t)
{
return (GetWaterClass(t) != WATER_CLASS_INVALID);
return (GetWaterClass(t) != WaterClass::Invalid);
}
/**
@@ -148,7 +148,7 @@ inline bool IsTileOnWater(Tile t)
*/
inline bool IsWater(Tile t)
{
return GetWaterTileType(t) == WATER_TILE_CLEAR;
return GetWaterTileType(t) == WaterTileType::Clear;
}
/**
@@ -159,7 +159,7 @@ inline bool IsWater(Tile t)
*/
inline bool IsSea(Tile t)
{
return IsWater(t) && GetWaterClass(t) == WATER_CLASS_SEA;
return IsWater(t) && GetWaterClass(t) == WaterClass::Sea;
}
/**
@@ -170,7 +170,7 @@ inline bool IsSea(Tile t)
*/
inline bool IsCanal(Tile t)
{
return IsWater(t) && GetWaterClass(t) == WATER_CLASS_CANAL;
return IsWater(t) && GetWaterClass(t) == WaterClass::Canal;
}
/**
@@ -181,7 +181,7 @@ inline bool IsCanal(Tile t)
*/
inline bool IsRiver(Tile t)
{
return IsWater(t) && GetWaterClass(t) == WATER_CLASS_RIVER;
return IsWater(t) && GetWaterClass(t) == WaterClass::River;
}
/**
@@ -202,7 +202,7 @@ inline bool IsWaterTile(Tile t)
*/
inline bool IsCoast(Tile t)
{
return GetWaterTileType(t) == WATER_TILE_COAST;
return GetWaterTileType(t) == WaterTileType::Coast;
}
/**
@@ -212,7 +212,7 @@ inline bool IsCoast(Tile t)
*/
inline bool IsCoastTile(Tile t)
{
return (IsTileType(t, MP_WATER) && IsCoast(t)) || (IsTileType(t, MP_TREES) && GetWaterClass(t) != WATER_CLASS_INVALID);
return (IsTileType(t, MP_WATER) && IsCoast(t)) || (IsTileType(t, MP_TREES) && GetWaterClass(t) != WaterClass::Invalid);
}
/**
@@ -223,7 +223,7 @@ inline bool IsCoastTile(Tile t)
*/
inline bool IsShipDepot(Tile t)
{
return GetWaterTileType(t) == WATER_TILE_DEPOT;
return GetWaterTileType(t) == WaterTileType::Depot;
}
/**
@@ -257,7 +257,7 @@ inline Axis GetShipDepotAxis(Tile t)
inline DepotPart GetShipDepotPart(Tile t)
{
assert(IsShipDepotTile(t));
return (DepotPart)GB(t.m5(), WBL_DEPOT_PART, 1);
return static_cast<DepotPart>(GB(t.m5(), WBL_DEPOT_PART, 1));
}
/**
@@ -268,7 +268,7 @@ inline DepotPart GetShipDepotPart(Tile t)
*/
inline DiagDirection GetShipDepotDirection(Tile t)
{
return XYNSToDiagDir(GetShipDepotAxis(t), GetShipDepotPart(t));
return XYNSToDiagDir(GetShipDepotAxis(t), to_underlying(GetShipDepotPart(t)));
}
/**
@@ -279,7 +279,7 @@ inline DiagDirection GetShipDepotDirection(Tile t)
*/
inline TileIndex GetOtherShipDepotTile(Tile t)
{
return TileIndex(t) + (GetShipDepotPart(t) != DEPOT_PART_NORTH ? -1 : 1) * TileOffsByAxis(GetShipDepotAxis(t));
return TileIndex(t) + (GetShipDepotPart(t) != DepotPart::North ? -1 : 1) * TileOffsByAxis(GetShipDepotAxis(t));
}
/**
@@ -304,7 +304,7 @@ inline TileIndex GetShipDepotNorthTile(Tile t)
*/
inline bool IsLock(Tile t)
{
return GetWaterTileType(t) == WATER_TILE_LOCK;
return GetWaterTileType(t) == WaterTileType::Lock;
}
/**
@@ -384,13 +384,13 @@ inline void MakeShore(Tile t)
{
SetTileType(t, MP_WATER);
SetTileOwner(t, OWNER_WATER);
SetWaterClass(t, WATER_CLASS_SEA);
SetWaterClass(t, WaterClass::Sea);
SetDockingTile(t, false);
t.m2() = 0;
t.m3() = 0;
t.m4() = 0;
t.m5() = 0;
SetWaterTileType(t, WATER_TILE_COAST);
SetWaterTileType(t, WaterTileType::Coast);
SB(t.m6(), 2, 6, 0);
t.m7() = 0;
t.m8() = 0;
@@ -413,7 +413,7 @@ inline void MakeWater(Tile t, Owner o, WaterClass wc, uint8_t random_bits)
t.m3() = 0;
t.m4() = random_bits;
t.m5() = 0;
SetWaterTileType(t, WATER_TILE_CLEAR);
SetWaterTileType(t, WaterTileType::Clear);
SB(t.m6(), 2, 6, 0);
t.m7() = 0;
t.m8() = 0;
@@ -425,7 +425,7 @@ inline void MakeWater(Tile t, Owner o, WaterClass wc, uint8_t random_bits)
*/
inline void MakeSea(Tile t)
{
MakeWater(t, OWNER_WATER, WATER_CLASS_SEA, 0);
MakeWater(t, OWNER_WATER, WaterClass::Sea, 0);
}
/**
@@ -435,7 +435,7 @@ inline void MakeSea(Tile t)
*/
inline void MakeRiver(Tile t, uint8_t random_bits)
{
MakeWater(t, OWNER_WATER, WATER_CLASS_RIVER, random_bits);
MakeWater(t, OWNER_WATER, WaterClass::River, random_bits);
}
/**
@@ -447,7 +447,7 @@ inline void MakeRiver(Tile t, uint8_t random_bits)
inline void MakeCanal(Tile t, Owner o, uint8_t random_bits)
{
assert(o != OWNER_WATER);
MakeWater(t, o, WATER_CLASS_CANAL, random_bits);
MakeWater(t, o, WaterClass::Canal, random_bits);
}
/**
@@ -455,7 +455,7 @@ inline void MakeCanal(Tile t, Owner o, uint8_t random_bits)
* @param t Tile to place the ship depot section.
* @param o Owner of the depot.
* @param did Depot ID.
* @param part Depot part (either #DEPOT_PART_NORTH or #DEPOT_PART_SOUTH).
* @param part Depot part (either #DepotPart::North or #DepotPart::South).
* @param a Axis of the depot.
* @param original_water_class Original water class.
*/
@@ -468,8 +468,8 @@ inline void MakeShipDepot(Tile t, Owner o, DepotID did, DepotPart part, Axis a,
t.m2() = did.base();
t.m3() = 0;
t.m4() = 0;
t.m5() = part << WBL_DEPOT_PART | a << WBL_DEPOT_AXIS;
SetWaterTileType(t, WATER_TILE_DEPOT);
t.m5() = to_underlying(part) << WBL_DEPOT_PART | a << WBL_DEPOT_AXIS;
SetWaterTileType(t, WaterTileType::Depot);
SB(t.m6(), 2, 6, 0);
t.m7() = 0;
t.m8() = 0;
@@ -493,8 +493,8 @@ inline void MakeLockTile(Tile t, Owner o, LockPart part, DiagDirection dir, Wate
t.m2() = 0;
t.m3() = 0;
t.m4() = 0;
t.m5() = part << WBL_LOCK_PART_BEGIN | dir << WBL_LOCK_ORIENT_BEGIN;
SetWaterTileType(t, WATER_TILE_LOCK);
t.m5() = to_underlying(part) << WBL_LOCK_PART_BEGIN | dir << WBL_LOCK_ORIENT_BEGIN;
SetWaterTileType(t, WaterTileType::Lock);
SB(t.m6(), 2, 6, 0);
t.m7() = 0;
t.m8() = 0;
@@ -517,9 +517,9 @@ inline void MakeLock(Tile t, Owner o, DiagDirection d, WaterClass wc_lower, Wate
/* Keep the current waterclass and owner for the tiles.
* It allows to restore them after the lock is deleted */
MakeLockTile(t, o, LOCK_PART_MIDDLE, d, wc_middle);
MakeLockTile(lower_tile, IsWaterTile(lower_tile) ? GetTileOwner(lower_tile) : o, LOCK_PART_LOWER, d, wc_lower);
MakeLockTile(upper_tile, IsWaterTile(upper_tile) ? GetTileOwner(upper_tile) : o, LOCK_PART_UPPER, d, wc_upper);
MakeLockTile(t, o, LockPart::Middle, d, wc_middle);
MakeLockTile(lower_tile, IsWaterTile(lower_tile) ? GetTileOwner(lower_tile) : o, LockPart::Lower, d, wc_lower);
MakeLockTile(upper_tile, IsWaterTile(upper_tile) ? GetTileOwner(upper_tile) : o, LockPart::Upper, d, wc_upper);
}
/**