mirrors
/
OpenTTD
mirror of https://github.com/OpenTTD/OpenTTD.git
2
0
Fork 0
Code Issues Projects Releases Wiki Activity

(svn r23091) -Codechange: rename some Get*Z functions to Get*PixelZ functions if they return the Z in pixels (like TilePixelHeight)

This commit is contained in:
rubidium 2011-11-04 10:18:13 +00:00
parent 47203dbeb5
commit 7757a2ed40
52 changed files with 322 additions and 322 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
src/ai/api/ai_tile.cpp
View File

@ -142,7 +142,7 @@
{ {
if (!::IsValidTile(tile)) return SLOPE_INVALID; if (!::IsValidTile(tile)) return SLOPE_INVALID;
return (Slope)::GetTileSlope(tile, NULL); return (Slope)::GetTilePixelSlope(tile, NULL);
} }
/* static */ AITile::Slope AITile::GetComplementSlope(Slope slope) /* static */ AITile::Slope AITile::GetComplementSlope(Slope slope)
@ -156,14 +156,14 @@
{ {
if (!::IsValidTile(tile)) return -1; if (!::IsValidTile(tile)) return -1;
return ::GetTileZ(tile) / ::TILE_HEIGHT; return ::GetTilePixelZ(tile) / ::TILE_HEIGHT;
} }
/* static */ int32 AITile::GetMaxHeight(TileIndex tile) /* static */ int32 AITile::GetMaxHeight(TileIndex tile)
{ {
if (!::IsValidTile(tile)) return -1; if (!::IsValidTile(tile)) return -1;
return ::GetTileMaxZ(tile) / ::TILE_HEIGHT; return ::GetTileMaxPixelZ(tile) / ::TILE_HEIGHT;
} }
/* static */ int32 AITile::GetCornerHeight(TileIndex tile, Corner corner) /* static */ int32 AITile::GetCornerHeight(TileIndex tile, Corner corner)
@ -171,8 +171,8 @@
if (!::IsValidTile(tile) || !::IsValidCorner((::Corner)corner)) return -1; if (!::IsValidTile(tile) || !::IsValidCorner((::Corner)corner)) return -1;
uint z; uint z;
::Slope slope = ::GetTileSlope(tile, &z); ::Slope slope = ::GetTilePixelSlope(tile, &z);
return (z + ::GetSlopeZInCorner(slope, (::Corner)corner)) / ::TILE_HEIGHT; return (z + ::GetSlopePixelZInCorner(slope, (::Corner)corner)) / ::TILE_HEIGHT;
} }
/* static */ AICompany::CompanyID AITile::GetOwner(TileIndex tile) /* static */ AICompany::CompanyID AITile::GetOwner(TileIndex tile)

4
src/ai/api/ai_tunnel.cpp
View File

@ -30,7 +30,7 @@
if (IsTunnelTile(tile)) return ::GetOtherTunnelEnd(tile); if (IsTunnelTile(tile)) return ::GetOtherTunnelEnd(tile);
uint start_z; uint start_z;
Slope start_tileh = ::GetTileSlope(tile, &start_z); Slope start_tileh = ::GetTilePixelSlope(tile, &start_z);
DiagDirection direction = ::GetInclinedSlopeDirection(start_tileh); DiagDirection direction = ::GetInclinedSlopeDirection(start_tileh);
if (direction == INVALID_DIAGDIR) return INVALID_TILE; if (direction == INVALID_DIAGDIR) return INVALID_TILE;
@ -40,7 +40,7 @@
tile += delta; tile += delta;
if (!::IsValidTile(tile)) return INVALID_TILE; if (!::IsValidTile(tile)) return INVALID_TILE;
::GetTileSlope(tile, &end_z); ::GetTilePixelSlope(tile, &end_z);
} while (start_z != end_z); } while (start_z != end_z);
return tile; return tile;

14
src/aircraft_cmd.cpp
View File

@ -251,7 +251,7 @@ CommandCost CmdBuildAircraft(TileIndex tile, DoCommandFlag flags, const Engine *
v->x_pos = u->x_pos = x; v->x_pos = u->x_pos = x;
v->y_pos = u->y_pos = y; v->y_pos = u->y_pos = y;
u->z_pos = GetSlopeZ(x, y); u->z_pos = GetSlopePixelZ(x, y);
v->z_pos = u->z_pos + 1; v->z_pos = u->z_pos + 1;
v->vehstatus = VS_HIDDEN | VS_STOPPED | VS_DEFPAL; v->vehstatus = VS_HIDDEN | VS_STOPPED | VS_DEFPAL;
@ -486,10 +486,10 @@ void SetAircraftPosition(Aircraft *v, int x, int y, int z)
int safe_x = Clamp(x, 0, MapMaxX() * TILE_SIZE); int safe_x = Clamp(x, 0, MapMaxX() * TILE_SIZE);
int safe_y = Clamp(y - 1, 0, MapMaxY() * TILE_SIZE); int safe_y = Clamp(y - 1, 0, MapMaxY() * TILE_SIZE);
u->x_pos = x; u->x_pos = x;
u->y_pos = y - ((v->z_pos - GetSlopeZ(safe_x, safe_y)) >> 3); u->y_pos = y - ((v->z_pos - GetSlopePixelZ(safe_x, safe_y)) >> 3);
safe_y = Clamp(u->y_pos, 0, MapMaxY() * TILE_SIZE); safe_y = Clamp(u->y_pos, 0, MapMaxY() * TILE_SIZE);
u->z_pos = GetSlopeZ(safe_x, safe_y); u->z_pos = GetSlopePixelZ(safe_x, safe_y);
u->cur_image = v->cur_image; u->cur_image = v->cur_image;
VehicleMove(u, true); VehicleMove(u, true);
@ -805,7 +805,7 @@ static bool AircraftController(Aircraft *v)
v->tile = tile; v->tile = tile;
/* Find altitude of landing position. */ /* Find altitude of landing position. */
int z = GetSlopeZ(x, y) + 1 + afc->delta_z; int z = GetSlopePixelZ(x, y) + 1 + afc->delta_z;
if (z == v->z_pos) { if (z == v->z_pos) {
Vehicle *u = v->Next()->Next(); Vehicle *u = v->Next()->Next();
@ -950,7 +950,7 @@ static bool AircraftController(Aircraft *v)
continue; continue;
} }
uint curz = GetSlopeZ(x + amd.x, y + amd.y) + 1; uint curz = GetSlopePixelZ(x + amd.x, y + amd.y) + 1;
/* We're not flying below our destination, right? */ /* We're not flying below our destination, right? */
assert(curz <= z); assert(curz <= z);
@ -966,7 +966,7 @@ static bool AircraftController(Aircraft *v)
/* We've landed. Decrease speed when we're reaching end of runway. */ /* We've landed. Decrease speed when we're reaching end of runway. */
if (amd.flag & AMED_BRAKE) { if (amd.flag & AMED_BRAKE) {
uint curz = GetSlopeZ(x, y) + 1; uint curz = GetSlopePixelZ(x, y) + 1;
if (z > curz) { if (z > curz) {
z--; z--;
@ -993,7 +993,7 @@ static bool HandleCrashedAircraft(Aircraft *v)
/* make aircraft crash down to the ground */ /* make aircraft crash down to the ground */
if (v->crashed_counter < 500 && st == NULL && ((v->crashed_counter % 3) == 0) ) { if (v->crashed_counter < 500 && st == NULL && ((v->crashed_counter % 3) == 0) ) {
uint z = GetSlopeZ(v->x_pos, v->y_pos); uint z = GetSlopePixelZ(v->x_pos, v->y_pos);
v->z_pos -= 1; v->z_pos -= 1;
if (v->z_pos == z) { if (v->z_pos == z) {
v->crashed_counter = 500; v->crashed_counter = 500;

2
src/autoslope.h
View File

@ -33,7 +33,7 @@
*/ */
static inline bool AutoslopeCheckForEntranceEdge(TileIndex tile, uint z_new, Slope tileh_new, DiagDirection entrance) static inline bool AutoslopeCheckForEntranceEdge(TileIndex tile, uint z_new, Slope tileh_new, DiagDirection entrance)
{ {
if (GetTileMaxZ(tile) != z_new + GetSlopeMaxZ(tileh_new)) return false; if (GetTileMaxPixelZ(tile) != z_new + GetSlopeMaxPixelZ(tileh_new)) return false;
return ((tileh_new == SLOPE_FLAT) || CanBuildDepotByTileh(entrance, tileh_new)); return ((tileh_new == SLOPE_FLAT) || CanBuildDepotByTileh(entrance, tileh_new));
} }

6
src/bridge_map.cpp
View File

@ -67,12 +67,12 @@ TileIndex GetOtherBridgeEnd(TileIndex tile)
* @param tile the bridge ramp tile to get the bridge height from * @param tile the bridge ramp tile to get the bridge height from
* @return the height of the bridge in pixels * @return the height of the bridge in pixels
*/ */
uint GetBridgeHeight(TileIndex t) uint GetBridgePixelHeight(TileIndex t)
{ {
uint h; uint h;
Slope tileh = GetTileSlope(t, &h); Slope tileh = GetTilePixelSlope(t, &h);
Foundation f = GetBridgeFoundation(tileh, DiagDirToAxis(GetTunnelBridgeDirection(t))); Foundation f = GetBridgeFoundation(tileh, DiagDirToAxis(GetTunnelBridgeDirection(t)));
/* one height level extra for the ramp */ /* one height level extra for the ramp */
return h + TILE_HEIGHT + ApplyFoundationToSlope(f, &tileh); return h + TILE_HEIGHT + ApplyPixelFoundationToSlope(f, &tileh);
} }

2
src/bridge_map.h
View File

@ -89,7 +89,7 @@ TileIndex GetNorthernBridgeEnd(TileIndex t);
TileIndex GetSouthernBridgeEnd(TileIndex t); TileIndex GetSouthernBridgeEnd(TileIndex t);
TileIndex GetOtherBridgeEnd(TileIndex t); TileIndex GetOtherBridgeEnd(TileIndex t);
uint GetBridgeHeight(TileIndex tile); uint GetBridgePixelHeight(TileIndex tile);
/** /**
* Remove the bridge over the given axis. * Remove the bridge over the given axis.

14
src/clear_cmd.cpp
View File

@ -67,7 +67,7 @@ void DrawClearLandFence(const TileInfo *ti)
if (!fence_sw && !fence_se) return; if (!fence_sw && !fence_se) return;
int z = GetSlopeZInCorner(ti->tileh, CORNER_S); int z = GetSlopePixelZInCorner(ti->tileh, CORNER_S);
if (fence_sw) { if (fence_sw) {
DrawGroundSpriteAt(_clear_land_fence_sprites[GetFenceSW(ti->tile) - 1] + _fence_mod_by_tileh_sw[ti->tileh], PAL_NONE, 0, 0, z); DrawGroundSpriteAt(_clear_land_fence_sprites[GetFenceSW(ti->tile) - 1] + _fence_mod_by_tileh_sw[ti->tileh], PAL_NONE, 0, 0, z);
@ -107,12 +107,12 @@ static void DrawTile_Clear(TileInfo *ti)
DrawBridgeMiddle(ti); DrawBridgeMiddle(ti);
} }
static uint GetSlopeZ_Clear(TileIndex tile, uint x, uint y) static uint GetSlopePixelZ_Clear(TileIndex tile, uint x, uint y)
{ {
uint z; uint z;
Slope tileh = GetTileSlope(tile, &z); Slope tileh = GetTilePixelSlope(tile, &z);
return z + GetPartialZ(x & 0xF, y & 0xF, tileh); return z + GetPartialPixelZ(x & 0xF, y & 0xF, tileh);
} }
static Foundation GetFoundation_Clear(TileIndex tile, Slope tileh) static Foundation GetFoundation_Clear(TileIndex tile, Slope tileh)
@ -158,7 +158,7 @@ void TileLoopClearHelper(TileIndex tile)
/** Convert to or from snowy tiles. */ /** Convert to or from snowy tiles. */
static void TileLoopClearAlps(TileIndex tile) static void TileLoopClearAlps(TileIndex tile)
{ {
int k = GetTileZ(tile) - GetSnowLine() + TILE_HEIGHT; int k = GetTilePixelZ(tile) - GetSnowLine() + TILE_HEIGHT;
if (k < 0) { if (k < 0) {
/* Below the snow line, do nothing if no snow. */ /* Below the snow line, do nothing if no snow. */
@ -231,7 +231,7 @@ static void TileLoop_Clear(TileIndex tile)
/* If the tile is at any edge flood it to prevent maps without water. */ /* If the tile is at any edge flood it to prevent maps without water. */
if (_settings_game.construction.freeform_edges && DistanceFromEdge(tile) == 1) { if (_settings_game.construction.freeform_edges && DistanceFromEdge(tile) == 1) {
uint z; uint z;
Slope slope = GetTileSlope(tile, &z); Slope slope = GetTilePixelSlope(tile, &z);
if (z == 0 && slope == SLOPE_FLAT) { if (z == 0 && slope == SLOPE_FLAT) {
DoFloodTile(tile); DoFloodTile(tile);
MarkTileDirtyByTile(tile); MarkTileDirtyByTile(tile);
@ -368,7 +368,7 @@ static CommandCost TerraformTile_Clear(TileIndex tile, DoCommandFlag flags, uint
extern const TileTypeProcs _tile_type_clear_procs = { extern const TileTypeProcs _tile_type_clear_procs = {
DrawTile_Clear, ///< draw_tile_proc DrawTile_Clear, ///< draw_tile_proc
GetSlopeZ_Clear, ///< get_slope_z_proc GetSlopePixelZ_Clear, ///< get_slope_z_proc
ClearTile_Clear, ///< clear_tile_proc ClearTile_Clear, ///< clear_tile_proc
NULL, ///< add_accepted_cargo_proc NULL, ///< add_accepted_cargo_proc
GetTileDesc_Clear, ///< get_tile_desc_proc GetTileDesc_Clear, ///< get_tile_desc_proc

2
src/command.cpp
View File

@ -540,7 +540,7 @@ bool DoCommandP(TileIndex tile, uint32 p1, uint32 p2, uint32 cmd, CommandCallbac
* the server, when it has cost the local company * the server, when it has cost the local company
* something. Furthermore in the editor there is no * something. Furthermore in the editor there is no
* concept of cost, so don't show it there either. */ * concept of cost, so don't show it there either. */
ShowCostOrIncomeAnimation(x, y, GetSlopeZ(x, y), res.GetCost()); ShowCostOrIncomeAnimation(x, y, GetSlopePixelZ(x, y), res.GetCost());
} }
if (!estimate_only && !only_sending && callback != NULL) { if (!estimate_only && !only_sending && callback != NULL) {

8
src/disaster_cmd.cpp
View File

@ -168,9 +168,9 @@ static void SetDisasterVehiclePos(DisasterVehicle *v, int x, int y, byte z)
int safe_y = Clamp(y - 1, 0, MapMaxY() * TILE_SIZE); int safe_y = Clamp(y - 1, 0, MapMaxY() * TILE_SIZE);
u->x_pos = x; u->x_pos = x;
u->y_pos = y - 1 - (max(z - GetSlopeZ(safe_x, safe_y), 0U) >> 3); u->y_pos = y - 1 - (max(z - GetSlopePixelZ(safe_x, safe_y), 0U) >> 3);
safe_y = Clamp(u->y_pos, 0, MapMaxY() * TILE_SIZE); safe_y = Clamp(u->y_pos, 0, MapMaxY() * TILE_SIZE);
u->z_pos = GetSlopeZ(safe_x, safe_y); u->z_pos = GetSlopePixelZ(safe_x, safe_y);
u->direction = v->direction; u->direction = v->direction;
DisasterVehicleUpdateImage(u); DisasterVehicleUpdateImage(u);
@ -249,7 +249,7 @@ static bool DisasterTick_Zeppeliner(DisasterVehicle *v)
int x = v->x_pos; int x = v->x_pos;
int y = v->y_pos; int y = v->y_pos;
byte z = GetSlopeZ(x, y); byte z = GetSlopePixelZ(x, y);
if (z < v->z_pos) z = v->z_pos - 1; if (z < v->z_pos) z = v->z_pos - 1;
SetDisasterVehiclePos(v, x, y, z); SetDisasterVehiclePos(v, x, y, z);
@ -509,7 +509,7 @@ static bool DisasterTick_Big_Ufo(DisasterVehicle *v)
return false; return false;
} }
byte z = GetSlopeZ(v->x_pos, v->y_pos); byte z = GetSlopePixelZ(v->x_pos, v->y_pos);
if (z < v->z_pos) { if (z < v->z_pos) {
SetDisasterVehiclePos(v, v->x_pos, v->y_pos, v->z_pos - 1); SetDisasterVehiclePos(v, v->x_pos, v->y_pos, v->z_pos - 1);
return true; return true;

8
src/dock_gui.cpp
View File

@ -60,7 +60,7 @@ void CcBuildCanal(const CommandCost &result, TileIndex tile, uint32 p1, uint32 p
static TileIndex GetOtherAqueductEnd(TileIndex tile_from, TileIndex *tile_to = NULL) static TileIndex GetOtherAqueductEnd(TileIndex tile_from, TileIndex *tile_to = NULL)
{ {
uint z; uint z;
DiagDirection dir = GetInclinedSlopeDirection(GetTileSlope(tile_from, &z)); DiagDirection dir = GetInclinedSlopeDirection(GetTilePixelSlope(tile_from, &z));
/* If the direction isn't right, just return the next tile so the command /* If the direction isn't right, just return the next tile so the command
* complains about the wrong slope instead of the ends not matching up. * complains about the wrong slope instead of the ends not matching up.
@ -79,7 +79,7 @@ static TileIndex GetOtherAqueductEnd(TileIndex tile_from, TileIndex *tile_to = N
if (length > max_length) break; if (length > max_length) break;
if (GetTileMaxZ(endtile) > z) { if (GetTileMaxPixelZ(endtile) > z) {
if (tile_to != NULL) *tile_to = endtile; if (tile_to != NULL) *tile_to = endtile;
break; break;
} }
@ -212,7 +212,7 @@ struct BuildDocksToolbarWindow : Window {
CommandContainer cmdcont = { tile, _ctrl_pressed, p2, CMD_BUILD_DOCK | CMD_MSG(STR_ERROR_CAN_T_BUILD_DOCK_HERE), CcBuildDocks, "" }; CommandContainer cmdcont = { tile, _ctrl_pressed, p2, CMD_BUILD_DOCK | CMD_MSG(STR_ERROR_CAN_T_BUILD_DOCK_HERE), CcBuildDocks, "" };
/* Determine the watery part of the dock. */ /* Determine the watery part of the dock. */
DiagDirection dir = GetInclinedSlopeDirection(GetTileSlope(tile, NULL)); DiagDirection dir = GetInclinedSlopeDirection(GetTilePixelSlope(tile, NULL));
TileIndex tile_to = (dir != INVALID_DIAGDIR ? TileAddByDiagDir(tile, ReverseDiagDir(dir)) : tile); TileIndex tile_to = (dir != INVALID_DIAGDIR ? TileAddByDiagDir(tile, ReverseDiagDir(dir)) : tile);
ShowSelectStationIfNeeded(cmdcont, TileArea(tile, tile_to)); ShowSelectStationIfNeeded(cmdcont, TileArea(tile, tile_to));
@ -276,7 +276,7 @@ struct BuildDocksToolbarWindow : Window {
if (this->last_clicked_widget == DTW_BUILD_AQUEDUCT) { if (this->last_clicked_widget == DTW_BUILD_AQUEDUCT) {
GetOtherAqueductEnd(tile_from, &tile_to); GetOtherAqueductEnd(tile_from, &tile_to);
} else { } else {
DiagDirection dir = GetInclinedSlopeDirection(GetTileSlope(tile_from, NULL)); DiagDirection dir = GetInclinedSlopeDirection(GetTilePixelSlope(tile_from, NULL));
if (IsValidDiagDirection(dir)) { if (IsValidDiagDirection(dir)) {
/* Locks and docks always select the tile "down" the slope. */ /* Locks and docks always select the tile "down" the slope. */
tile_to = TileAddByDiagDir(tile_from, ReverseDiagDir(dir)); tile_to = TileAddByDiagDir(tile_from, ReverseDiagDir(dir));

2
src/effectvehicle.cpp
View File

@ -624,7 +624,7 @@ EffectVehicle *CreateEffectVehicleAbove(int x, int y, int z, EffectVehicleType t
{ {
int safe_x = Clamp(x, 0, MapMaxX() * TILE_SIZE); int safe_x = Clamp(x, 0, MapMaxX() * TILE_SIZE);
int safe_y = Clamp(y, 0, MapMaxY() * TILE_SIZE); int safe_y = Clamp(y, 0, MapMaxY() * TILE_SIZE);
return CreateEffectVehicle(x, y, GetSlopeZ(safe_x, safe_y) + z, type); return CreateEffectVehicle(x, y, GetSlopePixelZ(safe_x, safe_y) + z, type);
} }
/** /**

32
src/elrail.cpp
View File

@ -216,16 +216,16 @@ static byte GetPCPElevation(TileIndex tile, DiagDirection PCPpos)
* *
* This position can be outside of the tile, i.e. ?_pcp_offset == TILE_SIZE > TILE_SIZE - 1. * This position can be outside of the tile, i.e. ?_pcp_offset == TILE_SIZE > TILE_SIZE - 1.
* So we have to move it inside the tile, because if the neighboured tile has a foundation, * So we have to move it inside the tile, because if the neighboured tile has a foundation,
* that does not smoothly connect to the current tile, we will get a wrong elevation from GetSlopeZ(). * that does not smoothly connect to the current tile, we will get a wrong elevation from GetSlopePixelZ().
* *
* When we move the position inside the tile, we will get a wrong elevation if we have a slope. * When we move the position inside the tile, we will get a wrong elevation if we have a slope.
* To catch all cases we round the Z position to the next (TILE_HEIGHT / 2). * To catch all cases we round the Z position to the next (TILE_HEIGHT / 2).
* This will return the correct elevation for slopes and will also detect non-continuous elevation on edges. * This will return the correct elevation for slopes and will also detect non-continuous elevation on edges.
* *
* Also note that the result of GetSlopeZ() is very special on bridge-ramps. * Also note that the result of GetSlopePixelZ() is very special on bridge-ramps.
*/ */
byte z = GetSlopeZ(TileX(tile) * TILE_SIZE + min(x_pcp_offsets[PCPpos], TILE_SIZE - 1), TileY(tile) * TILE_SIZE + min(y_pcp_offsets[PCPpos], TILE_SIZE - 1)); byte z = GetSlopePixelZ(TileX(tile) * TILE_SIZE + min(x_pcp_offsets[PCPpos], TILE_SIZE - 1), TileY(tile) * TILE_SIZE + min(y_pcp_offsets[PCPpos], TILE_SIZE - 1));
return (z + 2) & ~3; // this means z = (z + TILE_HEIGHT / 4) / (TILE_HEIGHT / 2) * (TILE_HEIGHT / 2); return (z + 2) & ~3; // this means z = (z + TILE_HEIGHT / 4) / (TILE_HEIGHT / 2) * (TILE_HEIGHT / 2);
} }
@ -255,7 +255,7 @@ void DrawCatenaryOnTunnel(const TileInfo *ti)
AddSortableSpriteToDraw( AddSortableSpriteToDraw(
wire_base + sss->image_offset, PAL_NONE, ti->x + sss->x_offset, ti->y + sss->y_offset, 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,
GetTileZ(ti->tile) + sss->z_offset, GetTilePixelZ(ti->tile) + sss->z_offset,
IsTransparencySet(TO_CATENARY), 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
); );
@ -317,9 +317,9 @@ static void DrawCatenaryRailway(const TileInfo *ti)
TileIndex neighbour = ti->tile + TileOffsByDiagDir(i); TileIndex neighbour = ti->tile + TileOffsByDiagDir(i);
byte elevation = GetPCPElevation(ti->tile, i); byte elevation = GetPCPElevation(ti->tile, i);
/* Here's one of the main headaches. GetTileSlope does not correct for possibly /* Here's one of the main headaches. GetTilePixelSlope does not correct for possibly
* existing foundataions, so we do have to do that manually later on.*/ * existing foundataions, so we do have to do that manually later on.*/
tileh[TS_NEIGHBOUR] = GetTileSlope(neighbour, NULL); tileh[TS_NEIGHBOUR] = GetTilePixelSlope(neighbour, NULL);
trackconfig[TS_NEIGHBOUR] = GetRailTrackBitsUniversal(neighbour, NULL); trackconfig[TS_NEIGHBOUR] = GetRailTrackBitsUniversal(neighbour, NULL);
wireconfig[TS_NEIGHBOUR] = MaskWireBits(neighbour, trackconfig[TS_NEIGHBOUR]); wireconfig[TS_NEIGHBOUR] = MaskWireBits(neighbour, trackconfig[TS_NEIGHBOUR]);
if (IsTunnelTile(neighbour) && i != GetTunnelBridgeDirection(neighbour)) wireconfig[TS_NEIGHBOUR] = trackconfig[TS_NEIGHBOUR] = TRACK_BIT_NONE; if (IsTunnelTile(neighbour) && i != GetTunnelBridgeDirection(neighbour)) wireconfig[TS_NEIGHBOUR] = trackconfig[TS_NEIGHBOUR] = TRACK_BIT_NONE;
@ -376,7 +376,7 @@ static void DrawCatenaryRailway(const TileInfo *ti)
foundation = GetBridgeFoundation(tileh[TS_NEIGHBOUR], DiagDirToAxis(GetTunnelBridgeDirection(neighbour))); foundation = GetBridgeFoundation(tileh[TS_NEIGHBOUR], DiagDirToAxis(GetTunnelBridgeDirection(neighbour)));
} }
ApplyFoundationToSlope(foundation, &tileh[TS_NEIGHBOUR]); ApplyPixelFoundationToSlope(foundation, &tileh[TS_NEIGHBOUR]);
/* Half tile slopes coincide only with horizontal/vertical track. /* Half tile slopes coincide only with horizontal/vertical track.
* Faking a flat slope results in the correct sprites on positions. */ * Faking a flat slope results in the correct sprites on positions. */
@ -401,9 +401,9 @@ static void DrawCatenaryRailway(const TileInfo *ti)
if (MayHaveBridgeAbove(ti->tile) && IsBridgeAbove(ti->tile)) { if (MayHaveBridgeAbove(ti->tile) && IsBridgeAbove(ti->tile)) {
Track bridgetrack = GetBridgeAxis(ti->tile) == AXIS_X ? TRACK_X : TRACK_Y; Track bridgetrack = GetBridgeAxis(ti->tile) == AXIS_X ? TRACK_X : TRACK_Y;
uint height = GetBridgeHeight(GetNorthernBridgeEnd(ti->tile)); uint height = GetBridgePixelHeight(GetNorthernBridgeEnd(ti->tile));
if ((height <= GetTileMaxZ(ti->tile) + TILE_HEIGHT) && if ((height <= GetTileMaxPixelZ(ti->tile) + TILE_HEIGHT) &&
(i == PCPpositions[bridgetrack][0] || i == PCPpositions[bridgetrack][1])) { (i == PCPpositions[bridgetrack][0] || i == PCPpositions[bridgetrack][1])) {
SetBit(OverridePCP, i); SetBit(OverridePCP, i);
} }
@ -438,9 +438,9 @@ static void DrawCatenaryRailway(const TileInfo *ti)
/* Don't draw a wire under a low bridge */ /* Don't draw a wire under a low bridge */
if (MayHaveBridgeAbove(ti->tile) && IsBridgeAbove(ti->tile) && !IsTransparencySet(TO_CATENARY)) { if (MayHaveBridgeAbove(ti->tile) && IsBridgeAbove(ti->tile) && !IsTransparencySet(TO_CATENARY)) {
uint height = GetBridgeHeight(GetNorthernBridgeEnd(ti->tile)); uint height = GetBridgePixelHeight(GetNorthernBridgeEnd(ti->tile));
if (height <= GetTileMaxZ(ti->tile) + TILE_HEIGHT) return; if (height <= GetTileMaxPixelZ(ti->tile) + TILE_HEIGHT) return;
} }
SpriteID wire_normal = GetWireBase(ti->tile); SpriteID wire_normal = GetWireBase(ti->tile);
@ -470,11 +470,11 @@ static void DrawCatenaryRailway(const TileInfo *ti)
/* /*
* The "wire"-sprite position is inside the tile, i.e. 0 <= sss->?_offset < TILE_SIZE. * The "wire"-sprite position is inside the tile, i.e. 0 <= sss->?_offset < TILE_SIZE.
* Therefore it is safe to use GetSlopeZ() for the elevation. * Therefore it is safe to use GetSlopePixelZ() for the elevation.
* Also note that the result of GetSlopeZ() is very special for bridge-ramps. * Also note that the result of GetSlopePixelZ() is very special for bridge-ramps.
*/ */
AddSortableSpriteToDraw(wire_base + sss->image_offset, PAL_NONE, ti->x + sss->x_offset, ti->y + sss->y_offset, AddSortableSpriteToDraw(wire_base + sss->image_offset, PAL_NONE, ti->x + sss->x_offset, ti->y + sss->y_offset,
sss->x_size, sss->y_size, sss->z_size, GetSlopeZ(ti->x + sss->x_offset, ti->y + sss->y_offset) + sss->z_offset, sss->x_size, sss->y_size, sss->z_size, GetSlopePixelZ(ti->x + sss->x_offset, ti->y + sss->y_offset) + sss->z_offset,
IsTransparencySet(TO_CATENARY)); IsTransparencySet(TO_CATENARY));
} }
} }
@ -510,7 +510,7 @@ void DrawCatenaryOnBridge(const TileInfo *ti)
sss = &CatenarySpriteData[WIRE_X_FLAT_SW + (num % 2) + offset]; sss = &CatenarySpriteData[WIRE_X_FLAT_SW + (num % 2) + offset];
} }
height = GetBridgeHeight(end); height = GetBridgePixelHeight(end);
SpriteID wire_base = GetWireBase(end, TCX_ON_BRIDGE); SpriteID wire_base = GetWireBase(end, TCX_ON_BRIDGE);
@ -561,7 +561,7 @@ void DrawCatenary(const TileInfo *ti)
AddSortableSpriteToDraw( AddSortableSpriteToDraw(
wire_base + sss->image_offset, PAL_NONE, ti->x + sss->x_offset, ti->y + sss->y_offset, wire_base + sss->image_offset, PAL_NONE, ti->x + sss->x_offset, ti->y + sss->y_offset,
sss->x_size, sss->y_size, sss->z_size, sss->x_size, sss->y_size, sss->z_size,
GetTileMaxZ(ti->tile) + sss->z_offset, GetTileMaxPixelZ(ti->tile) + sss->z_offset,
IsTransparencySet(TO_CATENARY) IsTransparencySet(TO_CATENARY)
); );
return; return;

12
src/ground_vehicle.hpp
View File

@ -134,7 +134,7 @@ struct GroundVehicle : public SpecializedVehicle<T, Type> {
*/ */
FORCEINLINE void UpdateZPositionAndInclination() FORCEINLINE void UpdateZPositionAndInclination()
{ {
this->z_pos = GetSlopeZ(this->x_pos, this->y_pos); this->z_pos = GetSlopePixelZ(this->x_pos, this->y_pos);
ClrBit(this->gv_flags, GVF_GOINGUP_BIT); ClrBit(this->gv_flags, GVF_GOINGUP_BIT);
ClrBit(this->gv_flags, GVF_GOINGDOWN_BIT); ClrBit(this->gv_flags, GVF_GOINGDOWN_BIT);
@ -143,7 +143,7 @@ struct GroundVehicle : public SpecializedVehicle<T, Type> {
* direction it is sloped, we get the 'z' at the center of * direction it is sloped, we get the 'z' at the center of
* the tile (middle_z) and the edge of the tile (old_z), * the tile (middle_z) and the edge of the tile (old_z),
* which we then can compare. */ * which we then can compare. */
byte middle_z = GetSlopeZ((this->x_pos & ~TILE_UNIT_MASK) | HALF_TILE_SIZE, (this->y_pos & ~TILE_UNIT_MASK) | HALF_TILE_SIZE); byte middle_z = GetSlopePixelZ((this->x_pos & ~TILE_UNIT_MASK) | HALF_TILE_SIZE, (this->y_pos & ~TILE_UNIT_MASK) | HALF_TILE_SIZE);
if (middle_z != this->z_pos) { if (middle_z != this->z_pos) {
SetBit(this->gv_flags, (middle_z > this->z_pos) ? GVF_GOINGUP_BIT : GVF_GOINGDOWN_BIT); SetBit(this->gv_flags, (middle_z > this->z_pos) ? GVF_GOINGUP_BIT : GVF_GOINGDOWN_BIT);
@ -198,9 +198,9 @@ struct GroundVehicle : public SpecializedVehicle<T, Type> {
* depending on orientation of the slope and vehicle's direction */ * depending on orientation of the slope and vehicle's direction */
if (HasBit(this->gv_flags, GVF_GOINGUP_BIT) || HasBit(this->gv_flags, GVF_GOINGDOWN_BIT)) { if (HasBit(this->gv_flags, GVF_GOINGUP_BIT) || HasBit(this->gv_flags, GVF_GOINGDOWN_BIT)) {
if (T::From(this)->HasToUseGetSlopeZ()) { if (T::From(this)->HasToUseGetSlopePixelZ()) {
/* In some cases, we have to use GetSlopeZ() */ /* In some cases, we have to use GetSlopePixelZ() */
this->z_pos = GetSlopeZ(this->x_pos, this->y_pos); this->z_pos = GetSlopePixelZ(this->x_pos, this->y_pos);
return; return;
} }
/* DirToDiagDir() is a simple right shift */ /* DirToDiagDir() is a simple right shift */
@ -220,7 +220,7 @@ struct GroundVehicle : public SpecializedVehicle<T, Type> {
this->z_pos += HasBit(this->gv_flags, GVF_GOINGUP_BIT) ? d : -d; this->z_pos += HasBit(this->gv_flags, GVF_GOINGUP_BIT) ? d : -d;
} }
assert(this->z_pos == GetSlopeZ(this->x_pos, this->y_pos)); assert(this->z_pos == GetSlopePixelZ(this->x_pos, this->y_pos));
} }
/** /**

24
src/industry_cmd.cpp
View File

@ -364,9 +364,9 @@ static void DrawTile_Industry(TileInfo *ti)
} }
} }
static uint GetSlopeZ_Industry(TileIndex tile, uint x, uint y) static uint GetSlopePixelZ_Industry(TileIndex tile, uint x, uint y)
{ {
return GetTileMaxZ(tile); return GetTileMaxPixelZ(tile);
} }
static Foundation GetFoundation_Industry(TileIndex tile, Slope tileh) static Foundation GetFoundation_Industry(TileIndex tile, Slope tileh)
@ -698,7 +698,7 @@ static void CreateChimneySmoke(TileIndex tile)
{ {
uint x = TileX(tile) * TILE_SIZE; uint x = TileX(tile) * TILE_SIZE;
uint y = TileY(tile) * TILE_SIZE; uint y = TileY(tile) * TILE_SIZE;
uint z = GetTileMaxZ(tile); uint z = GetTileMaxPixelZ(tile);
CreateEffectVehicle(x + 15, y + 14, z + 59, EV_CHIMNEY_SMOKE); CreateEffectVehicle(x + 15, y + 14, z + 59, EV_CHIMNEY_SMOKE);
} }
@ -979,7 +979,7 @@ static void SetupFarmFieldFence(TileIndex tile, int size, byte type, Axis direct
static void PlantFarmField(TileIndex tile, IndustryID industry) static void PlantFarmField(TileIndex tile, IndustryID industry)
{ {
if (_settings_game.game_creation.landscape == LT_ARCTIC) { if (_settings_game.game_creation.landscape == LT_ARCTIC) {
if (GetTileZ(tile) + TILE_HEIGHT * 2 >= GetSnowLine()) return; if (GetTilePixelZ(tile) + TILE_HEIGHT * 2 >= GetSnowLine()) return;
} }
/* determine field size */ /* determine field size */
@ -1165,7 +1165,7 @@ static CommandCost CheckNewIndustry_NULL(TileIndex tile)
static CommandCost CheckNewIndustry_Forest(TileIndex tile) static CommandCost CheckNewIndustry_Forest(TileIndex tile)
{ {
if (_settings_game.game_creation.landscape == LT_ARCTIC) { if (_settings_game.game_creation.landscape == LT_ARCTIC) {
if (GetTileZ(tile) < HighestSnowLine() + TILE_HEIGHT * 2U) { if (GetTilePixelZ(tile) < HighestSnowLine() + TILE_HEIGHT * 2U) {
return_cmd_error(STR_ERROR_FOREST_CAN_ONLY_BE_PLANTED); return_cmd_error(STR_ERROR_FOREST_CAN_ONLY_BE_PLANTED);
} }
} }
@ -1209,7 +1209,7 @@ static CommandCost CheckNewIndustry_OilRig(TileIndex tile)
static CommandCost CheckNewIndustry_Farm(TileIndex tile) static CommandCost CheckNewIndustry_Farm(TileIndex tile)
{ {
if (_settings_game.game_creation.landscape == LT_ARCTIC) { if (_settings_game.game_creation.landscape == LT_ARCTIC) {
if (GetTileZ(tile) + TILE_HEIGHT * 2 >= HighestSnowLine()) { if (GetTilePixelZ(tile) + TILE_HEIGHT * 2 >= HighestSnowLine()) {
return_cmd_error(STR_ERROR_SITE_UNSUITABLE); return_cmd_error(STR_ERROR_SITE_UNSUITABLE);
} }
} }
@ -1262,7 +1262,7 @@ static CommandCost CheckNewIndustry_Lumbermill(TileIndex tile)
*/ */
static CommandCost CheckNewIndustry_BubbleGen(TileIndex tile) static CommandCost CheckNewIndustry_BubbleGen(TileIndex tile)
{ {
if (GetTileZ(tile) > TILE_HEIGHT * 4) { if (GetTilePixelZ(tile) > TILE_HEIGHT * 4) {
return_cmd_error(STR_ERROR_CAN_ONLY_BE_BUILT_IN_LOW_AREAS); return_cmd_error(STR_ERROR_CAN_ONLY_BE_BUILT_IN_LOW_AREAS);
} }
return CommandCost(); return CommandCost();
@ -1359,7 +1359,7 @@ static CommandCost CheckIfIndustryTilesAreFree(TileIndex tile, const IndustryTil
if (gfx == GFX_WATERTILE_SPECIALCHECK) { if (gfx == GFX_WATERTILE_SPECIALCHECK) {
if (!IsTileType(cur_tile, MP_WATER) || if (!IsTileType(cur_tile, MP_WATER) ||
GetTileSlope(cur_tile, NULL) != SLOPE_FLAT) { GetTilePixelSlope(cur_tile, NULL) != SLOPE_FLAT) {
return_cmd_error(STR_ERROR_SITE_UNSUITABLE); return_cmd_error(STR_ERROR_SITE_UNSUITABLE);
} }
} else { } else {
@ -1379,7 +1379,7 @@ static CommandCost CheckIfIndustryTilesAreFree(TileIndex tile, const IndustryTil
CommandCost ret = PerformIndustryTileSlopeCheck(tile, cur_tile, its, type, gfx, itspec_index, initial_random_bits, founder, creation_type); CommandCost ret = PerformIndustryTileSlopeCheck(tile, cur_tile, its, type, gfx, itspec_index, initial_random_bits, founder, creation_type);
if (ret.Failed()) return ret; if (ret.Failed()) return ret;
} else { } else {
Slope tileh = GetTileSlope(cur_tile, NULL); Slope tileh = GetTilePixelSlope(cur_tile, NULL);
refused_slope |= IsSlopeRefused(tileh, its->slopes_refused); refused_slope |= IsSlopeRefused(tileh, its->slopes_refused);
} }
@ -2724,9 +2724,9 @@ static CommandCost TerraformTile_Industry(TileIndex tile, DoCommandFlag flags, u
* - Allow autoslope by default. * - Allow autoslope by default.
* - Disallow autoslope if callback succeeds and returns non-zero. * - Disallow autoslope if callback succeeds and returns non-zero.
*/ */
Slope tileh_old = GetTileSlope(tile, NULL); Slope tileh_old = GetTilePixelSlope(tile, NULL);
/* TileMaxZ must not be changed. Slopes must not be steep. */ /* TileMaxZ must not be changed. Slopes must not be steep. */
if (!IsSteepSlope(tileh_old) && !IsSteepSlope(tileh_new) && (GetTileMaxZ(tile) == z_new + GetSlopeMaxZ(tileh_new))) { if (!IsSteepSlope(tileh_old) && !IsSteepSlope(tileh_new) && (GetTileMaxPixelZ(tile) == z_new + GetSlopeMaxPixelZ(tileh_new))) {
const IndustryGfx gfx = GetIndustryGfx(tile); const IndustryGfx gfx = GetIndustryGfx(tile);
const IndustryTileSpec *itspec = GetIndustryTileSpec(gfx); const IndustryTileSpec *itspec = GetIndustryTileSpec(gfx);
@ -2746,7 +2746,7 @@ static CommandCost TerraformTile_Industry(TileIndex tile, DoCommandFlag flags, u
extern const TileTypeProcs _tile_type_industry_procs = { extern const TileTypeProcs _tile_type_industry_procs = {
DrawTile_Industry, // draw_tile_proc DrawTile_Industry, // draw_tile_proc
GetSlopeZ_Industry, // get_slope_z_proc GetSlopePixelZ_Industry, // get_slope_z_proc
ClearTile_Industry, // clear_tile_proc ClearTile_Industry, // clear_tile_proc
AddAcceptedCargo_Industry, // add_accepted_cargo_proc AddAcceptedCargo_Industry, // add_accepted_cargo_proc
GetTileDesc_Industry, // get_tile_desc_proc GetTileDesc_Industry, // get_tile_desc_proc

60
src/landscape.cpp
View File

@ -94,7 +94,7 @@ static SnowLine *_snow_line = NULL;
* @param s The #Slope to modify. * @param s The #Slope to modify.
* @return Increment to the tile Z coordinate. * @return Increment to the tile Z coordinate.
*/ */
uint ApplyFoundationToSlope(Foundation f, Slope *s) uint ApplyPixelFoundationToSlope(Foundation f, Slope *s)
{ {
if (!IsFoundation(f)) return 0; if (!IsFoundation(f)) return 0;
@ -147,24 +147,24 @@ uint ApplyFoundationToSlope(Foundation f, Slope *s)
* @param corners slope to examine * @param corners slope to examine
* @return height of given point of given slope * @return height of given point of given slope
*/ */
uint GetPartialZ(int x, int y, Slope corners) uint GetPartialPixelZ(int x, int y, Slope corners)
{ {
if (IsHalftileSlope(corners)) { if (IsHalftileSlope(corners)) {
switch (GetHalftileSlopeCorner(corners)) { switch (GetHalftileSlopeCorner(corners)) {
case CORNER_W: case CORNER_W:
if (x - y >= 0) return GetSlopeMaxZ(corners); if (x - y >= 0) return GetSlopeMaxPixelZ(corners);
break; break;
case CORNER_S: case CORNER_S:
if (x - (y ^ 0xF) >= 0) return GetSlopeMaxZ(corners); if (x - (y ^ 0xF) >= 0) return GetSlopeMaxPixelZ(corners);
break; break;
case CORNER_E: case CORNER_E:
if (y - x >= 0) return GetSlopeMaxZ(corners); if (y - x >= 0) return GetSlopeMaxPixelZ(corners);
break; break;
case CORNER_N: case CORNER_N:
if ((y ^ 0xF) - x >= 0) return GetSlopeMaxZ(corners); if ((y ^ 0xF) - x >= 0) return GetSlopeMaxPixelZ(corners);
break; break;
default: NOT_REACHED(); default: NOT_REACHED();
@ -274,7 +274,7 @@ uint GetPartialZ(int x, int y, Slope corners)
return z; return z;
} }
uint GetSlopeZ(int x, int y) uint GetSlopePixelZ(int x, int y)
{ {
TileIndex tile = TileVirtXY(x, y); TileIndex tile = TileVirtXY(x, y);
@ -290,7 +290,7 @@ uint GetSlopeZ(int x, int y)
* @param corner The corner. * @param corner The corner.
* @return Z position of corner relative to TileZ. * @return Z position of corner relative to TileZ.
*/ */
int GetSlopeZInCorner(Slope tileh, Corner corner) int GetSlopePixelZInCorner(Slope tileh, Corner corner)
{ {
assert(!IsHalftileSlope(tileh)); assert(!IsHalftileSlope(tileh));
return ((tileh & SlopeWithOneCornerRaised(corner)) != 0 ? TILE_HEIGHT : 0) + (tileh == SteepSlope(corner) ? TILE_HEIGHT : 0); return ((tileh & SlopeWithOneCornerRaised(corner)) != 0 ? TILE_HEIGHT : 0) + (tileh == SteepSlope(corner) ? TILE_HEIGHT : 0);
@ -308,7 +308,7 @@ int GetSlopeZInCorner(Slope tileh, Corner corner)
* @param z1 Gets incremented by the height of the first corner of the edge. (near corner wrt. the camera) * @param z1 Gets incremented by the height of the first corner of the edge. (near corner wrt. the camera)
* @param z2 Gets incremented by the height of the second corner of the edge. (far corner wrt. the camera) * @param z2 Gets incremented by the height of the second corner of the edge. (far corner wrt. the camera)
*/ */
void GetSlopeZOnEdge(Slope tileh, DiagDirection edge, int *z1, int *z2) void GetSlopePixelZOnEdge(Slope tileh, DiagDirection edge, int *z1, int *z2)
{ {
static const Slope corners[4][4] = { static const Slope corners[4][4] = {
/* corner | steep slope /* corner | steep slope
@ -331,17 +331,17 @@ void GetSlopeZOnEdge(Slope tileh, DiagDirection edge, int *z1, int *z2)
/** /**
* Get slope of a tile on top of a (possible) foundation * Get slope of a tile on top of a (possible) foundation
* If a tile does not have a foundation, the function returns the same as GetTileSlope. * If a tile does not have a foundation, the function returns the same as GetTilePixelSlope.
* *
* @param tile The tile of interest. * @param tile The tile of interest.
* @param z returns the z of the foundation slope. (Can be NULL, if not needed) * @param z returns the z of the foundation slope. (Can be NULL, if not needed)
* @return The slope on top of the foundation. * @return The slope on top of the foundation.
*/ */
Slope GetFoundationSlope(TileIndex tile, uint *z) Slope GetFoundationPixelSlope(TileIndex tile, uint *z)
{ {
Slope tileh = GetTileSlope(tile, z); Slope tileh = GetTilePixelSlope(tile, z);
Foundation f = _tile_type_procs[GetTileType(tile)]->get_foundation_proc(tile, tileh); Foundation f = _tile_type_procs[GetTileType(tile)]->get_foundation_proc(tile, tileh);
uint z_inc = ApplyFoundationToSlope(f, &tileh); uint z_inc = ApplyPixelFoundationToSlope(f, &tileh);
if (z != NULL) *z += z_inc; if (z != NULL) *z += z_inc;
return tileh; return tileh;
} }
@ -353,12 +353,12 @@ bool HasFoundationNW(TileIndex tile, Slope slope_here, uint z_here)
int z_W_here = z_here; int z_W_here = z_here;
int z_N_here = z_here; int z_N_here = z_here;
GetSlopeZOnEdge(slope_here, DIAGDIR_NW, &z_W_here, &z_N_here); GetSlopePixelZOnEdge(slope_here, DIAGDIR_NW, &z_W_here, &z_N_here);
Slope slope = GetFoundationSlope(TILE_ADDXY(tile, 0, -1), &z); Slope slope = GetFoundationPixelSlope(TILE_ADDXY(tile, 0, -1), &z);
int z_W = z; int z_W = z;
int z_N = z; int z_N = z;
GetSlopeZOnEdge(slope, DIAGDIR_SE, &z_W, &z_N); GetSlopePixelZOnEdge(slope, DIAGDIR_SE, &z_W, &z_N);
return (z_N_here > z_N) || (z_W_here > z_W); return (z_N_here > z_N) || (z_W_here > z_W);
} }
@ -370,12 +370,12 @@ bool HasFoundationNE(TileIndex tile, Slope slope_here, uint z_here)
int z_E_here = z_here; int z_E_here = z_here;
int z_N_here = z_here; int z_N_here = z_here;
GetSlopeZOnEdge(slope_here, DIAGDIR_NE, &z_E_here, &z_N_here); GetSlopePixelZOnEdge(slope_here, DIAGDIR_NE, &z_E_here, &z_N_here);
Slope slope = GetFoundationSlope(TILE_ADDXY(tile, -1, 0), &z); Slope slope = GetFoundationPixelSlope(TILE_ADDXY(tile, -1, 0), &z);
int z_E = z; int z_E = z;
int z_N = z; int z_N = z;
GetSlopeZOnEdge(slope, DIAGDIR_SW, &z_E, &z_N); GetSlopePixelZOnEdge(slope, DIAGDIR_SW, &z_E, &z_N);
return (z_N_here > z_N) || (z_E_here > z_E); return (z_N_here > z_N) || (z_E_here > z_E);
} }
@ -394,7 +394,7 @@ void DrawFoundation(TileInfo *ti, Foundation f)
uint sprite_block = 0; uint sprite_block = 0;
uint z; uint z;
Slope slope = GetFoundationSlope(ti->tile, &z); Slope slope = GetFoundationPixelSlope(ti->tile, &z);
/* Select the needed block of foundations sprites /* Select the needed block of foundations sprites
* Block 0: Walls at NW and NE edge * Block 0: Walls at NW and NE edge
@ -419,7 +419,7 @@ void DrawFoundation(TileInfo *ti, Foundation f)
} }
Corner highest_corner = GetHighestSlopeCorner(ti->tileh); Corner highest_corner = GetHighestSlopeCorner(ti->tileh);
ti->z += ApplyFoundationToSlope(f, &ti->tileh); ti->z += ApplyPixelFoundationToSlope(f, &ti->tileh);
if (IsInclinedFoundation(f)) { if (IsInclinedFoundation(f)) {
/* inclined foundation */ /* inclined foundation */
@ -481,7 +481,7 @@ void DrawFoundation(TileInfo *ti, Foundation f)
); );
OffsetGroundSprite(31, 9); OffsetGroundSprite(31, 9);
} }
ti->z += ApplyFoundationToSlope(f, &ti->tileh); ti->z += ApplyPixelFoundationToSlope(f, &ti->tileh);
} }
} }
@ -927,7 +927,7 @@ static void CreateDesertOrRainForest()
static bool FindSpring(TileIndex tile, void *user_data) static bool FindSpring(TileIndex tile, void *user_data)
{ {
uint referenceHeight; uint referenceHeight;
Slope s = GetTileSlope(tile, &referenceHeight); Slope s = GetTilePixelSlope(tile, &referenceHeight);
if (s != SLOPE_FLAT || IsWaterTile(tile)) return false; if (s != SLOPE_FLAT || IsWaterTile(tile)) return false;
/* In the tropics rivers start in the rainforest. */ /* In the tropics rivers start in the rainforest. */
@ -938,7 +938,7 @@ static bool FindSpring(TileIndex tile, void *user_data)
for (int dx = -1; dx <= 1; dx++) { for (int dx = -1; dx <= 1; dx++) {
for (int dy = -1; dy <= 1; dy++) { for (int dy = -1; dy <= 1; dy++) {
TileIndex t = TileAddWrap(tile, dx, dy); TileIndex t = TileAddWrap(tile, dx, dy);
if (t != INVALID_TILE && GetTileMaxZ(t) > referenceHeight) num++; if (t != INVALID_TILE && GetTileMaxPixelZ(t) > referenceHeight) num++;
} }
} }
@ -948,7 +948,7 @@ static bool FindSpring(TileIndex tile, void *user_data)
for (int dx = -16; dx <= 16; dx++) { for (int dx = -16; dx <= 16; dx++) {
for (int dy = -16; dy <= 16; dy++) { for (int dy = -16; dy <= 16; dy++) {
TileIndex t = TileAddWrap(tile, dx, dy); TileIndex t = TileAddWrap(tile, dx, dy);
if (t != INVALID_TILE && GetTileMaxZ(t) > referenceHeight + 2 * TILE_HEIGHT) return false; if (t != INVALID_TILE && GetTileMaxPixelZ(t) > referenceHeight + 2 * TILE_HEIGHT) return false;
} }
} }
@ -964,7 +964,7 @@ static bool FindSpring(TileIndex tile, void *user_data)
static bool MakeLake(TileIndex tile, void *user_data) static bool MakeLake(TileIndex tile, void *user_data)
{ {
uint height = *(uint*)user_data; uint height = *(uint*)user_data;
if (!IsValidTile(tile) || TileHeight(tile) != height || GetTileSlope(tile, NULL) != SLOPE_FLAT) return false; if (!IsValidTile(tile) || TileHeight(tile) != height || GetTilePixelSlope(tile, NULL) != SLOPE_FLAT) return false;
if (_settings_game.game_creation.landscape == LT_TROPIC && GetTropicZone(tile) == TROPICZONE_DESERT) return false; if (_settings_game.game_creation.landscape == LT_TROPIC && GetTropicZone(tile) == TROPICZONE_DESERT) return false;
for (DiagDirection d = DIAGDIR_BEGIN; d < DIAGDIR_END; d++) { for (DiagDirection d = DIAGDIR_BEGIN; d < DIAGDIR_END; d++) {
@ -990,8 +990,8 @@ static bool FlowsDown(TileIndex begin, TileIndex end)
uint heightBegin; uint heightBegin;
uint heightEnd; uint heightEnd;
Slope slopeBegin = GetTileSlope(begin, &heightBegin); Slope slopeBegin = GetTilePixelSlope(begin, &heightBegin);
Slope slopeEnd = GetTileSlope(end, &heightEnd); Slope slopeEnd = GetTilePixelSlope(end, &heightEnd);
return heightEnd <= heightBegin && return heightEnd <= heightBegin &&
/* Slope either is inclined or flat; rivers don't support other slopes. */ /* Slope either is inclined or flat; rivers don't support other slopes. */
@ -1113,7 +1113,7 @@ static bool FlowRiver(bool *marks, TileIndex spring, TileIndex begin)
queue.pop_front(); queue.pop_front();
uint height2 = TileHeight(end); uint height2 = TileHeight(end);
if (GetTileSlope(end, NULL) == SLOPE_FLAT && (height2 < height || (height2 == height && IsWaterTile(end)))) { if (GetTilePixelSlope(end, NULL) == SLOPE_FLAT && (height2 < height || (height2 == height && IsWaterTile(end)))) {
found = true; found = true;
break; break;
} }
@ -1140,7 +1140,7 @@ static bool FlowRiver(bool *marks, TileIndex spring, TileIndex begin)
if (IsValidTile(lakeCenter) && if (IsValidTile(lakeCenter) &&
/* A river, or lake, can only be built on flat slopes. */ /* A river, or lake, can only be built on flat slopes. */
GetTileSlope(lakeCenter, NULL) == SLOPE_FLAT && GetTilePixelSlope(lakeCenter, NULL) == SLOPE_FLAT &&
/* We want the lake to be built at the height of the river. */ /* We want the lake to be built at the height of the river. */
TileHeight(begin) == TileHeight(lakeCenter) && TileHeight(begin) == TileHeight(lakeCenter) &&
/* We don't want the lake at the entry of the valley. */ /* We don't want the lake at the entry of the valley. */

14
src/landscape.h
View File

@ -35,11 +35,11 @@ byte HighestSnowLine();
byte LowestSnowLine(); byte LowestSnowLine();
void ClearSnowLine(); void ClearSnowLine();
uint GetPartialZ(int x, int y, Slope corners); uint GetPartialPixelZ(int x, int y, Slope corners);
uint GetSlopeZ(int x, int y); uint GetSlopePixelZ(int x, int y);
void GetSlopeZOnEdge(Slope tileh, DiagDirection edge, int *z1, int *z2); void GetSlopePixelZOnEdge(Slope tileh, DiagDirection edge, int *z1, int *z2);
int GetSlopeZInCorner(Slope tileh, Corner corner); int GetSlopePixelZInCorner(Slope tileh, Corner corner);
Slope GetFoundationSlope(TileIndex tile, uint *z); Slope GetFoundationPixelSlope(TileIndex tile, uint *z);
/** /**
* Map 3D world or tile coordinate to equivalent 2D coordinate as used in the viewports and smallmap. * Map 3D world or tile coordinate to equivalent 2D coordinate as used in the viewports and smallmap.
@ -67,7 +67,7 @@ static inline Point RemapCoords(int x, int y, int z)
*/ */
static inline Point RemapCoords2(int x, int y) static inline Point RemapCoords2(int x, int y)
{ {
return RemapCoords(x, y, GetSlopeZ(x, y)); return RemapCoords(x, y, GetSlopePixelZ(x, y));
} }
/** /**
@ -84,7 +84,7 @@ static inline Point InverseRemapCoords(int x, int y)
return pt; return pt;
} }
uint ApplyFoundationToSlope(Foundation f, Slope *s); uint ApplyPixelFoundationToSlope(Foundation f, Slope *s);
void DrawFoundation(TileInfo *ti, Foundation f); void DrawFoundation(TileInfo *ti, Foundation f);
bool HasFoundationNW(TileIndex tile, Slope slope_here, uint z_here); bool HasFoundationNW(TileIndex tile, Slope slope_here, uint z_here);
bool HasFoundationNE(TileIndex tile, Slope slope_here, uint z_here); bool HasFoundationNE(TileIndex tile, Slope slope_here, uint z_here);

2
src/misc_gui.cpp
View File

@ -221,7 +221,7 @@ public:
snprintf(tmp, lengthof(tmp), "0x%.4X", tile); snprintf(tmp, lengthof(tmp), "0x%.4X", tile);
SetDParam(0, TileX(tile)); SetDParam(0, TileX(tile));
SetDParam(1, TileY(tile)); SetDParam(1, TileY(tile));
SetDParam(2, GetTileZ(tile) / TILE_HEIGHT); SetDParam(2, GetTilePixelZ(tile) / TILE_HEIGHT);
SetDParamStr(3, tmp); SetDParamStr(3, tmp);
GetString(this->landinfo_data[line_nr], STR_LAND_AREA_INFORMATION_LANDINFO_COORDS, lastof(this->landinfo_data[line_nr])); GetString(this->landinfo_data[line_nr], STR_LAND_AREA_INFORMATION_LANDINFO_COORDS, lastof(this->landinfo_data[line_nr]));
line_nr++; line_nr++;

2
src/newgrf_canal.cpp
View File

@ -48,7 +48,7 @@ static uint32 CanalGetVariable(const ResolverObject *object, byte variable, byte
switch (variable) { switch (variable) {
/* Height of tile */ /* Height of tile */
case 0x80: { case 0x80: {
uint z = GetTileZ(tile) / TILE_HEIGHT; uint z = GetTilePixelZ(tile) / TILE_HEIGHT;
/* Return consistent height within locks */ /* Return consistent height within locks */
if (IsTileType(tile, MP_WATER) && IsLock(tile) && GetLockPart(tile) == LOCK_PART_UPPER) z--; if (IsTileType(tile, MP_WATER) && IsLock(tile) && GetLockPart(tile) == LOCK_PART_UPPER) z--;
return z; return z;

8
src/newgrf_commons.cpp
View File

@ -380,7 +380,7 @@ uint32 GetTerrainType(TileIndex tile, TileContext context)
case MP_TUNNELBRIDGE: case MP_TUNNELBRIDGE:
if (context == TCX_ON_BRIDGE) { if (context == TCX_ON_BRIDGE) {
has_snow = (GetBridgeHeight(tile) > GetSnowLine()); has_snow = (GetBridgePixelHeight(tile) > GetSnowLine());
} else { } else {
/* During map generation the snowstate may not be valid yet, as the tileloop may not have run yet. */ /* During map generation the snowstate may not be valid yet, as the tileloop may not have run yet. */
if (_generating_world) goto genworld; // we do not care about foundations here if (_generating_world) goto genworld; // we do not care about foundations here
@ -393,13 +393,13 @@ uint32 GetTerrainType(TileIndex tile, TileContext context)
case MP_INDUSTRY: case MP_INDUSTRY:
case MP_OBJECT: case MP_OBJECT:
/* These tiles usually have a levelling foundation. So use max Z */ /* These tiles usually have a levelling foundation. So use max Z */
has_snow = (GetTileMaxZ(tile) > GetSnowLine()); has_snow = (GetTileMaxPixelZ(tile) > GetSnowLine());
break; break;
case MP_VOID: case MP_VOID:
case MP_WATER: case MP_WATER:
genworld: genworld:
has_snow = (GetTileZ(tile) > GetSnowLine()); has_snow = (GetTilePixelZ(tile) > GetSnowLine());
break; break;
default: NOT_REACHED(); default: NOT_REACHED();
@ -448,7 +448,7 @@ uint32 GetNearbyTileInformation(TileIndex tile)
if (IsTileType(tile, MP_TREES) && GetTreeGround(tile) == TREE_GROUND_SHORE) tile_type = MP_WATER; if (IsTileType(tile, MP_TREES) && GetTreeGround(tile) == TREE_GROUND_SHORE) tile_type = MP_WATER;
uint z; uint z;
Slope tileh = GetTileSlope(tile, &z); Slope tileh = GetTilePixelSlope(tile, &z);
/* Return 0 if the tile is a land tile */ /* Return 0 if the tile is a land tile */
byte terrain_type = (HasTileWaterClass(tile) ? (GetWaterClass(tile) + 1) & 3 : 0) << 5 | GetTerrainType(tile) << 2 | (tile_type == MP_WATER ? 1 : 0) << 1; byte terrain_type = (HasTileWaterClass(tile) ? (GetWaterClass(tile) + 1) & 3 : 0) << 5 | GetTerrainType(tile) << 2 | (tile_type == MP_WATER ? 1 : 0) << 1;
return tile_type << 24 | z << 16 | terrain_type << 8 | tileh; return tile_type << 24 | z << 16 | terrain_type << 8 | tileh;

2
src/newgrf_industries.cpp
View File

@ -488,7 +488,7 @@ uint32 IndustryLocationGetVariable(const ResolverObject *object, byte variable,
case 0x89: return min(DistanceManhattan(industry->town->xy, tile), 255); case 0x89: return min(DistanceManhattan(industry->town->xy, tile), 255);
/* Lowest height of the tile */ /* Lowest height of the tile */
case 0x8A: return GetTileZ(tile); case 0x8A: return GetTilePixelZ(tile);
/* Distance to the nearest water/land tile */ /* Distance to the nearest water/land tile */
case 0x8B: return GetClosestWaterDistance(tile, (GetIndustrySpec(industry->type)->behaviour & INDUSTRYBEH_BUILT_ONWATER) == 0); case 0x8B: return GetClosestWaterDistance(tile, (GetIndustrySpec(industry->type)->behaviour & INDUSTRYBEH_BUILT_ONWATER) == 0);

2
src/newgrf_industrytiles.cpp
View File

@ -295,7 +295,7 @@ CommandCost PerformIndustryTileSlopeCheck(TileIndex ind_base_tile, TileIndex ind
uint16 callback_res = GetIndustryTileCallback(CBID_INDTILE_SHAPE_CHECK, 0, creation_type << 8 | itspec_index, gfx, &ind, ind_tile); uint16 callback_res = GetIndustryTileCallback(CBID_INDTILE_SHAPE_CHECK, 0, creation_type << 8 | itspec_index, gfx, &ind, ind_tile);
if (callback_res == CALLBACK_FAILED) { if (callback_res == CALLBACK_FAILED) {
if (!IsSlopeRefused(GetTileSlope(ind_tile, NULL), its->slopes_refused)) return CommandCost(); if (!IsSlopeRefused(GetTilePixelSlope(ind_tile, NULL), its->slopes_refused)) return CommandCost();
return_cmd_error(STR_ERROR_SITE_UNSUITABLE); return_cmd_error(STR_ERROR_SITE_UNSUITABLE);
} }
if (its->grf_prop.grffile->grf_version < 7) { if (its->grf_prop.grffile->grf_version < 7) {

2
src/newgrf_object.cpp
View File

@ -289,7 +289,7 @@ static uint32 ObjectGetVariable(const ResolverObject *object, byte variable, byt
} }
/* Tile information. */ /* Tile information. */
case 0x41: return GetTileSlope(tile, NULL) << 8 | GetTerrainType(tile); case 0x41: return GetTilePixelSlope(tile, NULL) << 8 | GetTerrainType(tile);
/* Construction date */ /* Construction date */
case 0x42: return o->build_date; case 0x42: return o->build_date;

6
src/newgrf_station.cpp
View File

@ -293,7 +293,7 @@ static uint32 StationGetVariable(const ResolverObject *object, byte variable, by
if (object->u.station.axis != INVALID_AXIS && tile != INVALID_TILE) { if (object->u.station.axis != INVALID_AXIS && tile != INVALID_TILE) {
if (parameter != 0) tile = GetNearbyTile(parameter, tile, true, object->u.station.axis); // only perform if it is required if (parameter != 0) tile = GetNearbyTile(parameter, tile, true, object->u.station.axis); // only perform if it is required
Slope tileh = GetTileSlope(tile, NULL); Slope tileh = GetTilePixelSlope(tile, NULL);
bool swap = (object->u.station.axis == AXIS_Y && HasBit(tileh, CORNER_W) != HasBit(tileh, CORNER_E)); bool swap = (object->u.station.axis == AXIS_Y && HasBit(tileh, CORNER_W) != HasBit(tileh, CORNER_E));
return GetNearbyTileInformation(tile) ^ (swap ? SLOPE_EW : 0); return GetNearbyTileInformation(tile) ^ (swap ? SLOPE_EW : 0);
@ -350,7 +350,7 @@ static uint32 StationGetVariable(const ResolverObject *object, byte variable, by
if (parameter != 0) tile = GetNearbyTile(parameter, tile); // only perform if it is required if (parameter != 0) tile = GetNearbyTile(parameter, tile); // only perform if it is required
Slope tileh = GetTileSlope(tile, NULL); Slope tileh = GetTilePixelSlope(tile, NULL);
bool swap = (axis == AXIS_Y && HasBit(tileh, CORNER_W) != HasBit(tileh, CORNER_E)); bool swap = (axis == AXIS_Y && HasBit(tileh, CORNER_W) != HasBit(tileh, CORNER_E));
return GetNearbyTileInformation(tile) ^ (swap ? SLOPE_EW : 0); return GetNearbyTileInformation(tile) ^ (swap ? SLOPE_EW : 0);
@ -678,7 +678,7 @@ uint16 GetStationCallback(CallbackID callback, uint32 param1, uint32 param2, con
CommandCost PerformStationTileSlopeCheck(TileIndex north_tile, TileIndex cur_tile, const StationSpec *statspec, Axis axis, byte plat_len, byte numtracks) CommandCost PerformStationTileSlopeCheck(TileIndex north_tile, TileIndex cur_tile, const StationSpec *statspec, Axis axis, byte plat_len, byte numtracks)
{ {
TileIndexDiff diff = cur_tile - north_tile; TileIndexDiff diff = cur_tile - north_tile;
Slope slope = GetTileSlope(cur_tile, NULL); Slope slope = GetTilePixelSlope(cur_tile, NULL);
ResolverObject object; ResolverObject object;
NewStationResolver(&object, statspec, NULL, cur_tile); NewStationResolver(&object, statspec, NULL, cur_tile);

26
src/object_cmd.cpp
View File

@ -230,13 +230,13 @@ CommandCost CmdBuildObject(TileIndex tile, DoCommandFlag flags, uint32 p1, uint3
/* So, now the surface is checked... check the slope of said surface. */ /* So, now the surface is checked... check the slope of said surface. */
int allowed_z; int allowed_z;
if (GetTileSlope(tile, (uint*)&allowed_z) != SLOPE_FLAT) allowed_z += TILE_HEIGHT; if (GetTilePixelSlope(tile, (uint*)&allowed_z) != SLOPE_FLAT) allowed_z += TILE_HEIGHT;
TILE_AREA_LOOP(t, ta) { TILE_AREA_LOOP(t, ta) {
uint16 callback = CALLBACK_FAILED; uint16 callback = CALLBACK_FAILED;
if (HasBit(spec->callback_mask, CBM_OBJ_SLOPE_CHECK)) { if (HasBit(spec->callback_mask, CBM_OBJ_SLOPE_CHECK)) {
TileIndex diff = t - tile; TileIndex diff = t - tile;
callback = GetObjectCallback(CBID_OBJECT_LAND_SLOPE_CHECK, GetTileSlope(t, NULL), TileY(diff) << 4 | TileX(diff), spec, NULL, t, view); callback = GetObjectCallback(CBID_OBJECT_LAND_SLOPE_CHECK, GetTilePixelSlope(t, NULL), TileY(diff) << 4 | TileX(diff), spec, NULL, t, view);
} }
if (callback == CALLBACK_FAILED) { if (callback == CALLBACK_FAILED) {
@ -267,7 +267,7 @@ CommandCost CmdBuildObject(TileIndex tile, DoCommandFlag flags, uint32 p1, uint3
TILE_AREA_LOOP(t, ta) { TILE_AREA_LOOP(t, ta) {
if (MayHaveBridgeAbove(t) && IsBridgeAbove(t) && ( if (MayHaveBridgeAbove(t) && IsBridgeAbove(t) && (
!(spec->flags & OBJECT_FLAG_ALLOW_UNDER_BRIDGE) || !(spec->flags & OBJECT_FLAG_ALLOW_UNDER_BRIDGE) ||
(GetTileMaxZ(t) + spec->height * TILE_HEIGHT >= GetBridgeHeight(GetSouthernBridgeEnd(t))))) { (GetTileMaxPixelZ(t) + spec->height * TILE_HEIGHT >= GetBridgePixelHeight(GetSouthernBridgeEnd(t))))) {
return_cmd_error(STR_ERROR_MUST_DEMOLISH_BRIDGE_FIRST); return_cmd_error(STR_ERROR_MUST_DEMOLISH_BRIDGE_FIRST);
} }
} }
@ -276,7 +276,7 @@ CommandCost CmdBuildObject(TileIndex tile, DoCommandFlag flags, uint32 p1, uint3
switch (type) { switch (type) {
case OBJECT_TRANSMITTER: case OBJECT_TRANSMITTER:
case OBJECT_LIGHTHOUSE: case OBJECT_LIGHTHOUSE:
if (GetTileSlope(tile, NULL) != SLOPE_FLAT) return_cmd_error(STR_ERROR_FLAT_LAND_REQUIRED); if (GetTilePixelSlope(tile, NULL) != SLOPE_FLAT) return_cmd_error(STR_ERROR_FLAT_LAND_REQUIRED);
break; break;
case OBJECT_OWNED_LAND: case OBJECT_OWNED_LAND:
@ -381,15 +381,15 @@ static void DrawTile_Object(TileInfo *ti)
if (spec->flags & OBJECT_FLAG_ALLOW_UNDER_BRIDGE) DrawBridgeMiddle(ti); if (spec->flags & OBJECT_FLAG_ALLOW_UNDER_BRIDGE) DrawBridgeMiddle(ti);
} }
static uint GetSlopeZ_Object(TileIndex tile, uint x, uint y) static uint GetSlopePixelZ_Object(TileIndex tile, uint x, uint y)
{ {
if (IsOwnedLand(tile)) { if (IsOwnedLand(tile)) {
uint z; uint z;
Slope tileh = GetTileSlope(tile, &z); Slope tileh = GetTilePixelSlope(tile, &z);
return z + GetPartialZ(x & 0xF, y & 0xF, tileh); return z + GetPartialPixelZ(x & 0xF, y & 0xF, tileh);
} else { } else {
return GetTileMaxZ(tile); return GetTileMaxPixelZ(tile);
} }
} }
@ -643,7 +643,7 @@ void GenerateObjects()
TileIndex tile = RandomTile(); TileIndex tile = RandomTile();
uint h; uint h;
if (IsTileType(tile, MP_CLEAR) && GetTileSlope(tile, &h) == SLOPE_FLAT && h >= TILE_HEIGHT * 4 && !IsBridgeAbove(tile)) { if (IsTileType(tile, MP_CLEAR) && GetTilePixelSlope(tile, &h) == SLOPE_FLAT && h >= TILE_HEIGHT * 4 && !IsBridgeAbove(tile)) {
TileIndex t = tile; TileIndex t = tile;
if (CircularTileSearch(&t, 9, HasTransmitter, NULL)) continue; if (CircularTileSearch(&t, 9, HasTransmitter, NULL)) continue;
@ -680,7 +680,7 @@ void GenerateObjects()
for (int j = 0; j < 19; j++) { for (int j = 0; j < 19; j++) {
uint h; uint h;
if (IsTileType(tile, MP_CLEAR) && GetTileSlope(tile, &h) == SLOPE_FLAT && h <= TILE_HEIGHT * 2 && !IsBridgeAbove(tile)) { if (IsTileType(tile, MP_CLEAR) && GetTilePixelSlope(tile, &h) == SLOPE_FLAT && h <= TILE_HEIGHT * 2 && !IsBridgeAbove(tile)) {
BuildObject(OBJECT_LIGHTHOUSE, tile); BuildObject(OBJECT_LIGHTHOUSE, tile);
IncreaseGeneratingWorldProgress(GWP_OBJECT); IncreaseGeneratingWorldProgress(GWP_OBJECT);
lighthouses_to_build--; lighthouses_to_build--;
@ -731,9 +731,9 @@ static CommandCost TerraformTile_Object(TileIndex tile, DoCommandFlag flags, uin
* - Allow autoslope by default. * - Allow autoslope by default.
* - Disallow autoslope if callback succeeds and returns non-zero. * - Disallow autoslope if callback succeeds and returns non-zero.
*/ */
Slope tileh_old = GetTileSlope(tile, NULL); Slope tileh_old = GetTilePixelSlope(tile, NULL);
/* TileMaxZ must not be changed. Slopes must not be steep. */ /* TileMaxZ must not be changed. Slopes must not be steep. */
if (!IsSteepSlope(tileh_old) && !IsSteepSlope(tileh_new) && (GetTileMaxZ(tile) == z_new + GetSlopeMaxZ(tileh_new))) { if (!IsSteepSlope(tileh_old) && !IsSteepSlope(tileh_new) && (GetTileMaxPixelZ(tile) == z_new + GetSlopeMaxPixelZ(tileh_new))) {
const ObjectSpec *spec = ObjectSpec::Get(type); const ObjectSpec *spec = ObjectSpec::Get(type);
/* Call callback 'disable autosloping for objects'. */ /* Call callback 'disable autosloping for objects'. */
@ -753,7 +753,7 @@ static CommandCost TerraformTile_Object(TileIndex tile, DoCommandFlag flags, uin
extern const TileTypeProcs _tile_type_object_procs = { extern const TileTypeProcs _tile_type_object_procs = {
DrawTile_Object, // draw_tile_proc DrawTile_Object, // draw_tile_proc
GetSlopeZ_Object, // get_slope_z_proc GetSlopePixelZ_Object, // get_slope_z_proc
ClearTile_Object, // clear_tile_proc ClearTile_Object, // clear_tile_proc
AddAcceptedCargo_Object, // add_accepted_cargo_proc AddAcceptedCargo_Object, // add_accepted_cargo_proc
GetTileDesc_Object, // get_tile_desc_proc GetTileDesc_Object, // get_tile_desc_proc

4
src/pathfinder/npf/npf.cpp
View File

@ -237,8 +237,8 @@ static uint NPFSlopeCost(AyStarNode *current)
/* Get the height on both sides of the tile edge. /* Get the height on both sides of the tile edge.
* Avoid testing the height on the tile-center. This will fail for halftile-foundations. * Avoid testing the height on the tile-center. This will fail for halftile-foundations.
*/ */
int z1 = GetSlopeZ(x1 + dx4, y1 + dy4); int z1 = GetSlopePixelZ(x1 + dx4, y1 + dy4);
int z2 = GetSlopeZ(x2 - dx4, y2 - dy4); int z2 = GetSlopePixelZ(x2 - dx4, y2 - dy4);
if (z2 - z1 > 1) { if (z2 - z1 > 1) {
/* Slope up */ /* Slope up */

4
src/pathfinder/yapf/yapf_costbase.hpp
View File

@ -27,13 +27,13 @@ struct CYapfCostBase {
/* it is bridge ramp, check if we are entering the bridge */ /* it is bridge ramp, check if we are entering the bridge */
if (GetTunnelBridgeDirection(tile) != TrackdirToExitdir(td)) return false; // no, we are leaving it, no penalty if (GetTunnelBridgeDirection(tile) != TrackdirToExitdir(td)) return false; // no, we are leaving it, no penalty
/* we are entering the bridge */ /* we are entering the bridge */
Slope tile_slope = GetTileSlope(tile, NULL); Slope tile_slope = GetTilePixelSlope(tile, NULL);
Axis axis = DiagDirToAxis(GetTunnelBridgeDirection(tile)); Axis axis = DiagDirToAxis(GetTunnelBridgeDirection(tile));
return !HasBridgeFlatRamp(tile_slope, axis); return !HasBridgeFlatRamp(tile_slope, axis);
} else { } else {
/* not bridge ramp */ /* not bridge ramp */
if (IsTunnelTile(tile)) return false; // tunnel entry/exit doesn't slope if (IsTunnelTile(tile)) return false; // tunnel entry/exit doesn't slope
Slope tile_slope = GetTileSlope(tile, NULL); Slope tile_slope = GetTilePixelSlope(tile, NULL);
return IsUphillTrackdir(tile_slope, td); // slopes uphill => apply penalty return IsUphillTrackdir(tile_slope, td); // slopes uphill => apply penalty
} }
} }

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

@ -36,12 +36,12 @@ protected:
/* height of the center of the current tile */ /* height of the center of the current tile */
int x1 = TileX(tile) * TILE_SIZE; int x1 = TileX(tile) * TILE_SIZE;
int y1 = TileY(tile) * TILE_SIZE; int y1 = TileY(tile) * TILE_SIZE;
int z1 = GetSlopeZ(x1 + TILE_SIZE / 2, y1 + TILE_SIZE / 2); int z1 = GetSlopePixelZ(x1 + TILE_SIZE / 2, y1 + TILE_SIZE / 2);
/* height of the center of the next tile */ /* height of the center of the next tile */
int x2 = TileX(next_tile) * TILE_SIZE; int x2 = TileX(next_tile) * TILE_SIZE;
int y2 = TileY(next_tile) * TILE_SIZE; int y2 = TileY(next_tile) * TILE_SIZE;
int z2 = GetSlopeZ(x2 + TILE_SIZE / 2, y2 + TILE_SIZE / 2); int z2 = GetSlopePixelZ(x2 + TILE_SIZE / 2, y2 + TILE_SIZE / 2);
if (z2 - z1 > 1) { if (z2 - z1 > 1) {
/* Slope up */ /* Slope up */

48
src/rail_cmd.cpp
View File

@ -381,7 +381,7 @@ CommandCost CmdBuildSingleRail(TileIndex tile, DoCommandFlag flags, uint32 p1, u
if (!ValParamRailtype(railtype) || !ValParamTrackOrientation(track)) return CMD_ERROR; if (!ValParamRailtype(railtype) || !ValParamTrackOrientation(track)) return CMD_ERROR;
Slope tileh = GetTileSlope(tile, NULL); Slope tileh = GetTilePixelSlope(tile, NULL);
TrackBits trackbit = TrackToTrackBits(track); TrackBits trackbit = TrackToTrackBits(track);
switch (GetTileType(tile)) { switch (GetTileType(tile)) {
@ -590,7 +590,7 @@ CommandCost CmdRemoveSingleRail(TileIndex tile, DoCommandFlag flags, uint32 p1,
owner = GetTileOwner(tile); owner = GetTileOwner(tile);
present ^= trackbit; present ^= trackbit;
if (present == 0) { if (present == 0) {
Slope tileh = GetTileSlope(tile, NULL); Slope tileh = GetTilePixelSlope(tile, NULL);
/* If there is flat water on the lower halftile, convert the tile to shore so the water remains */ /* If there is flat water on the lower halftile, convert the tile to shore so the water remains */
if (GetRailGroundType(tile) == RAIL_GROUND_WATER && IsSlopeWithOneCornerRaised(tileh)) { if (GetRailGroundType(tile) == RAIL_GROUND_WATER && IsSlopeWithOneCornerRaised(tileh)) {
MakeShore(tile); MakeShore(tile);
@ -649,7 +649,7 @@ bool FloodHalftile(TileIndex t)
bool flooded = false; bool flooded = false;
if (GetRailGroundType(t) == RAIL_GROUND_WATER) return flooded; if (GetRailGroundType(t) == RAIL_GROUND_WATER) return flooded;
Slope tileh = GetTileSlope(t, NULL); Slope tileh = GetTilePixelSlope(t, NULL);
TrackBits rail_bits = GetTrackBits(t); TrackBits rail_bits = GetTrackBits(t);
if (IsSlopeWithOneCornerRaised(tileh)) { if (IsSlopeWithOneCornerRaised(tileh)) {
@ -676,7 +676,7 @@ bool FloodHalftile(TileIndex t)
} }
} else { } else {
/* Make shore on steep slopes and 'three-corners-raised'-slopes. */ /* Make shore on steep slopes and 'three-corners-raised'-slopes. */
if (ApplyFoundationToSlope(GetRailFoundation(tileh, rail_bits), &tileh) == 0) { if (ApplyPixelFoundationToSlope(GetRailFoundation(tileh, rail_bits), &tileh) == 0) {
if (IsSteepSlope(tileh) || IsSlopeWithThreeCornersRaised(tileh)) { if (IsSteepSlope(tileh) || IsSlopeWithThreeCornersRaised(tileh)) {
flooded = true; flooded = true;
SetRailGroundType(t, RAIL_GROUND_WATER); SetRailGroundType(t, RAIL_GROUND_WATER);
@ -861,7 +861,7 @@ CommandCost CmdBuildTrainDepot(TileIndex tile, DoCommandFlag flags, uint32 p1, u
RailType railtype = Extract<RailType, 0, 4>(p1); RailType railtype = Extract<RailType, 0, 4>(p1);
if (!ValParamRailtype(railtype)) return CMD_ERROR; if (!ValParamRailtype(railtype)) return CMD_ERROR;
Slope tileh = GetTileSlope(tile, NULL); Slope tileh = GetTilePixelSlope(tile, NULL);
DiagDirection dir = Extract<DiagDirection, 0, 2>(p2); DiagDirection dir = Extract<DiagDirection, 0, 2>(p2);
@ -1637,7 +1637,7 @@ static CommandCost ClearTile_Track(TileIndex tile, DoCommandFlag flags)
switch (GetRailTileType(tile)) { switch (GetRailTileType(tile)) {
case RAIL_TILE_SIGNALS: case RAIL_TILE_SIGNALS:
case RAIL_TILE_NORMAL: { case RAIL_TILE_NORMAL: {
Slope tileh = GetTileSlope(tile, NULL); Slope tileh = GetTilePixelSlope(tile, NULL);
/* Is there flat water on the lower halftile that gets cleared expensively? */ /* Is there flat water on the lower halftile that gets cleared expensively? */
bool water_ground = (GetRailGroundType(tile) == RAIL_GROUND_WATER && IsSlopeWithOneCornerRaised(tileh)); bool water_ground = (GetRailGroundType(tile) == RAIL_GROUND_WATER && IsSlopeWithOneCornerRaised(tileh));
@ -1683,7 +1683,7 @@ static uint GetSaveSlopeZ(uint x, uint y, Track track)
case TRACK_RIGHT: x &= ~0xF; y |= 0xF; break; case TRACK_RIGHT: x &= ~0xF; y |= 0xF; break;
default: break; default: break;
} }
return GetSlopeZ(x, y); return GetSlopePixelZ(x, y);
} }
static void DrawSingleSignal(TileIndex tile, Track track, byte condition, uint image, uint pos) static void DrawSingleSignal(TileIndex tile, Track track, byte condition, uint image, uint pos)
@ -1774,7 +1774,7 @@ static void DrawTrackFence_NE_SW(const TileInfo *ti, SpriteID base_image)
*/ */
static void DrawTrackFence_NS_1(const TileInfo *ti, SpriteID base_image) static void DrawTrackFence_NS_1(const TileInfo *ti, SpriteID base_image)
{ {
uint z = ti->z + GetSlopeZInCorner(RemoveHalftileSlope(ti->tileh), CORNER_W); uint z = ti->z + GetSlopePixelZInCorner(RemoveHalftileSlope(ti->tileh), CORNER_W);
AddSortableSpriteToDraw(base_image + RFO_FLAT_VERT, _drawtile_track_palette, AddSortableSpriteToDraw(base_image + RFO_FLAT_VERT, _drawtile_track_palette,
ti->x + TILE_SIZE / 2, ti->y + TILE_SIZE / 2, 1, 1, 4, z); ti->x + TILE_SIZE / 2, ti->y + TILE_SIZE / 2, 1, 1, 4, z);
} }
@ -1784,7 +1784,7 @@ static void DrawTrackFence_NS_1(const TileInfo *ti, SpriteID base_image)
*/ */
static void DrawTrackFence_NS_2(const TileInfo *ti, SpriteID base_image) static void DrawTrackFence_NS_2(const TileInfo *ti, SpriteID base_image)
{ {
uint z = ti->z + GetSlopeZInCorner(RemoveHalftileSlope(ti->tileh), CORNER_E); uint z = ti->z + GetSlopePixelZInCorner(RemoveHalftileSlope(ti->tileh), CORNER_E);
AddSortableSpriteToDraw(base_image + RFO_FLAT_VERT, _drawtile_track_palette, AddSortableSpriteToDraw(base_image + RFO_FLAT_VERT, _drawtile_track_palette,
ti->x + TILE_SIZE / 2, ti->y + TILE_SIZE / 2, 1, 1, 4, z); ti->x + TILE_SIZE / 2, ti->y + TILE_SIZE / 2, 1, 1, 4, z);
} }
@ -1794,7 +1794,7 @@ static void DrawTrackFence_NS_2(const TileInfo *ti, SpriteID base_image)
*/ */
static void DrawTrackFence_WE_1(const TileInfo *ti, SpriteID base_image) static void DrawTrackFence_WE_1(const TileInfo *ti, SpriteID base_image)
{ {
uint z = ti->z + GetSlopeZInCorner(RemoveHalftileSlope(ti->tileh), CORNER_N); uint z = ti->z + GetSlopePixelZInCorner(RemoveHalftileSlope(ti->tileh), CORNER_N);
AddSortableSpriteToDraw(base_image + RFO_FLAT_HORZ, _drawtile_track_palette, AddSortableSpriteToDraw(base_image + RFO_FLAT_HORZ, _drawtile_track_palette,
ti->x + TILE_SIZE / 2, ti->y + TILE_SIZE / 2, 1, 1, 4, z); ti->x + TILE_SIZE / 2, ti->y + TILE_SIZE / 2, 1, 1, 4, z);
} }
@ -1804,7 +1804,7 @@ static void DrawTrackFence_WE_1(const TileInfo *ti, SpriteID base_image)
*/ */
static void DrawTrackFence_WE_2(const TileInfo *ti, SpriteID base_image) static void DrawTrackFence_WE_2(const TileInfo *ti, SpriteID base_image)
{ {
uint z = ti->z + GetSlopeZInCorner(RemoveHalftileSlope(ti->tileh), CORNER_S); uint z = ti->z + GetSlopePixelZInCorner(RemoveHalftileSlope(ti->tileh), CORNER_S);
AddSortableSpriteToDraw(base_image + RFO_FLAT_HORZ, _drawtile_track_palette, AddSortableSpriteToDraw(base_image + RFO_FLAT_HORZ, _drawtile_track_palette,
ti->x + TILE_SIZE / 2, ti->y + TILE_SIZE / 2, 1, 1, 4, z); ti->x + TILE_SIZE / 2, ti->y + TILE_SIZE / 2, 1, 1, 4, z);
} }
@ -2335,17 +2335,17 @@ void DrawTrainDepotSprite(int x, int y, int dir, RailType railtype)
DrawRailTileSeqInGUI(x, y, dts, offset, 0, palette); DrawRailTileSeqInGUI(x, y, dts, offset, 0, palette);
} }
static uint GetSlopeZ_Track(TileIndex tile, uint x, uint y) static uint GetSlopePixelZ_Track(TileIndex tile, uint x, uint y)
{ {
if (IsPlainRail(tile)) { if (IsPlainRail(tile)) {
uint z; uint z;
Slope tileh = GetTileSlope(tile, &z); Slope tileh = GetTilePixelSlope(tile, &z);
if (tileh == SLOPE_FLAT) return z; if (tileh == SLOPE_FLAT) return z;
z += ApplyFoundationToSlope(GetRailFoundation(tileh, GetTrackBits(tile)), &tileh); z += ApplyPixelFoundationToSlope(GetRailFoundation(tileh, GetTrackBits(tile)), &tileh);
return z + GetPartialZ(x & 0xF, y & 0xF, tileh); return z + GetPartialPixelZ(x & 0xF, y & 0xF, tileh);
} else { } else {
return GetTileMaxZ(tile); return GetTileMaxPixelZ(tile);
} }
} }
@ -2367,7 +2367,7 @@ static void TileLoop_Track(TileIndex tile)
switch (_settings_game.game_creation.landscape) { switch (_settings_game.game_creation.landscape) {
case LT_ARCTIC: { case LT_ARCTIC: {
uint z; uint z;
Slope slope = GetTileSlope(tile, &z); Slope slope = GetTilePixelSlope(tile, &z);
bool half = false; bool half = false;
/* for non-flat track, use lower part of track /* for non-flat track, use lower part of track
@ -2795,8 +2795,8 @@ static CommandCost TestAutoslopeOnRailTile(TileIndex tile, uint flags, uint z_ol
if (CheckRailSlope(tileh_new, rail_bits, TRACK_BIT_NONE, tile).Failed()) return_cmd_error(STR_ERROR_MUST_REMOVE_RAILROAD_TRACK); if (CheckRailSlope(tileh_new, rail_bits, TRACK_BIT_NONE, tile).Failed()) return_cmd_error(STR_ERROR_MUST_REMOVE_RAILROAD_TRACK);
/* Get the slopes on top of the foundations */ /* Get the slopes on top of the foundations */
z_old += ApplyFoundationToSlope(GetRailFoundation(tileh_old, rail_bits), &tileh_old); z_old += ApplyPixelFoundationToSlope(GetRailFoundation(tileh_old, rail_bits), &tileh_old);
z_new += ApplyFoundationToSlope(GetRailFoundation(tileh_new, rail_bits), &tileh_new); z_new += ApplyPixelFoundationToSlope(GetRailFoundation(tileh_new, rail_bits), &tileh_new);
Corner track_corner; Corner track_corner;
switch (rail_bits) { switch (rail_bits) {
@ -2812,8 +2812,8 @@ static CommandCost TestAutoslopeOnRailTile(TileIndex tile, uint flags, uint z_ol
} }
/* The height of the track_corner must not be changed. The rest ensures GetRailFoundation() already. */ /* The height of the track_corner must not be changed. The rest ensures GetRailFoundation() already. */
z_old += GetSlopeZInCorner(RemoveHalftileSlope(tileh_old), track_corner); z_old += GetSlopePixelZInCorner(RemoveHalftileSlope(tileh_old), track_corner);
z_new += GetSlopeZInCorner(RemoveHalftileSlope(tileh_new), track_corner); z_new += GetSlopePixelZInCorner(RemoveHalftileSlope(tileh_new), track_corner);
if (z_old != z_new) return_cmd_error(STR_ERROR_MUST_REMOVE_RAILROAD_TRACK); if (z_old != z_new) return_cmd_error(STR_ERROR_MUST_REMOVE_RAILROAD_TRACK);
CommandCost cost = CommandCost(EXPENSES_CONSTRUCTION, _price[PR_BUILD_FOUNDATION]); CommandCost cost = CommandCost(EXPENSES_CONSTRUCTION, _price[PR_BUILD_FOUNDATION]);
@ -2829,7 +2829,7 @@ static CommandCost TestAutoslopeOnRailTile(TileIndex tile, uint flags, uint z_ol
static CommandCost TerraformTile_Track(TileIndex tile, DoCommandFlag flags, uint z_new, Slope tileh_new) static CommandCost TerraformTile_Track(TileIndex tile, DoCommandFlag flags, uint z_new, Slope tileh_new)
{ {
uint z_old; uint z_old;
Slope tileh_old = GetTileSlope(tile, &z_old); Slope tileh_old = GetTilePixelSlope(tile, &z_old);
if (IsPlainRail(tile)) { if (IsPlainRail(tile)) {
TrackBits rail_bits = GetTrackBits(tile); TrackBits rail_bits = GetTrackBits(tile);
/* Is there flat water on the lower halftile that must be cleared expensively? */ /* Is there flat water on the lower halftile that must be cleared expensively? */
@ -2856,7 +2856,7 @@ static CommandCost TerraformTile_Track(TileIndex tile, DoCommandFlag flags, uint
/* Everything is valid, which only changes allowed_corner */ /* Everything is valid, which only changes allowed_corner */
for (Corner corner = (Corner)0; corner < CORNER_END; corner = (Corner)(corner + 1)) { for (Corner corner = (Corner)0; corner < CORNER_END; corner = (Corner)(corner + 1)) {
if (allowed_corner == corner) continue; if (allowed_corner == corner) continue;
if (z_old + GetSlopeZInCorner(tileh_old, corner) != z_new + GetSlopeZInCorner(tileh_new, corner)) return autoslope_result; if (z_old + GetSlopePixelZInCorner(tileh_old, corner) != z_new + GetSlopePixelZInCorner(tileh_new, corner)) return autoslope_result;
} }
/* Make the ground dirty */ /* Make the ground dirty */
@ -2874,7 +2874,7 @@ static CommandCost TerraformTile_Track(TileIndex tile, DoCommandFlag flags, uint
extern const TileTypeProcs _tile_type_rail_procs = { extern const TileTypeProcs _tile_type_rail_procs = {
DrawTile_Track, // draw_tile_proc DrawTile_Track, // draw_tile_proc
GetSlopeZ_Track, // get_slope_z_proc GetSlopePixelZ_Track, // get_slope_z_proc
ClearTile_Track, // clear_tile_proc ClearTile_Track, // clear_tile_proc
NULL, // add_accepted_cargo_proc NULL, // add_accepted_cargo_proc
GetTileDesc_Track, // get_tile_desc_proc GetTileDesc_Track, // get_tile_desc_proc

2
src/road.cpp
View File

@ -32,7 +32,7 @@ static bool IsPossibleCrossing(const TileIndex tile, Axis ax)
return (IsTileType(tile, MP_RAILWAY) && return (IsTileType(tile, MP_RAILWAY) &&
GetRailTileType(tile) == RAIL_TILE_NORMAL && GetRailTileType(tile) == RAIL_TILE_NORMAL &&
GetTrackBits(tile) == (ax == AXIS_X ? TRACK_BIT_Y : TRACK_BIT_X) && GetTrackBits(tile) == (ax == AXIS_X ? TRACK_BIT_Y : TRACK_BIT_X) &&
GetFoundationSlope(tile, NULL) == SLOPE_FLAT); GetFoundationPixelSlope(tile, NULL) == SLOPE_FLAT);
} }
/** /**

44
src/road_cmd.cpp
View File

@ -254,7 +254,7 @@ static CommandCost RemoveRoad(TileIndex tile, DoCommandFlag flags, RoadBits piec
switch (GetRoadTileType(tile)) { switch (GetRoadTileType(tile)) {
case ROAD_TILE_NORMAL: { case ROAD_TILE_NORMAL: {
Slope tileh = GetTileSlope(tile, NULL); Slope tileh = GetTilePixelSlope(tile, NULL);
/* Steep slopes behave the same as slopes with one corner raised. */ /* Steep slopes behave the same as slopes with one corner raised. */
if (IsSteepSlope(tileh)) { if (IsSteepSlope(tileh)) {
@ -467,7 +467,7 @@ CommandCost CmdBuildRoad(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32
DisallowedRoadDirections toggle_drd = Extract<DisallowedRoadDirections, 6, 2>(p1); DisallowedRoadDirections toggle_drd = Extract<DisallowedRoadDirections, 6, 2>(p1);
Slope tileh = GetTileSlope(tile, NULL); Slope tileh = GetTilePixelSlope(tile, NULL);
bool need_to_clear = false; bool need_to_clear = false;
switch (GetTileType(tile)) { switch (GetTileType(tile)) {
@ -636,7 +636,7 @@ do_clear:;
/* Check if new road bits will have the same foundation as other existing road types */ /* Check if new road bits will have the same foundation as other existing road types */
if (IsNormalRoad(tile)) { if (IsNormalRoad(tile)) {
Slope slope = GetTileSlope(tile, NULL); Slope slope = GetTilePixelSlope(tile, NULL);
Foundation found_new = GetRoadFoundation(slope, pieces | existing); Foundation found_new = GetRoadFoundation(slope, pieces | existing);
/* Test if all other roadtypes can be built at that foundation */ /* Test if all other roadtypes can be built at that foundation */
@ -909,7 +909,7 @@ CommandCost CmdBuildRoadDepot(TileIndex tile, DoCommandFlag flags, uint32 p1, ui
if (!IsValidRoadType(rt) || !ValParamRoadType(rt)) return CMD_ERROR; if (!IsValidRoadType(rt) || !ValParamRoadType(rt)) return CMD_ERROR;
Slope tileh = GetTileSlope(tile, NULL); Slope tileh = GetTilePixelSlope(tile, NULL);
if (tileh != SLOPE_FLAT && ( if (tileh != SLOPE_FLAT && (
!_settings_game.construction.build_on_slopes || !_settings_game.construction.build_on_slopes ||
!CanBuildDepotByTileh(dir, tileh) !CanBuildDepotByTileh(dir, tileh)
@ -1080,9 +1080,9 @@ void DrawTramCatenary(const TileInfo *ti, RoadBits tram)
/* Don't draw the catenary under a low bridge */ /* Don't draw the catenary under a low bridge */
if (MayHaveBridgeAbove(ti->tile) && IsBridgeAbove(ti->tile) && !IsTransparencySet(TO_CATENARY)) { if (MayHaveBridgeAbove(ti->tile) && IsBridgeAbove(ti->tile) && !IsTransparencySet(TO_CATENARY)) {
uint height = GetBridgeHeight(GetNorthernBridgeEnd(ti->tile)); uint height = GetBridgePixelHeight(GetNorthernBridgeEnd(ti->tile));
if (height <= GetTileMaxZ(ti->tile) + TILE_HEIGHT) return; if (height <= GetTileMaxPixelZ(ti->tile) + TILE_HEIGHT) return;
} }
SpriteID front; SpriteID front;
@ -1113,7 +1113,7 @@ static void DrawRoadDetail(SpriteID img, const TileInfo *ti, int dx, int dy, int
int x = ti->x | dx; int x = ti->x | dx;
int y = ti->y | dy; int y = ti->y | dy;
byte z = ti->z; byte z = ti->z;
if (ti->tileh != SLOPE_FLAT) z = GetSlopeZ(x, y); if (ti->tileh != SLOPE_FLAT) z = GetSlopePixelZ(x, y);
AddSortableSpriteToDraw(img, PAL_NONE, x, y, 2, 2, h, z); AddSortableSpriteToDraw(img, PAL_NONE, x, y, 2, 2, h, z);
} }
@ -1170,7 +1170,7 @@ static void DrawRoadBits(TileInfo *ti)
if (road != ROAD_NONE) { if (road != ROAD_NONE) {
DisallowedRoadDirections drd = GetDisallowedRoadDirections(ti->tile); DisallowedRoadDirections drd = GetDisallowedRoadDirections(ti->tile);
if (drd != DRD_NONE) { if (drd != DRD_NONE) {
DrawGroundSpriteAt(SPR_ONEWAY_BASE + drd - 1 + ((road == ROAD_X) ? 0 : 3), PAL_NONE, 8, 8, GetPartialZ(8, 8, ti->tileh)); DrawGroundSpriteAt(SPR_ONEWAY_BASE + drd - 1 + ((road == ROAD_X) ? 0 : 3), PAL_NONE, 8, 8, GetPartialPixelZ(8, 8, ti->tileh));
} }
} }
@ -1187,8 +1187,8 @@ static void DrawRoadBits(TileInfo *ti)
/* Do not draw details (street lights, trees) under low bridge */ /* Do not draw details (street lights, trees) under low bridge */
if (MayHaveBridgeAbove(ti->tile) && IsBridgeAbove(ti->tile) && (roadside == ROADSIDE_TREES || roadside == ROADSIDE_STREET_LIGHTS)) { if (MayHaveBridgeAbove(ti->tile) && IsBridgeAbove(ti->tile) && (roadside == ROADSIDE_TREES || roadside == ROADSIDE_STREET_LIGHTS)) {
uint height = GetBridgeHeight(GetNorthernBridgeEnd(ti->tile)); uint height = GetBridgePixelHeight(GetNorthernBridgeEnd(ti->tile));
uint minz = GetTileMaxZ(ti->tile) + 2 * TILE_HEIGHT; uint minz = GetTileMaxPixelZ(ti->tile) + 2 * TILE_HEIGHT;
if (roadside == ROADSIDE_TREES) minz += TILE_HEIGHT; if (roadside == ROADSIDE_TREES) minz += TILE_HEIGHT;
@ -1337,19 +1337,19 @@ void UpdateNearestTownForRoadTiles(bool invalidate)
} }
} }
static uint GetSlopeZ_Road(TileIndex tile, uint x, uint y) static uint GetSlopePixelZ_Road(TileIndex tile, uint x, uint y)
{ {
if (IsNormalRoad(tile)) { if (IsNormalRoad(tile)) {
uint z; uint z;
Slope tileh = GetTileSlope(tile, &z); Slope tileh = GetTilePixelSlope(tile, &z);
if (tileh == SLOPE_FLAT) return z; if (tileh == SLOPE_FLAT) return z;
Foundation f = GetRoadFoundation(tileh, GetAllRoadBits(tile)); Foundation f = GetRoadFoundation(tileh, GetAllRoadBits(tile));
z += ApplyFoundationToSlope(f, &tileh); z += ApplyPixelFoundationToSlope(f, &tileh);
return z + GetPartialZ(x & 0xF, y & 0xF, tileh); return z + GetPartialPixelZ(x & 0xF, y & 0xF, tileh);
} else { } else {
return GetTileMaxZ(tile); return GetTileMaxPixelZ(tile);
} }
} }
@ -1383,7 +1383,7 @@ static void TileLoop_Road(TileIndex tile)
{ {
switch (_settings_game.game_creation.landscape) { switch (_settings_game.game_creation.landscape) {
case LT_ARCTIC: case LT_ARCTIC:
if (IsOnSnow(tile) != (GetTileZ(tile) > GetSnowLine())) { if (IsOnSnow(tile) != (GetTilePixelZ(tile) > GetSnowLine())) {
ToggleSnow(tile); ToggleSnow(tile);
MarkTileDirtyByTile(tile); MarkTileDirtyByTile(tile);
} }
@ -1410,7 +1410,7 @@ static void TileLoop_Road(TileIndex tile)
if (t->road_build_months != 0 && if (t->road_build_months != 0 &&
(DistanceManhattan(t->xy, tile) < 8 || grp != HZB_TOWN_EDGE) && (DistanceManhattan(t->xy, tile) < 8 || grp != HZB_TOWN_EDGE) &&
IsNormalRoad(tile) && !HasAtMostOneBit(GetAllRoadBits(tile))) { IsNormalRoad(tile) && !HasAtMostOneBit(GetAllRoadBits(tile))) {
if (GetFoundationSlope(tile, NULL) == SLOPE_FLAT && EnsureNoVehicleOnGround(tile).Succeeded() && Chance16(1, 40)) { if (GetFoundationPixelSlope(tile, NULL) == SLOPE_FLAT && EnsureNoVehicleOnGround(tile).Succeeded() && Chance16(1, 40)) {
StartRoadWorks(tile); StartRoadWorks(tile);
SndPlayTileFx(SND_21_JACKHAMMER, tile); SndPlayTileFx(SND_21_JACKHAMMER, tile);
@ -1682,7 +1682,7 @@ static CommandCost TerraformTile_Road(TileIndex tile, DoCommandFlag flags, uint
if (_settings_game.construction.build_on_slopes && AutoslopeEnabled()) { if (_settings_game.construction.build_on_slopes && AutoslopeEnabled()) {
switch (GetRoadTileType(tile)) { switch (GetRoadTileType(tile)) {
case ROAD_TILE_CROSSING: case ROAD_TILE_CROSSING:
if (!IsSteepSlope(tileh_new) && (GetTileMaxZ(tile) == z_new + GetSlopeMaxZ(tileh_new)) && HasBit(VALID_LEVEL_CROSSING_SLOPES, tileh_new)) return CommandCost(EXPENSES_CONSTRUCTION, _price[PR_BUILD_FOUNDATION]); if (!IsSteepSlope(tileh_new) && (GetTileMaxPixelZ(tile) == z_new + GetSlopeMaxPixelZ(tileh_new)) && HasBit(VALID_LEVEL_CROSSING_SLOPES, tileh_new)) return CommandCost(EXPENSES_CONSTRUCTION, _price[PR_BUILD_FOUNDATION]);
break; break;
case ROAD_TILE_DEPOT: case ROAD_TILE_DEPOT:
@ -1697,11 +1697,11 @@ static CommandCost TerraformTile_Road(TileIndex tile, DoCommandFlag flags, uint
/* CheckRoadSlope() sometimes changes the road_bits, if it does not agree with them. */ /* CheckRoadSlope() sometimes changes the road_bits, if it does not agree with them. */
if (bits == bits_copy) { if (bits == bits_copy) {
uint z_old; uint z_old;
Slope tileh_old = GetTileSlope(tile, &z_old); Slope tileh_old = GetTilePixelSlope(tile, &z_old);
/* Get the slope on top of the foundation */ /* Get the slope on top of the foundation */
z_old += ApplyFoundationToSlope(GetRoadFoundation(tileh_old, bits), &tileh_old); z_old += ApplyPixelFoundationToSlope(GetRoadFoundation(tileh_old, bits), &tileh_old);
z_new += ApplyFoundationToSlope(GetRoadFoundation(tileh_new, bits), &tileh_new); z_new += ApplyPixelFoundationToSlope(GetRoadFoundation(tileh_new, bits), &tileh_new);
/* The surface slope must not be changed */ /* The surface slope must not be changed */
if ((z_old == z_new) && (tileh_old == tileh_new)) return CommandCost(EXPENSES_CONSTRUCTION, _price[PR_BUILD_FOUNDATION]); if ((z_old == z_new) && (tileh_old == tileh_new)) return CommandCost(EXPENSES_CONSTRUCTION, _price[PR_BUILD_FOUNDATION]);
@ -1720,7 +1720,7 @@ static CommandCost TerraformTile_Road(TileIndex tile, DoCommandFlag flags, uint
/** Tile callback functions for road tiles */ /** Tile callback functions for road tiles */
extern const TileTypeProcs _tile_type_road_procs = { extern const TileTypeProcs _tile_type_road_procs = {
DrawTile_Road, // draw_tile_proc DrawTile_Road, // draw_tile_proc
GetSlopeZ_Road, // get_slope_z_proc GetSlopePixelZ_Road, // get_slope_z_proc
ClearTile_Road, // clear_tile_proc ClearTile_Road, // clear_tile_proc
NULL, // add_accepted_cargo_proc NULL, // add_accepted_cargo_proc
GetTileDesc_Road, // get_tile_desc_proc GetTileDesc_Road, // get_tile_desc_proc

4
src/roadveh.h
View File

@ -268,13 +268,13 @@ protected: // These functions should not be called outside acceleration code.
} }
/** /**
* Road vehicles have to use GetSlopeZ() to compute their height * Road vehicles have to use GetSlopePixelZ() to compute their height
* if they are reversing because in that case, their direction * if they are reversing because in that case, their direction
* is not parallel with the road. It is safe to return \c true * is not parallel with the road. It is safe to return \c true
* even if it is not reversing. * even if it is not reversing.
* @return are we (possibly) reversing? * @return are we (possibly) reversing?
*/ */
FORCEINLINE bool HasToUseGetSlopeZ() FORCEINLINE bool HasToUseGetSlopePixelZ()
{ {
const RoadVehicle *rv = this->First(); const RoadVehicle *rv = this->First();

2
src/roadveh_cmd.cpp
View File

@ -236,7 +236,7 @@ CommandCost CmdBuildRoadVehicle(TileIndex tile, DoCommandFlag flags, const Engin
int y = TileY(tile) * TILE_SIZE + TILE_SIZE / 2; int y = TileY(tile) * TILE_SIZE + TILE_SIZE / 2;
v->x_pos = x; v->x_pos = x;
v->y_pos = y; v->y_pos = y;
v->z_pos = GetSlopeZ(x, y); v->z_pos = GetSlopePixelZ(x, y);
v->state = RVSB_IN_DEPOT; v->state = RVSB_IN_DEPOT;
v->vehstatus = VS_HIDDEN | VS_STOPPED | VS_DEFPAL; v->vehstatus = VS_HIDDEN | VS_STOPPED | VS_DEFPAL;

20
src/saveload/afterload.cpp
View File

@ -77,7 +77,7 @@ void SetWaterClassDependingOnSurroundings(TileIndex t, bool include_invalid_wate
{ {
/* If the slope is not flat, we always assume 'land' (if allowed). Also for one-corner-raised-shores. /* If the slope is not flat, we always assume 'land' (if allowed). Also for one-corner-raised-shores.
* Note: Wrt. autosloping under industry tiles this is the most fool-proof behaviour. */ * Note: Wrt. autosloping under industry tiles this is the most fool-proof behaviour. */
if (GetTileSlope(t, NULL) != SLOPE_FLAT) { if (GetTilePixelSlope(t, NULL) != SLOPE_FLAT) {
if (include_invalid_water_class) { if (include_invalid_water_class) {
SetWaterClass(t, WATER_CLASS_INVALID); SetWaterClass(t, WATER_CLASS_INVALID);
return; return;
@ -458,12 +458,12 @@ static uint FixVehicleInclination(Vehicle *v, Direction dir)
case INVALID_DIR: break; case INVALID_DIR: break;
default: NOT_REACHED(); default: NOT_REACHED();
} }
byte entry_z = GetSlopeZ(entry_x, entry_y); byte entry_z = GetSlopePixelZ(entry_x, entry_y);
/* Compute middle of the tile. */ /* Compute middle of the tile. */
int middle_x = (v->x_pos & ~TILE_UNIT_MASK) + HALF_TILE_SIZE; int middle_x = (v->x_pos & ~TILE_UNIT_MASK) + HALF_TILE_SIZE;
int middle_y = (v->y_pos & ~TILE_UNIT_MASK) + HALF_TILE_SIZE; int middle_y = (v->y_pos & ~TILE_UNIT_MASK) + HALF_TILE_SIZE;
byte middle_z = GetSlopeZ(middle_x, middle_y); byte middle_z = GetSlopePixelZ(middle_x, middle_y);
/* middle_z == entry_z, no height change. */ /* middle_z == entry_z, no height change. */
if (middle_z == entry_z) return 0; if (middle_z == entry_z) return 0;
@ -1060,7 +1060,7 @@ bool AfterLoadGame()
if (GB(_m[t].m5, 3, 2) == 0) { if (GB(_m[t].m5, 3, 2) == 0) {
MakeClear(t, CLEAR_GRASS, 3); MakeClear(t, CLEAR_GRASS, 3);
} else { } else {
if (GetTileSlope(t, NULL) != SLOPE_FLAT) { if (GetTilePixelSlope(t, NULL) != SLOPE_FLAT) {
MakeShore(t); MakeShore(t);
} else { } else {
if (GetTileOwner(t) == OWNER_WATER) { if (GetTileOwner(t) == OWNER_WATER) {
@ -1096,7 +1096,7 @@ bool AfterLoadGame()
case DIAGDIR_SW: if ((v->x_pos & 0xF) != TILE_SIZE - 1) continue; break; case DIAGDIR_SW: if ((v->x_pos & 0xF) != TILE_SIZE - 1) continue; break;
case DIAGDIR_NW: if ((v->y_pos & 0xF) != 0) continue; break; case DIAGDIR_NW: if ((v->y_pos & 0xF) != 0) continue; break;
} }
} else if (v->z_pos > GetSlopeZ(v->x_pos, v->y_pos)) { } else if (v->z_pos > GetSlopePixelZ(v->x_pos, v->y_pos)) {
v->tile = GetNorthernBridgeEnd(v->tile); v->tile = GetNorthernBridgeEnd(v->tile);
} else { } else {
continue; continue;
@ -1670,7 +1670,7 @@ bool AfterLoadGame()
* on its neighbouring tiles. Done after river and canal updates to * on its neighbouring tiles. Done after river and canal updates to
* ensure neighbours are correct. */ * ensure neighbours are correct. */
for (TileIndex t = 0; t < map_size; t++) { for (TileIndex t = 0; t < map_size; t++) {
if (GetTileSlope(t, NULL) != SLOPE_FLAT) continue; if (GetTilePixelSlope(t, NULL) != SLOPE_FLAT) continue;
if (IsTileType(t, MP_WATER) && IsLock(t)) SetWaterClassDependingOnSurroundings(t, false); if (IsTileType(t, MP_WATER) && IsLock(t)) SetWaterClassDependingOnSurroundings(t, false);
if (IsTileType(t, MP_STATION) && (IsDock(t) || IsBuoy(t))) SetWaterClassDependingOnSurroundings(t, false); if (IsTileType(t, MP_STATION) && (IsDock(t) || IsBuoy(t))) SetWaterClassDependingOnSurroundings(t, false);
@ -2355,7 +2355,7 @@ bool AfterLoadGame()
if (IsSavegameVersionBefore(149)) { if (IsSavegameVersionBefore(149)) {
for (TileIndex t = 0; t < map_size; t++) { for (TileIndex t = 0; t < map_size; t++) {
if (!IsTileType(t, MP_STATION)) continue; if (!IsTileType(t, MP_STATION)) continue;
if (!IsBuoy(t) && !IsOilRig(t) && !(IsDock(t) && GetTileSlope(t, NULL) == SLOPE_FLAT)) { if (!IsBuoy(t) && !IsOilRig(t) && !(IsDock(t) && GetTilePixelSlope(t, NULL) == SLOPE_FLAT)) {
SetWaterClass(t, WATER_CLASS_INVALID); SetWaterClass(t, WATER_CLASS_INVALID);
} }
} }
@ -2394,7 +2394,7 @@ bool AfterLoadGame()
if (!IsTunnelTile(vtile)) continue; if (!IsTunnelTile(vtile)) continue;
/* Are we actually in this tunnel? Or maybe a lower tunnel? */ /* Are we actually in this tunnel? Or maybe a lower tunnel? */
if (GetSlopeZ(v->x_pos, v->y_pos) != v->z_pos) continue; if (GetSlopePixelZ(v->x_pos, v->y_pos) != v->z_pos) continue;
/* What way are we going? */ /* What way are we going? */
const DiagDirection dir = GetTunnelBridgeDirection(vtile); const DiagDirection dir = GetTunnelBridgeDirection(vtile);
@ -2544,7 +2544,7 @@ bool AfterLoadGame()
/* In old versions, z_pos was 1 unit lower on bridge heads. /* In old versions, z_pos was 1 unit lower on bridge heads.
* However, this invalid state could be converted to new savegames * However, this invalid state could be converted to new savegames
* by loading and saving the game in a new version. */ * by loading and saving the game in a new version. */
v->z_pos = GetSlopeZ(v->x_pos, v->y_pos); v->z_pos = GetSlopePixelZ(v->x_pos, v->y_pos);
DiagDirection dir = GetTunnelBridgeDirection(v->tile); DiagDirection dir = GetTunnelBridgeDirection(v->tile);
if (v->type == VEH_TRAIN && !(v->vehstatus & VS_CRASHED) && if (v->type == VEH_TRAIN && !(v->vehstatus & VS_CRASHED) &&
v->direction != DiagDirToDir(dir)) { v->direction != DiagDirToDir(dir)) {
@ -2558,7 +2558,7 @@ bool AfterLoadGame()
/* If the vehicle is really above v->tile (not in a wormhole), /* If the vehicle is really above v->tile (not in a wormhole),
* it should have set v->z_pos correctly. */ * it should have set v->z_pos correctly. */
assert(v->tile != TileVirtXY(v->x_pos, v->y_pos) || v->z_pos == GetSlopeZ(v->x_pos, v->y_pos)); assert(v->tile != TileVirtXY(v->x_pos, v->y_pos) || v->z_pos == GetSlopePixelZ(v->x_pos, v->y_pos));
} }
/* Fill Vehicle::cur_real_order_index */ /* Fill Vehicle::cur_real_order_index */

4
src/ship_cmd.cpp
View File

@ -596,7 +596,7 @@ static void ShipController(Ship *v)
dir = ShipGetNewDirection(v, gp.x, gp.y); dir = ShipGetNewDirection(v, gp.x, gp.y);
v->x_pos = gp.x; v->x_pos = gp.x;
v->y_pos = gp.y; v->y_pos = gp.y;
v->z_pos = GetSlopeZ(gp.x, gp.y); v->z_pos = GetSlopePixelZ(gp.x, gp.y);
getout: getout:
v->UpdateViewport(true, true); v->UpdateViewport(true, true);
@ -644,7 +644,7 @@ CommandCost CmdBuildShip(TileIndex tile, DoCommandFlag flags, const Engine *e, u
y = TileY(tile) * TILE_SIZE + TILE_SIZE / 2; y = TileY(tile) * TILE_SIZE + TILE_SIZE / 2;
v->x_pos = x; v->x_pos = x;
v->y_pos = y; v->y_pos = y;
v->z_pos = GetSlopeZ(x, y); v->z_pos = GetSlopePixelZ(x, y);
v->UpdateDeltaXY(v->direction); v->UpdateDeltaXY(v->direction);
v->vehstatus = VS_HIDDEN | VS_STOPPED | VS_DEFPAL; v->vehstatus = VS_HIDDEN | VS_STOPPED | VS_DEFPAL;

2
src/signs_cmd.cpp
View File

@ -51,7 +51,7 @@ CommandCost CmdPlaceSign(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32
si->x = x; si->x = x;
si->y = y; si->y = y;
si->z = GetSlopeZ(x, y); si->z = GetSlopePixelZ(x, y);
if (!StrEmpty(text)) { if (!StrEmpty(text)) {
si->name = strdup(text); si->name = strdup(text);
} }

2
src/slope_func.h
View File

@ -159,7 +159,7 @@ static inline Corner GetHalftileSlopeCorner(Slope s)
* @param s The #Slope. * @param s The #Slope.
* @return Relative height of highest corner. * @return Relative height of highest corner.
*/ */
static inline uint GetSlopeMaxZ(Slope s) static inline uint GetSlopeMaxPixelZ(Slope s)
{ {
if (s == SLOPE_FLAT) return 0; if (s == SLOPE_FLAT) return 0;
if (IsSteepSlope(s)) return 2 * TILE_HEIGHT; if (IsSteepSlope(s)) return 2 * TILE_HEIGHT;

4
src/sound.cpp
View File

@ -255,10 +255,10 @@ void SndPlayTileFx(SoundID sound, TileIndex tile)
/* emits sound from center of the tile */ /* emits sound from center of the tile */
int x = min(MapMaxX() - 1, TileX(tile)) * TILE_SIZE + TILE_SIZE / 2; int x = min(MapMaxX() - 1, TileX(tile)) * TILE_SIZE + TILE_SIZE / 2;
int y = min(MapMaxY() - 1, TileY(tile)) * TILE_SIZE - TILE_SIZE / 2; int y = min(MapMaxY() - 1, TileY(tile)) * TILE_SIZE - TILE_SIZE / 2;
uint z = (y < 0 ? 0 : GetSlopeZ(x, y)); uint z = (y < 0 ? 0 : GetSlopePixelZ(x, y));
Point pt = RemapCoords(x, y, z); Point pt = RemapCoords(x, y, z);
y += 2 * TILE_SIZE; y += 2 * TILE_SIZE;
Point pt2 = RemapCoords(x, y, GetSlopeZ(x, y)); Point pt2 = RemapCoords(x, y, GetSlopePixelZ(x, y));
SndPlayScreenCoordFx(sound, pt.x, pt2.x, pt.y, pt2.y); SndPlayScreenCoordFx(sound, pt.x, pt2.x, pt.y, pt2.y);
} }

28
src/station_cmd.cpp
View File

@ -306,8 +306,8 @@ static StringID GenerateStationName(Station *st, TileIndex tile, StationNaming n
} }
/* check elevation compared to town */ /* check elevation compared to town */
uint z = GetTileZ(tile); uint z = GetTilePixelZ(tile);
uint z2 = GetTileZ(t->xy); uint z2 = GetTilePixelZ(t->xy);
if (z < z2) { if (z < z2) {
if (HasBit(free_names, M(STR_SV_STNAME_VALLEY))) return STR_SV_STNAME_VALLEY; if (HasBit(free_names, M(STR_SV_STNAME_VALLEY))) return STR_SV_STNAME_VALLEY;
} else if (z > z2) { } else if (z > z2) {
@ -665,7 +665,7 @@ CommandCost CheckBuildableTile(TileIndex tile, uint invalid_dirs, int &allowed_z
if (ret.Failed()) return ret; if (ret.Failed()) return ret;
uint z; uint z;
Slope tileh = GetTileSlope(tile, &z); Slope tileh = GetTilePixelSlope(tile, &z);
/* Prohibit building if /* Prohibit building if
* 1) The tile is "steep" (i.e. stretches two height levels). * 1) The tile is "steep" (i.e. stretches two height levels).
@ -677,7 +677,7 @@ CommandCost CheckBuildableTile(TileIndex tile, uint invalid_dirs, int &allowed_z
} }
CommandCost cost(EXPENSES_CONSTRUCTION); CommandCost cost(EXPENSES_CONSTRUCTION);
int flat_z = z + GetSlopeMaxZ(tileh); int flat_z = z + GetSlopeMaxPixelZ(tileh);
if (tileh != SLOPE_FLAT) { if (tileh != SLOPE_FLAT) {
/* Forbid building if the tile faces a slope in a invalid direction. */ /* Forbid building if the tile faces a slope in a invalid direction. */
for (DiagDirection dir = DIAGDIR_BEGIN; dir != DIAGDIR_END; dir++) { for (DiagDirection dir = DIAGDIR_BEGIN; dir != DIAGDIR_END; dir++) {
@ -2347,7 +2347,7 @@ CommandCost CmdBuildDock(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32
if (distant_join && (!_settings_game.station.distant_join_stations || !Station::IsValidID(station_to_join))) return CMD_ERROR; if (distant_join && (!_settings_game.station.distant_join_stations || !Station::IsValidID(station_to_join))) return CMD_ERROR;
DiagDirection direction = GetInclinedSlopeDirection(GetTileSlope(tile, NULL)); DiagDirection direction = GetInclinedSlopeDirection(GetTilePixelSlope(tile, NULL));
if (direction == INVALID_DIAGDIR) return_cmd_error(STR_ERROR_SITE_UNSUITABLE); if (direction == INVALID_DIAGDIR) return_cmd_error(STR_ERROR_SITE_UNSUITABLE);
direction = ReverseDiagDir(direction); direction = ReverseDiagDir(direction);
@ -2364,7 +2364,7 @@ CommandCost CmdBuildDock(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32
TileIndex tile_cur = tile + TileOffsByDiagDir(direction); TileIndex tile_cur = tile + TileOffsByDiagDir(direction);
if (!IsTileType(tile_cur, MP_WATER) || GetTileSlope(tile_cur, NULL) != SLOPE_FLAT) { if (!IsTileType(tile_cur, MP_WATER) || GetTilePixelSlope(tile_cur, NULL) != SLOPE_FLAT) {
return_cmd_error(STR_ERROR_SITE_UNSUITABLE); return_cmd_error(STR_ERROR_SITE_UNSUITABLE);
} }
@ -2377,7 +2377,7 @@ CommandCost CmdBuildDock(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32
if (ret.Failed()) return ret; if (ret.Failed()) return ret;
tile_cur += TileOffsByDiagDir(direction); tile_cur += TileOffsByDiagDir(direction);
if (!IsTileType(tile_cur, MP_WATER) || GetTileSlope(tile_cur, NULL) != SLOPE_FLAT) { if (!IsTileType(tile_cur, MP_WATER) || GetTilePixelSlope(tile_cur, NULL) != SLOPE_FLAT) {
return_cmd_error(STR_ERROR_SITE_UNSUITABLE); return_cmd_error(STR_ERROR_SITE_UNSUITABLE);
} }
@ -2585,7 +2585,7 @@ static void DrawTile_Station(TileInfo *ti)
* Check whether the foundation continues beyond the tile's upper sides. */ * Check whether the foundation continues beyond the tile's upper sides. */
uint edge_info = 0; uint edge_info = 0;
uint z; uint z;
Slope slope = GetFoundationSlope(ti->tile, &z); Slope slope = GetFoundationPixelSlope(ti->tile, &z);
if (!HasFoundationNW(ti->tile, slope, z)) SetBit(edge_info, 0); if (!HasFoundationNW(ti->tile, slope, z)) SetBit(edge_info, 0);
if (!HasFoundationNE(ti->tile, slope, z)) SetBit(edge_info, 1); if (!HasFoundationNE(ti->tile, slope, z)) SetBit(edge_info, 1);
SpriteID image = GetCustomStationFoundationRelocation(statspec, st, ti->tile, tile_layout, edge_info); SpriteID image = GetCustomStationFoundationRelocation(statspec, st, ti->tile, tile_layout, edge_info);
@ -2641,7 +2641,7 @@ static void DrawTile_Station(TileInfo *ti)
} }
OffsetGroundSprite(31, 1); OffsetGroundSprite(31, 1);
ti->z += ApplyFoundationToSlope(FOUNDATION_LEVELED, &ti->tileh); ti->z += ApplyPixelFoundationToSlope(FOUNDATION_LEVELED, &ti->tileh);
} else { } else {
draw_default_foundation: draw_default_foundation:
DrawFoundation(ti, FOUNDATION_LEVELED); DrawFoundation(ti, FOUNDATION_LEVELED);
@ -2756,9 +2756,9 @@ void StationPickerDrawSprite(int x, int y, StationType st, RailType railtype, Ro
DrawRailTileSeqInGUI(x, y, t, st == STATION_WAYPOINT ? 0 : total_offset, 0, pal); DrawRailTileSeqInGUI(x, y, t, st == STATION_WAYPOINT ? 0 : total_offset, 0, pal);
} }
static uint GetSlopeZ_Station(TileIndex tile, uint x, uint y) static uint GetSlopePixelZ_Station(TileIndex tile, uint x, uint y)
{ {
return GetTileMaxZ(tile); return GetTileMaxPixelZ(tile);
} }
static Foundation GetFoundation_Station(TileIndex tile, Slope tileh) static Foundation GetFoundation_Station(TileIndex tile, Slope tileh)
@ -2898,7 +2898,7 @@ static void TileLoop_Station(TileIndex tile)
break; break;
case STATION_DOCK: case STATION_DOCK:
if (GetTileSlope(tile, NULL) != SLOPE_FLAT) break; // only handle water part if (GetTilePixelSlope(tile, NULL) != SLOPE_FLAT) break; // only handle water part
/* FALL THROUGH */ /* FALL THROUGH */
case STATION_OILRIG: //(station part) case STATION_OILRIG: //(station part)
case STATION_BUOY: case STATION_BUOY:
@ -3595,7 +3595,7 @@ static CommandCost TerraformTile_Station(TileIndex tile, DoCommandFlag flags, ui
/* TODO: If you implement newgrf callback 149 'land slope check', you have to decide what to do with it here. /* TODO: If you implement newgrf callback 149 'land slope check', you have to decide what to do with it here.
* TTDP does not call it. * TTDP does not call it.
*/ */
if (GetTileMaxZ(tile) == z_new + GetSlopeMaxZ(tileh_new)) { if (GetTileMaxPixelZ(tile) == z_new + GetSlopeMaxPixelZ(tileh_new)) {
switch (GetStationType(tile)) { switch (GetStationType(tile)) {
case STATION_WAYPOINT: case STATION_WAYPOINT:
case STATION_RAIL: { case STATION_RAIL: {
@ -3628,7 +3628,7 @@ static CommandCost TerraformTile_Station(TileIndex tile, DoCommandFlag flags, ui
extern const TileTypeProcs _tile_type_station_procs = { extern const TileTypeProcs _tile_type_station_procs = {
DrawTile_Station, // draw_tile_proc DrawTile_Station, // draw_tile_proc
GetSlopeZ_Station, // get_slope_z_proc GetSlopePixelZ_Station, // get_slope_z_proc
ClearTile_Station, // clear_tile_proc ClearTile_Station, // clear_tile_proc
NULL, // add_accepted_cargo_proc NULL, // add_accepted_cargo_proc
GetTileDesc_Station, // get_tile_desc_proc GetTileDesc_Station, // get_tile_desc_proc

2
src/terraform_cmd.cpp
View File

@ -311,7 +311,7 @@ CommandCost CmdTerraformLand(TileIndex tile, DoCommandFlag flags, uint32 p1, uin
if (pass == 0) { if (pass == 0) {
/* Check if bridge would take damage */ /* Check if bridge would take damage */
if (direction == 1 && MayHaveBridgeAbove(tile) && IsBridgeAbove(tile) && if (direction == 1 && MayHaveBridgeAbove(tile) && IsBridgeAbove(tile) &&
GetBridgeHeight(GetSouthernBridgeEnd(tile)) <= z_max * TILE_HEIGHT) { GetBridgePixelHeight(GetSouthernBridgeEnd(tile)) <= z_max * TILE_HEIGHT) {
_terraform_err_tile = tile; // highlight the tile under the bridge _terraform_err_tile = tile; // highlight the tile under the bridge
return_cmd_error(STR_ERROR_MUST_DEMOLISH_BRIDGE_FIRST); return_cmd_error(STR_ERROR_MUST_DEMOLISH_BRIDGE_FIRST);
} }

6
src/tile_map.cpp
View File

@ -18,7 +18,7 @@
* @param h If not \c NULL, pointer to storage of z height * @param h If not \c NULL, pointer to storage of z height
* @return Slope of the tile, except for the HALFTILE part * @return Slope of the tile, except for the HALFTILE part
*/ */
Slope GetTileSlope(TileIndex tile, uint *h) Slope GetTilePixelSlope(TileIndex tile, uint *h)
{ {
assert(tile < MapSize()); assert(tile < MapSize());
@ -64,7 +64,7 @@ Slope GetTileSlope(TileIndex tile, uint *h)
* @param tile Tile to compute height of * @param tile Tile to compute height of
* @return Minimum height of the tile * @return Minimum height of the tile
*/ */
uint GetTileZ(TileIndex tile) uint GetTilePixelZ(TileIndex tile)
{ {
if (TileX(tile) == MapMaxX() || TileY(tile) == MapMaxY()) return 0; if (TileX(tile) == MapMaxX() || TileY(tile) == MapMaxY()) return 0;
@ -81,7 +81,7 @@ uint GetTileZ(TileIndex tile)
* @param t Tile to compute height of * @param t Tile to compute height of
* @return Maximum height of the tile * @return Maximum height of the tile
*/ */
uint GetTileMaxZ(TileIndex t) uint GetTileMaxPixelZ(TileIndex t)
{ {
if (TileX(t) == MapMaxX() || TileY(t) == MapMaxY()) return 0; if (TileX(t) == MapMaxX() || TileY(t) == MapMaxY()) return 0;

6
src/tile_map.h
View File

@ -226,9 +226,9 @@ static inline void SetAnimationFrame(TileIndex t, byte frame)
_me[t].m7 = frame; _me[t].m7 = frame;
} }
Slope GetTileSlope(TileIndex tile, uint *h); Slope GetTilePixelSlope(TileIndex tile, uint *h);
uint GetTileZ(TileIndex tile); uint GetTilePixelZ(TileIndex tile);
uint GetTileMaxZ(TileIndex tile); uint GetTileMaxPixelZ(TileIndex tile);
/** /**

32
src/town_cmd.cpp
View File

@ -255,9 +255,9 @@ static void DrawTile_Town(TileInfo *ti)
} }
} }
static uint GetSlopeZ_Town(TileIndex tile, uint x, uint y) static uint GetSlopePixelZ_Town(TileIndex tile, uint x, uint y)
{ {
return GetTileMaxZ(tile); return GetTileMaxPixelZ(tile);
} }
/** Tile callback routine */ /** Tile callback routine */
@ -787,7 +787,7 @@ static bool IsRoadAllowedHere(Town *t, TileIndex tile, DiagDirection dir)
} }
} }
Slope cur_slope = _settings_game.construction.build_on_slopes ? GetFoundationSlope(tile, NULL) : GetTileSlope(tile, NULL); Slope cur_slope = _settings_game.construction.build_on_slopes ? GetFoundationPixelSlope(tile, NULL) : GetTilePixelSlope(tile, NULL);
bool ret = !IsNeighborRoadTile(tile, dir, t->layout == TL_ORIGINAL ? 1 : 2); bool ret = !IsNeighborRoadTile(tile, dir, t->layout == TL_ORIGINAL ? 1 : 2);
if (cur_slope == SLOPE_FLAT) return ret; if (cur_slope == SLOPE_FLAT) return ret;
@ -828,7 +828,7 @@ static void LevelTownLand(TileIndex tile)
/* Don't terraform if land is plain or if there's a house there. */ /* Don't terraform if land is plain or if there's a house there. */
if (IsTileType(tile, MP_HOUSE)) return; if (IsTileType(tile, MP_HOUSE)) return;
Slope tileh = GetTileSlope(tile, NULL); Slope tileh = GetTilePixelSlope(tile, NULL);
if (tileh == SLOPE_FLAT) return; if (tileh == SLOPE_FLAT) return;
/* First try up, then down */ /* First try up, then down */
@ -871,7 +871,7 @@ static RoadBits GetTownRoadGridElement(Town *t, TileIndex tile, DiagDirection di
RoadBits rb_template; RoadBits rb_template;
switch (GetTileSlope(tile, NULL)) { switch (GetTilePixelSlope(tile, NULL)) {
default: rb_template = ROAD_ALL; break; default: rb_template = ROAD_ALL; break;
case SLOPE_W: rb_template = ROAD_NW | ROAD_SW; break; case SLOPE_W: rb_template = ROAD_NW | ROAD_SW; break;
case SLOPE_SW: rb_template = ROAD_Y | ROAD_SW; break; case SLOPE_SW: rb_template = ROAD_Y | ROAD_SW; break;
@ -970,7 +970,7 @@ static bool GrowTownWithBridge(const Town *t, const TileIndex tile, const DiagDi
{ {
assert(bridge_dir < DIAGDIR_END); assert(bridge_dir < DIAGDIR_END);
const Slope slope = GetTileSlope(tile, NULL); const Slope slope = GetTilePixelSlope(tile, NULL);
/* Make sure the direction is compatible with the slope. /* Make sure the direction is compatible with the slope.
* Well we check if the slope has an up bit set in the * Well we check if the slope has an up bit set in the
@ -1337,7 +1337,7 @@ static bool GrowTown(Town *t)
tile = t->xy; tile = t->xy;
for (ptr = _town_coord_mod; ptr != endof(_town_coord_mod); ++ptr) { for (ptr = _town_coord_mod; ptr != endof(_town_coord_mod); ++ptr) {
/* Only work with plain land that not already has a house */ /* Only work with plain land that not already has a house */
if (!IsTileType(tile, MP_HOUSE) && GetTileSlope(tile, NULL) == SLOPE_FLAT) { if (!IsTileType(tile, MP_HOUSE) && GetTilePixelSlope(tile, NULL) == SLOPE_FLAT) {
if (DoCommand(tile, 0, 0, DC_AUTO | DC_NO_WATER, CMD_LANDSCAPE_CLEAR).Succeeded()) { if (DoCommand(tile, 0, 0, DC_AUTO | DC_NO_WATER, CMD_LANDSCAPE_CLEAR).Succeeded()) {
DoCommand(tile, GenRandomRoadBits(), t->index, DC_EXEC | DC_AUTO, CMD_BUILD_ROAD); DoCommand(tile, GenRandomRoadBits(), t->index, DC_EXEC | DC_AUTO, CMD_BUILD_ROAD);
cur_company.Restore(); cur_company.Restore();
@ -1500,7 +1500,7 @@ static CommandCost TownCanBePlacedHere(TileIndex tile)
} }
/* Can only build on clear flat areas, possibly with trees. */ /* Can only build on clear flat areas, possibly with trees. */
if ((!IsTileType(tile, MP_CLEAR) && !IsTileType(tile, MP_TREES)) || GetTileSlope(tile, NULL) != SLOPE_FLAT) { if ((!IsTileType(tile, MP_CLEAR) && !IsTileType(tile, MP_TREES)) || GetTilePixelSlope(tile, NULL) != SLOPE_FLAT) {
return_cmd_error(STR_ERROR_SITE_UNSUITABLE); return_cmd_error(STR_ERROR_SITE_UNSUITABLE);
} }
@ -1697,7 +1697,7 @@ static bool FindFurthestFromWater(TileIndex tile, void *user_data)
uint dist = GetClosestWaterDistance(tile, true); uint dist = GetClosestWaterDistance(tile, true);
if (IsTileType(tile, MP_CLEAR) && if (IsTileType(tile, MP_CLEAR) &&
GetTileSlope(tile, NULL) == SLOPE_FLAT && GetTilePixelSlope(tile, NULL) == SLOPE_FLAT &&
IsTileAlignedToGrid(tile, sp->layout) && IsTileAlignedToGrid(tile, sp->layout) &&
dist > sp->max_dist) { dist > sp->max_dist) {
sp->tile = tile; sp->tile = tile;
@ -1907,7 +1907,7 @@ static void MakeTownHouse(TileIndex t, Town *town, byte counter, byte stage, Hou
static inline bool CanBuildHouseHere(TileIndex tile, TownID town, bool noslope) static inline bool CanBuildHouseHere(TileIndex tile, TownID town, bool noslope)
{ {
/* cannot build on these slopes... */ /* cannot build on these slopes... */
Slope slope = GetTileSlope(tile, NULL); Slope slope = GetTilePixelSlope(tile, NULL);
if ((noslope && slope != SLOPE_FLAT) || IsSteepSlope(slope)) return false; if ((noslope && slope != SLOPE_FLAT) || IsSteepSlope(slope)) return false;
/* building under a bridge? */ /* building under a bridge? */
@ -1935,7 +1935,7 @@ static inline bool CheckBuildHouseSameZ(TileIndex tile, TownID town, uint z, boo
if (!CanBuildHouseHere(tile, town, noslope)) return false; if (!CanBuildHouseHere(tile, town, noslope)) return false;
/* if building on slopes is allowed, there will be flattening foundation (to tile max z) */ /* if building on slopes is allowed, there will be flattening foundation (to tile max z) */
if (GetTileMaxZ(tile) != z) return false; if (GetTileMaxPixelZ(tile) != z) return false;
return true; return true;
} }
@ -2096,7 +2096,7 @@ static bool BuildTownHouse(Town *t, TileIndex tile)
if (!CanBuildHouseHere(tile, t->index, false)) return false; if (!CanBuildHouseHere(tile, t->index, false)) return false;
uint z; uint z;
Slope slope = GetTileSlope(tile, &z); Slope slope = GetTilePixelSlope(tile, &z);
/* Get the town zone type of the current tile, as well as the climate. /* Get the town zone type of the current tile, as well as the climate.
* This will allow to easily compare with the specs of the new house to build */ * This will allow to easily compare with the specs of the new house to build */
@ -2139,7 +2139,7 @@ static bool BuildTownHouse(Town *t, TileIndex tile)
houses[num++] = (HouseID)i; houses[num++] = (HouseID)i;
} }
uint maxz = GetTileMaxZ(tile); uint maxz = GetTileMaxPixelZ(tile);
TileIndex baseTile = tile; TileIndex baseTile = tile;
while (probability_max > 0) { while (probability_max > 0) {
@ -2525,7 +2525,7 @@ static CommandCost TownActionRoadRebuild(Town *t, DoCommandFlag flags)
static bool SearchTileForStatue(TileIndex tile, void *user_data) static bool SearchTileForStatue(TileIndex tile, void *user_data)
{ {
/* Statues can be build on slopes, just like houses. Only the steep slopes is a no go. */ /* Statues can be build on slopes, just like houses. Only the steep slopes is a no go. */
if (IsSteepSlope(GetTileSlope(tile, NULL))) return false; if (IsSteepSlope(GetTilePixelSlope(tile, NULL))) return false;
/* Don't build statues under bridges. */ /* Don't build statues under bridges. */
if (MayHaveBridgeAbove(tile) && IsBridgeAbove(tile)) return false; if (MayHaveBridgeAbove(tile) && IsBridgeAbove(tile)) return false;
@ -3055,7 +3055,7 @@ static CommandCost TerraformTile_Town(TileIndex tile, DoCommandFlag flags, uint
/* Here we differ from TTDP by checking TILE_NOT_SLOPED */ /* Here we differ from TTDP by checking TILE_NOT_SLOPED */
if (((hs->building_flags & TILE_NOT_SLOPED) == 0) && !IsSteepSlope(tileh_new) && if (((hs->building_flags & TILE_NOT_SLOPED) == 0) && !IsSteepSlope(tileh_new) &&
(GetTileMaxZ(tile) == z_new + GetSlopeMaxZ(tileh_new))) { (GetTileMaxPixelZ(tile) == z_new + GetSlopeMaxPixelZ(tileh_new))) {
bool allow_terraform = true; bool allow_terraform = true;
/* Call the autosloping callback per tile, not for the whole building at once. */ /* Call the autosloping callback per tile, not for the whole building at once. */
@ -3077,7 +3077,7 @@ static CommandCost TerraformTile_Town(TileIndex tile, DoCommandFlag flags, uint
/** Tile callback functions for a town */ /** Tile callback functions for a town */
extern const TileTypeProcs _tile_type_town_procs = { extern const TileTypeProcs _tile_type_town_procs = {
DrawTile_Town, // draw_tile_proc DrawTile_Town, // draw_tile_proc
GetSlopeZ_Town, // get_slope_z_proc GetSlopePixelZ_Town, // get_slope_z_proc
ClearTile_Town, // clear_tile_proc ClearTile_Town, // clear_tile_proc
AddAcceptedCargo_Town, // add_accepted_cargo_proc AddAcceptedCargo_Town, // add_accepted_cargo_proc
GetTileDesc_Town, // get_tile_desc_proc GetTileDesc_Town, // get_tile_desc_proc

2
src/train.h
View File

@ -303,7 +303,7 @@ protected: // These functions should not be called outside acceleration code.
* have always the same direction as the track under them. * have always the same direction as the track under them.
* @return false * @return false
*/ */
FORCEINLINE bool HasToUseGetSlopeZ() FORCEINLINE bool HasToUseGetSlopePixelZ()
{ {
return false; return false;
} }

4
src/train_cmd.cpp
View File

@ -573,7 +573,7 @@ static CommandCost CmdBuildRailWagon(TileIndex tile, DoCommandFlag flags, const
v->x_pos = x; v->x_pos = x;
v->y_pos = y; v->y_pos = y;
v->z_pos = GetSlopeZ(x, y); v->z_pos = GetSlopePixelZ(x, y);
v->owner = _current_company; v->owner = _current_company;
v->track = TRACK_BIT_DEPOT; v->track = TRACK_BIT_DEPOT;
v->vehstatus = VS_HIDDEN | VS_DEFPAL; v->vehstatus = VS_HIDDEN | VS_DEFPAL;
@ -698,7 +698,7 @@ CommandCost CmdBuildRailVehicle(TileIndex tile, DoCommandFlag flags, const Engin
v->owner = _current_company; v->owner = _current_company;
v->x_pos = x; v->x_pos = x;
v->y_pos = y; v->y_pos = y;
v->z_pos = GetSlopeZ(x, y); v->z_pos = GetSlopePixelZ(x, y);
v->track = TRACK_BIT_DEPOT; v->track = TRACK_BIT_DEPOT;
v->vehstatus = VS_HIDDEN | VS_STOPPED | VS_DEFPAL; v->vehstatus = VS_HIDDEN | VS_STOPPED | VS_DEFPAL;
v->spritenum = rvi->image_index; v->spritenum = rvi->image_index;

22
src/tree_cmd.cpp
View File

@ -70,7 +70,7 @@ static bool CanPlantTreesOnTile(TileIndex tile, bool allow_desert)
{ {
switch (GetTileType(tile)) { switch (GetTileType(tile)) {
case MP_WATER: case MP_WATER:
return !IsBridgeAbove(tile) && IsCoast(tile) && !IsSlopeWithOneCornerRaised(GetTileSlope(tile, NULL)); return !IsBridgeAbove(tile) && IsCoast(tile) && !IsSlopeWithOneCornerRaised(GetTilePixelSlope(tile, NULL));
case MP_CLEAR: case MP_CLEAR:
return !IsBridgeAbove(tile) && !IsClearGround(tile, CLEAR_FIELDS) && GetRawClearGround(tile) != CLEAR_ROCKS && return !IsBridgeAbove(tile) && !IsClearGround(tile, CLEAR_FIELDS) && GetRawClearGround(tile) != CLEAR_ROCKS &&
@ -232,7 +232,7 @@ static void PlaceTreeAtSameHeight(TileIndex tile, uint height)
if (!CanPlantTreesOnTile(cur_tile, true)) continue; if (!CanPlantTreesOnTile(cur_tile, true)) continue;
/* Not too much height difference */ /* Not too much height difference */
if (Delta(GetTileZ(cur_tile), height) > 2) continue; if (Delta(GetTilePixelZ(cur_tile), height) > 2) continue;
/* Place one tree and quit */ /* Place one tree and quit */
PlaceTree(cur_tile, r); PlaceTree(cur_tile, r);
@ -264,9 +264,9 @@ void PlaceTreesRandomly()
/* Place a number of trees based on the tile height. /* Place a number of trees based on the tile height.
* This gives a cool effect of multiple trees close together. * This gives a cool effect of multiple trees close together.
* It is almost real life ;) */ * It is almost real life ;) */
ht = GetTileZ(tile); ht = GetTilePixelZ(tile);
/* The higher we get, the more trees we plant */ /* The higher we get, the more trees we plant */
j = GetTileZ(tile) / TILE_HEIGHT * 2; j = GetTilePixelZ(tile) / TILE_HEIGHT * 2;
/* Above snowline more trees! */ /* Above snowline more trees! */
if (_settings_game.game_creation.landscape == LT_ARCTIC && ht > GetSnowLine()) j *= 3; if (_settings_game.game_creation.landscape == LT_ARCTIC && ht > GetSnowLine()) j *= 3;
while (j--) { while (j--) {
@ -363,7 +363,7 @@ CommandCost CmdPlantTree(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32
break; break;
case MP_WATER: case MP_WATER:
if (!IsCoast(tile) || IsSlopeWithOneCornerRaised(GetTileSlope(tile, NULL))) { if (!IsCoast(tile) || IsSlopeWithOneCornerRaised(GetTilePixelSlope(tile, NULL))) {
msg = STR_ERROR_CAN_T_BUILD_ON_WATER; msg = STR_ERROR_CAN_T_BUILD_ON_WATER;
continue; continue;
} }
@ -493,7 +493,7 @@ static void DrawTile_Trees(TileInfo *ti)
} }
/* draw them in a sorted way */ /* draw them in a sorted way */
byte z = ti->z + GetSlopeMaxZ(ti->tileh) / 2; byte z = ti->z + GetSlopeMaxPixelZ(ti->tileh) / 2;
for (; trees > 0; trees--) { for (; trees > 0; trees--) {
uint min = te[0].x + te[0].y; uint min = te[0].x + te[0].y;
@ -516,12 +516,12 @@ static void DrawTile_Trees(TileInfo *ti)
} }
static uint GetSlopeZ_Trees(TileIndex tile, uint x, uint y) static uint GetSlopePixelZ_Trees(TileIndex tile, uint x, uint y)
{ {
uint z; uint z;
Slope tileh = GetTileSlope(tile, &z); Slope tileh = GetTilePixelSlope(tile, &z);
return z + GetPartialZ(x & 0xF, y & 0xF, tileh); return z + GetPartialPixelZ(x & 0xF, y & 0xF, tileh);
} }
static Foundation GetFoundation_Trees(TileIndex tile, Slope tileh) static Foundation GetFoundation_Trees(TileIndex tile, Slope tileh)
@ -588,7 +588,7 @@ static void TileLoopTreesDesert(TileIndex tile)
static void TileLoopTreesAlps(TileIndex tile) static void TileLoopTreesAlps(TileIndex tile)
{ {
int k = GetTileZ(tile) - GetSnowLine() + TILE_HEIGHT; int k = GetTilePixelZ(tile) - GetSnowLine() + TILE_HEIGHT;
if (k < 0) { if (k < 0) {
switch (GetTreeGround(tile)) { switch (GetTreeGround(tile)) {
@ -784,7 +784,7 @@ static CommandCost TerraformTile_Trees(TileIndex tile, DoCommandFlag flags, uint
extern const TileTypeProcs _tile_type_trees_procs = { extern const TileTypeProcs _tile_type_trees_procs = {
DrawTile_Trees, // draw_tile_proc DrawTile_Trees, // draw_tile_proc
GetSlopeZ_Trees, // get_slope_z_proc GetSlopePixelZ_Trees, // get_slope_z_proc
ClearTile_Trees, // clear_tile_proc ClearTile_Trees, // clear_tile_proc
NULL, // add_accepted_cargo_proc NULL, // add_accepted_cargo_proc
GetTileDesc_Trees, // get_tile_desc_proc GetTileDesc_Trees, // get_tile_desc_proc

6
src/tunnel_map.cpp
View File

@ -23,7 +23,7 @@ TileIndex GetOtherTunnelEnd(TileIndex tile)
{ {
DiagDirection dir = GetTunnelBridgeDirection(tile); DiagDirection dir = GetTunnelBridgeDirection(tile);
TileIndexDiff delta = TileOffsByDiagDir(dir); TileIndexDiff delta = TileOffsByDiagDir(dir);
uint z = GetTileZ(tile); uint z = GetTilePixelZ(tile);
dir = ReverseDiagDir(dir); dir = ReverseDiagDir(dir);
do { do {
@ -31,7 +31,7 @@ TileIndex GetOtherTunnelEnd(TileIndex tile)
} while ( } while (
!IsTunnelTile(tile) || !IsTunnelTile(tile) ||
GetTunnelBridgeDirection(tile) != dir || GetTunnelBridgeDirection(tile) != dir ||
GetTileZ(tile) != z GetTilePixelZ(tile) != z
); );
return tile; return tile;
@ -53,7 +53,7 @@ bool IsTunnelInWayDir(TileIndex tile, uint z, DiagDirection dir)
do { do {
tile -= delta; tile -= delta;
if (!IsValidTile(tile)) return false; if (!IsValidTile(tile)) return false;
height = GetTileZ(tile); height = GetTilePixelZ(tile);
} while (z < height); } while (z < height);
return z == height && IsTunnelTile(tile) && GetTunnelBridgeDirection(tile) == dir; return z == height && IsTunnelTile(tile) && GetTunnelBridgeDirection(tile) == dir;

48
src/tunnelbridge_cmd.cpp
View File

@ -113,7 +113,7 @@ Foundation GetBridgeFoundation(Slope tileh, Axis axis)
*/ */
bool HasBridgeFlatRamp(Slope tileh, Axis axis) bool HasBridgeFlatRamp(Slope tileh, Axis axis)
{ {
ApplyFoundationToSlope(GetBridgeFoundation(tileh, axis), &tileh); ApplyPixelFoundationToSlope(GetBridgeFoundation(tileh, axis), &tileh);
/* If the foundation slope is flat the bridge has a non-flat ramp and vice versa. */ /* If the foundation slope is flat the bridge has a non-flat ramp and vice versa. */
return (tileh != SLOPE_FLAT); return (tileh != SLOPE_FLAT);
} }
@ -141,7 +141,7 @@ static inline const PalSpriteID *GetBridgeSpriteTable(int index, BridgePieces ta
static CommandCost CheckBridgeSlopeNorth(Axis axis, Slope *tileh, uint *z) static CommandCost CheckBridgeSlopeNorth(Axis axis, Slope *tileh, uint *z)
{ {
Foundation f = GetBridgeFoundation(*tileh, axis); Foundation f = GetBridgeFoundation(*tileh, axis);
*z += ApplyFoundationToSlope(f, tileh); *z += ApplyPixelFoundationToSlope(f, tileh);
Slope valid_inclined = (axis == AXIS_X ? SLOPE_NE : SLOPE_NW); Slope valid_inclined = (axis == AXIS_X ? SLOPE_NE : SLOPE_NW);
if ((*tileh != SLOPE_FLAT) && (*tileh != valid_inclined)) return CMD_ERROR; if ((*tileh != SLOPE_FLAT) && (*tileh != valid_inclined)) return CMD_ERROR;
@ -162,7 +162,7 @@ static CommandCost CheckBridgeSlopeNorth(Axis axis, Slope *tileh, uint *z)
static CommandCost CheckBridgeSlopeSouth(Axis axis, Slope *tileh, uint *z) static CommandCost CheckBridgeSlopeSouth(Axis axis, Slope *tileh, uint *z)
{ {
Foundation f = GetBridgeFoundation(*tileh, axis); Foundation f = GetBridgeFoundation(*tileh, axis);
*z += ApplyFoundationToSlope(f, tileh); *z += ApplyPixelFoundationToSlope(f, tileh);
Slope valid_inclined = (axis == AXIS_X ? SLOPE_SW : SLOPE_SE); Slope valid_inclined = (axis == AXIS_X ? SLOPE_SW : SLOPE_SE);
if ((*tileh != SLOPE_FLAT) && (*tileh != valid_inclined)) return CMD_ERROR; if ((*tileh != SLOPE_FLAT) && (*tileh != valid_inclined)) return CMD_ERROR;
@ -269,8 +269,8 @@ CommandCost CmdBuildBridge(TileIndex end_tile, DoCommandFlag flags, uint32 p1, u
uint z_start; uint z_start;
uint z_end; uint z_end;
Slope tileh_start = GetTileSlope(tile_start, &z_start); Slope tileh_start = GetTilePixelSlope(tile_start, &z_start);
Slope tileh_end = GetTileSlope(tile_end, &z_end); Slope tileh_end = GetTilePixelSlope(tile_end, &z_end);
bool pbs_reservation = false; bool pbs_reservation = false;
CommandCost terraform_cost_north = CheckBridgeSlopeNorth(direction, &tileh_start, &z_start); CommandCost terraform_cost_north = CheckBridgeSlopeNorth(direction, &tileh_start, &z_start);
@ -361,7 +361,7 @@ CommandCost CmdBuildBridge(TileIndex end_tile, DoCommandFlag flags, uint32 p1, u
if (direction == GetBridgeAxis(heads[i])) return_cmd_error(STR_ERROR_MUST_DEMOLISH_BRIDGE_FIRST); if (direction == GetBridgeAxis(heads[i])) return_cmd_error(STR_ERROR_MUST_DEMOLISH_BRIDGE_FIRST);
if (z_start + TILE_HEIGHT == GetBridgeHeight(north_head)) { if (z_start + TILE_HEIGHT == GetBridgePixelHeight(north_head)) {
return_cmd_error(STR_ERROR_MUST_DEMOLISH_BRIDGE_FIRST); return_cmd_error(STR_ERROR_MUST_DEMOLISH_BRIDGE_FIRST);
} }
} }
@ -370,7 +370,7 @@ CommandCost CmdBuildBridge(TileIndex end_tile, DoCommandFlag flags, uint32 p1, u
TileIndexDiff delta = (direction == AXIS_X ? TileDiffXY(1, 0) : TileDiffXY(0, 1)); TileIndexDiff delta = (direction == AXIS_X ? TileDiffXY(1, 0) : TileDiffXY(0, 1));
for (TileIndex tile = tile_start + delta; tile != tile_end; tile += delta) { for (TileIndex tile = tile_start + delta; tile != tile_end; tile += delta) {
if (GetTileMaxZ(tile) > z_start) return_cmd_error(STR_ERROR_BRIDGE_TOO_LOW_FOR_TERRAIN); if (GetTileMaxPixelZ(tile) > z_start) return_cmd_error(STR_ERROR_BRIDGE_TOO_LOW_FOR_TERRAIN);
if (MayHaveBridgeAbove(tile) && IsBridgeAbove(tile)) { if (MayHaveBridgeAbove(tile) && IsBridgeAbove(tile)) {
/* Disallow crossing bridges for the time being */ /* Disallow crossing bridges for the time being */
@ -393,13 +393,13 @@ CommandCost CmdBuildBridge(TileIndex end_tile, DoCommandFlag flags, uint32 p1, u
case MP_TUNNELBRIDGE: case MP_TUNNELBRIDGE:
if (IsTunnel(tile)) break; if (IsTunnel(tile)) break;
if (direction == DiagDirToAxis(GetTunnelBridgeDirection(tile))) goto not_valid_below; if (direction == DiagDirToAxis(GetTunnelBridgeDirection(tile))) goto not_valid_below;
if (z_start < GetBridgeHeight(tile)) goto not_valid_below; if (z_start < GetBridgePixelHeight(tile)) goto not_valid_below;
break; break;
case MP_OBJECT: { case MP_OBJECT: {
const ObjectSpec *spec = ObjectSpec::GetByTile(tile); const ObjectSpec *spec = ObjectSpec::GetByTile(tile);
if ((spec->flags & OBJECT_FLAG_ALLOW_UNDER_BRIDGE) == 0) goto not_valid_below; if ((spec->flags & OBJECT_FLAG_ALLOW_UNDER_BRIDGE) == 0) goto not_valid_below;
if (GetTileMaxZ(tile) + spec->height * TILE_HEIGHT > z_start) goto not_valid_below; if (GetTileMaxPixelZ(tile) + spec->height * TILE_HEIGHT > z_start) goto not_valid_below;
break; break;
} }
@ -527,7 +527,7 @@ CommandCost CmdBuildTunnel(TileIndex start_tile, DoCommandFlag flags, uint32 p1,
uint start_z; uint start_z;
uint end_z; uint end_z;
Slope start_tileh = GetTileSlope(start_tile, &start_z); Slope start_tileh = GetTilePixelSlope(start_tile, &start_z);
DiagDirection direction = GetInclinedSlopeDirection(start_tileh); DiagDirection direction = GetInclinedSlopeDirection(start_tileh);
if (direction == INVALID_DIAGDIR) return_cmd_error(STR_ERROR_SITE_UNSUITABLE_FOR_TUNNEL); if (direction == INVALID_DIAGDIR) return_cmd_error(STR_ERROR_SITE_UNSUITABLE_FOR_TUNNEL);
@ -563,7 +563,7 @@ CommandCost CmdBuildTunnel(TileIndex start_tile, DoCommandFlag flags, uint32 p1,
for (;;) { for (;;) {
end_tile += delta; end_tile += delta;
if (!IsValidTile(end_tile)) return_cmd_error(STR_ERROR_TUNNEL_THROUGH_MAP_BORDER); if (!IsValidTile(end_tile)) return_cmd_error(STR_ERROR_TUNNEL_THROUGH_MAP_BORDER);
end_tileh = GetTileSlope(end_tile, &end_z); end_tileh = GetTilePixelSlope(end_tile, &end_z);
if (start_z == end_z) break; if (start_z == end_z) break;
@ -794,7 +794,7 @@ static CommandCost DoClearBridge(TileIndex tile, DoCommandFlag flags)
/* read this value before actual removal of bridge */ /* read this value before actual removal of bridge */
bool rail = GetTunnelBridgeTransportType(tile) == TRANSPORT_RAIL; bool rail = GetTunnelBridgeTransportType(tile) == TRANSPORT_RAIL;
Owner owner = GetTileOwner(tile); Owner owner = GetTileOwner(tile);
uint height = GetBridgeHeight(tile); uint height = GetBridgePixelHeight(tile);
Train *v = NULL; Train *v = NULL;
if (rail && HasTunnelBridgeReservation(tile)) { if (rail && HasTunnelBridgeReservation(tile)) {
@ -807,7 +807,7 @@ static CommandCost DoClearBridge(TileIndex tile, DoCommandFlag flags)
for (TileIndex c = tile + delta; c != endtile; c += delta) { for (TileIndex c = tile + delta; c != endtile; c += delta) {
/* do not let trees appear from 'nowhere' after removing bridge */ /* do not let trees appear from 'nowhere' after removing bridge */
if (IsNormalRoadTile(c) && GetRoadside(c) == ROADSIDE_TREES) { if (IsNormalRoadTile(c) && GetRoadside(c) == ROADSIDE_TREES) {
uint minz = GetTileMaxZ(c) + 3 * TILE_HEIGHT; uint minz = GetTileMaxPixelZ(c) + 3 * TILE_HEIGHT;
if (height < minz) SetRoadside(c, ROADSIDE_PAVED); if (height < minz) SetRoadside(c, ROADSIDE_PAVED);
} }
ClearBridgeMiddle(c); ClearBridgeMiddle(c);
@ -913,8 +913,8 @@ static void DrawBridgePillars(const PalSpriteID *psid, const TileInfo *ti, Axis
int z_back_north = ti->z; int z_back_north = ti->z;
int z_front_south = ti->z; int z_front_south = ti->z;
int z_back_south = ti->z; int z_back_south = ti->z;
GetSlopeZOnEdge(ti->tileh, south_dir, &z_front_south, &z_back_south); GetSlopePixelZOnEdge(ti->tileh, south_dir, &z_front_south, &z_back_south);
GetSlopeZOnEdge(ti->tileh, ReverseDiagDir(south_dir), &z_front_north, &z_back_north); GetSlopePixelZOnEdge(ti->tileh, ReverseDiagDir(south_dir), &z_front_north, &z_back_north);
/* Shared height of pillars */ /* Shared height of pillars */
int z_front = max(z_front_north, z_front_south); int z_front = max(z_front_north, z_front_south);
@ -1277,7 +1277,7 @@ void DrawBridgeMiddle(const TileInfo *ti)
int x = ti->x; int x = ti->x;
int y = ti->y; int y = ti->y;
uint bridge_z = GetBridgeHeight(rampsouth); uint bridge_z = GetBridgePixelHeight(rampsouth);
uint z = bridge_z - BRIDGE_Z_START; uint z = bridge_z - BRIDGE_Z_START;
/* Add a bounding box that separates the bridge from things below it. */ /* Add a bounding box that separates the bridge from things below it. */
@ -1359,10 +1359,10 @@ void DrawBridgeMiddle(const TileInfo *ti)
} }
static uint GetSlopeZ_TunnelBridge(TileIndex tile, uint x, uint y) static uint GetSlopePixelZ_TunnelBridge(TileIndex tile, uint x, uint y)
{ {
uint z; uint z;
Slope tileh = GetTileSlope(tile, &z); Slope tileh = GetTilePixelSlope(tile, &z);
x &= 0xF; x &= 0xF;
y &= 0xF; y &= 0xF;
@ -1376,7 +1376,7 @@ static uint GetSlopeZ_TunnelBridge(TileIndex tile, uint x, uint y)
DiagDirection dir = GetTunnelBridgeDirection(tile); DiagDirection dir = GetTunnelBridgeDirection(tile);
uint pos = (DiagDirToAxis(dir) == AXIS_X ? y : x); uint pos = (DiagDirToAxis(dir) == AXIS_X ? y : x);
z += ApplyFoundationToSlope(GetBridgeFoundation(tileh, DiagDirToAxis(dir)), &tileh); z += ApplyPixelFoundationToSlope(GetBridgeFoundation(tileh, DiagDirToAxis(dir)), &tileh);
/* On the bridge ramp? */ /* On the bridge ramp? */
if (5 <= pos && pos <= 10) { if (5 <= pos && pos <= 10) {
@ -1395,7 +1395,7 @@ static uint GetSlopeZ_TunnelBridge(TileIndex tile, uint x, uint y)
} }
} }
return z + GetPartialZ(x, y, tileh); return z + GetPartialPixelZ(x, y, tileh);
} }
static Foundation GetFoundation_TunnelBridge(TileIndex tile, Slope tileh) static Foundation GetFoundation_TunnelBridge(TileIndex tile, Slope tileh)
@ -1457,7 +1457,7 @@ static void TileLoop_TunnelBridge(TileIndex tile)
/* As long as we do not have a snow density, we want to use the density /* As long as we do not have a snow density, we want to use the density
* from the entry endge. For tunnels this is the lowest point for bridges the highest point. * from the entry endge. For tunnels this is the lowest point for bridges the highest point.
* (Independent of foundations) */ * (Independent of foundations) */
uint z = IsBridge(tile) ? GetTileMaxZ(tile) : GetTileZ(tile); uint z = IsBridge(tile) ? GetTileMaxPixelZ(tile) : GetTilePixelZ(tile);
if (snow_or_desert != (z > GetSnowLine())) { if (snow_or_desert != (z > GetSnowLine())) {
SetTunnelBridgeSnowOrDesert(tile, !snow_or_desert); SetTunnelBridgeSnowOrDesert(tile, !snow_or_desert);
MarkTileDirtyByTile(tile); MarkTileDirtyByTile(tile);
@ -1532,7 +1532,7 @@ extern const byte _tunnel_visibility_frame[DIAGDIR_END] = {12, 8, 8, 12};
static VehicleEnterTileStatus VehicleEnter_TunnelBridge(Vehicle *v, TileIndex tile, int x, int y) static VehicleEnterTileStatus VehicleEnter_TunnelBridge(Vehicle *v, TileIndex tile, int x, int y)
{ {
int z = GetSlopeZ(x, y) - v->z_pos; int z = GetSlopePixelZ(x, y) - v->z_pos;
if (abs(z) > 2) return VETSB_CANNOT_ENTER; if (abs(z) > 2) return VETSB_CANNOT_ENTER;
/* Direction into the wormhole */ /* Direction into the wormhole */
@ -1680,7 +1680,7 @@ static CommandCost TerraformTile_TunnelBridge(TileIndex tile, DoCommandFlag flag
Axis axis = DiagDirToAxis(direction); Axis axis = DiagDirToAxis(direction);
CommandCost res; CommandCost res;
uint z_old; uint z_old;
Slope tileh_old = GetTileSlope(tile, &z_old); Slope tileh_old = GetTilePixelSlope(tile, &z_old);
/* Check if new slope is valid for bridges in general (so we can safely call GetBridgeFoundation()) */ /* Check if new slope is valid for bridges in general (so we can safely call GetBridgeFoundation()) */
if ((direction == DIAGDIR_NW) || (direction == DIAGDIR_NE)) { if ((direction == DIAGDIR_NW) || (direction == DIAGDIR_NE)) {
@ -1700,7 +1700,7 @@ static CommandCost TerraformTile_TunnelBridge(TileIndex tile, DoCommandFlag flag
extern const TileTypeProcs _tile_type_tunnelbridge_procs = { extern const TileTypeProcs _tile_type_tunnelbridge_procs = {
DrawTile_TunnelBridge, // draw_tile_proc DrawTile_TunnelBridge, // draw_tile_proc
GetSlopeZ_TunnelBridge, // get_slope_z_proc GetSlopePixelZ_TunnelBridge, // get_slope_z_proc
ClearTile_TunnelBridge, // clear_tile_proc ClearTile_TunnelBridge, // clear_tile_proc
NULL, // add_accepted_cargo_proc NULL, // add_accepted_cargo_proc
GetTileDesc_TunnelBridge, // get_tile_desc_proc GetTileDesc_TunnelBridge, // get_tile_desc_proc

2
src/vehicle.cpp
View File

@ -430,7 +430,7 @@ static Vehicle *EnsureNoVehicleProcZ(Vehicle *v, void *data)
*/ */
CommandCost EnsureNoVehicleOnGround(TileIndex tile) CommandCost EnsureNoVehicleOnGround(TileIndex tile)
{ {
byte z = GetTileMaxZ(tile); byte z = GetTileMaxPixelZ(tile);
/* Value v is not safe in MP games, however, it is used to generate a local /* Value v is not safe in MP games, however, it is used to generate a local
* error message only (which may be different for different machines). * error message only (which may be different for different machines).

20
src/viewport.cpp
View File

@ -205,7 +205,7 @@ void InitializeWindowViewport(Window *w, int x, int y,
uint y = TileY(follow_flags) * TILE_SIZE; uint y = TileY(follow_flags) * TILE_SIZE;
vp->follow_vehicle = INVALID_VEHICLE; vp->follow_vehicle = INVALID_VEHICLE;
pt = MapXYZToViewport(vp, x, y, GetSlopeZ(x, y)); pt = MapXYZToViewport(vp, x, y, GetSlopePixelZ(x, y));
} }
vp->scrollpos_x = pt.x; vp->scrollpos_x = pt.x;
@ -400,9 +400,9 @@ static Point TranslateXYToTileCoord(const ViewPort *vp, int x, int y)
int min_coord = _settings_game.construction.freeform_edges ? TILE_SIZE : 0; int min_coord = _settings_game.construction.freeform_edges ? TILE_SIZE : 0;
for (int i = 0; i < 5; i++) z = GetSlopeZ(Clamp(a + (int)max(z, 4u) - 4, min_coord, MapMaxX() * TILE_SIZE - 1), Clamp(b + (int)max(z, 4u) - 4, min_coord, MapMaxY() * TILE_SIZE - 1)) / 2; for (int i = 0; i < 5; i++) z = GetSlopePixelZ(Clamp(a + (int)max(z, 4u) - 4, min_coord, MapMaxX() * TILE_SIZE - 1), Clamp(b + (int)max(z, 4u) - 4, min_coord, MapMaxY() * TILE_SIZE - 1)) / 2;
for (uint malus = 3; malus > 0; malus--) z = GetSlopeZ(Clamp(a + (int)max(z, malus) - (int)malus, min_coord, MapMaxX() * TILE_SIZE - 1), Clamp(b + (int)max(z, malus) - (int)malus, min_coord, MapMaxY() * TILE_SIZE - 1)) / 2; for (uint malus = 3; malus > 0; malus--) z = GetSlopePixelZ(Clamp(a + (int)max(z, malus) - (int)malus, min_coord, MapMaxX() * TILE_SIZE - 1), Clamp(b + (int)max(z, malus) - (int)malus, min_coord, MapMaxY() * TILE_SIZE - 1)) / 2;
for (int i = 0; i < 5; i++) z = GetSlopeZ(Clamp(a + (int)z, min_coord, MapMaxX() * TILE_SIZE - 1), Clamp(b + (int)z, min_coord, MapMaxY() * TILE_SIZE - 1)) / 2; for (int i = 0; i < 5; i++) z = GetSlopePixelZ(Clamp(a + (int)z, min_coord, MapMaxX() * TILE_SIZE - 1), Clamp(b + (int)z, min_coord, MapMaxY() * TILE_SIZE - 1)) / 2;
pt.x = Clamp(a + (int)z, min_coord, MapMaxX() * TILE_SIZE - 1); pt.x = Clamp(a + (int)z, min_coord, MapMaxX() * TILE_SIZE - 1);
pt.y = Clamp(b + (int)z, min_coord, MapMaxY() * TILE_SIZE - 1); pt.y = Clamp(b + (int)z, min_coord, MapMaxY() * TILE_SIZE - 1);
@ -1084,7 +1084,7 @@ static void ViewportAddLandscape()
} }
ti.tile = tile; ti.tile = tile;
ti.tileh = GetTileSlope(tile, &ti.z); ti.tileh = GetTilePixelSlope(tile, &ti.z);
tt = GetTileType(tile); tt = GetTileType(tile);
} }
} }
@ -1101,7 +1101,7 @@ static void ViewportAddLandscape()
(y_cur == (int)MapMaxY() * TILE_SIZE && IsInsideMM(x_cur, 0, MapMaxX() * TILE_SIZE + 1))) { (y_cur == (int)MapMaxY() * TILE_SIZE && IsInsideMM(x_cur, 0, MapMaxX() * TILE_SIZE + 1))) {
TileIndex tile = TileVirtXY(x_cur, y_cur); TileIndex tile = TileVirtXY(x_cur, y_cur);
ti.tile = tile; ti.tile = tile;
ti.tileh = GetTileSlope(tile, &ti.z); ti.tileh = GetTilePixelSlope(tile, &ti.z);
tt = GetTileType(tile); tt = GetTileType(tile);
} }
if (ti.tile != INVALID_TILE) DrawTileSelection(&ti); if (ti.tile != INVALID_TILE) DrawTileSelection(&ti);
@ -1652,7 +1652,7 @@ void MarkAllViewportsDirty(int left, int top, int right, int bottom)
*/ */
void MarkTileDirtyByTile(TileIndex tile) void MarkTileDirtyByTile(TileIndex tile)
{ {
Point pt = RemapCoords(TileX(tile) * TILE_SIZE, TileY(tile) * TILE_SIZE, GetTileZ(tile)); Point pt = RemapCoords(TileX(tile) * TILE_SIZE, TileY(tile) * TILE_SIZE, GetTilePixelZ(tile));
MarkAllViewportsDirty( MarkAllViewportsDirty(
pt.x - 31, pt.x - 31,
pt.y - 122, pt.y - 122,
@ -1725,11 +1725,11 @@ static void SetSelectionTilesDirty()
do { do {
/* topmost dirty point */ /* topmost dirty point */
TileIndex top_tile = TileVirtXY(top_x, top_y); TileIndex top_tile = TileVirtXY(top_x, top_y);
Point top = RemapCoords(top_x, top_y, GetTileMaxZ(top_tile)); Point top = RemapCoords(top_x, top_y, GetTileMaxPixelZ(top_tile));
/* bottommost point */ /* bottommost point */
TileIndex bottom_tile = TileVirtXY(bot_x, bot_y); TileIndex bottom_tile = TileVirtXY(bot_x, bot_y);
Point bot = RemapCoords(bot_x + TILE_SIZE, bot_y + TILE_SIZE, GetTileZ(bottom_tile)); // bottommost point Point bot = RemapCoords(bot_x + TILE_SIZE, bot_y + TILE_SIZE, GetTilePixelZ(bottom_tile)); // bottommost point
/* the 'x' coordinate of 'top' and 'bot' is the same (and always in the same distance from tile middle), /* the 'x' coordinate of 'top' and 'bot' is the same (and always in the same distance from tile middle),
* tile height/slope affects only the 'y' on-screen coordinate! */ * tile height/slope affects only the 'y' on-screen coordinate! */
@ -1946,7 +1946,7 @@ bool HandleViewportClicked(const ViewPort *vp, int x, int y)
bool ScrollWindowTo(int x, int y, int z, Window *w, bool instant) bool ScrollWindowTo(int x, int y, int z, Window *w, bool instant)
{ {
/* The slope cannot be acquired outside of the map, so make sure we are always within the map. */ /* The slope cannot be acquired outside of the map, so make sure we are always within the map. */
if (z == -1) z = GetSlopeZ(Clamp(x, 0, MapSizeX() * TILE_SIZE - 1), Clamp(y, 0, MapSizeY() * TILE_SIZE - 1)); if (z == -1) z = GetSlopePixelZ(Clamp(x, 0, MapSizeX() * TILE_SIZE - 1), Clamp(y, 0, MapSizeY() * TILE_SIZE - 1));
Point pt = MapXYZToViewport(w->viewport, x, y, z); Point pt = MapXYZToViewport(w->viewport, x, y, z);
w->viewport->follow_vehicle = INVALID_VEHICLE; w->viewport->follow_vehicle = INVALID_VEHICLE;

4
src/void_cmd.cpp
View File

@ -23,7 +23,7 @@ static void DrawTile_Void(TileInfo *ti)
} }
static uint GetSlopeZ_Void(TileIndex tile, uint x, uint y) static uint GetSlopePixelZ_Void(TileIndex tile, uint x, uint y)
{ {
return TilePixelHeight(tile); return TilePixelHeight(tile);
} }
@ -67,7 +67,7 @@ static CommandCost TerraformTile_Void(TileIndex tile, DoCommandFlag flags, uint
extern const TileTypeProcs _tile_type_void_procs = { extern const TileTypeProcs _tile_type_void_procs = {
DrawTile_Void, // draw_tile_proc DrawTile_Void, // draw_tile_proc
GetSlopeZ_Void, // get_slope_z_proc GetSlopePixelZ_Void, // get_slope_z_proc
ClearTile_Void, // clear_tile_proc ClearTile_Void, // clear_tile_proc
NULL, // add_accepted_cargo_proc NULL, // add_accepted_cargo_proc
GetTileDesc_Void, // get_tile_desc_proc GetTileDesc_Void, // get_tile_desc_proc

50
src/water_cmd.cpp
View File

@ -106,7 +106,7 @@ CommandCost CmdBuildShipDepot(TileIndex tile, DoCommandFlag flags, uint32 p1, ui
if ((MayHaveBridgeAbove(tile) && IsBridgeAbove(tile)) || if ((MayHaveBridgeAbove(tile) && IsBridgeAbove(tile)) ||
(MayHaveBridgeAbove(tile2) && IsBridgeAbove(tile2))) return_cmd_error(STR_ERROR_MUST_DEMOLISH_BRIDGE_FIRST); (MayHaveBridgeAbove(tile2) && IsBridgeAbove(tile2))) return_cmd_error(STR_ERROR_MUST_DEMOLISH_BRIDGE_FIRST);
if (GetTileSlope(tile, NULL) != SLOPE_FLAT || GetTileSlope(tile2, NULL) != SLOPE_FLAT) { if (GetTilePixelSlope(tile, NULL) != SLOPE_FLAT || GetTilePixelSlope(tile2, NULL) != SLOPE_FLAT) {
/* Prevent depots on rapids */ /* Prevent depots on rapids */
return_cmd_error(STR_ERROR_SITE_UNSUITABLE); return_cmd_error(STR_ERROR_SITE_UNSUITABLE);
} }
@ -150,7 +150,7 @@ void MakeWaterKeepingClass(TileIndex tile, Owner o)
/* Autoslope might turn an originally canal or river tile into land */ /* Autoslope might turn an originally canal or river tile into land */
uint z; uint z;
if (GetTileSlope(tile, &z) != SLOPE_FLAT) wc = WATER_CLASS_INVALID; if (GetTilePixelSlope(tile, &z) != SLOPE_FLAT) wc = WATER_CLASS_INVALID;
if (wc == WATER_CLASS_SEA && z > 0) wc = WATER_CLASS_CANAL; if (wc == WATER_CLASS_SEA && z > 0) wc = WATER_CLASS_CANAL;
@ -220,7 +220,7 @@ static CommandCost DoBuildLock(TileIndex tile, DiagDirection dir, DoCommandFlag
cost.AddCost(ret); cost.AddCost(ret);
cost.AddCost(_price[PR_BUILD_CANAL]); cost.AddCost(_price[PR_BUILD_CANAL]);
} }
if (GetTileSlope(tile - delta, NULL) != SLOPE_FLAT) { if (GetTilePixelSlope(tile - delta, NULL) != SLOPE_FLAT) {
return_cmd_error(STR_ERROR_LAND_SLOPED_IN_WRONG_DIRECTION); return_cmd_error(STR_ERROR_LAND_SLOPED_IN_WRONG_DIRECTION);
} }
@ -233,7 +233,7 @@ static CommandCost DoBuildLock(TileIndex tile, DiagDirection dir, DoCommandFlag
cost.AddCost(ret); cost.AddCost(ret);
cost.AddCost(_price[PR_BUILD_CANAL]); cost.AddCost(_price[PR_BUILD_CANAL]);
} }
if (GetTileSlope(tile + delta, NULL) != SLOPE_FLAT) { if (GetTilePixelSlope(tile + delta, NULL) != SLOPE_FLAT) {
return_cmd_error(STR_ERROR_LAND_SLOPED_IN_WRONG_DIRECTION); return_cmd_error(STR_ERROR_LAND_SLOPED_IN_WRONG_DIRECTION);
} }
@ -299,7 +299,7 @@ static CommandCost RemoveLock(TileIndex tile, DoCommandFlag flags)
*/ */
CommandCost CmdBuildLock(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text) CommandCost CmdBuildLock(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
{ {
DiagDirection dir = GetInclinedSlopeDirection(GetTileSlope(tile, NULL)); DiagDirection dir = GetInclinedSlopeDirection(GetTilePixelSlope(tile, NULL));
if (dir == INVALID_DIAGDIR) return_cmd_error(STR_ERROR_LAND_SLOPED_IN_WRONG_DIRECTION); if (dir == INVALID_DIAGDIR) return_cmd_error(STR_ERROR_LAND_SLOPED_IN_WRONG_DIRECTION);
/* Disallow building of locks on river rapids */ /* Disallow building of locks on river rapids */
@ -341,7 +341,7 @@ CommandCost CmdBuildCanal(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32
TILE_AREA_LOOP(tile, ta) { TILE_AREA_LOOP(tile, ta) {
CommandCost ret; CommandCost ret;
Slope slope = GetTileSlope(tile, NULL); Slope slope = GetTilePixelSlope(tile, NULL);
if (slope != SLOPE_FLAT && (wc != WATER_CLASS_RIVER || !IsInclinedSlope(slope))) { if (slope != SLOPE_FLAT && (wc != WATER_CLASS_RIVER || !IsInclinedSlope(slope))) {
return_cmd_error(STR_ERROR_FLAT_LAND_REQUIRED); return_cmd_error(STR_ERROR_FLAT_LAND_REQUIRED);
} }
@ -419,7 +419,7 @@ static CommandCost ClearTile_Water(TileIndex tile, DoCommandFlag flags)
} }
case WATER_TILE_COAST: { case WATER_TILE_COAST: {
Slope slope = GetTileSlope(tile, NULL); Slope slope = GetTilePixelSlope(tile, NULL);
/* Make sure no vehicle is on the tile */ /* Make sure no vehicle is on the tile */
CommandCost ret = EnsureNoVehicleOnGround(tile); CommandCost ret = EnsureNoVehicleOnGround(tile);
@ -477,7 +477,7 @@ static bool IsWateredTile(TileIndex tile, Direction from)
case WATER_TILE_LOCK: return DiagDirToAxis(GetLockDirection(tile)) == DiagDirToAxis(DirToDiagDir(from)); case WATER_TILE_LOCK: return DiagDirToAxis(GetLockDirection(tile)) == DiagDirToAxis(DirToDiagDir(from));
case WATER_TILE_COAST: case WATER_TILE_COAST:
switch (GetTileSlope(tile, NULL)) { switch (GetTilePixelSlope(tile, NULL)) {
case SLOPE_W: return (from == DIR_SE) || (from == DIR_E) || (from == DIR_NE); 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); case SLOPE_S: return (from == DIR_NE) || (from == DIR_N) || (from == DIR_NW);
case SLOPE_E: return (from == DIR_NW) || (from == DIR_W) || (from == DIR_SW); case SLOPE_E: return (from == DIR_NW) || (from == DIR_W) || (from == DIR_SW);
@ -489,7 +489,7 @@ static bool IsWateredTile(TileIndex tile, Direction from)
case MP_RAILWAY: case MP_RAILWAY:
if (GetRailGroundType(tile) == RAIL_GROUND_WATER) { if (GetRailGroundType(tile) == RAIL_GROUND_WATER) {
assert(IsPlainRail(tile)); assert(IsPlainRail(tile));
switch (GetTileSlope(tile, NULL)) { switch (GetTilePixelSlope(tile, NULL)) {
case SLOPE_W: return (from == DIR_SE) || (from == DIR_E) || (from == DIR_NE); 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); case SLOPE_S: return (from == DIR_NE) || (from == DIR_N) || (from == DIR_NW);
case SLOPE_E: return (from == DIR_NW) || (from == DIR_W) || (from == DIR_SW); case SLOPE_E: return (from == DIR_NW) || (from == DIR_W) || (from == DIR_SW);
@ -509,7 +509,7 @@ static bool IsWateredTile(TileIndex tile, Direction from)
return IsTileOnWater(tile); return IsTileOnWater(tile);
} }
return (IsDock(tile) && GetTileSlope(tile, NULL) == SLOPE_FLAT) || IsBuoy(tile); return (IsDock(tile) && GetTilePixelSlope(tile, NULL) == SLOPE_FLAT) || IsBuoy(tile);
case MP_INDUSTRY: { case MP_INDUSTRY: {
/* Do not draw waterborders inside of industries. /* Do not draw waterborders inside of industries.
@ -794,12 +794,12 @@ void DrawShipDepotSprite(int x, int y, Axis axis, DepotPart part)
} }
static uint GetSlopeZ_Water(TileIndex tile, uint x, uint y) static uint GetSlopePixelZ_Water(TileIndex tile, uint x, uint y)
{ {
uint z; uint z;
Slope tileh = GetTileSlope(tile, &z); Slope tileh = GetTilePixelSlope(tile, &z);
return z + GetPartialZ(x & 0xF, y & 0xF, tileh); return z + GetPartialPixelZ(x & 0xF, y & 0xF, tileh);
} }
static Foundation GetFoundation_Water(TileIndex tile, Slope tileh) static Foundation GetFoundation_Water(TileIndex tile, Slope tileh)
@ -860,7 +860,7 @@ static Vehicle *FloodVehicleProc(Vehicle *v, void *data)
default: break; default: break;
case VEH_AIRCRAFT: { case VEH_AIRCRAFT: {
if (!IsAirportTile(v->tile) || GetTileMaxZ(v->tile) != 0) break; if (!IsAirportTile(v->tile) || GetTileMaxPixelZ(v->tile) != 0) break;
if (v->subtype == AIR_SHADOW) break; if (v->subtype == AIR_SHADOW) break;
/* We compare v->z_pos against delta_z + 1 because the shadow /* We compare v->z_pos against delta_z + 1 because the shadow
@ -910,7 +910,7 @@ static void FloodVehicles(TileIndex tile)
} }
TileIndex end = GetOtherBridgeEnd(tile); TileIndex end = GetOtherBridgeEnd(tile);
z = GetBridgeHeight(tile); z = GetBridgePixelHeight(tile);
FindVehicleOnPos(tile, &z, &FloodVehicleProc); FindVehicleOnPos(tile, &z, &FloodVehicleProc);
FindVehicleOnPos(end, &z, &FloodVehicleProc); FindVehicleOnPos(end, &z, &FloodVehicleProc);
@ -931,7 +931,7 @@ FloodingBehaviour GetFloodingBehaviour(TileIndex tile)
switch (GetTileType(tile)) { switch (GetTileType(tile)) {
case MP_WATER: case MP_WATER:
if (IsCoast(tile)) { if (IsCoast(tile)) {
Slope tileh = GetTileSlope(tile, NULL); Slope tileh = GetTilePixelSlope(tile, NULL);
return (IsSlopeWithOneCornerRaised(tileh) ? FLOOD_ACTIVE : FLOOD_DRYUP); return (IsSlopeWithOneCornerRaised(tileh) ? FLOOD_ACTIVE : FLOOD_DRYUP);
} }
/* FALL THROUGH */ /* FALL THROUGH */
@ -942,7 +942,7 @@ FloodingBehaviour GetFloodingBehaviour(TileIndex tile)
case MP_RAILWAY: case MP_RAILWAY:
if (GetRailGroundType(tile) == RAIL_GROUND_WATER) { if (GetRailGroundType(tile) == RAIL_GROUND_WATER) {
return (IsSlopeWithOneCornerRaised(GetTileSlope(tile, NULL)) ? FLOOD_ACTIVE : FLOOD_DRYUP); return (IsSlopeWithOneCornerRaised(GetTilePixelSlope(tile, NULL)) ? FLOOD_ACTIVE : FLOOD_DRYUP);
} }
return FLOOD_NONE; return FLOOD_NONE;
@ -965,7 +965,7 @@ void DoFloodTile(TileIndex target)
Backup<CompanyByte> cur_company(_current_company, OWNER_WATER, FILE_LINE); Backup<CompanyByte> cur_company(_current_company, OWNER_WATER, FILE_LINE);
Slope tileh = GetTileSlope(target, NULL); Slope tileh = GetTilePixelSlope(target, NULL);
if (tileh != SLOPE_FLAT) { if (tileh != SLOPE_FLAT) {
/* make coast.. */ /* make coast.. */
switch (GetTileType(target)) { switch (GetTileType(target)) {
@ -1080,7 +1080,7 @@ void TileLoop_Water(TileIndex tile)
if (IsTileType(dest, MP_WATER)) continue; if (IsTileType(dest, MP_WATER)) continue;
uint z_dest; uint z_dest;
Slope slope_dest = GetFoundationSlope(dest, &z_dest) & ~SLOPE_HALFTILE_MASK & ~SLOPE_STEEP; Slope slope_dest = GetFoundationPixelSlope(dest, &z_dest) & ~SLOPE_HALFTILE_MASK & ~SLOPE_STEEP;
if (z_dest > 0) continue; if (z_dest > 0) continue;
if (!HasBit(_flood_from_dirs[slope_dest], ReverseDir(dir))) continue; if (!HasBit(_flood_from_dirs[slope_dest], ReverseDir(dir))) continue;
@ -1090,7 +1090,7 @@ void TileLoop_Water(TileIndex tile)
break; break;
case FLOOD_DRYUP: { case FLOOD_DRYUP: {
Slope slope_here = GetFoundationSlope(tile, NULL) & ~SLOPE_HALFTILE_MASK & ~SLOPE_STEEP; Slope slope_here = GetFoundationPixelSlope(tile, NULL) & ~SLOPE_HALFTILE_MASK & ~SLOPE_STEEP;
uint dir; uint dir;
FOR_EACH_SET_BIT(dir, _flood_from_dirs[slope_here]) { FOR_EACH_SET_BIT(dir, _flood_from_dirs[slope_here]) {
TileIndex dest = AddTileIndexDiffCWrap(tile, TileIndexDiffCByDir((Direction)dir)); TileIndex dest = AddTileIndexDiffCWrap(tile, TileIndexDiffCByDir((Direction)dir));
@ -1112,7 +1112,7 @@ void ConvertGroundTilesIntoWaterTiles()
uint z; uint z;
for (TileIndex tile = 0; tile < MapSize(); ++tile) { for (TileIndex tile = 0; tile < MapSize(); ++tile) {
Slope slope = GetTileSlope(tile, &z); Slope slope = GetTilePixelSlope(tile, &z);
if (IsTileType(tile, MP_CLEAR) && z == 0) { if (IsTileType(tile, MP_CLEAR) && z == 0) {
/* Make both water for tiles at level 0 /* Make both water for tiles at level 0
* and make shore, as that looks much better * and make shore, as that looks much better
@ -1133,7 +1133,7 @@ void ConvertGroundTilesIntoWaterTiles()
uint dir; uint dir;
FOR_EACH_SET_BIT(dir, _flood_from_dirs[slope & ~SLOPE_STEEP]) { FOR_EACH_SET_BIT(dir, _flood_from_dirs[slope & ~SLOPE_STEEP]) {
TileIndex dest = TILE_ADD(tile, TileOffsByDir((Direction)dir)); TileIndex dest = TILE_ADD(tile, TileOffsByDir((Direction)dir));
Slope slope_dest = GetTileSlope(dest, NULL) & ~SLOPE_STEEP; Slope slope_dest = GetTilePixelSlope(dest, NULL) & ~SLOPE_STEEP;
if (slope_dest == SLOPE_FLAT || IsSlopeWithOneCornerRaised(slope_dest)) { if (slope_dest == SLOPE_FLAT || IsSlopeWithOneCornerRaised(slope_dest)) {
MakeShore(tile); MakeShore(tile);
break; break;
@ -1154,8 +1154,8 @@ static TrackStatus GetTileTrackStatus_Water(TileIndex tile, TransportType mode,
if (mode != TRANSPORT_WATER) return 0; if (mode != TRANSPORT_WATER) return 0;
switch (GetWaterTileType(tile)) { switch (GetWaterTileType(tile)) {
case WATER_TILE_CLEAR: ts = (GetTileSlope(tile, NULL) == SLOPE_FLAT) ? TRACK_BIT_ALL : TRACK_BIT_NONE; break; case WATER_TILE_CLEAR: ts = (GetTilePixelSlope(tile, NULL) == SLOPE_FLAT) ? TRACK_BIT_ALL : TRACK_BIT_NONE; break;
case WATER_TILE_COAST: ts = (TrackBits)coast_tracks[GetTileSlope(tile, NULL) & 0xF]; break; case WATER_TILE_COAST: ts = (TrackBits)coast_tracks[GetTilePixelSlope(tile, NULL) & 0xF]; break;
case WATER_TILE_LOCK: ts = DiagDirToDiagTrackBits(GetLockDirection(tile)); break; case WATER_TILE_LOCK: ts = DiagDirToDiagTrackBits(GetLockDirection(tile)); break;
case WATER_TILE_DEPOT: ts = AxisToTrackBits(GetShipDepotAxis(tile)); break; case WATER_TILE_DEPOT: ts = AxisToTrackBits(GetShipDepotAxis(tile)); break;
default: return 0; default: return 0;
@ -1213,7 +1213,7 @@ static CommandCost TerraformTile_Water(TileIndex tile, DoCommandFlag flags, uint
extern const TileTypeProcs _tile_type_water_procs = { extern const TileTypeProcs _tile_type_water_procs = {
DrawTile_Water, // draw_tile_proc DrawTile_Water, // draw_tile_proc
GetSlopeZ_Water, // get_slope_z_proc GetSlopePixelZ_Water, // get_slope_z_proc
ClearTile_Water, // clear_tile_proc ClearTile_Water, // clear_tile_proc
NULL, // add_accepted_cargo_proc NULL, // add_accepted_cargo_proc
GetTileDesc_Water, // get_tile_desc_proc GetTileDesc_Water, // get_tile_desc_proc

4
src/waypoint_cmd.cpp
View File

@ -124,7 +124,7 @@ static CommandCost IsValidTileForWaypoint(TileIndex tile, Axis axis, StationID *
if (ret.Succeeded()) ret = EnsureNoVehicleOnGround(tile); if (ret.Succeeded()) ret = EnsureNoVehicleOnGround(tile);
if (ret.Failed()) return ret; if (ret.Failed()) return ret;
Slope tileh = GetTileSlope(tile, NULL); Slope tileh = GetTilePixelSlope(tile, NULL);
if (tileh != SLOPE_FLAT && if (tileh != SLOPE_FLAT &&
(!_settings_game.construction.build_on_slopes || IsSteepSlope(tileh) || !(tileh & (0x3 << axis)) || !(tileh & ~(0x3 << axis)))) { (!_settings_game.construction.build_on_slopes || IsSteepSlope(tileh) || !(tileh & (0x3 << axis)) || !(tileh & ~(0x3 << axis)))) {
return_cmd_error(STR_ERROR_FLAT_LAND_REQUIRED); return_cmd_error(STR_ERROR_FLAT_LAND_REQUIRED);
@ -285,7 +285,7 @@ CommandCost CmdBuildBuoy(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32
if (tile == 0 || !HasTileWaterGround(tile)) return_cmd_error(STR_ERROR_SITE_UNSUITABLE); if (tile == 0 || !HasTileWaterGround(tile)) return_cmd_error(STR_ERROR_SITE_UNSUITABLE);
if (MayHaveBridgeAbove(tile) && IsBridgeAbove(tile)) return_cmd_error(STR_ERROR_MUST_DEMOLISH_BRIDGE_FIRST); if (MayHaveBridgeAbove(tile) && IsBridgeAbove(tile)) return_cmd_error(STR_ERROR_MUST_DEMOLISH_BRIDGE_FIRST);
if (GetTileSlope(tile, NULL) != SLOPE_FLAT) return_cmd_error(STR_ERROR_SITE_UNSUITABLE); if (GetTilePixelSlope(tile, NULL) != SLOPE_FLAT) return_cmd_error(STR_ERROR_SITE_UNSUITABLE);
/* Check if there is an already existing, deleted, waypoint close to us that we can reuse. */ /* Check if there is an already existing, deleted, waypoint close to us that we can reuse. */
Waypoint *wp = FindDeletedWaypointCloseTo(tile, STR_SV_STNAME_BUOY, OWNER_NONE); Waypoint *wp = FindDeletedWaypointCloseTo(tile, STR_SV_STNAME_BUOY, OWNER_NONE);