diff --git a/src/openrct2-ui/windows/Guest.cpp b/src/openrct2-ui/windows/Guest.cpp
index f17ab8e30f..7be15e3544 100644
--- a/src/openrct2-ui/windows/Guest.cpp
+++ b/src/openrct2-ui/windows/Guest.cpp
@@ -711,7 +711,7 @@ void window_guest_viewport_init(rct_window* w)
     w->viewport_focus_coordinates.z = focus.coordinate.z;
     w->viewport_focus_coordinates.rotation = focus.coordinate.rotation;
 
-    if (peep->State != PEEP_STATE_PICKED && w->viewport == nullptr)
+    if (peep->State != PeepState::Picked && w->viewport == nullptr)
     {
         auto view_widget = &w->widgets[WIDX_VIEWPORT];
         auto screenPos = ScreenCoordsXY{ view_widget->left + 1 + w->windowPos.x, view_widget->top + 1 + w->windowPos.y };
diff --git a/src/openrct2-ui/windows/Staff.cpp b/src/openrct2-ui/windows/Staff.cpp
index 7ef39203b6..0e1d2fdb70 100644
--- a/src/openrct2-ui/windows/Staff.cpp
+++ b/src/openrct2-ui/windows/Staff.cpp
@@ -288,7 +288,7 @@ rct_window* window_staff_open(Peep* peep)
     window_init_scroll_widgets(w);
     window_staff_viewport_init(w);
 
-    if (peep->State == PEEP_STATE_PICKED)
+    if (peep->State == PeepState::Picked)
         window_event_mouse_up_call(w, WIDX_CHECKBOX_3);
 
     return w;
@@ -1339,7 +1339,7 @@ void window_staff_viewport_init(rct_window* w)
         return;
     }
 
-    if (peep->State == PEEP_STATE_PICKED)
+    if (peep->State == PeepState::Picked)
     {
         focus.sprite_id = SPRITE_INDEX_NULL;
     }
@@ -1375,7 +1375,7 @@ void window_staff_viewport_init(rct_window* w)
     w->viewport_focus_sprite.type = focus.type;
     w->viewport_focus_sprite.rotation = focus.rotation;
 
-    if (peep->State != PEEP_STATE_PICKED)
+    if (peep->State != PeepState::Picked)
     {
         if (!(w->viewport))
         {
diff --git a/src/openrct2/actions/RideDemolishAction.hpp b/src/openrct2/actions/RideDemolishAction.hpp
index eed98f5f52..5748711c5d 100644
--- a/src/openrct2/actions/RideDemolishAction.hpp
+++ b/src/openrct2/actions/RideDemolishAction.hpp
@@ -160,7 +160,7 @@ private:
 
             // clear ride from potentially being in RidesBeenOn
             peep->RidesBeenOn[ride_id_offset] &= ~(1 << ride_id_bit);
-            if (peep->State == PEEP_STATE_WATCHING)
+            if (peep->State == PeepState::Watching)
             {
                 if (peep->CurrentRide == _rideIndex)
                 {
diff --git a/src/openrct2/actions/StaffHireNewAction.hpp b/src/openrct2/actions/StaffHireNewAction.hpp
index bbb96c6c2c..1e7ff452a6 100644
--- a/src/openrct2/actions/StaffHireNewAction.hpp
+++ b/src/openrct2/actions/StaffHireNewAction.hpp
@@ -221,7 +221,7 @@ private:
             else
             {
                 // NOTE: This state is required for the window to act.
-                newPeep->State = PEEP_STATE_PICKED;
+                newPeep->State = PeepState::Picked;
 
                 newPeep->MoveTo({ newPeep->x, newPeep->y, newPeep->z });
             }
@@ -260,7 +260,7 @@ private:
     void AutoPositionNewStaff(Peep * newPeep) const
     {
         // Find a location to place new staff member
-        newPeep->State = PEEP_STATE_FALLING;
+        newPeep->State = PeepState::Falling;
 
         uint32_t count = 0;
         PathElement* guest_tile = nullptr;
@@ -269,7 +269,7 @@ private:
         {
             for (auto guest : EntityList<Guest>(EntityListId::Peep))
             {
-                if (guest->State == PEEP_STATE_WALKING)
+                if (guest->State == PeepState::Walking)
                 {
                     // Check the walking guest's tile. Only count them if they're on a path tile.
                     guest_tile = map_get_path_element_at(TileCoordsXYZ{ guest->NextLoc });
@@ -288,7 +288,7 @@ private:
 
             for (auto guest : EntityList<Guest>(EntityListId::Peep))
             {
-                if (guest->State == PEEP_STATE_WALKING)
+                if (guest->State == PeepState::Walking)
                 {
                     guest_tile = map_get_path_element_at(TileCoordsXYZ{ guest->NextLoc });
                     if (guest_tile != nullptr)
@@ -312,7 +312,7 @@ private:
             else
             {
                 // User must pick a location
-                newPeep->State = PEEP_STATE_PICKED;
+                newPeep->State = PeepState::Picked;
                 newLocation.x = newPeep->x;
                 newLocation.y = newPeep->y;
                 newLocation.z = newPeep->z;
@@ -334,7 +334,7 @@ private:
             else
             {
                 // User must pick a location
-                newPeep->State = PEEP_STATE_PICKED;
+                newPeep->State = PeepState::Picked;
                 newLocation.x = newPeep->x;
                 newLocation.y = newPeep->y;
                 newLocation.z = newPeep->z;
diff --git a/src/openrct2/interface/Viewport.cpp b/src/openrct2/interface/Viewport.cpp
index e60912e653..3a27712e82 100644
--- a/src/openrct2/interface/Viewport.cpp
+++ b/src/openrct2/interface/Viewport.cpp
@@ -692,7 +692,7 @@ viewport_focus viewport_update_smart_guest_follow(rct_window* window, Peep* peep
     focus.type = VIEWPORT_FOCUS_TYPE_SPRITE;
     focus.sprite.sprite_id = peep->sprite_index;
 
-    if (peep->State == PEEP_STATE_PICKED)
+    if (peep->State == PeepState::Picked)
     {
         focus.sprite.sprite_id = SPRITE_INDEX_NULL;
         window->viewport_smart_follow_sprite = SPRITE_INDEX_NULL;
@@ -702,8 +702,8 @@ viewport_focus viewport_update_smart_guest_follow(rct_window* window, Peep* peep
     else
     {
         bool overallFocus = true;
-        if (peep->State == PEEP_STATE_ON_RIDE || peep->State == PEEP_STATE_ENTERING_RIDE
-            || (peep->State == PEEP_STATE_LEAVING_RIDE && peep->x == LOCATION_NULL))
+        if (peep->State == PeepState::OnRide || peep->State == PeepState::EnteringRide
+            || (peep->State == PeepState::LeavingRide && peep->x == LOCATION_NULL))
         {
             auto ride = get_ride(peep->CurrentRide);
             if (ride != nullptr && (ride->lifecycle_flags & RIDE_LIFECYCLE_ON_TRACK))
@@ -752,7 +752,7 @@ void viewport_update_smart_staff_follow(rct_window* window, Peep* peep)
 
     focus.sprite_id = window->viewport_smart_follow_sprite;
 
-    if (peep->State == PEEP_STATE_PICKED)
+    if (peep->State == PeepState::Picked)
     {
         // focus.sprite.sprite_id = SPRITE_INDEX_NULL;
         window->viewport_smart_follow_sprite = SPRITE_INDEX_NULL;
diff --git a/src/openrct2/management/NewsItem.cpp b/src/openrct2/management/NewsItem.cpp
index 5286ac4aa4..d4b64708f6 100644
--- a/src/openrct2/management/NewsItem.cpp
+++ b/src/openrct2/management/NewsItem.cpp
@@ -228,7 +228,7 @@ std::optional<CoordsXYZ> News::GetSubjectLocation(News::ItemType type, int32_t s
             if (subjectLoc->x != LOCATION_NULL)
                 break;
 
-            if (peep->State != PEEP_STATE_ON_RIDE && peep->State != PEEP_STATE_ENTERING_RIDE)
+            if (peep->State != PeepState::OnRide && peep->State != PeepState::EnteringRide)
             {
                 subjectLoc = std::nullopt;
                 break;
diff --git a/src/openrct2/peep/Guest.cpp b/src/openrct2/peep/Guest.cpp
index e3395307fc..d867f948ae 100644
--- a/src/openrct2/peep/Guest.cpp
+++ b/src/openrct2/peep/Guest.cpp
@@ -471,7 +471,7 @@ void Guest::MakePassingPeepsSick(Guest* passingPeep)
 {
     if (this == passingPeep)
         return;
-    if (passingPeep->State != PEEP_STATE_WALKING)
+    if (passingPeep->State != PeepState::Walking)
         return;
 
     if (passingPeep->Action == PEEP_ACTION_NONE_1 || passingPeep->Action == PEEP_ACTION_NONE_2)
@@ -723,7 +723,7 @@ void Guest::loc_68F9F3()
         Toilet--;
     }
 
-    if (State == PEEP_STATE_WALKING && NauseaTarget >= 128)
+    if (State == PeepState::Walking && NauseaTarget >= 128)
     {
         if ((scenario_rand() & 0xFF) <= static_cast<uint8_t>((Nausea - 128) / 2))
         {
@@ -746,7 +746,7 @@ void Guest::loc_68FA89()
         TimeToConsume += 3;
     }
 
-    if (TimeToConsume != 0 && State != PEEP_STATE_ON_RIDE)
+    if (TimeToConsume != 0 && State != PeepState::OnRide)
     {
         TimeToConsume = std::max(TimeToConsume - 3, 0);
 
@@ -888,7 +888,7 @@ void Guest::Tick128UpdateGuest(int32_t index)
 
         if (PeepFlags & PEEP_FLAGS_EXPLODE && x != LOCATION_NULL)
         {
-            if (State == PEEP_STATE_WALKING || State == PEEP_STATE_SITTING)
+            if (State == PeepState::Walking || State == PeepState::Sitting)
             {
                 audio_play_sound_at_location(SoundId::Crash, { x, y, z });
 
@@ -931,7 +931,7 @@ void Guest::Tick128UpdateGuest(int32_t index)
         if (Angriness != 0)
             Angriness--;
 
-        if (State == PEEP_STATE_WALKING || State == PEEP_STATE_SITTING)
+        if (State == PeepState::Walking || State == PeepState::Sitting)
         {
             SurroundingsThoughtTimeout++;
             if (SurroundingsThoughtTimeout >= 18)
@@ -952,7 +952,7 @@ void Guest::Tick128UpdateGuest(int32_t index)
 
         UpdateSpriteType();
 
-        if (State == PEEP_STATE_ON_RIDE || State == PEEP_STATE_ENTERING_RIDE)
+        if (State == PeepState::OnRide || State == PeepState::EnteringRide)
         {
             GuestTimeOnRide = std::min(255, GuestTimeOnRide + 1);
 
@@ -980,7 +980,7 @@ void Guest::Tick128UpdateGuest(int32_t index)
             }
         }
 
-        if (State == PEEP_STATE_WALKING && !OutsideOfPark && !(PeepFlags & PEEP_FLAGS_LEAVING_PARK) && GuestNumRides == 0
+        if (State == PeepState::Walking && !OutsideOfPark && !(PeepFlags & PEEP_FLAGS_LEAVING_PARK) && GuestNumRides == 0
             && GuestHeadingToRideId == RIDE_ID_NULL)
         {
             uint32_t time_duration = gScenarioTicks - TimeInPark;
@@ -1015,7 +1015,7 @@ void Guest::Tick128UpdateGuest(int32_t index)
              * is executed to once every second time the encompassing
              * conditional executes. */
 
-            if (!OutsideOfPark && (State == PEEP_STATE_WALKING || State == PEEP_STATE_SITTING))
+            if (!OutsideOfPark && (State == PeepState::Walking || State == PeepState::Sitting))
             {
                 uint8_t num_thoughts = 0;
                 PeepThoughtType possible_thoughts[5];
@@ -1105,14 +1105,14 @@ void Guest::Tick128UpdateGuest(int32_t index)
 
         switch (State)
         {
-            case PEEP_STATE_WALKING:
-            case PEEP_STATE_LEAVING_PARK:
-            case PEEP_STATE_ENTERING_PARK:
+            case PeepState::Walking:
+            case PeepState::LeavingPark:
+            case PeepState::EnteringPark:
                 peep_decide_whether_to_leave_park(this);
                 peep_update_hunger(this);
                 break;
 
-            case PEEP_STATE_SITTING:
+            case PeepState::Sitting:
                 if (EnergyTarget <= 135)
                     EnergyTarget += 5;
 
@@ -1131,7 +1131,7 @@ void Guest::Tick128UpdateGuest(int32_t index)
                 peep_update_hunger(this);
                 break;
 
-            case PEEP_STATE_QUEUING:
+            case PeepState::Queuing:
                 if (TimeInQueue >= 2000)
                 {
                     /* Peep happiness is affected once the peep has been waiting
@@ -1181,7 +1181,7 @@ void Guest::Tick128UpdateGuest(int32_t index)
                 }
                 peep_update_hunger(this);
                 break;
-            case PEEP_STATE_ENTERING_RIDE:
+            case PeepState::EnteringRide:
                 if (SubState == 17 || SubState == 15)
                 {
                     peep_decide_whether_to_leave_park(this);
@@ -1212,7 +1212,7 @@ void Guest::TryGetUpFromSitting()
     if (TimeToSitdown)
         return;
 
-    SetState(PEEP_STATE_WALKING);
+    SetState(PeepState::Walking);
 
     // Set destination to the centre of the tile.
     DestinationX = (x & 0xFFE0) + 16;
@@ -1267,7 +1267,7 @@ void Guest::UpdateSitting()
 
         if ((PeepFlags & PEEP_FLAGS_LEAVING_PARK))
         {
-            SetState(PEEP_STATE_WALKING);
+            SetState(PeepState::Walking);
 
             // Set destination to the centre of the tile
             DestinationX = (x & 0xFFE0) + 16;
@@ -1858,7 +1858,7 @@ bool Guest::HasFood() const
  */
 void Guest::PickRideToGoOn()
 {
-    if (State != PEEP_STATE_WALKING)
+    if (State != PeepState::Walking)
         return;
     if (GuestHeadingToRideId != RIDE_ID_NULL)
         return;
@@ -2557,7 +2557,7 @@ void Guest::GoToRideEntrance(Ride* ride)
     DestinationY = location.y;
     DestinationTolerance = 2;
 
-    SetState(PEEP_STATE_ENTERING_RIDE);
+    SetState(PeepState::EnteringRide);
     SubState = PEEP_RIDE_IN_ENTRANCE;
 
     RejoinQueueTimeout = 0;
@@ -2640,7 +2640,7 @@ static void peep_update_ride_at_entrance_try_leave(Guest* peep)
     if (peep->DestinationTolerance == 0)
     {
         peep->RemoveFromQueue();
-        peep->SetState(PEEP_STATE_FALLING);
+        peep->SetState(PeepState::Falling);
     }
 }
 
@@ -3151,7 +3151,7 @@ static void peep_leave_park(Peep* peep)
 
 template<typename T> static void peep_head_for_nearest_ride(Guest* peep, bool considerOnlyCloseRides, T predicate)
 {
-    if (peep->State != PEEP_STATE_SITTING && peep->State != PEEP_STATE_WATCHING && peep->State != PEEP_STATE_WALKING)
+    if (peep->State != PeepState::Sitting && peep->State != PeepState::Watching && peep->State != PeepState::Walking)
     {
         return;
     }
@@ -3366,7 +3366,7 @@ void Guest::UpdateBuying()
     auto ride = get_ride(CurrentRide);
     if (ride == nullptr || ride->status != RIDE_STATUS_OPEN)
     {
-        SetState(PEEP_STATE_FALLING);
+        SetState(PeepState::Falling);
         return;
     }
 
@@ -3392,7 +3392,7 @@ void Guest::UpdateBuying()
         DestinationY = NextLoc.y + 16;
         PeepDirection = direction_reverse(PeepDirection);
 
-        SetState(PEEP_STATE_WALKING);
+        SetState(PeepState::Walking);
         return;
     }
 
@@ -3933,7 +3933,7 @@ static void peep_update_ride_no_free_vehicle_rejoin_queue(Peep* peep, Ride* ride
     peep->DestinationY = y;
     peep->DestinationTolerance = 2;
 
-    peep->SetState(PEEP_STATE_QUEUING_FRONT);
+    peep->SetState(PeepState::QueuingFront);
     peep->SubState = PEEP_RIDE_AT_ENTRANCE;
 
     ride->QueueInsertGuestAtFront(peep->CurrentRideStation, peep);
@@ -4090,7 +4090,7 @@ void Guest::UpdateRideEnterVehicle()
 
                     vehicle->mass += seatedGuest->Mass;
                     seatedGuest->MoveTo({ LOCATION_NULL, 0, 0 });
-                    seatedGuest->SetState(PEEP_STATE_ON_RIDE);
+                    seatedGuest->SetState(PeepState::OnRide);
                     seatedGuest->GuestTimeOnRide = 0;
                     seatedGuest->SubState = PEEP_RIDE_ON_RIDE;
                     seatedGuest->OnEnterRide(CurrentRide);
@@ -4105,7 +4105,7 @@ void Guest::UpdateRideEnterVehicle()
 
             MoveTo({ LOCATION_NULL, 0, 0 });
 
-            SetState(PEEP_STATE_ON_RIDE);
+            SetState(PeepState::OnRide);
 
             GuestTimeOnRide = 0;
             SubState = PEEP_RIDE_ON_RIDE;
@@ -5020,7 +5020,7 @@ void Guest::UpdateRideLeaveExit()
     }
 
     InteractionRideIndex = RIDE_ID_NULL;
-    SetState(PEEP_STATE_FALLING);
+    SetState(PeepState::Falling);
 
     CoordsXY targetLoc = { x, y };
 
@@ -5132,8 +5132,8 @@ void Guest::UpdateRideShopLeave()
             return;
     }
 
-    //#11758 Previously SetState(PEEP_STATE_WALKING) caused Peeps to double-back to exit point of shop
-    SetState(PEEP_STATE_FALLING);
+    //#11758 Previously SetState(PeepState::Walking) caused Peeps to double-back to exit point of shop
+    SetState(PeepState::Falling);
 
     auto ride = get_ride(CurrentRide);
     if (ride != nullptr)
@@ -5148,37 +5148,37 @@ void Guest::UpdateGuest()
 {
     switch (State)
     {
-        case PEEP_STATE_QUEUING_FRONT:
+        case PeepState::QueuingFront:
             UpdateRide();
             break;
-        case PEEP_STATE_LEAVING_RIDE:
+        case PeepState::LeavingRide:
             UpdateRide();
             break;
-        case PEEP_STATE_WALKING:
+        case PeepState::Walking:
             UpdateWalking();
             break;
-        case PEEP_STATE_QUEUING:
+        case PeepState::Queuing:
             UpdateQueuing();
             break;
-        case PEEP_STATE_ENTERING_RIDE:
+        case PeepState::EnteringRide:
             UpdateRide();
             break;
-        case PEEP_STATE_SITTING:
+        case PeepState::Sitting:
             UpdateSitting();
             break;
-        case PEEP_STATE_ENTERING_PARK:
+        case PeepState::EnteringPark:
             UpdateEnteringPark();
             break;
-        case PEEP_STATE_LEAVING_PARK:
+        case PeepState::LeavingPark:
             UpdateLeavingPark();
             break;
-        case PEEP_STATE_BUYING:
+        case PeepState::Buying:
             UpdateBuying();
             break;
-        case PEEP_STATE_WATCHING:
+        case PeepState::Watching:
             UpdateWatching();
             break;
-        case PEEP_STATE_USING_BIN:
+        case PeepState::UsingBin:
             UpdateUsingBin();
             break;
         default:
@@ -5408,7 +5408,7 @@ void Guest::UpdateWalking()
             if (water_height > 0)
             {
                 MoveTo({ x, y, water_height });
-                SetState(PEEP_STATE_FALLING);
+                SetState(PeepState::Falling);
                 return;
             }
         }
@@ -5426,7 +5426,7 @@ void Guest::UpdateWalking()
 
     peep_update_walking_break_scenery(this);
 
-    if (State != PEEP_STATE_WALKING)
+    if (State != PeepState::Walking)
         return;
 
     if (PeepFlags & PEEP_FLAGS_LEAVING_PARK)
@@ -5499,7 +5499,7 @@ void Guest::UpdateWalking()
     // Check if there is a peep watching (and if there is place for us)
     for (auto peep : EntityTileList<Peep>({ x, y }))
     {
-        if (peep->State != PEEP_STATE_WATCHING)
+        if (peep->State != PeepState::Watching)
             continue;
 
         if (z != peep->z)
@@ -5523,7 +5523,7 @@ void Guest::UpdateWalking()
     CurrentSeat = ride_seat_to_view;
     Var37 = chosen_edge | (chosen_position << 2);
 
-    SetState(PEEP_STATE_WATCHING);
+    SetState(PeepState::Watching);
     SubState = 0;
 
     int32_t destX = (x & 0xFFE0) + _WatchingPositionOffsets[Var37 & 0x1F].x;
@@ -5558,7 +5558,7 @@ void Guest::UpdateQueuing()
     if (ride == nullptr || ride->status != RIDE_STATUS_OPEN)
     {
         RemoveFromQueue();
-        SetState(PEEP_STATE_1);
+        SetState(PeepState::One);
         return;
     }
 
@@ -5583,7 +5583,7 @@ void Guest::UpdateQueuing()
         {
             // Happens every time peep goes onto ride.
             DestinationTolerance = 0;
-            SetState(PEEP_STATE_QUEUING_FRONT);
+            SetState(PeepState::QueuingFront);
             SubState = PEEP_RIDE_AT_ENTRANCE;
             return;
         }
@@ -5592,7 +5592,7 @@ void Guest::UpdateQueuing()
         sprite_direction ^= (1 << 4);
         Invalidate();
         RemoveFromQueue();
-        SetState(PEEP_STATE_1);
+        SetState(PeepState::One);
         return;
     }
 
@@ -5664,7 +5664,7 @@ void Guest::UpdateQueuing()
         sprite_direction ^= (1 << 4);
         Invalidate();
         RemoveFromQueue();
-        SetState(PEEP_STATE_1);
+        SetState(PeepState::One);
     }
 }
 
@@ -5689,7 +5689,7 @@ void Guest::UpdateEnteringPark()
         MoveTo({ *loc, z });
         return;
     }
-    SetState(PEEP_STATE_FALLING);
+    SetState(PeepState::Falling);
 
     OutsideOfPark = false;
     TimeInPark = gScenarioTicks;
@@ -5821,7 +5821,7 @@ void Guest::UpdateWatching()
         if (TimeToStand != 0)
             return;
 
-        SetState(PEEP_STATE_WALKING);
+        SetState(PeepState::Walking);
         UpdateSpriteType();
         // Send peep to the centre of current tile.
         DestinationX = (x & 0xFFE0) + 16;
@@ -6079,7 +6079,7 @@ bool Guest::UpdateWalkingFindBench()
     // Check if there is no peep sitting in chosen_edge
     for (auto peep : EntityTileList<Peep>({ x, y }))
     {
-        if (peep->State != PEEP_STATE_SITTING)
+        if (peep->State != PeepState::Sitting)
             continue;
 
         if (z != peep->z)
@@ -6103,7 +6103,7 @@ bool Guest::UpdateWalkingFindBench()
 
     Var37 = ((free_edge & 1) << 2) | chosen_edge;
 
-    SetState(PEEP_STATE_SITTING);
+    SetState(PeepState::Sitting);
 
     SittingSubState = PeepSittingSubState::TryingToSit;
 
@@ -6188,7 +6188,7 @@ bool Guest::UpdateWalkingFindBin()
 
     peep->Var37 = chosen_edge;
 
-    peep->SetState(PEEP_STATE_USING_BIN);
+    peep->SetState(PeepState::UsingBin);
     peep->SubState = PEEP_USING_BIN_WALKING_TO_BIN;
 
     int32_t binX = (peep->x & 0xFFE0) + BinUseOffsets[peep->Var37 & 0x3].x;
@@ -6216,7 +6216,7 @@ static void peep_update_walking_break_scenery(Peep* peep)
             return;
         if (peep->Energy < 85)
             return;
-        if (peep->State != PEEP_STATE_WALKING)
+        if (peep->State != PeepState::Walking)
             return;
 
         if ((peep->LitterCount & 0xC0) != 0xC0 && (peep->DisgustingCount & 0xC0) != 0xC0)
@@ -6266,7 +6266,7 @@ static void peep_update_walking_break_scenery(Peep* peep)
     // Check if a peep is already sitting on the bench. If so, do not vandalise it.
     for (auto peep2 : EntityTileList<Peep>({ peep->x, peep->y }))
     {
-        if ((peep2->State != PEEP_STATE_SITTING) || (peep->z != peep2->z))
+        if ((peep2->State != PeepState::Sitting) || (peep->z != peep2->z))
         {
             continue;
         }
@@ -6780,13 +6780,13 @@ void Guest::SetSpriteType(PeepSpriteType new_sprite_type)
     ActionSpriteType = PEEP_ACTION_SPRITE_TYPE_INVALID;
     UpdateCurrentActionSpriteType();
 
-    if (State == PEEP_STATE_SITTING)
+    if (State == PeepState::Sitting)
     {
         Action = PEEP_ACTION_NONE_1;
         NextActionSpriteType = PEEP_ACTION_SPRITE_TYPE_SITTING_IDLE;
         SwitchNextActionSpriteType();
     }
-    if (State == PEEP_STATE_WATCHING)
+    if (State == PeepState::Watching)
     {
         Action = PEEP_ACTION_NONE_1;
         NextActionSpriteType = PEEP_ACTION_SPRITE_TYPE_WATCH_RIDE;
@@ -6903,7 +6903,7 @@ void Guest::UpdateSpriteType()
         }
     }
 
-    if (State == PEEP_STATE_WATCHING && StandingFlags & (1 << 1))
+    if (State == PeepState::Watching && StandingFlags & (1 << 1))
     {
         SetSpriteType(PEEP_SPRITE_TYPE_WATCHING);
         return;
diff --git a/src/openrct2/peep/GuestPathfinding.cpp b/src/openrct2/peep/GuestPathfinding.cpp
index 77577eb263..34342acb3e 100644
--- a/src/openrct2/peep/GuestPathfinding.cpp
+++ b/src/openrct2/peep/GuestPathfinding.cpp
@@ -135,7 +135,7 @@ static int32_t peep_move_one_tile(Direction direction, Peep* peep)
     peep->DestinationX = newTile.x;
     peep->DestinationY = newTile.y;
     peep->DestinationTolerance = 2;
-    if (peep->State != PEEP_STATE_QUEUING)
+    if (peep->State != PeepState::Queuing)
     {
         peep->DestinationTolerance = (scenario_rand() & 7) + 2;
     }
@@ -2045,9 +2045,9 @@ int32_t guest_path_finding(Guest* peep)
 #endif // defined(DEBUG_LEVEL_1) && DEBUG_LEVEL_1
         switch (peep->State)
         {
-            case PEEP_STATE_ENTERING_PARK:
+            case PeepState::EnteringPark:
                 return guest_path_find_entering_park(peep, edges);
-            case PEEP_STATE_LEAVING_PARK:
+            case PeepState::LeavingPark:
                 return guest_path_find_leaving_park(peep, edges);
             default:
                 return guest_path_find_aimless(peep, edges);
diff --git a/src/openrct2/peep/Peep.cpp b/src/openrct2/peep/Peep.cpp
index 8cf3075996..ff44194aa6 100644
--- a/src/openrct2/peep/Peep.cpp
+++ b/src/openrct2/peep/Peep.cpp
@@ -468,7 +468,7 @@ bool Peep::CheckForPath()
     } while (!(tile_element++)->IsLastForTile());
 
     // Found no suitable path
-    SetState(PEEP_STATE_FALLING);
+    SetState(PeepState::Falling);
     return false;
 }
 
@@ -534,7 +534,7 @@ void Peep::SwitchToSpecialSprite(uint8_t special_sprite_id)
 
 void Peep::StateReset()
 {
-    SetState(PEEP_STATE_1);
+    SetState(PeepState::One);
     SwitchToSpecialSprite(0);
 }
 
@@ -653,7 +653,7 @@ std::optional<CoordsXY> Peep::UpdateAction(int16_t& xy_distance)
  */
 void peep_decrement_num_riders(Peep* peep)
 {
-    if (peep->State == PEEP_STATE_ON_RIDE || peep->State == PEEP_STATE_ENTERING_RIDE)
+    if (peep->State == PeepState::OnRide || peep->State == PeepState::EnteringRide)
     {
         auto ride = get_ride(peep->CurrentRide);
         if (ride != nullptr)
@@ -677,7 +677,7 @@ void peep_window_state_update(Peep* peep)
 
     if (peep->AssignedPeepType == PeepType::Guest)
     {
-        if (peep->State == PEEP_STATE_ON_RIDE || peep->State == PEEP_STATE_ENTERING_RIDE)
+        if (peep->State == PeepState::OnRide || peep->State == PeepState::EnteringRide)
         {
             auto ride = get_ride(peep->CurrentRide);
             if (ride != nullptr)
@@ -705,20 +705,20 @@ void Peep::Pickup()
         guest->RemoveFromRide();
     }
     MoveTo({ LOCATION_NULL, y, z });
-    SetState(PEEP_STATE_PICKED);
+    SetState(PeepState::Picked);
     SubState = 0;
 }
 
 void Peep::PickupAbort(int32_t old_x)
 {
-    if (State != PEEP_STATE_PICKED)
+    if (State != PeepState::Picked)
         return;
 
     MoveTo({ old_x, y, z + 8 });
 
     if (x != LOCATION_NULL)
     {
-        SetState(PEEP_STATE_FALLING);
+        SetState(PeepState::Falling);
         Action = PEEP_ACTION_NONE_2;
         SpecialSprite = 0;
         ActionSpriteImageOffset = 0;
@@ -768,7 +768,7 @@ std::unique_ptr<GameActionResult> Peep::Place(const TileCoordsXYZ& location, boo
     if (apply)
     {
         MoveTo(destination);
-        SetState(PEEP_STATE_FALLING);
+        SetState(PeepState::Falling);
         Action = PEEP_ACTION_NONE_2;
         SpecialSprite = 0;
         ActionSpriteImageOffset = 0;
@@ -838,7 +838,7 @@ void Peep::Remove()
             auto intent = Intent(INTENT_ACTION_UPDATE_GUEST_COUNT);
             context_broadcast_intent(&intent);
         }
-        if (State == PEEP_STATE_ENTERING_PARK)
+        if (State == PeepState::EnteringPark)
         {
             decrement_guests_heading_for_park();
         }
@@ -961,7 +961,7 @@ void Peep::UpdateFalling()
     {
         SetNextFlags(saved_map->AsPath()->GetSlopeDirection(), saved_map->AsPath()->IsSloped(), false);
     }
-    SetState(PEEP_STATE_1);
+    SetState(PeepState::One);
 }
 
 /**
@@ -975,11 +975,11 @@ void Peep::Update1()
 
     if (AssignedPeepType == PeepType::Guest)
     {
-        SetState(PEEP_STATE_WALKING);
+        SetState(PeepState::Walking);
     }
     else
     {
-        SetState(PEEP_STATE_PATROLLING);
+        SetState(PeepState::Patrolling);
     }
 
     DestinationX = x;
@@ -1088,14 +1088,14 @@ void Peep::Update()
 
     // Walking speed logic
     uint32_t stepsToTake = Energy;
-    if (stepsToTake < 95 && State == PEEP_STATE_QUEUING)
+    if (stepsToTake < 95 && State == PeepState::Queuing)
         stepsToTake = 95;
-    if ((PeepFlags & PEEP_FLAGS_SLOW_WALK) && State != PEEP_STATE_QUEUING)
+    if ((PeepFlags & PEEP_FLAGS_SLOW_WALK) && State != PeepState::Queuing)
         stepsToTake /= 2;
     if (Action == PEEP_ACTION_NONE_2 && (GetNextIsSloped()))
     {
         stepsToTake /= 2;
-        if (State == PEEP_STATE_QUEUING)
+        if (State == PeepState::Queuing)
             stepsToTake += stepsToTake / 2;
     }
 
@@ -1114,16 +1114,16 @@ void Peep::Update()
         // loc_68FD2F
         switch (State)
         {
-            case PEEP_STATE_FALLING:
+            case PeepState::Falling:
                 UpdateFalling();
                 break;
-            case PEEP_STATE_1:
+            case PeepState::One:
                 Update1();
                 break;
-            case PEEP_STATE_ON_RIDE:
+            case PeepState::OnRide:
                 // No action
                 break;
-            case PEEP_STATE_PICKED:
+            case PeepState::Picked:
                 UpdatePicked();
                 break;
             default:
@@ -1353,7 +1353,7 @@ void peep_update_crowd_noise()
         if (viewport->viewPos.y + viewport->view_height < peep->sprite_top)
             continue;
 
-        visiblePeeps += peep->State == PEEP_STATE_QUEUING ? 1 : 2;
+        visiblePeeps += peep->State == PeepState::Queuing ? 1 : 2;
     }
 
     // This function doesn't account for the fact that the screen might be so big that 100 peeps could potentially be very
@@ -1412,7 +1412,7 @@ void peep_applause()
         peep_release_balloon(peep, peep->z + 9);
 
         // Clap
-        if ((peep->State == PEEP_STATE_WALKING || peep->State == PEEP_STATE_QUEUING) && peep->Action >= 254)
+        if ((peep->State == PeepState::Walking || peep->State == PeepState::Queuing) && peep->Action >= 254)
         {
             peep->Action = PEEP_ACTION_CLAP;
             peep->ActionFrame = 0;
@@ -1433,7 +1433,7 @@ void peep_update_days_in_queue()
 {
     for (auto peep : EntityList<Guest>(EntityListId::Peep))
     {
-        if (!peep->OutsideOfPark && peep->State == PEEP_STATE_QUEUING)
+        if (!peep->OutsideOfPark && peep->State == PeepState::Queuing)
         {
             if (peep->DaysInQueue < 255)
             {
@@ -1580,7 +1580,7 @@ Peep* Peep::Generate(const CoordsXYZ& coords)
     peep->sprite_identifier = SPRITE_IDENTIFIER_PEEP;
     peep->SpriteType = PEEP_SPRITE_TYPE_NORMAL;
     peep->OutsideOfPark = true;
-    peep->State = PEEP_STATE_FALLING;
+    peep->State = PeepState::Falling;
     peep->Action = PEEP_ACTION_NONE_2;
     peep->SpecialSprite = 0;
     peep->ActionSpriteImageOffset = 0;
@@ -1747,15 +1747,15 @@ void Peep::FormatActionTo(Formatter& ft) const
 {
     switch (State)
     {
-        case PEEP_STATE_FALLING:
+        case PeepState::Falling:
             ft.Add<rct_string_id>(Action == PEEP_ACTION_DROWNING ? STR_DROWNING : STR_WALKING);
             break;
-        case PEEP_STATE_1:
+        case PeepState::One:
             ft.Add<rct_string_id>(STR_WALKING);
             break;
-        case PEEP_STATE_ON_RIDE:
-        case PEEP_STATE_LEAVING_RIDE:
-        case PEEP_STATE_ENTERING_RIDE:
+        case PeepState::OnRide:
+        case PeepState::LeavingRide:
+        case PeepState::EnteringRide:
         {
             auto ride = get_ride(CurrentRide);
             if (ride != nullptr)
@@ -1769,7 +1769,7 @@ void Peep::FormatActionTo(Formatter& ft) const
             }
             break;
         }
-        case PEEP_STATE_BUYING:
+        case PeepState::Buying:
         {
             ft.Add<rct_string_id>(STR_AT_RIDE);
             auto ride = get_ride(CurrentRide);
@@ -1783,8 +1783,8 @@ void Peep::FormatActionTo(Formatter& ft) const
             }
             break;
         }
-        case PEEP_STATE_WALKING:
-        case PEEP_STATE_USING_BIN:
+        case PeepState::Walking:
+        case PeepState::UsingBin:
             if (GuestHeadingToRideId != RIDE_ID_NULL)
             {
                 auto ride = get_ride(GuestHeadingToRideId);
@@ -1799,8 +1799,8 @@ void Peep::FormatActionTo(Formatter& ft) const
                 ft.Add<rct_string_id>((PeepFlags & PEEP_FLAGS_LEAVING_PARK) ? STR_LEAVING_PARK : STR_WALKING);
             }
             break;
-        case PEEP_STATE_QUEUING_FRONT:
-        case PEEP_STATE_QUEUING:
+        case PeepState::QueuingFront:
+        case PeepState::Queuing:
         {
             auto ride = get_ride(CurrentRide);
             if (ride != nullptr)
@@ -1810,10 +1810,10 @@ void Peep::FormatActionTo(Formatter& ft) const
             }
             break;
         }
-        case PEEP_STATE_SITTING:
+        case PeepState::Sitting:
             ft.Add<rct_string_id>(STR_SITTING);
             break;
-        case PEEP_STATE_WATCHING:
+        case PeepState::Watching:
             if (CurrentRide != RIDE_ID_NULL)
             {
                 auto ride = get_ride(CurrentRide);
@@ -1828,27 +1828,27 @@ void Peep::FormatActionTo(Formatter& ft) const
                 ft.Add<rct_string_id>((StandingFlags & 0x1) ? STR_WATCHING_NEW_RIDE_BEING_CONSTRUCTED : STR_LOOKING_AT_SCENERY);
             }
             break;
-        case PEEP_STATE_PICKED:
+        case PeepState::Picked:
             ft.Add<rct_string_id>(STR_SELECT_LOCATION);
             break;
-        case PEEP_STATE_PATROLLING:
-        case PEEP_STATE_ENTERING_PARK:
-        case PEEP_STATE_LEAVING_PARK:
+        case PeepState::Patrolling:
+        case PeepState::EnteringPark:
+        case PeepState::LeavingPark:
             ft.Add<rct_string_id>(STR_WALKING);
             break;
-        case PEEP_STATE_MOWING:
+        case PeepState::Mowing:
             ft.Add<rct_string_id>(STR_MOWING_GRASS);
             break;
-        case PEEP_STATE_SWEEPING:
+        case PeepState::Sweeping:
             ft.Add<rct_string_id>(STR_SWEEPING_FOOTPATH);
             break;
-        case PEEP_STATE_WATERING:
+        case PeepState::Watering:
             ft.Add<rct_string_id>(STR_WATERING_GARDENS);
             break;
-        case PEEP_STATE_EMPTYING_BIN:
+        case PeepState::EmptyingBin:
             ft.Add<rct_string_id>(STR_EMPTYING_LITTER_BIN);
             break;
-        case PEEP_STATE_ANSWERING:
+        case PeepState::Answering:
             if (SubState == 0)
             {
                 ft.Add<rct_string_id>(STR_WALKING);
@@ -1871,7 +1871,7 @@ void Peep::FormatActionTo(Formatter& ft) const
                 }
             }
             break;
-        case PEEP_STATE_FIXING:
+        case PeepState::Fixing:
         {
             ft.Add<rct_string_id>(STR_FIXING_RIDE);
             auto ride = get_ride(CurrentRide);
@@ -1885,7 +1885,7 @@ void Peep::FormatActionTo(Formatter& ft) const
             }
             break;
         }
-        case PEEP_STATE_HEADING_TO_INSPECTION:
+        case PeepState::HeadingToInspection:
         {
             ft.Add<rct_string_id>(STR_HEADING_TO_RIDE_FOR_INSPECTION);
             auto ride = get_ride(CurrentRide);
@@ -1899,7 +1899,7 @@ void Peep::FormatActionTo(Formatter& ft) const
             }
             break;
         }
-        case PEEP_STATE_INSPECTING:
+        case PeepState::Inspecting:
         {
             ft.Add<rct_string_id>(STR_INSPECTING_RIDE);
             auto ride = get_ride(CurrentRide);
@@ -2019,31 +2019,31 @@ void peep_thought_set_format_args(const rct_peep_thought* thought, Formatter& ft
 }
 
 /** rct2: 0x00982004 */
-static constexpr const bool peep_allow_pick_up[] = {
-    true,  // PEEP_STATE_FALLING
-    false, // PEEP_STATE_1
-    false, // PEEP_STATE_QUEUING_FRONT
-    false, // PEEP_STATE_ON_RIDE
-    false, // PEEP_STATE_LEAVING_RIDE
-    true,  // PEEP_STATE_WALKING
-    true,  // PEEP_STATE_QUEUING
-    false, // PEEP_STATE_ENTERING_RIDE
-    true,  // PEEP_STATE_SITTING
-    true,  // PEEP_STATE_PICKED
-    true,  // PEEP_STATE_PATROLLING
-    true,  // PEEP_STATE_MOWING
-    true,  // PEEP_STATE_SWEEPING
-    false, // PEEP_STATE_ENTERING_PARK
-    false, // PEEP_STATE_LEAVING_PARK
-    true,  // PEEP_STATE_ANSWERING
-    false, // PEEP_STATE_FIXING
-    false, // PEEP_STATE_BUYING
-    true,  // PEEP_STATE_WATCHING
-    true,  // PEEP_STATE_EMPTYING_BIN
-    true,  // PEEP_STATE_USING_BIN
-    true,  // PEEP_STATE_WATERING
-    true,  // PEEP_STATE_HEADING_TO_INSPECTION
-    false, // PEEP_STATE_INSPECTING
+static const std::map<PeepState, bool> peep_allow_pick_up{
+    { PeepState::Falling, true },
+    { PeepState::One, false },
+    { PeepState::QueuingFront, false },
+    { PeepState::OnRide, false },
+    { PeepState::LeavingRide, false },
+    { PeepState::Walking, true },
+    { PeepState::Queuing, true },
+    { PeepState::EnteringRide, false },
+    { PeepState::Sitting, true },
+    { PeepState::Picked, true },
+    { PeepState::Patrolling, true },
+    { PeepState::Mowing, true },
+    { PeepState::Sweeping, true },
+    { PeepState::EnteringPark, false },
+    { PeepState::LeavingPark, false },
+    { PeepState::Answering, true },
+    { PeepState::Fixing, false },
+    { PeepState::Buying, false },
+    { PeepState::Watching, true },
+    { PeepState::EmptyingBin, true },
+    { PeepState::UsingBin, true },
+    { PeepState::Watering, true },
+    { PeepState::HeadingToInspection, true },
+    { PeepState::Inspecting, false },
 };
 
 /**
@@ -2053,7 +2053,7 @@ static constexpr const bool peep_allow_pick_up[] = {
  */
 bool peep_can_be_picked_up(Peep* peep)
 {
-    return peep_allow_pick_up[peep->State];
+    return peep_allow_pick_up.find(peep->State)->second;
 }
 
 enum
@@ -2330,7 +2330,7 @@ static void peep_interact_with_entrance(Peep* peep, const CoordsXYE& coords, uin
             return;
         }
 
-        if (peep->State == PEEP_STATE_QUEUING)
+        if (peep->State == PeepState::Queuing)
         {
             // Guest is in the ride queue.
             peep->SubState = 11;
@@ -2375,7 +2375,7 @@ static void peep_interact_with_entrance(Peep* peep, const CoordsXYE& coords, uin
         peep->CurrentRide = rideIndex;
         peep->CurrentRideStation = stationNum;
         peep->DaysInQueue = 0;
-        peep->SetState(PEEP_STATE_QUEUING);
+        peep->SetState(PeepState::Queuing);
         peep->SubState = 11;
         peep->TimeInQueue = 0;
         if (peep->PeepFlags & PEEP_FLAGS_TRACKING)
@@ -2418,7 +2418,7 @@ static void peep_interact_with_entrance(Peep* peep, const CoordsXYE& coords, uin
             }
 
             // Peep is leaving the park.
-            if (peep->State != PEEP_STATE_WALKING)
+            if (peep->State != PeepState::Walking)
             {
                 peep_return_to_centre_of_tile(peep);
                 return;
@@ -2438,7 +2438,7 @@ static void peep_interact_with_entrance(Peep* peep, const CoordsXYE& coords, uin
             peep->DestinationY += CoordsDirectionDelta[peep->PeepDirection].y;
             peep->DestinationTolerance = 9;
             peep->MoveTo({ coords, peep->z });
-            peep->SetState(PEEP_STATE_LEAVING_PARK);
+            peep->SetState(PeepState::LeavingPark);
 
             peep->Var37 = 0;
             if (peep->PeepFlags & PEEP_FLAGS_TRACKING)
@@ -2455,7 +2455,7 @@ static void peep_interact_with_entrance(Peep* peep, const CoordsXYE& coords, uin
 
         // Peep is entering the park.
 
-        if (peep->State != PEEP_STATE_ENTERING_PARK)
+        if (peep->State != PeepState::EnteringPark)
         {
             peep_return_to_centre_of_tile(peep);
             return;
@@ -2463,7 +2463,7 @@ static void peep_interact_with_entrance(Peep* peep, const CoordsXYE& coords, uin
 
         if (!(gParkFlags & PARK_FLAGS_PARK_OPEN))
         {
-            peep->State = PEEP_STATE_LEAVING_PARK;
+            peep->State = PeepState::LeavingPark;
             peep->Var37 = 1;
             decrement_guests_heading_for_park();
             peep_window_state_update(peep);
@@ -2527,7 +2527,7 @@ static void peep_interact_with_entrance(Peep* peep, const CoordsXYE& coords, uin
 
         if (!found)
         {
-            peep->State = PEEP_STATE_LEAVING_PARK;
+            peep->State = PeepState::LeavingPark;
             peep->Var37 = 1;
             decrement_guests_heading_for_park();
             peep_window_state_update(peep);
@@ -2555,7 +2555,7 @@ static void peep_interact_with_entrance(Peep* peep, const CoordsXYE& coords, uin
             }
             if (entranceFee > peep->CashInPocket)
             {
-                peep->State = PEEP_STATE_LEAVING_PARK;
+                peep->State = PeepState::LeavingPark;
                 peep->Var37 = 1;
                 decrement_guests_heading_for_park();
                 peep_window_state_update(peep);
@@ -2631,7 +2631,7 @@ static void peep_footpath_move_forward(Peep* peep, const CoordsXYE& coords, bool
     {
         if (auto other_peep = entity->As<Peep>(); other_peep != nullptr)
         {
-            if (other_peep->State != PEEP_STATE_WALKING)
+            if (other_peep->State != PeepState::Walking)
                 continue;
 
             if (abs(other_peep->z - peep->NextLoc.z) > 16)
@@ -2653,7 +2653,7 @@ static void peep_footpath_move_forward(Peep* peep, const CoordsXYE& coords, bool
         }
     }
 
-    if (crowded >= 10 && peep->State == PEEP_STATE_WALKING && (scenario_rand() & 0xFFFF) <= 21845)
+    if (crowded >= 10 && peep->State == PeepState::Walking && (scenario_rand() & 0xFFFF) <= 21845)
     {
         peep->InsertNewThought(PEEP_THOUGHT_TYPE_CROWDED, PEEP_THOUGHT_ITEM_NONE);
         peep->HappinessTarget = std::max(0, peep->HappinessTarget - 14);
@@ -2754,7 +2754,7 @@ static void peep_interact_with_path(Peep* peep, const CoordsXYE& coords)
     if (guest != nullptr && tile_element->AsPath()->IsQueue())
     {
         auto rideIndex = tile_element->AsPath()->GetRideIndex();
-        if (peep->State == PEEP_STATE_QUEUING)
+        if (peep->State == PeepState::Queuing)
         {
             // Check if this queue is connected to the ride the
             // peep is queuing for, i.e. the player hasn't edited
@@ -2768,7 +2768,7 @@ static void peep_interact_with_path(Peep* peep, const CoordsXYE& coords)
                 // Queue got disconnected from the original ride.
                 peep->InteractionRideIndex = 0xFF;
                 guest->RemoveFromQueue();
-                peep->SetState(PEEP_STATE_1);
+                peep->SetState(PeepState::One);
                 peep_footpath_move_forward(peep, { coords, tile_element }, vandalism_present);
             }
         }
@@ -2800,7 +2800,7 @@ static void peep_interact_with_path(Peep* peep, const CoordsXYE& coords)
                     peep_decrement_num_riders(peep);
                     peep->CurrentRide = rideIndex;
                     peep->CurrentRideStation = stationNum;
-                    peep->State = PEEP_STATE_QUEUING;
+                    peep->State = PeepState::Queuing;
                     peep->DaysInQueue = 0;
                     peep_window_state_update(peep);
 
@@ -2838,10 +2838,10 @@ static void peep_interact_with_path(Peep* peep, const CoordsXYE& coords)
     else
     {
         peep->InteractionRideIndex = 0xFF;
-        if (peep->State == PEEP_STATE_QUEUING)
+        if (peep->State == PeepState::Queuing)
         {
             peep->RemoveFromQueue();
-            peep->SetState(PEEP_STATE_1);
+            peep->SetState(PeepState::One);
         }
         peep_footpath_move_forward(peep, { coords, tile_element }, vandalism_present);
     }
@@ -2911,7 +2911,7 @@ static bool peep_interact_with_shop(Peep* peep, const CoordsXYE& coords)
         peep->DestinationTolerance = 3;
 
         peep->CurrentRide = rideIndex;
-        peep->SetState(PEEP_STATE_ENTERING_RIDE);
+        peep->SetState(PeepState::EnteringRide);
         peep->SubState = PEEP_SHOP_APPROACH;
 
         peep->GuestTimeOnRide = 0;
@@ -2934,7 +2934,7 @@ static bool peep_interact_with_shop(Peep* peep, const CoordsXYE& coords)
         if (peep->GuestHeadingToRideId == rideIndex)
             peep->GuestHeadingToRideId = RIDE_ID_NULL;
         peep->ActionSpriteImageOffset = _unk_F1AEF0;
-        peep->SetState(PEEP_STATE_BUYING);
+        peep->SetState(PeepState::Buying);
         peep->CurrentRide = rideIndex;
         peep->SubState = 0;
     }
@@ -2960,7 +2960,7 @@ void Peep::PerformNextAction(uint8_t& pathing_result, TileElement*& tile_result)
     if (Action == PEEP_ACTION_NONE_1)
         Action = PEEP_ACTION_NONE_2;
 
-    if (State == PEEP_STATE_QUEUING)
+    if (State == PeepState::Queuing)
     {
         if (peep_update_queue_position(this, previousAction))
             return;
@@ -3052,10 +3052,10 @@ void Peep::PerformNextAction(uint8_t& pathing_result, TileElement*& tile_result)
         if (height <= 3 || (AssignedPeepType == PeepType::Staff && height <= 32))
         {
             InteractionRideIndex = 0xFF;
-            if (State == PEEP_STATE_QUEUING)
+            if (State == PeepState::Queuing)
             {
                 RemoveFromQueue();
-                SetState(PEEP_STATE_1);
+                SetState(PeepState::One);
             }
 
             if (!map_is_location_in_park(newLoc))
@@ -3315,7 +3315,7 @@ void Peep::RemoveFromQueue()
  */
 void Peep::RemoveFromRide()
 {
-    if (State == PEEP_STATE_QUEUING)
+    if (State == PeepState::Queuing)
     {
         RemoveFromQueue();
     }
diff --git a/src/openrct2/peep/Peep.h b/src/openrct2/peep/Peep.h
index 3297d27f5c..997dd0e958 100644
--- a/src/openrct2/peep/Peep.h
+++ b/src/openrct2/peep/Peep.h
@@ -214,32 +214,32 @@ enum PeepThoughtType : uint8_t
     PEEP_THOUGHT_TYPE_NONE = 255
 };
 
-enum PeepState : uint8_t
+enum class PeepState : uint8_t
 {
-    PEEP_STATE_FALLING = 0, // Drowning is part of falling
-    PEEP_STATE_1 = 1,
-    PEEP_STATE_QUEUING_FRONT = 2,
-    PEEP_STATE_ON_RIDE = 3,
-    PEEP_STATE_LEAVING_RIDE = 4,
-    PEEP_STATE_WALKING = 5,
-    PEEP_STATE_QUEUING = 6,
-    PEEP_STATE_ENTERING_RIDE = 7,
-    PEEP_STATE_SITTING = 8,
-    PEEP_STATE_PICKED = 9,
-    PEEP_STATE_PATROLLING = 10, // Not sure
-    PEEP_STATE_MOWING = 11,
-    PEEP_STATE_SWEEPING = 12,
-    PEEP_STATE_ENTERING_PARK = 13,
-    PEEP_STATE_LEAVING_PARK = 14,
-    PEEP_STATE_ANSWERING = 15,
-    PEEP_STATE_FIXING = 16,
-    PEEP_STATE_BUYING = 17,
-    PEEP_STATE_WATCHING = 18,
-    PEEP_STATE_EMPTYING_BIN = 19,
-    PEEP_STATE_USING_BIN = 20,
-    PEEP_STATE_WATERING = 21,
-    PEEP_STATE_HEADING_TO_INSPECTION = 22,
-    PEEP_STATE_INSPECTING = 23
+    Falling = 0, // Drowning is part of falling
+    One = 1,     // was PEEP_STATE_1
+    QueuingFront = 2,
+    OnRide = 3,
+    LeavingRide = 4,
+    Walking = 5,
+    Queuing = 6,
+    EnteringRide = 7,
+    Sitting = 8,
+    Picked = 9,
+    Patrolling = 10, // Not sure
+    Mowing = 11,
+    Sweeping = 12,
+    EnteringPark = 13,
+    LeavingPark = 14,
+    Answering = 15,
+    Fixing = 16,
+    Buying = 17,
+    Watching = 18,
+    EmptyingBin = 19,
+    UsingBin = 20,
+    Watering = 21,
+    HeadingToInspection = 22,
+    Inspecting = 23
 };
 
 enum class PeepSittingSubState : uint8_t
diff --git a/src/openrct2/peep/Staff.cpp b/src/openrct2/peep/Staff.cpp
index f5ba7268ca..e765b9c53c 100644
--- a/src/openrct2/peep/Staff.cpp
+++ b/src/openrct2/peep/Staff.cpp
@@ -667,7 +667,7 @@ bool Staff::DoHandymanPathFinding()
     DestinationX = chosenTile.x + 16;
     DestinationY = chosenTile.y + 16;
     DestinationTolerance = 3;
-    if (State == PEEP_STATE_QUEUING)
+    if (State == PeepState::Queuing)
     {
         DestinationTolerance = (scenario_rand() & 7) + 2;
     }
@@ -721,8 +721,7 @@ Direction Staff::MechanicDirectionSurface() const
     Direction direction = scenario_rand() & 3;
 
     auto ride = get_ride(CurrentRide);
-    if (ride != nullptr && (State == PEEP_STATE_ANSWERING || State == PEEP_STATE_HEADING_TO_INSPECTION)
-        && (scenario_rand() & 1))
+    if (ride != nullptr && (State == PeepState::Answering || State == PeepState::HeadingToInspection) && (scenario_rand() & 1))
     {
         auto location = ride_get_exit_location(ride, CurrentRideStation);
         if (location.isNull())
@@ -785,7 +784,7 @@ Direction Staff::MechanicDirectionPath(uint8_t validDirections, PathElement* pat
     pathDirections &= ~(1 << direction);
     if (pathDirections == 0)
     {
-        if (State != PEEP_STATE_ANSWERING && State != PEEP_STATE_HEADING_TO_INSPECTION)
+        if (State != PeepState::Answering && State != PeepState::HeadingToInspection)
         {
             return direction;
         }
@@ -801,7 +800,7 @@ Direction Staff::MechanicDirectionPath(uint8_t validDirections, PathElement* pat
 
     // Mechanic is heading to ride (either broken down or for inspection).
     auto ride = get_ride(CurrentRide);
-    if (ride != nullptr && (State == PEEP_STATE_ANSWERING || State == PEEP_STATE_HEADING_TO_INSPECTION))
+    if (ride != nullptr && (State == PeepState::Answering || State == PeepState::HeadingToInspection))
     {
         /* Find location of the exit for the target ride station
          * or if the ride has no exit, the entrance. */
@@ -898,7 +897,7 @@ bool Staff::DoMechanicPathFinding()
 Direction Staff::DirectionPath(uint8_t validDirections, PathElement* pathElement) const
 {
     uint8_t pathDirections = pathElement->GetEdges();
-    if (State != PEEP_STATE_ANSWERING && State != PEEP_STATE_HEADING_TO_INSPECTION)
+    if (State != PeepState::Answering && State != PeepState::HeadingToInspection)
     {
         pathDirections &= validDirections;
     }
@@ -994,11 +993,11 @@ void Staff::EntertainerUpdateNearbyPeeps() const
         if (y_dist > 96)
             continue;
 
-        if (guest->State == PEEP_STATE_WALKING)
+        if (guest->State == PeepState::Walking)
         {
             guest->HappinessTarget = std::min(guest->HappinessTarget + 4, PEEP_MAX_HAPPINESS);
         }
-        else if (guest->State == PEEP_STATE_QUEUING)
+        else if (guest->State == PeepState::Queuing)
         {
             guest->TimeInQueue = std::max(0, guest->TimeInQueue - 200);
             guest->HappinessTarget = std::min(guest->HappinessTarget + 3, PEEP_MAX_HAPPINESS);
@@ -1381,20 +1380,20 @@ void Staff::UpdateHeadingToInspect()
     auto ride = get_ride(CurrentRide);
     if (ride == nullptr)
     {
-        SetState(PEEP_STATE_FALLING);
+        SetState(PeepState::Falling);
         return;
     }
 
     if (ride_get_exit_location(ride, CurrentRideStation).isNull())
     {
         ride->lifecycle_flags &= ~RIDE_LIFECYCLE_DUE_INSPECTION;
-        SetState(PEEP_STATE_FALLING);
+        SetState(PeepState::Falling);
         return;
     }
 
     if (ride->mechanic_status != RIDE_MECHANIC_STATUS_HEADING || !(ride->lifecycle_flags & RIDE_LIFECYCLE_DUE_INSPECTION))
     {
-        SetState(PEEP_STATE_FALLING);
+        SetState(PeepState::Falling);
         return;
     }
 
@@ -1414,7 +1413,7 @@ void Staff::UpdateHeadingToInspect()
             {
                 ride->mechanic_status = RIDE_MECHANIC_STATUS_CALLING;
             }
-            SetState(PEEP_STATE_FALLING);
+            SetState(PeepState::Falling);
             return;
         }
 
@@ -1475,7 +1474,7 @@ void Staff::UpdateHeadingToInspect()
         return;
     }
 
-    SetState(PEEP_STATE_INSPECTING);
+    SetState(PeepState::Inspecting);
     SubState = 0;
 }
 
@@ -1488,7 +1487,7 @@ void Staff::UpdateAnswering()
     auto ride = get_ride(CurrentRide);
     if (ride == nullptr || ride->mechanic_status != RIDE_MECHANIC_STATUS_HEADING)
     {
-        SetState(PEEP_STATE_FALLING);
+        SetState(PeepState::Falling);
         return;
     }
 
@@ -1525,7 +1524,7 @@ void Staff::UpdateAnswering()
         {
             ride->mechanic_status = RIDE_MECHANIC_STATUS_CALLING;
             ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_MAINTENANCE;
-            SetState(PEEP_STATE_FALLING);
+            SetState(PeepState::Falling);
             return;
         }
 
@@ -1586,7 +1585,7 @@ void Staff::UpdateAnswering()
         return;
     }
 
-    SetState(PEEP_STATE_FIXING);
+    SetState(PeepState::Fixing);
     SubState = 0;
 }
 
@@ -1653,7 +1652,7 @@ bool Staff::UpdatePatrollingFindWatering()
                 }
             }
 
-            SetState(PEEP_STATE_WATERING);
+            SetState(PeepState::Watering);
             Var37 = chosen_position;
 
             SubState = 0;
@@ -1723,7 +1722,7 @@ bool Staff::UpdatePatrollingFindBin()
         return false;
 
     Var37 = chosen_position;
-    SetState(PEEP_STATE_EMPTYING_BIN);
+    SetState(PeepState::EmptyingBin);
 
     SubState = 0;
     DestinationX = (x & 0xFFE0) + BinUseOffsets[chosen_position].x;
@@ -1752,7 +1751,7 @@ bool Staff::UpdatePatrollingFindGrass()
     {
         if ((surfaceElement->GetGrassLength() & 0x7) >= GRASS_LENGTH_CLEAR_1)
         {
-            SetState(PEEP_STATE_MOWING);
+            SetState(PeepState::Mowing);
             Var37 = 0;
             // Original code used .y for both x and y. Changed to .x to make more sense (both x and y are 28)
             DestinationX = NextLoc.x + _MowingWaypoints[0].x;
@@ -1780,7 +1779,7 @@ bool Staff::UpdatePatrollingFindSweeping()
         if (z_diff >= 16)
             continue;
 
-        SetState(PEEP_STATE_SWEEPING);
+        SetState(PeepState::Sweeping);
 
         Var37 = 0;
         DestinationX = litter->x;
@@ -1798,7 +1797,7 @@ void Staff::Tick128UpdateStaff()
         return;
 
     PeepSpriteType newSpriteType = PEEP_SPRITE_TYPE_SECURITY_ALT;
-    if (State != PEEP_STATE_PATROLLING)
+    if (State != PeepState::Patrolling)
         newSpriteType = PEEP_SPRITE_TYPE_SECURITY;
 
     if (SpriteType == newSpriteType)
@@ -1831,31 +1830,31 @@ void Staff::UpdateStaff(uint32_t stepsToTake)
 {
     switch (State)
     {
-        case PEEP_STATE_PATROLLING:
+        case PeepState::Patrolling:
             UpdatePatrolling();
             break;
-        case PEEP_STATE_MOWING:
+        case PeepState::Mowing:
             UpdateMowing();
             break;
-        case PEEP_STATE_SWEEPING:
+        case PeepState::Sweeping:
             UpdateSweeping();
             break;
-        case PEEP_STATE_ANSWERING:
+        case PeepState::Answering:
             UpdateAnswering();
             break;
-        case PEEP_STATE_FIXING:
+        case PeepState::Fixing:
             UpdateFixing(stepsToTake);
             break;
-        case PEEP_STATE_INSPECTING:
+        case PeepState::Inspecting:
             UpdateFixing(stepsToTake);
             break;
-        case PEEP_STATE_EMPTYING_BIN:
+        case PeepState::EmptyingBin:
             UpdateEmptyingBin();
             break;
-        case PEEP_STATE_WATERING:
+        case PeepState::Watering:
             UpdateWatering();
             break;
-        case PEEP_STATE_HEADING_TO_INSPECTION:
+        case PeepState::HeadingToInspection:
             UpdateHeadingToInspect();
             break;
         default:
@@ -1889,7 +1888,7 @@ void Staff::UpdatePatrolling()
             if (water_height > 0)
             {
                 MoveTo({ x, y, water_height });
-                SetState(PEEP_STATE_FALLING);
+                SetState(PeepState::Falling);
                 return;
             }
         }
@@ -2020,19 +2019,19 @@ void Staff::UpdateFixing(int32_t steps)
     auto ride = get_ride(CurrentRide);
     if (ride == nullptr)
     {
-        SetState(PEEP_STATE_FALLING);
+        SetState(PeepState::Falling);
         return;
     }
 
     bool progressToNextSubstate = true;
     bool firstRun = true;
 
-    if ((State == PEEP_STATE_INSPECTING)
+    if ((State == PeepState::Inspecting)
         && (ride->lifecycle_flags & (RIDE_LIFECYCLE_BREAKDOWN_PENDING | RIDE_LIFECYCLE_BROKEN_DOWN)))
     {
         // Ride has broken down since Mechanic was called to inspect it.
         // Mechanic identifies the breakdown and switches to fixing it.
-        State = PEEP_STATE_FIXING;
+        State = PeepState::Fixing;
     }
 
     while (progressToNextSubstate)
@@ -2106,7 +2105,7 @@ void Staff::UpdateFixing(int32_t steps)
         int32_t subState = SubState;
         uint32_t sub_state_sequence_mask = FixingSubstatesForBreakdown[8];
 
-        if (State != PEEP_STATE_INSPECTING)
+        if (State != PeepState::Inspecting)
         {
             sub_state_sequence_mask = FixingSubstatesForBreakdown[ride->breakdown_reason_pending];
         }
@@ -2572,7 +2571,7 @@ bool Staff::UpdateFixingFinishFixOrInspect(bool firstRun, int32_t steps, Ride* r
     {
         ride->mechanic_status = RIDE_MECHANIC_STATUS_UNDEFINED;
 
-        if (State == PEEP_STATE_INSPECTING)
+        if (State == PeepState::Inspecting)
         {
             UpdateRideInspected(CurrentRide);
 
@@ -2621,7 +2620,7 @@ bool Staff::UpdateFixingLeaveByEntranceExit(bool firstRun, const Ride* ride)
 
             if (exitPosition.isNull())
             {
-                SetState(PEEP_STATE_FALLING);
+                SetState(PeepState::Falling);
                 return false;
             }
         }
@@ -2650,7 +2649,7 @@ bool Staff::UpdateFixingLeaveByEntranceExit(bool firstRun, const Ride* ride)
         MoveTo({ *loc, stationHeight });
         return false;
     }
-    SetState(PEEP_STATE_FALLING);
+    SetState(PeepState::Falling);
     return false;
 }
 
diff --git a/src/openrct2/rct1/S4Importer.cpp b/src/openrct2/rct1/S4Importer.cpp
index 10923eae90..e610fbccee 100644
--- a/src/openrct2/rct1/S4Importer.cpp
+++ b/src/openrct2/rct1/S4Importer.cpp
@@ -1561,7 +1561,7 @@ private:
 
         if (dst->AssignedPeepType == PeepType::Guest)
         {
-            if (dst->OutsideOfPark && dst->State != PEEP_STATE_LEAVING_PARK)
+            if (dst->OutsideOfPark && dst->State != PeepState::LeavingPark)
             {
                 increment_guests_heading_for_park();
             }
@@ -3040,10 +3040,10 @@ private:
             // First, make the queuing peep exit
             for (auto peep : EntityList<Guest>(EntityListId::Peep))
             {
-                if (peep->State == PEEP_STATE_QUEUING_FRONT && peep->CurrentRide == 0)
+                if (peep->State == PeepState::QueuingFront && peep->CurrentRide == 0)
                 {
                     peep->RemoveFromQueue();
-                    peep->SetState(PEEP_STATE_FALLING);
+                    peep->SetState(PeepState::Falling);
                     break;
                 }
             }
diff --git a/src/openrct2/rct2/S6Importer.cpp b/src/openrct2/rct2/S6Importer.cpp
index fe7aebc9fd..61d32cdac6 100644
--- a/src/openrct2/rct2/S6Importer.cpp
+++ b/src/openrct2/rct2/S6Importer.cpp
@@ -1024,7 +1024,8 @@ public:
             if (sprite.unknown.sprite_identifier == SPRITE_IDENTIFIER_PEEP)
             {
                 if (sprite.peep.current_ride == rideIndex
-                    && (sprite.peep.state == PEEP_STATE_ON_RIDE || sprite.peep.state == PEEP_STATE_ENTERING_RIDE))
+                    && (static_cast<PeepState>(sprite.peep.state) == PeepState::OnRide
+                        || static_cast<PeepState>(sprite.peep.state) == PeepState::EnteringRide))
                 {
                     numRiders++;
                 }
diff --git a/src/openrct2/ride/Ride.cpp b/src/openrct2/ride/Ride.cpp
index 99d1c33dab..66d5a755d6 100644
--- a/src/openrct2/ride/Ride.cpp
+++ b/src/openrct2/ride/Ride.cpp
@@ -1121,14 +1121,14 @@ void ride_remove_peeps(Ride* ride)
     // Place all the peeps at exit
     for (auto peep : EntityList<Peep>(EntityListId::Peep))
     {
-        if (peep->State == PEEP_STATE_QUEUING_FRONT || peep->State == PEEP_STATE_ENTERING_RIDE
-            || peep->State == PEEP_STATE_LEAVING_RIDE || peep->State == PEEP_STATE_ON_RIDE)
+        if (peep->State == PeepState::QueuingFront || peep->State == PeepState::EnteringRide
+            || peep->State == PeepState::LeavingRide || peep->State == PeepState::OnRide)
         {
             if (peep->CurrentRide != ride->id)
                 continue;
 
             peep_decrement_num_riders(peep);
-            if (peep->State == PEEP_STATE_QUEUING_FRONT && peep->SubState == PEEP_RIDE_AT_ENTRANCE)
+            if (peep->State == PeepState::QueuingFront && peep->SubState == PEEP_RIDE_AT_ENTRANCE)
                 peep->RemoveFromQueue();
 
             if (exitPosition.direction == INVALID_DIRECTION)
@@ -1145,7 +1145,7 @@ void ride_remove_peeps(Ride* ride)
                 peep->sprite_direction = exitPosition.direction;
             }
 
-            peep->State = PEEP_STATE_FALLING;
+            peep->State = PeepState::Falling;
             peep->SwitchToSpecialSprite(0);
 
             peep->Happiness = std::min(peep->Happiness, peep->HappinessTarget) / 2;
@@ -2616,7 +2616,7 @@ static void ride_mechanic_status_update(Ride* ride, int32_t mechanicStatus)
         {
             auto mechanic = ride_get_mechanic(ride);
             if (mechanic == nullptr
-                || (mechanic->State != PEEP_STATE_HEADING_TO_INSPECTION && mechanic->State != PEEP_STATE_ANSWERING)
+                || (mechanic->State != PeepState::HeadingToInspection && mechanic->State != PeepState::Answering)
                 || mechanic->CurrentRide != ride->id)
             {
                 ride->mechanic_status = RIDE_MECHANIC_STATUS_CALLING;
@@ -2629,8 +2629,8 @@ static void ride_mechanic_status_update(Ride* ride, int32_t mechanicStatus)
         {
             auto mechanic = ride_get_mechanic(ride);
             if (mechanic == nullptr
-                || (mechanic->State != PEEP_STATE_HEADING_TO_INSPECTION && mechanic->State != PEEP_STATE_FIXING
-                    && mechanic->State != PEEP_STATE_INSPECTING && mechanic->State != PEEP_STATE_ANSWERING))
+                || (mechanic->State != PeepState::HeadingToInspection && mechanic->State != PeepState::Fixing
+                    && mechanic->State != PeepState::Inspecting && mechanic->State != PeepState::Answering))
             {
                 ride->mechanic_status = RIDE_MECHANIC_STATUS_CALLING;
                 ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_MAINTENANCE;
@@ -2647,7 +2647,7 @@ static void ride_mechanic_status_update(Ride* ride, int32_t mechanicStatus)
  */
 static void ride_call_mechanic(Ride* ride, Peep* mechanic, int32_t forInspection)
 {
-    mechanic->SetState(forInspection ? PEEP_STATE_HEADING_TO_INSPECTION : PEEP_STATE_ANSWERING);
+    mechanic->SetState(forInspection ? PeepState::HeadingToInspection : PeepState::Answering);
     mechanic->SubState = 0;
     ride->mechanic_status = RIDE_MECHANIC_STATUS_HEADING;
     ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_MAINTENANCE;
@@ -2709,12 +2709,12 @@ Peep* find_closest_mechanic(const CoordsXY& entrancePosition, int32_t forInspect
 
         if (!forInspection)
         {
-            if (peep->State == PEEP_STATE_HEADING_TO_INSPECTION)
+            if (peep->State == PeepState::HeadingToInspection)
             {
                 if (peep->SubState >= 4)
                     continue;
             }
-            else if (peep->State != PEEP_STATE_PATROLLING)
+            else if (peep->State != PeepState::Patrolling)
                 continue;
 
             if (!(peep->StaffOrders & STAFF_ORDERS_FIX_RIDES))
@@ -2722,7 +2722,7 @@ Peep* find_closest_mechanic(const CoordsXY& entrancePosition, int32_t forInspect
         }
         else
         {
-            if (peep->State != PEEP_STATE_PATROLLING || !(peep->StaffOrders & STAFF_ORDERS_INSPECT_RIDES))
+            if (peep->State != PeepState::Patrolling || !(peep->StaffOrders & STAFF_ORDERS_INSPECT_RIDES))
                 continue;
         }
 
@@ -5471,13 +5471,13 @@ void Ride::StopGuestsQueuing()
 {
     for (auto peep : EntityList<Guest>(EntityListId::Peep))
     {
-        if (peep->State != PEEP_STATE_QUEUING)
+        if (peep->State != PeepState::Queuing)
             continue;
         if (peep->CurrentRide != id)
             continue;
 
         peep->RemoveFromQueue();
-        peep->SetState(PEEP_STATE_FALLING);
+        peep->SetState(PeepState::Falling);
     }
 }
 
diff --git a/src/openrct2/ride/Vehicle.cpp b/src/openrct2/ride/Vehicle.cpp
index e0015d1f99..7a7d427d51 100644
--- a/src/openrct2/ride/Vehicle.cpp
+++ b/src/openrct2/ride/Vehicle.cpp
@@ -4101,7 +4101,7 @@ void Vehicle::UpdateUnloadingPassengers()
 
             if (firstGuest != nullptr)
             {
-                firstGuest->SetState(PEEP_STATE_LEAVING_RIDE);
+                firstGuest->SetState(PeepState::LeavingRide);
                 firstGuest->SubState = PEEP_RIDE_LEAVE_VEHICLE;
             }
 
@@ -4110,7 +4110,7 @@ void Vehicle::UpdateUnloadingPassengers()
 
             if (secondGuest != nullptr)
             {
-                secondGuest->SetState(PEEP_STATE_LEAVING_RIDE);
+                secondGuest->SetState(PeepState::LeavingRide);
                 secondGuest->SubState = PEEP_RIDE_LEAVE_VEHICLE;
             }
         }
@@ -4146,7 +4146,7 @@ void Vehicle::UpdateUnloadingPassengers()
                 Peep* curPeep = GetEntity<Guest>(train->peep[peepIndex]);
                 if (curPeep != nullptr)
                 {
-                    curPeep->SetState(PEEP_STATE_LEAVING_RIDE);
+                    curPeep->SetState(PeepState::LeavingRide);
                     curPeep->SubState = PEEP_RIDE_LEAVE_VEHICLE;
                 }
             }
diff --git a/src/openrct2/ride/gentle/FerrisWheel.cpp b/src/openrct2/ride/gentle/FerrisWheel.cpp
index 793975047c..d2b30faec5 100644
--- a/src/openrct2/ride/gentle/FerrisWheel.cpp
+++ b/src/openrct2/ride/gentle/FerrisWheel.cpp
@@ -105,7 +105,7 @@ static void paint_ferris_wheel_structure(
         for (int32_t i = 0; i < 32; i += 2)
         {
             auto* peep = GetEntity<Guest>(vehicle->peep[i]);
-            if (peep == nullptr || peep->State != PEEP_STATE_ON_RIDE)
+            if (peep == nullptr || peep->State != PeepState::OnRide)
             {
                 continue;
             }
diff --git a/src/openrct2/scripting/ScEntity.hpp b/src/openrct2/scripting/ScEntity.hpp
index 63b1967110..747d8d0ffa 100644
--- a/src/openrct2/scripting/ScEntity.hpp
+++ b/src/openrct2/scripting/ScEntity.hpp
@@ -142,7 +142,7 @@ namespace OpenRCT2::Scripting
                         auto peep = static_cast<Peep*>(entity);
                         // We can't remove a single peep from a ride at the moment as this can cause complications with the
                         // vehicle car having an unsupported peep capacity.
-                        if (peep->State == PEEP_STATE_ON_RIDE || peep->State == PEEP_STATE_ENTERING_RIDE)
+                        if (peep->State == PeepState::OnRide || peep->State == PeepState::EnteringRide)
                         {
                             duk_error(ctx, DUK_ERR_ERROR, "Removing a peep that is on a ride is currently unsupported.");
                         }
diff --git a/src/openrct2/world/Footpath.cpp b/src/openrct2/world/Footpath.cpp
index 022cbe39c8..2c20636935 100644
--- a/src/openrct2/world/Footpath.cpp
+++ b/src/openrct2/world/Footpath.cpp
@@ -417,11 +417,11 @@ void footpath_interrupt_peeps(const CoordsXYZ& footpathPos)
     auto quad = EntityTileList<Peep>(footpathPos);
     for (auto peep : quad)
     {
-        if (peep->State == PEEP_STATE_SITTING || peep->State == PEEP_STATE_WATCHING)
+        if (peep->State == PeepState::Sitting || peep->State == PeepState::Watching)
         {
             if (peep->z == footpathPos.z)
             {
-                peep->SetState(PEEP_STATE_WALKING);
+                peep->SetState(PeepState::Walking);
                 peep->DestinationX = (peep->x & 0xFFE0) + 16;
                 peep->DestinationY = (peep->y & 0xFFE0) + 16;
                 peep->DestinationTolerance = 5;
diff --git a/src/openrct2/world/MapAnimation.cpp b/src/openrct2/world/MapAnimation.cpp
index 6cabb5bd15..693c82354a 100644
--- a/src/openrct2/world/MapAnimation.cpp
+++ b/src/openrct2/world/MapAnimation.cpp
@@ -194,7 +194,7 @@ static bool map_animation_invalidate_small_scenery(const CoordsXYZ& loc)
                 auto quad = EntityTileList<Peep>(CoordsXY{ loc } - CoordsDirectionDelta[direction]);
                 for (auto peep : quad)
                 {
-                    if (peep->State != PEEP_STATE_WALKING)
+                    if (peep->State != PeepState::Walking)
                         continue;
                     if (peep->z != loc.z)
                         continue;
diff --git a/src/openrct2/world/Park.cpp b/src/openrct2/world/Park.cpp
index 8cb2c70eb3..0b4d7dadd6 100644
--- a/src/openrct2/world/Park.cpp
+++ b/src/openrct2/world/Park.cpp
@@ -729,7 +729,7 @@ Peep* Park::GenerateGuest()
             peep->DestinationTolerance = 5;
             peep->PeepDirection = direction;
             peep->Var37 = 0;
-            peep->State = PEEP_STATE_ENTERING_PARK;
+            peep->State = PeepState::EnteringPark;
         }
     }
     return peep;
diff --git a/test/tests/PlayTests.cpp b/test/tests/PlayTests.cpp
index 15bc708a70..ae6e58f096 100644
--- a/test/tests/PlayTests.cpp
+++ b/test/tests/PlayTests.cpp
@@ -118,7 +118,7 @@ TEST_F(PlayTests, SecondGuestInQueueShouldNotRideIfNoFunds)
     richGuest->CashInPocket = 3000;
 
     // Wait for rich guest to get in queue
-    bool matched = updateUntil(*gs, 1000, [&]() { return richGuest->State == PEEP_STATE_QUEUING; });
+    bool matched = updateUntil(*gs, 1000, [&]() { return richGuest->State == PeepState::Queuing; });
     ASSERT_TRUE(matched);
 
     // Insert poor guest
@@ -126,7 +126,7 @@ TEST_F(PlayTests, SecondGuestInQueueShouldNotRideIfNoFunds)
     poorGuest->CashInPocket = 5;
 
     // Wait for poor guest to get in queue
-    matched = updateUntil(*gs, 1000, [&]() { return poorGuest->State == PEEP_STATE_QUEUING; });
+    matched = updateUntil(*gs, 1000, [&]() { return poorGuest->State == PeepState::Queuing; });
     ASSERT_TRUE(matched);
 
     // Raise the price of the ride to a value poor guest can't pay
@@ -136,8 +136,8 @@ TEST_F(PlayTests, SecondGuestInQueueShouldNotRideIfNoFunds)
     // since it doesn't have enough money to pay for it
     bool enteredTheRide = false;
     matched = updateUntil(*gs, 10000, [&]() {
-        enteredTheRide |= poorGuest->State == PEEP_STATE_ON_RIDE;
-        return poorGuest->State == PEEP_STATE_WALKING || enteredTheRide;
+        enteredTheRide |= poorGuest->State == PeepState::OnRide;
+        return poorGuest->State == PeepState::Walking || enteredTheRide;
     });
 
     ASSERT_TRUE(matched);
@@ -181,7 +181,7 @@ TEST_F(PlayTests, CarRideWithOneCarOnlyAcceptsTwoGuests)
     }
 
     // Wait until one of them is riding
-    auto guestIsOnRide = [](auto* g) { return g->State == PEEP_STATE_ON_RIDE; };
+    auto guestIsOnRide = [](auto* g) { return g->State == PeepState::OnRide; };
     bool matched = updateUntil(*gs, 10000, [&]() { return std::any_of(guests.begin(), guests.end(), guestIsOnRide); });
     ASSERT_TRUE(matched);