mirrors/OpenRCT2
1
0
Fork 0
mirror of https://github.com/OpenRCT2/OpenRCT2 synced 2026-01-04 05:32:54 +01:00
Code Issues Releases Wiki Activity

Merge pull request #9959 from richard-fine/directions

Browse Source 
Convert more code to use proper Direction symbols
This commit is contained in:
Michael Steenbeek
2019-09-22 16:59:41 +02:00
committed by GitHub
parent 565ad3798d 92f50efedc
commit a5700a3d07
18 changed files with 161 additions and 84 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
src/openrct2/actions/FootpathPlaceAction.hpp
View File

@@ -28,11 +28,11 @@ private:
CoordsXYZ _loc;
uint8_t _slope;
uint8_t _type;
uint8_t _direction = 0xFF;
Direction _direction = INVALID_DIRECTION;
public:
FootpathPlaceAction() = default;
FootpathPlaceAction(CoordsXYZ loc, uint8_t slope, uint8_t type, uint8_t direction = 0xFF)
FootpathPlaceAction(CoordsXYZ loc, uint8_t slope, uint8_t type, Direction direction = INVALID_DIRECTION)
: _loc(loc)
, _slope(slope)
, _type(type)
@@ -88,7 +88,7 @@ public:
return MakeResult(GA_ERROR::DISALLOWED, STR_CANT_BUILD_FOOTPATH_HERE, STR_TOO_HIGH);
}
if (_direction != 0xFF && _direction > 15)
if (_direction != INVALID_DIRECTION && !direction_valid(_direction))
{
log_error("Direction invalid. direction = %u", _direction);
return MakeResult(GA_ERROR::INVALID_PARAMETERS, STR_CANT_BUILD_FOOTPATH_HERE);
@@ -127,7 +127,7 @@ public:
if (!(GetFlags() & GAME_COMMAND_FLAG_GHOST))
{
if (_direction != 0xFF && !gCheatsDisableClearanceChecks)
if (_direction != INVALID_DIRECTION && !gCheatsDisableClearanceChecks)
{
// It is possible, let's remove walls between the old and new piece of path
auto zLow = _loc.z / 8;

2
src/openrct2/actions/LandSetHeightAction.hpp
View File

@@ -339,7 +339,7 @@ private:
money32 GetSurfaceHeightChangeCost(SurfaceElement * surfaceElement) const
{
money32 cost{ 0 };
for (int32_t i = 0; i < 4; i += 1)
for (Direction i : ALL_DIRECTIONS)
{
int32_t cornerHeight = tile_element_get_corner_height(surfaceElement, i);
cornerHeight -= map_get_corner_height(_height, _style & TILE_ELEMENT_SURFACE_SLOPE_MASK, i);

2
src/openrct2/actions/RideDemolishAction.hpp
View File

@@ -332,7 +332,7 @@ private:
{ 16, 0 },
};
for (uint8_t dir = 0; dir < 4; dir++)
for (Direction dir : ALL_DIRECTIONS)
{
const LocationXY16& off = DirOffsets[dir];
money32 removePrice = MazeRemoveTrack(x + off.x, y + off.y, z, dir);

4
src/openrct2/actions/WallPlaceAction.hpp
View File

@@ -54,7 +54,7 @@ DEFINE_GAME_ACTION(WallPlaceAction, GAME_COMMAND_PLACE_WALL, WallPlaceActionResu
private:
int32_t _wallType{ -1 };
CoordsXYZ _loc;
uint8_t _edge{ std::numeric_limits<uint8_t>::max() };
Direction _edge{ INVALID_DIRECTION };
int32_t _primaryColour;
int32_t _secondaryColour;
int32_t _tertiaryColour;
@@ -557,7 +557,7 @@ private:
{
if (!(TrackCoordinates[trackType].rotation_begin & 4))
{
direction = trackElement->GetDirectionWithOffset(2);
direction = direction_reverse(trackElement->GetDirection());
if (direction == _edge)
{
const rct_preview_track* trackBlock = &TrackBlocks[trackType][sequence];

8
src/openrct2/core/Endianness.h
View File

@@ -17,6 +17,7 @@ template<size_t size> struct ByteSwapT
template<> struct ByteSwapT<1>
{
typedef uint8_t UIntType;
static uint8_t SwapBE(uint8_t value)
{
return value;
@@ -25,6 +26,7 @@ template<> struct ByteSwapT<1>
template<> struct ByteSwapT<2>
{
typedef uint16_t UIntType;
static uint16_t SwapBE(uint16_t value)
{
return (uint16_t)((value << 8) | (value >> 8));
@@ -33,6 +35,7 @@ template<> struct ByteSwapT<2>
template<> struct ByteSwapT<4>
{
typedef uint32_t UIntType;
static uint32_t SwapBE(uint32_t value)
{
return (uint32_t)(((value << 24) | ((value << 8) & 0x00FF0000) | ((value >> 8) & 0x0000FF00) | (value >> 24)));
@@ -41,6 +44,7 @@ template<> struct ByteSwapT<4>
template<> struct ByteSwapT<8>
{
typedef uint64_t UIntType;
static uint64_t SwapBE(uint64_t value)
{
value = (value & 0x00000000FFFFFFFF) << 32 | (value & 0xFFFFFFFF00000000) >> 32;
@@ -52,5 +56,7 @@ template<> struct ByteSwapT<8>
template<typename T> static T ByteSwapBE(const T& value)
{
return ByteSwapT<sizeof(T)>::SwapBE(value);
typedef ByteSwapT<sizeof(T)> ByteSwap;
typename ByteSwap::UIntType result = ByteSwap::SwapBE(reinterpret_cast<const typename ByteSwap::UIntType&>(value));
return *reinterpret_cast<T*>(&result);
}

2
src/openrct2/paint/tile_element/Paint.TileElement.cpp
View File

@@ -248,7 +248,7 @@ static void sub_68B3FB(paint_session* session, int32_t x, int32_t y)
if ((session->ViewFlags & VIEWPORT_FLAG_CLIP_VIEW) && (tile_element->base_height > gClipHeight))
continue;
int32_t direction = tile_element->GetDirectionWithOffset(rotation);
Direction direction = tile_element->GetDirectionWithOffset(rotation);
int32_t height = tile_element->base_height * 8;
// If we are on a new height level, look through elements on the

6
src/openrct2/peep/Guest.cpp
View File

@@ -6472,7 +6472,7 @@ static bool peep_find_ride_to_look_at(Peep* peep, uint8_t edge, uint8_t* rideToV
}
if (tileElement->GetType() != TILE_ELEMENT_TYPE_WALL)
continue;
if (tileElement->GetDirectionWithOffset(2) != edge)
if (direction_reverse(tileElement->GetDirection()) != edge)
continue;
auto wallEntry = tileElement->AsWall()->GetEntry();
if (wallEntry == nullptr || (wallEntry->wall.flags2 & WALL_SCENERY_2_IS_OPAQUE))
@@ -6590,7 +6590,7 @@ static bool peep_find_ride_to_look_at(Peep* peep, uint8_t edge, uint8_t* rideToV
}
if (tileElement->GetType() != TILE_ELEMENT_TYPE_WALL)
continue;
if (tileElement->GetDirectionWithOffset(2) != edge)
if (direction_reverse(tileElement->GetDirection()) != edge)
continue;
auto wallEntry = tileElement->AsWall()->GetEntry();
if (wallEntry == nullptr || (wallEntry->wall.flags2 & WALL_SCENERY_2_IS_OPAQUE))
@@ -6706,7 +6706,7 @@ static bool peep_find_ride_to_look_at(Peep* peep, uint8_t edge, uint8_t* rideToV
}
if (tileElement->GetType() != TILE_ELEMENT_TYPE_WALL)
continue;
if (tileElement->GetDirectionWithOffset(2) != edge)
if (direction_reverse(tileElement->GetDirection()) != edge)
continue;
auto wallEntry = tileElement->AsWall()->GetEntry();
if (wallEntry == nullptr || (wallEntry->wall.flags2 & WALL_SCENERY_2_IS_OPAQUE))

75
src/openrct2/peep/GuestPathfinding.cpp
View File

@@ -33,7 +33,7 @@ static int32_t guest_surface_path_finding(Peep* peep);
static struct
{
TileCoordsXYZ location;
uint8_t direction;
Direction direction;
} _peepPathFindHistory[16];
enum
@@ -105,9 +105,9 @@ static int32_t path_get_permitted_edges(PathElement* pathElement)
*
* rct2: 0x0069524E
*/
static int32_t peep_move_one_tile(uint8_t direction, Peep* peep)
static int32_t peep_move_one_tile(Direction direction, Peep* peep)
{
assert(direction <= 3);
assert(direction_valid(direction));
int16_t x = peep->next_x;
int16_t y = peep->next_y;
x += CoordsDirectionDelta[direction].x;
@@ -139,13 +139,13 @@ static int32_t guest_surface_path_finding(Peep* peep)
int16_t x = peep->next_x;
int16_t y = peep->next_y;
int16_t z = peep->next_z;
uint8_t randDirection = scenario_rand() & 3;
Direction randDirection = scenario_rand() & 3;
if (!fence_in_the_way(x, y, z, z + 4, randDirection))
{
x += CoordsDirectionDelta[randDirection].x;
y += CoordsDirectionDelta[randDirection].y;
uint8_t backwardsDirection = direction_reverse(randDirection);
Direction backwardsDirection = direction_reverse(randDirection);
if (!fence_in_the_way(x, y, z, z + 4, backwardsDirection))
{
@@ -170,7 +170,7 @@ static int32_t guest_surface_path_finding(Peep* peep)
{
x += CoordsDirectionDelta[randDirection].x;
y += CoordsDirectionDelta[randDirection].y;
uint8_t backwardsDirection = direction_reverse(randDirection);
Direction backwardsDirection = direction_reverse(randDirection);
if (!fence_in_the_way(x, y, z, z + 4, backwardsDirection))
{
@@ -190,7 +190,7 @@ static int32_t guest_surface_path_finding(Peep* peep)
{
x += CoordsDirectionDelta[randDirection].x;
y += CoordsDirectionDelta[randDirection].y;
uint8_t backwardsDirection = direction_reverse(randDirection);
Direction backwardsDirection = direction_reverse(randDirection);
if (!fence_in_the_way(x, y, z, z + 4, backwardsDirection))
{
@@ -223,7 +223,7 @@ static int32_t guest_surface_path_finding(Peep* peep)
* Returns the type of the next footpath tile a peep can get to from x,y,z /
* inputTileElement in the given direction.
*/
static uint8_t footpath_element_next_in_direction(TileCoordsXYZ loc, PathElement* pathElement, uint8_t chosenDirection)
static uint8_t footpath_element_next_in_direction(TileCoordsXYZ loc, PathElement* pathElement, Direction chosenDirection)
{
TileElement* nextTileElement;
@@ -275,10 +275,11 @@ static uint8_t footpath_element_next_in_direction(TileCoordsXYZ loc, PathElement
*
* This is the recursive portion of footpath_element_destination_in_direction().
*/
static uint8_t footpath_element_dest_in_dir(TileCoordsXYZ loc, uint8_t chosenDirection, ride_id_t* outRideIndex, int32_t level)
static uint8_t footpath_element_dest_in_dir(
TileCoordsXYZ loc, Direction chosenDirection, ride_id_t* outRideIndex, int32_t level)
{
TileElement* tileElement;
int32_t direction;
Direction direction;
if (level > 25)
return PATH_SEARCH_LIMIT_REACHED;
@@ -344,23 +345,23 @@ static uint8_t footpath_element_dest_in_dir(TileCoordsXYZ loc, uint8_t chosenDir
edges &= ~(1 << direction_reverse(chosenDirection));
loc.z = tileElement->base_height;
for (direction = 0; direction < 4; direction++)
for (Direction dir : ALL_DIRECTIONS)
{
if (!(edges & (1 << direction)))
if (!(edges & (1 << dir)))
continue;
edges &= ~(1 << direction);
edges &= ~(1 << dir);
if (edges != 0)
return PATH_SEARCH_JUNCTION;
if (tileElement->AsPath()->IsSloped())
{
if (tileElement->AsPath()->GetSlopeDirection() == direction)
if (tileElement->AsPath()->GetSlopeDirection() == dir)
{
loc.z += 2;
}
}
return footpath_element_dest_in_dir(loc, direction, outRideIndex, level + 1);
return footpath_element_dest_in_dir(loc, dir, outRideIndex, level + 1);
}
return PATH_SEARCH_DEAD_END;
}
@@ -393,7 +394,7 @@ static uint8_t footpath_element_dest_in_dir(TileCoordsXYZ loc, uint8_t chosenDir
* width path, for example that leads from a ride exit back to the main path.
*/
static uint8_t footpath_element_destination_in_direction(
TileCoordsXYZ loc, PathElement* pathElement, uint8_t chosenDirection, ride_id_t* outRideIndex)
TileCoordsXYZ loc, PathElement* pathElement, Direction chosenDirection, ride_id_t* outRideIndex)
{
if (pathElement->IsSloped())
{
@@ -423,7 +424,7 @@ static int32_t guest_path_find_aimless(Peep* peep, uint8_t edges)
while (true)
{
uint8_t direction = scenario_rand() & 3;
Direction direction = scenario_rand() & 3;
// Otherwise go in a random direction allowed from the tile.
if (edges & (1 << direction))
{
@@ -596,8 +597,8 @@ static int32_t CalculateHeuristicPathingScore(TileCoordsXYZ loc1, TileCoordsXYZ
*/
static void peep_pathfind_heuristic_search(
TileCoordsXYZ loc, Peep* peep, TileElement* currentTileElement, bool inPatrolArea, uint8_t counter, uint16_t* endScore,
int32_t test_edge, uint8_t* endJunctions, TileCoordsXYZ junctionList[16], uint8_t directionList[16], TileCoordsXYZ* endXYZ,
uint8_t* endSteps)
Direction test_edge, uint8_t* endJunctions, TileCoordsXYZ junctionList[16], uint8_t directionList[16],
TileCoordsXYZ* endXYZ, uint8_t* endSteps)
{
uint8_t searchResult = PATH_SEARCH_FAILED;
@@ -680,7 +681,7 @@ static void peep_pathfind_heuristic_search(
case TILE_ELEMENT_TYPE_ENTRANCE:
if (loc.z != tileElement->base_height)
continue;
int32_t direction;
Direction direction;
searchResult = PATH_SEARCH_OTHER;
switch (tileElement->AsEntrance()->GetEntranceType())
{
@@ -905,7 +906,7 @@ static void peep_pathfind_heuristic_search(
#endif // defined(DEBUG_LEVEL_2) && DEBUG_LEVEL_2
/* Remove the reverse edge (i.e. the edge back to the previous map element.) */
edges &= ~(1 << (test_edge ^ 2));
edges &= ~(1 << direction_reverse(test_edge));
int32_t next_test_edge = bitscanforward(edges);
@@ -1162,7 +1163,7 @@ static void peep_pathfind_heuristic_search(
*
* rct2: 0x0069A5F0
*/
int32_t peep_pathfind_choose_direction(TileCoordsXYZ loc, Peep* peep)
Direction peep_pathfind_choose_direction(TileCoordsXYZ loc, Peep* peep)
{
// The max number of thin junctions searched - a per-search-path limit.
_peepPathFindMaxJunctions = peep_pathfind_get_max_number_junctions(peep);
@@ -1231,7 +1232,7 @@ int32_t peep_pathfind_choose_direction(TileCoordsXYZ loc, Peep* peep)
} while (!(dest_tile_element++)->IsLastForTile());
// Peep is not on a path.
if (!found)
return -1;
return INVALID_DIRECTION;
permitted_edges &= 0xF;
uint8_t edges = permitted_edges;
@@ -1302,7 +1303,7 @@ int32_t peep_pathfind_choose_direction(TileCoordsXYZ loc, Peep* peep)
/* If this is a new goal for the peep. Store it and reset the peep's
* pathfind_history. */
if (peep->pathfind_goal.direction > 3 || peep->pathfind_goal.x != goal.x || peep->pathfind_goal.y != goal.y
if (!direction_valid(peep->pathfind_goal.direction) || peep->pathfind_goal.x != goal.x || peep->pathfind_goal.y != goal.y
|| peep->pathfind_goal.z != goal.z)
{
peep->pathfind_goal.x = goal.x;
@@ -1322,7 +1323,7 @@ int32_t peep_pathfind_choose_direction(TileCoordsXYZ loc, Peep* peep)
// Peep has tried all edges.
if (edges == 0)
return -1;
return INVALID_DIRECTION;
int32_t chosen_edge = bitscanforward(edges);
@@ -1465,7 +1466,7 @@ int32_t peep_pathfind_choose_direction(TileCoordsXYZ loc, Peep* peep)
log_verbose("Pathfind heuristic search failed.");
}
#endif // defined(DEBUG_LEVEL_1) && DEBUG_LEVEL_1
return -1;
return INVALID_DIRECTION;
}
#if defined(DEBUG_LEVEL_1) && DEBUG_LEVEL_1
if (gPathFindDebug)
@@ -1578,9 +1579,9 @@ static int32_t guest_path_find_entering_park(Peep* peep, uint8_t edges)
gPeepPathFindIgnoreForeignQueues = true;
gPeepPathFindQueueRideIndex = RIDE_ID_NULL;
int32_t chosenDirection = peep_pathfind_choose_direction({ peep->next_x / 32, peep->next_y / 32, peep->next_z }, peep);
Direction chosenDirection = peep_pathfind_choose_direction({ peep->next_x / 32, peep->next_y / 32, peep->next_z }, peep);
if (chosenDirection == -1)
if (chosenDirection == INVALID_DIRECTION)
return guest_path_find_aimless(peep, edges);
else
return peep_move_one_tile(chosenDirection, peep);
@@ -1628,7 +1629,7 @@ static int32_t guest_path_find_leaving_park(Peep* peep, uint8_t edges)
int16_t x = peepSpawn->x & 0xFFE0;
int16_t y = peepSpawn->y & 0xFFE0;
uint8_t z = peepSpawn->z / 8;
uint8_t direction = peepSpawn->direction;
Direction direction = peepSpawn->direction;
gPeepPathFindGoalPosition = { x / 32, y / 32, z };
if (x == peep->next_x && y == peep->next_y)
@@ -1639,7 +1640,7 @@ static int32_t guest_path_find_leaving_park(Peep* peep, uint8_t edges)
gPeepPathFindIgnoreForeignQueues = true;
gPeepPathFindQueueRideIndex = RIDE_ID_NULL;
direction = peep_pathfind_choose_direction({ peep->next_x / 32, peep->next_y / 32, peep->next_z }, peep);
if (direction == 0xFF)
if (direction == INVALID_DIRECTION)
return guest_path_find_aimless(peep, edges);
else
return peep_move_one_tile(direction, peep);
@@ -1694,13 +1695,13 @@ static int32_t guest_path_find_park_entrance(Peep* peep, uint8_t edges)
pathfind_logging_enable(peep);
#endif // defined(DEBUG_LEVEL_1) && DEBUG_LEVEL_1
int32_t chosenDirection = peep_pathfind_choose_direction({ peep->next_x / 32, peep->next_y / 32, peep->next_z }, peep);
Direction chosenDirection = peep_pathfind_choose_direction({ peep->next_x / 32, peep->next_y / 32, peep->next_z }, peep);
#if defined(DEBUG_LEVEL_1) && DEBUG_LEVEL_1
pathfind_logging_disable();
#endif // defined(DEBUG_LEVEL_1) && DEBUG_LEVEL_1
if (chosenDirection == -1)
if (chosenDirection == INVALID_DIRECTION)
return guest_path_find_aimless(peep, edges);
else
return peep_move_one_tile(chosenDirection, peep);
@@ -1740,7 +1741,7 @@ static void get_ride_queue_end(TileCoordsXYZ& loc)
if (!found)
return;
uint8_t direction = tileElement->GetDirectionWithOffset(2);
Direction direction = direction_reverse(tileElement->GetDirection());
TileElement* lastPathElement = nullptr;
TileElement* firstPathElement = nullptr;
@@ -1889,7 +1890,7 @@ int32_t guest_path_finding(Guest* peep)
/* If this tileElement is adjacent to any non-wide paths,
* remove all of the edges to wide paths. */
uint8_t adjustedEdges = edges;
for (int32_t chosenDirection = 0; chosenDirection < 4; chosenDirection++)
for (Direction chosenDirection : ALL_DIRECTIONS)
{
// If there is no path in that direction try another
if (!(adjustedEdges & (1 << chosenDirection)))
@@ -1906,7 +1907,7 @@ int32_t guest_path_finding(Guest* peep)
edges = adjustedEdges;
}
int8_t direction = direction_reverse(peep->direction);
int32_t direction = direction_reverse(peep->direction);
// Check if in a dead end (i.e. only edge is where the peep came from)
if (!(edges & ~(1 << direction)))
{
@@ -1971,7 +1972,7 @@ int32_t guest_path_finding(Guest* peep)
if (!peep->HasFood() && (scenario_rand() & 0xFFFF) >= 2184)
{
uint8_t adjustedEdges = edges;
for (int32_t chosenDirection = 0; chosenDirection < 4; chosenDirection++)
for (Direction chosenDirection : ALL_DIRECTIONS)
{
// If there is no path in that direction try another
if (!(adjustedEdges & (1 << chosenDirection)))
@@ -2134,7 +2135,7 @@ int32_t guest_path_finding(Guest* peep)
direction = peep_pathfind_choose_direction({ peep->next_x / 32, peep->next_y / 32, peep->next_z }, peep);
if (direction == -1)
if (direction == INVALID_DIRECTION)
{
/* Heuristic search failed for all directions.
* Reset the pathfind_goal - this means that the pathfind_history

4
src/openrct2/peep/Peep.h
View File

@@ -615,7 +615,7 @@ struct Peep : rct_sprite_common
union
{
uint8_t maze_last_edge; // 0x78
uint8_t direction; // Direction ?
Direction direction; // Direction ?
};
uint8_t interaction_ride_index;
uint16_t time_in_queue; // 0x7A
@@ -983,7 +983,7 @@ void peep_update_names(bool realNames);
void guest_set_name(uint16_t spriteIndex, const char* name);
int32_t peep_pathfind_choose_direction(TileCoordsXYZ loc, Peep* peep);
Direction peep_pathfind_choose_direction(TileCoordsXYZ loc, Peep* peep);
void peep_reset_pathfind_goal(Peep* peep);
bool is_valid_path_z_and_direction(TileElement* tileElement, int32_t currentZ, int32_t currentDirection);

26
src/openrct2/peep/Staff.cpp
View File

@@ -234,7 +234,7 @@ bool staff_can_ignore_wide_flag(Peep* staff, int32_t x, int32_t y, uint8_t z, Ti
uint8_t total = 0;
uint8_t pathcount = 0;
uint8_t widecount = 0;
for (int32_t adjac_dir = 0; adjac_dir <= 3; adjac_dir++)
for (Direction adjac_dir : ALL_DIRECTIONS)
{
int32_t adjac_x = x + CoordsDirectionDelta[adjac_dir].x;
int32_t adjac_y = y + CoordsDirectionDelta[adjac_dir].y;
@@ -514,15 +514,15 @@ static uint8_t staff_handyman_direction_to_uncut_grass(Peep* peep, uint8_t valid
auto surfaceElement = map_get_surface_element_at({ peep->next_x, peep->next_y });
if (peep->next_z != surfaceElement->base_height)
return 0xFF;
return INVALID_DIRECTION;
if (peep->GetNextIsSloped())
{
if (surfaceElement->GetSlope() != PathSlopeToLandSlope[peep->GetNextDirection()])
return 0xFF;
return INVALID_DIRECTION;
}
else if (surfaceElement->GetSlope() != TILE_ELEMENT_SLOPE_FLAT)
return 0xFF;
return INVALID_DIRECTION;
}
uint8_t chosenDirection = scenario_rand() & 0x3;
@@ -553,7 +553,7 @@ static uint8_t staff_handyman_direction_to_uncut_grass(Peep* peep, uint8_t valid
}
}
}
return 0xFF;
return INVALID_DIRECTION;
}
/**
@@ -600,13 +600,13 @@ static bool staff_path_finding_handyman(Peep* peep)
litterDirection = staff_handyman_direction_to_nearest_litter(peep);
}
uint8_t direction = 0xFF;
Direction direction = INVALID_DIRECTION;
if (litterDirection == 0xFF && (peep->staff_orders & STAFF_ORDERS_MOWING) && peep->staff_mowing_timeout >= 12)
{
direction = staff_handyman_direction_to_uncut_grass(peep, validDirections);
}
if (direction == 0xFF)
if (direction == INVALID_DIRECTION)
{
if (peep->GetNextIsSurface())
{
@@ -784,7 +784,7 @@ static uint8_t staff_mechanic_direction_path_rand(Peep* peep, uint8_t pathDirect
*/
static uint8_t staff_mechanic_direction_path(Peep* peep, uint8_t validDirections, PathElement* pathElement)
{
uint8_t direction = 0xFF;
Direction direction = INVALID_DIRECTION;
uint8_t pathDirections = pathElement->GetEdges();
pathDirections &= validDirections;
@@ -847,14 +847,14 @@ static uint8_t staff_mechanic_direction_path(Peep* peep, uint8_t validDirections
pathfind_logging_enable(peep);
#endif // defined(DEBUG_LEVEL_1) && DEBUG_LEVEL_1
int32_t pathfindDirection = peep_pathfind_choose_direction(
Direction pathfindDirection = peep_pathfind_choose_direction(
{ peep->next_x / 32, peep->next_y / 32, peep->next_z }, peep);
#if defined(DEBUG_LEVEL_1) && DEBUG_LEVEL_1
pathfind_logging_disable();
#endif // defined(DEBUG_LEVEL_1) && DEBUG_LEVEL_1
if (pathfindDirection == -1)
if (pathfindDirection == INVALID_DIRECTION)
{
/* Heuristic search failed for all directions.
* Reset the pathfind_goal - this means that the pathfind_history
@@ -878,7 +878,7 @@ static uint8_t staff_mechanic_direction_path(Peep* peep, uint8_t validDirections
static bool staff_path_finding_mechanic(Peep* peep)
{
uint8_t validDirections = staff_get_valid_patrol_directions(peep, peep->next_x, peep->next_y);
uint8_t direction = 0xFF;
Direction direction = INVALID_DIRECTION;
if (peep->GetNextIsSurface())
{
direction = staff_mechanic_direction_surface(peep);
@@ -919,7 +919,7 @@ static bool staff_path_finding_mechanic(Peep* peep)
*/
static uint8_t staff_direction_path(Peep* peep, uint8_t validDirections, PathElement* pathElement)
{
uint8_t direction = 0xFF;
Direction direction = INVALID_DIRECTION;
uint8_t pathDirections = pathElement->GetEdges();
if (peep->state != PEEP_STATE_ANSWERING && peep->state != PEEP_STATE_HEADING_TO_INSPECTION)
{
@@ -966,7 +966,7 @@ static bool staff_path_finding_misc(Peep* peep)
{
uint8_t validDirections = staff_get_valid_patrol_directions(peep, peep->next_x, peep->next_y);
uint8_t direction = 0xFF;
Direction direction = INVALID_DIRECTION;
if (peep->GetNextIsSurface())
{
direction = staff_direction_surface(peep, scenario_rand() & 3);

2
src/openrct2/ride/Ride.cpp
View File

@@ -7043,7 +7043,7 @@ void sub_6CB945(Ride* ride)
uint8_t trackType = trackElement->AsTrack()->GetTrackType();
uint8_t trackSequence = trackElement->AsTrack()->GetSequenceIndex();
uint8_t direction = (tileElement->GetDirection() - trackElement->GetDirectionWithOffset(2)) & 3;
Direction direction = (tileElement->GetDirection() - direction_reverse(trackElement->GetDirection())) & 3;
if (!(TrackSequenceProperties[trackType][trackSequence] & (1 << direction)))
{

16
src/openrct2/world/Footpath.cpp
View File

@@ -755,7 +755,7 @@ static bool footpath_disconnect_queue_from_path(int32_t x, int32_t y, TileElemen
return true;
}
for (int32_t direction = 0; direction < 4; direction++)
for (Direction direction : ALL_DIRECTIONS)
{
if ((action < 0) && (direction == tileElement->AsPath()->GetSlopeDirection()))
continue;
@@ -994,7 +994,7 @@ void footpath_connect_edges(int32_t x, int32_t y, TileElement* tileElement, int3
neighbour_list_init(&neighbourList);
footpath_update_queue_entrance_banner(x, y, tileElement);
for (int32_t direction = 0; direction < 4; direction++)
for (Direction direction : ALL_DIRECTIONS)
{
loc_6A6C85(x, y, direction, tileElement, flags, true, &neighbourList);
}
@@ -1212,7 +1212,7 @@ void footpath_update_queue_chains()
if (tileElement->AsEntrance()->GetRideIndex() != rideIndex)
continue;
uint8_t direction = tileElement->GetDirectionWithOffset(2);
Direction direction = direction_reverse(tileElement->GetDirection());
footpath_chain_ride_queue(rideIndex, i, location.x << 5, location.y << 5, tileElement, direction);
} while (!(tileElement++)->IsLastForTile());
}
@@ -1425,15 +1425,15 @@ void PathElement::SetSloped(bool isSloped)
entryIndex |= FOOTPATH_PROPERTIES_FLAG_IS_SLOPED;
}
uint8_t PathElement::GetSlopeDirection() const
Direction PathElement::GetSlopeDirection() const
{
return entryIndex & FOOTPATH_PROPERTIES_SLOPE_DIRECTION_MASK;
return static_cast<Direction>(entryIndex & FOOTPATH_PROPERTIES_SLOPE_DIRECTION_MASK);
}
void PathElement::SetSlopeDirection(uint8_t newSlope)
void PathElement::SetSlopeDirection(Direction newSlope)
{
entryIndex &= ~FOOTPATH_PROPERTIES_SLOPE_DIRECTION_MASK;
entryIndex |= newSlope & FOOTPATH_PROPERTIES_SLOPE_DIRECTION_MASK;
entryIndex |= static_cast<uint8_t>(newSlope) & FOOTPATH_PROPERTIES_SLOPE_DIRECTION_MASK;
}
bool PathElement::IsQueue() const
@@ -1891,7 +1891,7 @@ void footpath_update_queue_entrance_banner(int32_t x, int32_t y, TileElement* ti
if (tileElement->AsEntrance()->GetEntranceType() == ENTRANCE_TYPE_RIDE_ENTRANCE)
{
footpath_queue_chain_push(tileElement->AsEntrance()->GetRideIndex());
footpath_chain_ride_queue(255, 0, x, y, tileElement, tileElement->GetDirectionWithOffset(2));
footpath_chain_ride_queue(255, 0, x, y, tileElement, direction_reverse(tileElement->GetDirection()));
}
break;
}

26
src/openrct2/world/Location.hpp
View File

@@ -267,6 +267,14 @@ struct TileCoordsXYZ
*/
typedef uint8_t Direction;
const Direction INVALID_DIRECTION = 0xFF;
/**
* Array of all valid cardinal directions, to make it easy to write range-based for loops like:
* for (Direction d : ALL_DIRECTIONS)
*/
constexpr Direction ALL_DIRECTIONS[] = { 0, 1, 2, 3 };
/**
* Given a direction, return the direction that points the other way,
* on the same axis.
@@ -281,6 +289,24 @@ typedef uint8_t Direction;
return dir < 4;
}
/**
* Given a direction, return the next cardinal direction, wrapping around if necessary.
* (TODO: Figure out if this is CW or CCW)
*/
[[maybe_unused]] static constexpr Direction direction_next(Direction dir)
{
return (dir + 1) & 0x03;
}
/**
* Given a direction, return the previous cardinal direction, wrapping around if necessary.
* (TODO: Figure out if this is CW or CCW)
*/
[[maybe_unused]] static constexpr Direction direction_prev(Direction dir)
{
return (dir - 1) & 0x03;
}
struct CoordsXYZD : public CoordsXYZ
{
Direction direction = 0;

6
src/openrct2/world/TileElement.cpp
View File

@@ -28,18 +28,18 @@ void TileElementBase::SetType(uint8_t newType)
this->type |= (newType & TILE_ELEMENT_TYPE_MASK);
}
uint8_t TileElementBase::GetDirection() const
Direction TileElementBase::GetDirection() const
{
return this->type & TILE_ELEMENT_DIRECTION_MASK;
}
void TileElementBase::SetDirection(uint8_t direction)
void TileElementBase::SetDirection(Direction direction)
{
this->type &= ~TILE_ELEMENT_DIRECTION_MASK;
this->type |= (direction & TILE_ELEMENT_DIRECTION_MASK);
}
uint8_t TileElementBase::GetDirectionWithOffset(uint8_t offset) const
Direction TileElementBase::GetDirectionWithOffset(uint8_t offset) const
{
return ((this->type & TILE_ELEMENT_DIRECTION_MASK) + offset) & TILE_ELEMENT_DIRECTION_MASK;
}

10
src/openrct2/world/TileElement.h
View File

@@ -68,9 +68,9 @@ struct TileElementBase
uint8_t GetType() const;
void SetType(uint8_t newType);
uint8_t GetDirection() const;
void SetDirection(uint8_t direction);
uint8_t GetDirectionWithOffset(uint8_t offset) const;
Direction GetDirection() const;
void SetDirection(Direction direction);
Direction GetDirectionWithOffset(uint8_t offset) const;
bool IsLastForTile() const;
void SetLastForTile(bool on);
bool IsGhost() const;
@@ -206,8 +206,8 @@ public:
bool IsSloped() const;
void SetSloped(bool isSloped);
uint8_t GetSlopeDirection() const;
void SetSlopeDirection(uint8_t newSlope);
Direction GetSlopeDirection() const;
void SetSlopeDirection(Direction newSlope);
ride_id_t GetRideIndex() const;
void SetRideIndex(ride_id_t newRideIndex);

43
test/tests/Endianness.cpp Normal file
View File

@@ -0,0 +1,43 @@
#include "openrct2/core/Endianness.h"
#include <gtest/gtest.h>
TEST(SwapBETest, ForUInt8_DoesNothing)
{
uint8_t before = 0x12;
uint8_t after = ByteSwapBE(before);
ASSERT_EQ(before, after);
}
TEST(SwapBETest, ForUInt16_SwapsBytes)
{
uint16_t before = 0x1234;
uint16_t after = ByteSwapBE(before);
ASSERT_EQ(0x3412u, after);
}
TEST(SwapBETest, ForUInt32_SwapsBytes)
{
uint32_t before = 0x12345678;
uint32_t after = ByteSwapBE(before);
ASSERT_EQ(0x78563412u, after);
}
TEST(SwapBETest, ForUInt64_SwapsBytes)
{
uint64_t before = 0x1234567887654321;
uint64_t after = ByteSwapBE(before);
ASSERT_EQ(0x2143658778563412u, after);
}
TEST(SwapBETest, ForCustomBlittableType_SwapsBytes)
{
struct MyStruct
{
uint16_t value;
};
MyStruct before = { 0x1234 };
MyStruct after = ByteSwapBE(before);
ASSERT_EQ(0x3412, after.value);
}

4
test/tests/Pathfinding.cpp
View File

@@ -83,8 +83,8 @@ protected:
// Pick the direction the peep should initially move in, given the goal position.
// This will also store the goal position and initialize pathfinding data for the peep.
gPeepPathFindGoalPosition = goal;
const int32_t moveDir = peep_pathfind_choose_direction(*pos, peep);
if (moveDir < 0)
const Direction moveDir = peep_pathfind_choose_direction(*pos, peep);
if (moveDir == INVALID_DIRECTION)
{
// Couldn't determine a direction to move off in
return false;

1
test/tests/tests.vcxproj
View File

@@ -58,6 +58,7 @@
<ItemGroup>
<ClCompile Include="CircularBuffer.cpp" />
<ClCompile Include="CryptTests.cpp" />
<ClCompile Include="Endianness.cpp" />
<ClCompile Include="LanguagePackTest.cpp" />
<ClCompile Include="ImageImporterTests.cpp" />
<ClCompile Include="IniReaderTest.cpp" />