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

refactor: ObjectType to use strong enum 

enum renaming complete
This commit is contained in:
Łukasz Pękalski 2020-11-09 10:36:37 +01:00
parent 1ab3f4b250
commit 6e5105ab3b
40 changed files with 255 additions and 255 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/openrct2-ui/interface/LandTool.cpp
View File

@ -64,7 +64,7 @@ void LandTool::ShowSurfaceStyleDropdown(rct_window* w, rct_widget* widget, uint8
auto itemIndex = 0;
for (size_t i = 0; i < MAX_TERRAIN_SURFACE_OBJECTS; i++)
{
const auto surfaceObj = static_cast<TerrainSurfaceObject*>(objManager.GetLoadedObject(OBJECT_TYPE_TERRAIN_SURFACE, i));
const auto surfaceObj = static_cast<TerrainSurfaceObject*>(objManager.GetLoadedObject(ObjectType::TerrainSurface, i));
if (surfaceObj != nullptr)
{
gDropdownItemsFormat[itemIndex] = Dropdown::FormatLandPicker;
@ -97,7 +97,7 @@ void LandTool::ShowEdgeStyleDropdown(rct_window* w, rct_widget* widget, uint8_t
auto itemIndex = 0;
for (size_t i = 0; i < MAX_TERRAIN_EDGE_OBJECTS; i++)
{
const auto edgeObj = static_cast<TerrainEdgeObject*>(objManager.GetLoadedObject(OBJECT_TYPE_TERRAIN_EDGE, i));
const auto edgeObj = static_cast<TerrainEdgeObject*>(objManager.GetLoadedObject(ObjectType::TerrainEdge, i));
if (edgeObj != nullptr && edgeObj->NumImagesLoaded > 1)
{
gDropdownItemsFormat[itemIndex] = Dropdown::FormatLandPicker;

8
src/openrct2-ui/windows/EditorInventionsList.cpp
View File

@ -126,7 +126,7 @@ static void move_research_item(ResearchItem* beforeItem, int32_t scrollIndex);
static void research_rides_setup()
{
// Reset all objects to not required
for (uint8_t objectType = OBJECT_TYPE_RIDE; objectType < OBJECT_TYPE_COUNT; objectType++)
for (uint8_t objectType = ObjectType::Ride; objectType < ObjectType::Count; objectType++)
{
auto maxObjects = object_entry_group_counts[objectType];
for (int32_t i = 0; i < maxObjects; i++)
@ -138,7 +138,7 @@ static void research_rides_setup()
// Set research required for rides in use
for (const auto& ride : GetRideManager())
{
Editor::SetSelectedObject(OBJECT_TYPE_RIDE, ride.subtype, OBJECT_SELECTION_FLAG_SELECTED);
Editor::SetSelectedObject(ObjectType::Ride, ride.subtype, OBJECT_SELECTION_FLAG_SELECTED);
}
}
@ -531,9 +531,9 @@ static void window_editor_inventions_list_paint(rct_window* w, rct_drawpixelinfo
return;
// Preview image
int32_t objectEntryType = OBJECT_TYPE_SCENERY_GROUP;
int32_t objectEntryType = ObjectType::SceneryGroup;
if (researchItem->type == Research::EntryType::Ride)
objectEntryType = OBJECT_TYPE_RIDE;
objectEntryType = ObjectType::Ride;
auto chunk = object_entry_get_chunk(objectEntryType, researchItem->entryIndex);
if (chunk == nullptr)

26
src/openrct2-ui/windows/EditorObjectSelection.cpp
View File

@ -64,7 +64,7 @@ enum
static constexpr uint8_t _numSourceGameItems = 8;
static uint32_t _filter_flags;
static uint16_t _filter_object_counts[OBJECT_TYPE_COUNT];
static uint16_t _filter_object_counts[ObjectType::Count];
static char _filter_string[MAX_PATH];
@ -871,7 +871,7 @@ static void window_editor_object_selection_invalidate(rct_window* w)
w->widgets[WIDX_PREVIEW].right = w->widgets[WIDX_PREVIEW].left + 113;
w->widgets[WIDX_FILTER_RIDE_TAB_FRAME].right = w->widgets[WIDX_LIST].right;
bool ridePage = (get_selected_object_type(w) == OBJECT_TYPE_RIDE);
bool ridePage = (get_selected_object_type(w) == ObjectType::Ride);
w->widgets[WIDX_LIST].top = (ridePage ? 118 : 60);
w->widgets[WIDX_FILTER_TEXT_BOX].right = w->widgets[WIDX_LIST].right - 77;
w->widgets[WIDX_FILTER_TEXT_BOX].top = (ridePage ? 79 : 45);
@ -965,7 +965,7 @@ static void window_editor_object_selection_paint(rct_window* w, rct_drawpixelinf
const int32_t ThrillRidesTabAnimationSequence[] = { 5, 6, 5, 4, 3, 2, 1, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 0, 0, 0 };
// Draw ride tabs
if (get_selected_object_type(w) == OBJECT_TYPE_RIDE)
if (get_selected_object_type(w) == ObjectType::Ride)
{
for (int32_t i = 0; i < 7; i++)
{
@ -1078,7 +1078,7 @@ static void window_editor_object_selection_paint(rct_window* w, rct_drawpixelinf
auto screenPos = w->windowPos + ScreenCoordsXY{ w->width - 5, w->height - (LIST_ROW_HEIGHT * 5) };
// Draw ride type.
if (get_selected_object_type(w) == OBJECT_TYPE_RIDE)
if (get_selected_object_type(w) == ObjectType::Ride)
{
auto stringId = get_ride_type_string_id(listItem->repositoryItem);
DrawTextBasic(dpi, screenPos, stringId, {}, COLOUR_WHITE, TextAlignment::RIGHT);
@ -1131,7 +1131,7 @@ static void window_editor_object_selection_scrollpaint(rct_window* w, rct_drawpi
int32_t colour, colour2;
ScreenCoordsXY screenCoords;
bool ridePage = (get_selected_object_type(w) == OBJECT_TYPE_RIDE);
bool ridePage = (get_selected_object_type(w) == ObjectType::Ride);
uint8_t paletteIndex = ColourMapA[w->colours[1]].mid_light;
gfx_clear(dpi, paletteIndex);
@ -1224,7 +1224,7 @@ static void window_editor_object_set_page(rct_window* w, int32_t page)
w->scrolls[0].v_top = 0;
w->frame_no = 0;
if (page == OBJECT_TYPE_RIDE)
if (page == ObjectType::Ride)
{
_listSortType = RIDE_SORT_TYPE;
_listSortDescending = false;
@ -1277,7 +1277,7 @@ static void window_editor_object_selection_manage_tracks()
gS6Info.editor_step = EDITOR_STEP_TRACK_DESIGNS_MANAGER;
int32_t entry_index = 0;
for (; object_entry_get_chunk(OBJECT_TYPE_RIDE, entry_index) == nullptr; entry_index++)
for (; object_entry_get_chunk(ObjectType::Ride, entry_index) == nullptr; entry_index++)
;
rct_ride_entry* ride_entry = get_ride_entry(entry_index);
@ -1316,14 +1316,14 @@ static void editor_load_selected_objects()
// Defaults selected items to researched (if in-game)
uint8_t objectType = entry->GetType();
auto entryIndex = object_manager_get_loaded_object_entry_index(loadedObject);
if (objectType == OBJECT_TYPE_RIDE)
if (objectType == ObjectType::Ride)
{
rct_ride_entry* rideEntry = get_ride_entry(entryIndex);
uint8_t rideType = ride_entry_get_first_non_null_ride_type(rideEntry);
ResearchCategory category = static_cast<ResearchCategory>(RideTypeDescriptors[rideType].Category);
research_insert_ride_entry(rideType, entryIndex, category, true);
}
else if (objectType == OBJECT_TYPE_SCENERY_GROUP)
else if (objectType == ObjectType::SceneryGroup)
{
research_insert_scenery_group_entry(entryIndex, true);
}
@ -1428,7 +1428,7 @@ static bool filter_string(const ObjectRepositoryItem* item)
// Check if the searched string exists in the name, ride type, or filename
bool inName = strstr(name_lower, filter_lower) != nullptr;
bool inRideType = (item->ObjectEntry.GetType() == OBJECT_TYPE_RIDE) && strstr(type_lower, filter_lower) != nullptr;
bool inRideType = (item->ObjectEntry.GetType() == ObjectType::Ride) && strstr(type_lower, filter_lower) != nullptr;
bool inPath = strstr(object_path, filter_lower) != nullptr;
return inName || inRideType || inPath;
@ -1473,7 +1473,7 @@ static bool filter_chunks(const ObjectRepositoryItem* item)
{
switch (item->ObjectEntry.GetType())
{
case OBJECT_TYPE_RIDE:
case ObjectType::Ride:
uint8_t rideType = 0;
for (int32_t i = 0; i < MAX_RIDE_TYPES_PER_RIDE_ENTRY; i++)
@ -1529,7 +1529,7 @@ static std::string object_get_description(const Object* object)
{
switch (object->GetObjectType())
{
case OBJECT_TYPE_RIDE:
case ObjectType::Ride:
{
const RideObject* rideObject = static_cast<const RideObject*>(object);
return rideObject->GetDescription();
@ -1542,7 +1542,7 @@ static std::string object_get_description(const Object* object)
static int32_t get_selected_object_type(rct_window* w)
{
auto tab = w->selected_tab;
if (tab >= OBJECT_TYPE_SCENARIO_TEXT)
if (tab >= ObjectType::ScenarioText)
return tab + 1;
else
return tab;

2
src/openrct2-ui/windows/Footpath.cpp
View File

@ -1218,7 +1218,7 @@ static bool footpath_select_default()
{
// Select first available footpath
int32_t footpathId = -1;
for (int32_t i = 0; i < object_entry_group_counts[OBJECT_TYPE_PATHS]; i++)
for (int32_t i = 0; i < object_entry_group_counts[ObjectType::Paths]; i++)
{
PathSurfaceEntry* pathEntry = get_path_surface_entry(i);
if (pathEntry != nullptr)

6
src/openrct2-ui/windows/Land.cpp
View File

@ -279,7 +279,7 @@ static void window_land_invalidate(rct_window* w)
auto& objManager = GetContext()->GetObjectManager();
const auto surfaceObj = static_cast<TerrainSurfaceObject*>(
objManager.GetLoadedObject(OBJECT_TYPE_TERRAIN_SURFACE, _selectedFloorTexture));
objManager.GetLoadedObject(ObjectType::TerrainSurface, _selectedFloorTexture));
if (surfaceObj != nullptr)
{
surfaceImage = surfaceObj->IconImageId;
@ -289,7 +289,7 @@ static void window_land_invalidate(rct_window* w)
}
}
const auto edgeObj = static_cast<TerrainEdgeObject*>(
objManager.GetLoadedObject(OBJECT_TYPE_TERRAIN_EDGE, _selectedWallTexture));
objManager.GetLoadedObject(ObjectType::TerrainEdge, _selectedWallTexture));
if (edgeObj != nullptr)
{
edgeImage = edgeObj->IconImageId;
@ -361,7 +361,7 @@ static void window_land_paint(rct_window* w, rct_drawpixelinfo* dpi)
{
auto& objManager = GetContext()->GetObjectManager();
const auto surfaceObj = static_cast<TerrainSurfaceObject*>(
objManager.GetLoadedObject(OBJECT_TYPE_TERRAIN_SURFACE, gLandToolTerrainSurface));
objManager.GetLoadedObject(ObjectType::TerrainSurface, gLandToolTerrainSurface));
if (surfaceObj != nullptr)
{
price += numTiles * surfaceObj->Price;

8
src/openrct2-ui/windows/MapGen.cpp
View File

@ -657,7 +657,7 @@ static void window_mapgen_base_invalidate(rct_window* w)
auto& objManager = GetContext()->GetObjectManager();
const auto surfaceObj = static_cast<TerrainSurfaceObject*>(
objManager.GetLoadedObject(OBJECT_TYPE_TERRAIN_SURFACE, _floorTexture));
objManager.GetLoadedObject(ObjectType::TerrainSurface, _floorTexture));
if (surfaceObj != nullptr)
{
surfaceImage = surfaceObj->IconImageId;
@ -666,7 +666,7 @@ static void window_mapgen_base_invalidate(rct_window* w)
surfaceImage |= SPRITE_ID_PALETTE_COLOUR_1(surfaceObj->Colour);
}
}
const auto edgeObj = static_cast<TerrainEdgeObject*>(objManager.GetLoadedObject(OBJECT_TYPE_TERRAIN_EDGE, _wallTexture));
const auto edgeObj = static_cast<TerrainEdgeObject*>(objManager.GetLoadedObject(ObjectType::TerrainEdge, _wallTexture));
if (edgeObj != nullptr)
{
edgeImage = edgeObj->IconImageId;
@ -961,7 +961,7 @@ static void window_mapgen_simplex_invalidate(rct_window* w)
auto& objManager = GetContext()->GetObjectManager();
const auto surfaceObj = static_cast<TerrainSurfaceObject*>(
objManager.GetLoadedObject(OBJECT_TYPE_TERRAIN_SURFACE, _floorTexture));
objManager.GetLoadedObject(ObjectType::TerrainSurface, _floorTexture));
if (surfaceObj != nullptr)
{
surfaceImage = surfaceObj->IconImageId;
@ -970,7 +970,7 @@ static void window_mapgen_simplex_invalidate(rct_window* w)
surfaceImage |= SPRITE_ID_PALETTE_COLOUR_1(surfaceObj->Colour);
}
}
const auto edgeObj = static_cast<TerrainEdgeObject*>(objManager.GetLoadedObject(OBJECT_TYPE_TERRAIN_EDGE, _wallTexture));
const auto edgeObj = static_cast<TerrainEdgeObject*>(objManager.GetLoadedObject(ObjectType::TerrainEdge, _wallTexture));
if (edgeObj != nullptr)
{
edgeImage = edgeObj->IconImageId;

20
src/openrct2-ui/windows/ObjectLoadError.cpp
View File

@ -327,34 +327,34 @@ static rct_string_id get_object_type_string(const rct_object_entry* entry)
rct_string_id result;
switch (entry->GetType())
{
case OBJECT_TYPE_RIDE:
case ObjectType::Ride:
result = STR_OBJECT_SELECTION_RIDE_VEHICLES_ATTRACTIONS;
break;
case OBJECT_TYPE_SMALL_SCENERY:
case ObjectType::SmallScenery:
result = STR_OBJECT_SELECTION_SMALL_SCENERY;
break;
case OBJECT_TYPE_LARGE_SCENERY:
case ObjectType::LargeScenery:
result = STR_OBJECT_SELECTION_LARGE_SCENERY;
break;
case OBJECT_TYPE_WALLS:
case ObjectType::Walls:
result = STR_OBJECT_SELECTION_WALLS_FENCES;
break;
case OBJECT_TYPE_BANNERS:
case ObjectType::Banners:
result = STR_OBJECT_SELECTION_PATH_SIGNS;
break;
case OBJECT_TYPE_PATHS:
case ObjectType::Paths:
result = STR_OBJECT_SELECTION_FOOTPATHS;
break;
case OBJECT_TYPE_PATH_BITS:
case ObjectType::PathBits:
result = STR_OBJECT_SELECTION_PATH_EXTRAS;
break;
case OBJECT_TYPE_SCENERY_GROUP:
case ObjectType::SceneryGroup:
result = STR_OBJECT_SELECTION_SCENERY_GROUPS;
break;
case OBJECT_TYPE_PARK_ENTRANCE:
case ObjectType::ParkEntrance:
result = STR_OBJECT_SELECTION_PARK_ENTRANCE;
break;
case OBJECT_TYPE_WATER:
case ObjectType::Water:
result = STR_OBJECT_SELECTION_WATER;
break;
default:

4
src/openrct2-ui/windows/Ride.cpp
View File

@ -4344,7 +4344,7 @@ static void window_ride_colour_mousedown(rct_window* w, rct_widgetindex widgetIn
auto& objManager = GetContext()->GetObjectManager();
for (i = 0; i < MAX_STATION_OBJECTS; i++)
{
auto stationObj = static_cast<StationObject*>(objManager.GetLoadedObject(OBJECT_TYPE_STATION, i));
auto stationObj = static_cast<StationObject*>(objManager.GetLoadedObject(ObjectType::Station, i));
if (stationObj != nullptr)
{
gDropdownItemsFormat[ddIndex] = STR_DROPDOWN_MENU_LABEL;
@ -4463,7 +4463,7 @@ static void window_ride_colour_dropdown(rct_window* w, rct_widgetindex widgetInd
auto& objManager = GetContext()->GetObjectManager();
for (auto i = 0; i < MAX_STATION_OBJECTS; i++)
{
auto stationObj = static_cast<StationObject*>(objManager.GetLoadedObject(OBJECT_TYPE_STATION, i));
auto stationObj = static_cast<StationObject*>(objManager.GetLoadedObject(ObjectType::Station, i));
if (stationObj != nullptr)
{
if (ddIndex == dropdownIndex)

18
src/openrct2/CmdlineSprite.cpp
View File

@ -487,17 +487,17 @@ int32_t cmdline_for_sprite(const char** argv, int32_t argc)
int32_t imagesOffset = 0;
switch (objectType)
{
case OBJECT_TYPE_RIDE:
case ObjectType::Ride:
{
auto rideEntry = get_ride_entry(entryIndex);
imagesOffset = rideEntry->images_offset;
break;
}
case OBJECT_TYPE_SMALL_SCENERY:
case OBJECT_TYPE_LARGE_SCENERY:
case OBJECT_TYPE_WALLS:
case OBJECT_TYPE_BANNERS:
case OBJECT_TYPE_PATH_BITS:
case ObjectType::SmallScenery:
case ObjectType::LargeScenery:
case ObjectType::Walls:
case ObjectType::Banners:
case ObjectType::PathBits:
{
auto obj = objManager.GetLoadedObject(objectType, entryIndex);
if (obj != nullptr)
@ -507,19 +507,19 @@ int32_t cmdline_for_sprite(const char** argv, int32_t argc)
}
break;
}
case OBJECT_TYPE_PATHS:
case ObjectType::Paths:
{
auto pathEntry = get_path_surface_entry(entryIndex);
imagesOffset = pathEntry->image;
break;
}
case OBJECT_TYPE_SCENERY_GROUP:
case ObjectType::SceneryGroup:
{
auto sceneryGroupEntry = get_scenery_group_entry(entryIndex);
imagesOffset = sceneryGroupEntry->image;
break;
}
case OBJECT_TYPE_PARK_ENTRANCE:
case ObjectType::ParkEntrance:
{
auto obj = objManager.GetLoadedObject(objectType, entryIndex);
if (obj != nullptr)

18
src/openrct2/Editor.cpp
View File

@ -47,7 +47,7 @@ using namespace OpenRCT2;
namespace Editor
{
static std::array<std::vector<uint8_t>, OBJECT_TYPE_COUNT> _editorSelectedObjectFlags;
static std::array<std::vector<uint8_t>, ObjectType::Count> _editorSelectedObjectFlags;
static void ConvertSaveToScenarioCallback(int32_t result, const utf8* path);
static void SetAllLandOwned();
@ -451,31 +451,31 @@ namespace Editor
if (!isTrackDesignerManager)
{
if (!editor_check_object_group_at_least_one_selected(OBJECT_TYPE_PATHS))
if (!editor_check_object_group_at_least_one_selected(ObjectType::Paths))
{
gGameCommandErrorText = STR_AT_LEAST_ONE_PATH_OBJECT_MUST_BE_SELECTED;
return OBJECT_TYPE_PATHS;
return ObjectType::Paths;
}
}
if (!editor_check_object_group_at_least_one_selected(OBJECT_TYPE_RIDE))
if (!editor_check_object_group_at_least_one_selected(ObjectType::Ride))
{
gGameCommandErrorText = STR_AT_LEAST_ONE_RIDE_OBJECT_MUST_BE_SELECTED;
return OBJECT_TYPE_RIDE;
return ObjectType::Ride;
}
if (!isTrackDesignerManager)
{
if (!editor_check_object_group_at_least_one_selected(OBJECT_TYPE_PARK_ENTRANCE))
if (!editor_check_object_group_at_least_one_selected(ObjectType::ParkEntrance))
{
gGameCommandErrorText = STR_PARK_ENTRANCE_TYPE_MUST_BE_SELECTED;
return OBJECT_TYPE_PARK_ENTRANCE;
return ObjectType::ParkEntrance;
}
if (!editor_check_object_group_at_least_one_selected(OBJECT_TYPE_WATER))
if (!editor_check_object_group_at_least_one_selected(ObjectType::Water))
{
gGameCommandErrorText = STR_WATER_TYPE_MUST_BE_SELECTED;
return OBJECT_TYPE_WATER;
return ObjectType::Water;
}
}

52
src/openrct2/EditorObjectSelectionSession.cpp
View File

@ -30,8 +30,8 @@
bool _maxObjectsWasHit;
std::vector<uint8_t> _objectSelectionFlags;
int32_t _numSelectedObjectsForType[OBJECT_TYPE_COUNT];
static int32_t _numAvailableObjectsForType[OBJECT_TYPE_COUNT];
int32_t _numSelectedObjectsForType[ObjectType::Count];
static int32_t _numAvailableObjectsForType[ObjectType::Count];
static void setup_in_use_selection_flags();
static void setup_track_designer_objects();
@ -51,7 +51,7 @@ static void setup_track_manager_objects()
uint8_t* selectionFlags = &_objectSelectionFlags[i];
const ObjectRepositoryItem* item = &items[i];
uint8_t object_type = item->ObjectEntry.GetType();
if (object_type == OBJECT_TYPE_RIDE)
if (object_type == ObjectType::Ride)
{
*selectionFlags |= OBJECT_SELECTION_FLAG_6;
@ -80,7 +80,7 @@ static void setup_track_designer_objects()
uint8_t* selectionFlags = &_objectSelectionFlags[i];
const ObjectRepositoryItem* item = &items[i];
uint8_t objectType = item->ObjectEntry.GetType();
if (objectType == OBJECT_TYPE_RIDE)
if (objectType == ObjectType::Ride)
{
*selectionFlags |= OBJECT_SELECTION_FLAG_6;
@ -107,7 +107,7 @@ void setup_in_use_selection_flags()
{
auto& objectMgr = OpenRCT2::GetContext()->GetObjectManager();
for (uint8_t objectType = 0; objectType < OBJECT_TYPE_COUNT; objectType++)
for (uint8_t objectType = 0; objectType < ObjectType::Count; objectType++)
{
for (int32_t i = 0; i < object_entry_group_counts[objectType]; i++)
{
@ -135,19 +135,19 @@ void setup_in_use_selection_flags()
break;
case TILE_ELEMENT_TYPE_PATH:
type = iter.element->AsPath()->GetSurfaceEntryIndex();
assert(type < object_entry_group_counts[OBJECT_TYPE_PATHS]);
Editor::SetSelectedObject(OBJECT_TYPE_PATHS, type, OBJECT_SELECTION_FLAG_SELECTED);
assert(type < object_entry_group_counts[ObjectType::Paths]);
Editor::SetSelectedObject(ObjectType::Paths, type, OBJECT_SELECTION_FLAG_SELECTED);
if (iter.element->AsPath()->HasAddition())
{
uint8_t path_additions = iter.element->AsPath()->GetAdditionEntryIndex();
Editor::SetSelectedObject(OBJECT_TYPE_PATH_BITS, path_additions, OBJECT_SELECTION_FLAG_SELECTED);
Editor::SetSelectedObject(ObjectType::PathBits, path_additions, OBJECT_SELECTION_FLAG_SELECTED);
}
break;
case TILE_ELEMENT_TYPE_SMALL_SCENERY:
type = iter.element->AsSmallScenery()->GetEntryIndex();
assert(type < object_entry_group_counts[OBJECT_TYPE_SMALL_SCENERY]);
Editor::SetSelectedObject(OBJECT_TYPE_SMALL_SCENERY, type, OBJECT_SELECTION_FLAG_SELECTED);
assert(type < object_entry_group_counts[ObjectType::SmallScenery]);
Editor::SetSelectedObject(ObjectType::SmallScenery, type, OBJECT_SELECTION_FLAG_SELECTED);
break;
case TILE_ELEMENT_TYPE_ENTRANCE:
if (iter.element->AsEntrance()->GetEntranceType() != ENTRANCE_TYPE_PARK_ENTRANCE)
@ -156,21 +156,21 @@ void setup_in_use_selection_flags()
if (iter.element->AsEntrance()->GetSequenceIndex() != 0)
break;
Editor::SetSelectedObject(OBJECT_TYPE_PARK_ENTRANCE, 0, OBJECT_SELECTION_FLAG_SELECTED);
Editor::SetSelectedObject(ObjectType::ParkEntrance, 0, OBJECT_SELECTION_FLAG_SELECTED);
type = iter.element->AsEntrance()->GetPathType();
assert(type < object_entry_group_counts[OBJECT_TYPE_PATHS]);
Editor::SetSelectedObject(OBJECT_TYPE_PATHS, type, OBJECT_SELECTION_FLAG_SELECTED);
assert(type < object_entry_group_counts[ObjectType::Paths]);
Editor::SetSelectedObject(ObjectType::Paths, type, OBJECT_SELECTION_FLAG_SELECTED);
break;
case TILE_ELEMENT_TYPE_WALL:
type = iter.element->AsWall()->GetEntryIndex();
assert(type < object_entry_group_counts[OBJECT_TYPE_WALLS]);
Editor::SetSelectedObject(OBJECT_TYPE_WALLS, type, OBJECT_SELECTION_FLAG_SELECTED);
assert(type < object_entry_group_counts[ObjectType::Walls]);
Editor::SetSelectedObject(ObjectType::Walls, type, OBJECT_SELECTION_FLAG_SELECTED);
break;
case TILE_ELEMENT_TYPE_LARGE_SCENERY:
type = iter.element->AsLargeScenery()->GetEntryIndex();
assert(type < object_entry_group_counts[OBJECT_TYPE_LARGE_SCENERY]);
Editor::SetSelectedObject(OBJECT_TYPE_LARGE_SCENERY, type, OBJECT_SELECTION_FLAG_SELECTED);
assert(type < object_entry_group_counts[ObjectType::LargeScenery]);
Editor::SetSelectedObject(ObjectType::LargeScenery, type, OBJECT_SELECTION_FLAG_SELECTED);
break;
case TILE_ELEMENT_TYPE_BANNER:
{
@ -178,8 +178,8 @@ void setup_in_use_selection_flags()
if (banner != nullptr)
{
type = banner->type;
assert(type < object_entry_group_counts[OBJECT_TYPE_BANNERS]);
Editor::SetSelectedObject(OBJECT_TYPE_BANNERS, type, OBJECT_SELECTION_FLAG_SELECTED);
assert(type < object_entry_group_counts[ObjectType::Banners]);
Editor::SetSelectedObject(ObjectType::Banners, type, OBJECT_SELECTION_FLAG_SELECTED);
}
break;
}
@ -192,7 +192,7 @@ void setup_in_use_selection_flags()
if (ride != nullptr)
{
ObjectEntryIndex type = ride->subtype;
Editor::SetSelectedObject(OBJECT_TYPE_RIDE, type, OBJECT_SELECTION_FLAG_SELECTED);
Editor::SetSelectedObject(ObjectType::Ride, type, OBJECT_SELECTION_FLAG_SELECTED);
}
}
@ -230,7 +230,7 @@ void sub_6AB211()
int32_t numObjects = static_cast<int32_t>(object_repository_get_items_count());
_objectSelectionFlags = std::vector<uint8_t>(numObjects);
for (uint8_t objectType = 0; objectType < OBJECT_TYPE_COUNT; objectType++)
for (uint8_t objectType = 0; objectType < ObjectType::Count; objectType++)
{
_numSelectedObjectsForType[objectType] = 0;
_numAvailableObjectsForType[objectType] = 0;
@ -289,7 +289,7 @@ static void remove_selected_objects_from_research(const rct_object_entry* instal
if (!find_object_in_entry_group(installedObject, &entry_type, &entry_index))
return;
if (entry_type == OBJECT_TYPE_RIDE)
if (entry_type == ObjectType::Ride)
{
auto rideEntry = get_ride_entry(entry_index);
@ -302,7 +302,7 @@ static void remove_selected_objects_from_research(const rct_object_entry* instal
research_remove(&tmp);
}
}
else if (entry_type == OBJECT_TYPE_SCENERY_GROUP)
else if (entry_type == ObjectType::SceneryGroup)
{
ResearchItem tmp = {};
tmp.type = Research::EntryType::Scenery;
@ -451,7 +451,7 @@ bool window_editor_object_selection_select_object(uint8_t isMasterObject, int32_
}
uint8_t objectType = item->ObjectEntry.GetType();
if (objectType == OBJECT_TYPE_SCENERY_GROUP && (flags & INPUT_FLAG_EDITOR_OBJECT_SELECT_OBJECTS_IN_SCENERY_GROUP))
if (objectType == ObjectType::SceneryGroup && (flags & INPUT_FLAG_EDITOR_OBJECT_SELECT_OBJECTS_IN_SCENERY_GROUP))
{
for (const auto& sgEntry : item->SceneryGroupInfo.Entries)
{
@ -490,7 +490,7 @@ bool window_editor_object_selection_select_object(uint8_t isMasterObject, int32_
return false;
}
if (objectType == OBJECT_TYPE_SCENERY_GROUP && (flags & INPUT_FLAG_EDITOR_OBJECT_SELECT_OBJECTS_IN_SCENERY_GROUP))
if (objectType == ObjectType::SceneryGroup && (flags & INPUT_FLAG_EDITOR_OBJECT_SELECT_OBJECTS_IN_SCENERY_GROUP))
{
for (const auto& sgEntry : item->SceneryGroupInfo.Entries)
{
@ -572,7 +572,7 @@ int32_t editor_remove_unused_objects()
const ObjectRepositoryItem* item = &items[i];
uint8_t objectType = item->ObjectEntry.GetType();
if (objectType >= OBJECT_TYPE_SCENERY_GROUP)
if (objectType >= ObjectType::SceneryGroup)
{
continue;
}

2
src/openrct2/EditorObjectSelectionSession.h
View File

@ -24,7 +24,7 @@ enum EDITOR_INPUT_FLAGS
extern bool _maxObjectsWasHit;
extern std::vector<uint8_t> _objectSelectionFlags;
extern int32_t _numSelectedObjectsForType[OBJECT_TYPE_COUNT];
extern int32_t _numSelectedObjectsForType[ObjectType::Count];
bool editor_check_object_group_at_least_one_selected(int32_t objectType);
void editor_object_flags_free();

2
src/openrct2/Game.cpp
View File

@ -144,7 +144,7 @@ enum
*/
void update_palette_effects()
{
auto water_type = static_cast<rct_water_type*>(object_entry_get_chunk(OBJECT_TYPE_WATER, 0));
auto water_type = static_cast<rct_water_type*>(object_entry_get_chunk(ObjectType::Water, 0));
if (gClimateLightningFlash == 1)
{

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

@ -68,7 +68,7 @@ public:
}
const auto surfaceObj = static_cast<TerrainSurfaceObject*>(
objManager.GetLoadedObject(OBJECT_TYPE_TERRAIN_SURFACE, _surfaceStyle));
objManager.GetLoadedObject(ObjectType::TerrainSurface, _surfaceStyle));
if (surfaceObj == nullptr)
{
@ -86,7 +86,7 @@ public:
}
const auto edgeObj = static_cast<TerrainEdgeObject*>(
objManager.GetLoadedObject(OBJECT_TYPE_TERRAIN_EDGE, _edgeStyle));
objManager.GetLoadedObject(ObjectType::TerrainEdge, _edgeStyle));
if (edgeObj == nullptr)
{
@ -139,7 +139,7 @@ public:
if (_surfaceStyle != curSurfaceStyle)
{
const auto surfaceObject = static_cast<TerrainSurfaceObject*>(
objManager.GetLoadedObject(OBJECT_TYPE_TERRAIN_SURFACE, _surfaceStyle));
objManager.GetLoadedObject(ObjectType::TerrainSurface, _surfaceStyle));
if (surfaceObject != nullptr)
{
surfaceCost += surfaceObject->Price;
@ -215,7 +215,7 @@ public:
{
auto& objManager = OpenRCT2::GetContext()->GetObjectManager();
const auto surfaceObject = static_cast<TerrainSurfaceObject*>(
objManager.GetLoadedObject(OBJECT_TYPE_TERRAIN_SURFACE, _surfaceStyle));
objManager.GetLoadedObject(ObjectType::TerrainSurface, _surfaceStyle));
if (surfaceObject != nullptr)
{
surfaceCost += surfaceObject->Price;

2
src/openrct2/drawing/Drawing.cpp
View File

@ -627,7 +627,7 @@ void load_palette()
return;
}
auto water_type = static_cast<rct_water_type*>(object_entry_get_chunk(OBJECT_TYPE_WATER, 0));
auto water_type = static_cast<rct_water_type*>(object_entry_get_chunk(ObjectType::Water, 0));
uint32_t palette = 0x5FC;

4
src/openrct2/interface/InteractiveConsole.cpp
View File

@ -1074,7 +1074,7 @@ static int32_t cc_load_object(InteractiveConsole& console, const arguments_t& ar
auto groupIndex = object_manager_get_loaded_object_entry_index(loadedObject);
uint8_t objectType = entry->GetType();
if (objectType == OBJECT_TYPE_RIDE)
if (objectType == ObjectType::Ride)
{
// Automatically research the ride so it's supported by the game.
rct_ride_entry* rideEntry;
@ -1096,7 +1096,7 @@ static int32_t cc_load_object(InteractiveConsole& console, const arguments_t& ar
research_reset_current_item();
gSilentResearch = false;
}
else if (objectType == OBJECT_TYPE_SCENERY_GROUP)
else if (objectType == ObjectType::SceneryGroup)
{
research_insert_scenery_group_entry(groupIndex, true);

10
src/openrct2/object/Object.cpp
View File

@ -145,15 +145,15 @@ std::optional<uint8_t> rct_object_entry::GetSceneryType() const
{
switch (GetType())
{
case OBJECT_TYPE_SMALL_SCENERY:
case ObjectType::SmallScenery:
return SCENERY_TYPE_SMALL;
case OBJECT_TYPE_LARGE_SCENERY:
case ObjectType::LargeScenery:
return SCENERY_TYPE_LARGE;
case OBJECT_TYPE_WALLS:
case ObjectType::Walls:
return SCENERY_TYPE_WALL;
case OBJECT_TYPE_BANNERS:
case ObjectType::Banners:
return SCENERY_TYPE_BANNER;
case OBJECT_TYPE_PATH_BITS:
case ObjectType::PathBits:
return SCENERY_TYPE_PATH_ITEM;
default:
return std::nullopt;

34
src/openrct2/object/Object.h
View File

@ -23,25 +23,25 @@ using ObjectEntryIndex = uint16_t;
constexpr const ObjectEntryIndex OBJECT_ENTRY_INDEX_NULL = std::numeric_limits<ObjectEntryIndex>::max();
// First 0xF of rct_object_entry->flags
enum OBJECT_TYPE
enum ObjectType : uint8_t
{
OBJECT_TYPE_RIDE,
OBJECT_TYPE_SMALL_SCENERY,
OBJECT_TYPE_LARGE_SCENERY,
OBJECT_TYPE_WALLS,
OBJECT_TYPE_BANNERS,
OBJECT_TYPE_PATHS,
OBJECT_TYPE_PATH_BITS,
OBJECT_TYPE_SCENERY_GROUP,
OBJECT_TYPE_PARK_ENTRANCE,
OBJECT_TYPE_WATER,
OBJECT_TYPE_SCENARIO_TEXT,
OBJECT_TYPE_TERRAIN_SURFACE,
OBJECT_TYPE_TERRAIN_EDGE,
OBJECT_TYPE_STATION,
OBJECT_TYPE_MUSIC,
Ride,
SmallScenery,
LargeScenery,
Walls,
Banners,
Paths,
PathBits,
SceneryGroup,
ParkEntrance,
Water,
ScenarioText,
TerrainSurface,
TerrainEdge,
Station,
Music,
OBJECT_TYPE_COUNT
Count
};
enum OBJECT_SELECTION_FLAGS

56
src/openrct2/object/ObjectFactory.cpp
View File

@ -212,7 +212,7 @@ namespace ObjectFactory
rct_object_entry entry = fs.ReadValue<rct_object_entry>();
if (entry.GetType() != OBJECT_TYPE_SCENARIO_TEXT)
if (entry.GetType() != ObjectType::ScenarioText)
{
result = CreateObject(entry);
@ -273,45 +273,45 @@ namespace ObjectFactory
std::unique_ptr<Object> result;
switch (entry.GetType())
{
case OBJECT_TYPE_RIDE:
case ObjectType::Ride:
result = std::make_unique<RideObject>(entry);
break;
case OBJECT_TYPE_SMALL_SCENERY:
case ObjectType::SmallScenery:
result = std::make_unique<SmallSceneryObject>(entry);
break;
case OBJECT_TYPE_LARGE_SCENERY:
case ObjectType::LargeScenery:
result = std::make_unique<LargeSceneryObject>(entry);
break;
case OBJECT_TYPE_WALLS:
case ObjectType::Walls:
result = std::make_unique<WallObject>(entry);
break;
case OBJECT_TYPE_BANNERS:
case ObjectType::Banners:
result = std::make_unique<BannerObject>(entry);
break;
case OBJECT_TYPE_PATHS:
case ObjectType::Paths:
result = std::make_unique<FootpathObject>(entry);
break;
case OBJECT_TYPE_PATH_BITS:
case ObjectType::PathBits:
result = std::make_unique<FootpathItemObject>(entry);
break;
case OBJECT_TYPE_SCENERY_GROUP:
case ObjectType::SceneryGroup:
result = std::make_unique<SceneryGroupObject>(entry);
break;
case OBJECT_TYPE_PARK_ENTRANCE:
case ObjectType::ParkEntrance:
result = std::make_unique<EntranceObject>(entry);
break;
case OBJECT_TYPE_WATER:
case ObjectType::Water:
result = std::make_unique<WaterObject>(entry);
break;
case OBJECT_TYPE_SCENARIO_TEXT:
case ObjectType::ScenarioText:
break;
case OBJECT_TYPE_TERRAIN_SURFACE:
case ObjectType::TerrainSurface:
result = std::make_unique<TerrainSurfaceObject>(entry);
break;
case OBJECT_TYPE_TERRAIN_EDGE:
case ObjectType::TerrainEdge:
result = std::make_unique<TerrainEdgeObject>(entry);
break;
case OBJECT_TYPE_STATION:
case ObjectType::Station:
result = std::make_unique<StationObject>(entry);
break;
default:
@ -323,31 +323,31 @@ namespace ObjectFactory
static uint8_t ParseObjectType(const std::string& s)
{
if (s == "ride")
return OBJECT_TYPE_RIDE;
return ObjectType::Ride;
if (s == "footpath")
return OBJECT_TYPE_PATHS;
return ObjectType::Paths;
if (s == "footpath_banner")
return OBJECT_TYPE_BANNERS;
return ObjectType::Banners;
if (s == "footpath_item")
return OBJECT_TYPE_PATH_BITS;
return ObjectType::PathBits;
if (s == "scenery_small")
return OBJECT_TYPE_SMALL_SCENERY;
return ObjectType::SmallScenery;
if (s == "scenery_large")
return OBJECT_TYPE_LARGE_SCENERY;
return ObjectType::LargeScenery;
if (s == "scenery_wall")
return OBJECT_TYPE_WALLS;
return ObjectType::Walls;
if (s == "scenery_group")
return OBJECT_TYPE_SCENERY_GROUP;
return ObjectType::SceneryGroup;
if (s == "park_entrance")
return OBJECT_TYPE_PARK_ENTRANCE;
return ObjectType::ParkEntrance;
if (s == "water")
return OBJECT_TYPE_WATER;
return ObjectType::Water;
if (s == "terrain_surface")
return OBJECT_TYPE_TERRAIN_SURFACE;
return ObjectType::TerrainSurface;
if (s == "terrain_edge")
return OBJECT_TYPE_TERRAIN_EDGE;
return ObjectType::TerrainEdge;
if (s == "station")
return OBJECT_TYPE_STATION;
return ObjectType::Station;
return 0xFF;
}

4
src/openrct2/object/ObjectList.cpp
View File

@ -87,7 +87,7 @@ void object_create_identifier_name(char* string_buffer, size_t size, const rct_o
bool find_object_in_entry_group(const rct_object_entry* entry, uint8_t* entry_type, ObjectEntryIndex* entryIndex)
{
int32_t objectType = entry->GetType();
if (objectType >= OBJECT_TYPE_COUNT)
if (objectType >= ObjectType::Count)
{
return false;
}
@ -113,7 +113,7 @@ bool find_object_in_entry_group(const rct_object_entry* entry, uint8_t* entry_ty
void get_type_entry_index(size_t index, uint8_t* outObjectType, ObjectEntryIndex* outEntryIndex)
{
uint8_t objectType = OBJECT_TYPE_RIDE;
uint8_t objectType = ObjectType::Ride;
for (size_t groupCount : object_entry_group_counts)
{
if (index >= groupCount)

20
src/openrct2/object/ObjectManager.cpp
View File

@ -426,27 +426,27 @@ private:
rct_scenery_entry* sceneryEntry;
switch (loadedObject->GetObjectType())
{
case OBJECT_TYPE_SMALL_SCENERY:
case ObjectType::SmallScenery:
sceneryEntry = static_cast<rct_scenery_entry*>(loadedObject->GetLegacyData());
sceneryEntry->small_scenery.scenery_tab_id = GetPrimarySceneryGroupEntryIndex(loadedObject.get());
break;
case OBJECT_TYPE_LARGE_SCENERY:
case ObjectType::LargeScenery:
sceneryEntry = static_cast<rct_scenery_entry*>(loadedObject->GetLegacyData());
sceneryEntry->large_scenery.scenery_tab_id = GetPrimarySceneryGroupEntryIndex(loadedObject.get());
break;
case OBJECT_TYPE_WALLS:
case ObjectType::Walls:
sceneryEntry = static_cast<rct_scenery_entry*>(loadedObject->GetLegacyData());
sceneryEntry->wall.scenery_tab_id = GetPrimarySceneryGroupEntryIndex(loadedObject.get());
break;
case OBJECT_TYPE_BANNERS:
case ObjectType::Banners:
sceneryEntry = static_cast<rct_scenery_entry*>(loadedObject->GetLegacyData());
sceneryEntry->banner.scenery_tab_id = GetPrimarySceneryGroupEntryIndex(loadedObject.get());
break;
case OBJECT_TYPE_PATH_BITS:
case ObjectType::PathBits:
sceneryEntry = static_cast<rct_scenery_entry*>(loadedObject->GetLegacyData());
sceneryEntry->path_bit.scenery_tab_id = GetPrimarySceneryGroupEntryIndex(loadedObject.get());
break;
case OBJECT_TYPE_SCENERY_GROUP:
case ObjectType::SceneryGroup:
auto sgObject = dynamic_cast<SceneryGroupObject*>(loadedObject.get());
sgObject->UpdateEntryIndexes();
break;
@ -499,7 +499,7 @@ private:
ori = _objectRepository.FindObject(&entry);
if (ori == nullptr)
{
if (entry.GetType() != OBJECT_TYPE_SCENARIO_TEXT)
if (entry.GetType() != ObjectType::ScenarioText)
{
invalidEntries.push_back(entry);
ReportMissingObject(&entry);
@ -539,7 +539,7 @@ private:
if (!object_entry_is_empty(entry))
{
ori = _objectRepository.FindObject(entry);
if (ori == nullptr && entry->GetType() != OBJECT_TYPE_SCENARIO_TEXT)
if (ori == nullptr && entry->GetType() != ObjectType::ScenarioText)
{
missingObjects.push_back(*entry);
ReportMissingObject(entry);
@ -684,10 +684,10 @@ private:
}
// Build object lists
auto maxRideObjects = static_cast<size_t>(object_entry_group_counts[OBJECT_TYPE_RIDE]);
auto maxRideObjects = static_cast<size_t>(object_entry_group_counts[ObjectType::Ride]);
for (size_t i = 0; i < maxRideObjects; i++)
{
auto rideObject = static_cast<RideObject*>(GetLoadedObject(OBJECT_TYPE_RIDE, i));
auto rideObject = static_cast<RideObject*>(GetLoadedObject(ObjectType::Ride, i));
if (rideObject != nullptr)
{
const auto entry = static_cast<rct_ride_entry*>(rideObject->GetLegacyData());

10
src/openrct2/object/ObjectRepository.cpp
View File

@ -148,7 +148,7 @@ protected:
switch (item.ObjectEntry.GetType())
{
case OBJECT_TYPE_RIDE:
case ObjectType::Ride:
stream->WriteValue<uint8_t>(item.RideInfo.RideFlags);
for (int32_t i = 0; i < MAX_CATEGORIES_PER_RIDE; i++)
{
@ -159,7 +159,7 @@ protected:
stream->WriteValue<uint8_t>(item.RideInfo.RideType[i]);
}
break;
case OBJECT_TYPE_SCENERY_GROUP:
case ObjectType::SceneryGroup:
stream->WriteValue<uint16_t>(static_cast<uint16_t>(item.SceneryGroupInfo.Entries.size()));
for (const auto& entry : item.SceneryGroupInfo.Entries)
{
@ -194,7 +194,7 @@ protected:
switch (item.ObjectEntry.GetType())
{
case OBJECT_TYPE_RIDE:
case ObjectType::Ride:
item.RideInfo.RideFlags = stream->ReadValue<uint8_t>();
for (int32_t i = 0; i < MAX_CATEGORIES_PER_RIDE; i++)
{
@ -205,7 +205,7 @@ protected:
item.RideInfo.RideType[i] = stream->ReadValue<uint8_t>();
}
break;
case OBJECT_TYPE_SCENERY_GROUP:
case ObjectType::SceneryGroup:
{
auto numEntries = stream->ReadValue<uint16_t>();
item.SceneryGroupInfo.Entries = std::vector<rct_object_entry>(numEntries);
@ -689,7 +689,7 @@ bool IsObjectCustom(const ObjectRepositoryItem* object)
// Do not count our new object types as custom yet, otherwise the game
// will try to pack them into saved games.
auto type = object->ObjectEntry.GetType();
if (type > OBJECT_TYPE_SCENARIO_TEXT)
if (type > ObjectType::ScenarioText)
{
return false;
}

4
src/openrct2/paint/tile_element/Paint.Entrance.cpp
View File

@ -252,7 +252,7 @@ static void park_entrance_paint(paint_session* session, uint8_t direction, int32
PaintAddImageAsParent(session, image_id, 0, 0, 32, 0x1C, 0, height, 0, 2, height);
}
entrance = static_cast<rct_entrance_type*>(object_entry_get_chunk(OBJECT_TYPE_PARK_ENTRANCE, 0));
entrance = static_cast<rct_entrance_type*>(object_entry_get_chunk(ObjectType::ParkEntrance, 0));
if (entrance == nullptr)
{
return;
@ -307,7 +307,7 @@ static void park_entrance_paint(paint_session* session, uint8_t direction, int32
break;
case 1:
case 2:
entrance = static_cast<rct_entrance_type*>(object_entry_get_chunk(OBJECT_TYPE_PARK_ENTRANCE, 0));
entrance = static_cast<rct_entrance_type*>(object_entry_get_chunk(ObjectType::ParkEntrance, 0));
if (entrance == nullptr)
{
return;

6
src/openrct2/paint/tile_element/Paint.Surface.cpp
View File

@ -295,7 +295,7 @@ static const TerrainSurfaceObject* get_surface_object(size_t index)
{
TerrainSurfaceObject* result{};
auto& objMgr = OpenRCT2::GetContext()->GetObjectManager();
auto obj = objMgr.GetLoadedObject(OBJECT_TYPE_TERRAIN_SURFACE, index);
auto obj = objMgr.GetLoadedObject(ObjectType::TerrainSurface, index);
if (obj != nullptr)
{
return static_cast<TerrainSurfaceObject*>(obj);
@ -360,7 +360,7 @@ static uint32_t get_edge_image_with_offset(uint8_t index, uint32_t offset)
{
uint32_t result = 0;
auto& objMgr = OpenRCT2::GetContext()->GetObjectManager();
auto obj = objMgr.GetLoadedObject(OBJECT_TYPE_TERRAIN_EDGE, index);
auto obj = objMgr.GetLoadedObject(ObjectType::TerrainEdge, index);
if (obj != nullptr)
{
auto tobj = static_cast<TerrainEdgeObject*>(obj);
@ -393,7 +393,7 @@ static uint32_t get_tunnel_image(ObjectEntryIndex index, uint8_t type)
bool hasDoors = false;
auto& objMgr = OpenRCT2::GetContext()->GetObjectManager();
auto obj = objMgr.GetLoadedObject(OBJECT_TYPE_TERRAIN_EDGE, index);
auto obj = objMgr.GetLoadedObject(ObjectType::TerrainEdge, index);
if (obj != nullptr)
{
auto tobj = static_cast<TerrainEdgeObject*>(obj);

70
src/openrct2/rct1/S4Importer.cpp
View File

@ -532,11 +532,11 @@ private:
uint8_t objectType = foundObject->ObjectEntry.GetType();
switch (objectType)
{
case OBJECT_TYPE_SMALL_SCENERY:
case OBJECT_TYPE_LARGE_SCENERY:
case OBJECT_TYPE_WALLS:
case OBJECT_TYPE_PATHS:
case OBJECT_TYPE_PATH_BITS:
case ObjectType::SmallScenery:
case ObjectType::LargeScenery:
case ObjectType::Walls:
case ObjectType::Paths:
case ObjectType::PathBits:
EntryList* entries = GetEntryList(objectType);
// Check if there are spare entries available
@ -1868,15 +1868,15 @@ private:
auto& objectManager = OpenRCT2::GetContext()->GetObjectManager();
objectManager.LoadDefaultObjects();
LoadObjects(OBJECT_TYPE_RIDE, _rideEntries);
LoadObjects(OBJECT_TYPE_SMALL_SCENERY, _smallSceneryEntries);
LoadObjects(OBJECT_TYPE_LARGE_SCENERY, _largeSceneryEntries);
LoadObjects(OBJECT_TYPE_WALLS, _wallEntries);
LoadObjects(OBJECT_TYPE_PATHS, _pathEntries);
LoadObjects(OBJECT_TYPE_PATH_BITS, _pathAdditionEntries);
LoadObjects(OBJECT_TYPE_SCENERY_GROUP, _sceneryGroupEntries);
LoadObjects(ObjectType::Ride, _rideEntries);
LoadObjects(ObjectType::SmallScenery, _smallSceneryEntries);
LoadObjects(ObjectType::LargeScenery, _largeSceneryEntries);
LoadObjects(ObjectType::Walls, _wallEntries);
LoadObjects(ObjectType::Paths, _pathEntries);
LoadObjects(ObjectType::PathBits, _pathAdditionEntries);
LoadObjects(ObjectType::SceneryGroup, _sceneryGroupEntries);
LoadObjects(
OBJECT_TYPE_BANNERS,
ObjectType::Banners,
std::vector<const char*>({
"BN1 ",
"BN2 ",
@ -1888,8 +1888,8 @@ private:
"BN8 ",
"BN9 ",
}));
LoadObjects(OBJECT_TYPE_PARK_ENTRANCE, std::vector<const char*>({ "PKENT1 " }));
LoadObjects(OBJECT_TYPE_WATER, _waterEntry);
LoadObjects(ObjectType::ParkEntrance, std::vector<const char*>({ "PKENT1 " }));
LoadObjects(ObjectType::Water, _waterEntry);
}
void LoadObjects(uint8_t objectType, const EntryList& entries)
@ -1910,7 +1910,7 @@ private:
entry.checksum = 0;
Object* object = objectManager.LoadObject(&entry);
if (object == nullptr && objectType != OBJECT_TYPE_SCENERY_GROUP)
if (object == nullptr && objectType != ObjectType::SceneryGroup)
{
log_error("Failed to load %s.", objectName);
throw std::runtime_error("Failed to load object.");
@ -1940,15 +1940,15 @@ private:
std::vector<rct_object_entry> GetRequiredObjects()
{
std::vector<rct_object_entry> result;
AppendRequiredObjects(result, OBJECT_TYPE_RIDE, _rideEntries);
AppendRequiredObjects(result, OBJECT_TYPE_SMALL_SCENERY, _smallSceneryEntries);
AppendRequiredObjects(result, OBJECT_TYPE_LARGE_SCENERY, _largeSceneryEntries);
AppendRequiredObjects(result, OBJECT_TYPE_WALLS, _wallEntries);
AppendRequiredObjects(result, OBJECT_TYPE_PATHS, _pathEntries);
AppendRequiredObjects(result, OBJECT_TYPE_PATH_BITS, _pathAdditionEntries);
AppendRequiredObjects(result, OBJECT_TYPE_SCENERY_GROUP, _sceneryGroupEntries);
AppendRequiredObjects(result, ObjectType::Ride, _rideEntries);
AppendRequiredObjects(result, ObjectType::SmallScenery, _smallSceneryEntries);
AppendRequiredObjects(result, ObjectType::LargeScenery, _largeSceneryEntries);
AppendRequiredObjects(result, ObjectType::Walls, _wallEntries);
AppendRequiredObjects(result, ObjectType::Paths, _pathEntries);
AppendRequiredObjects(result, ObjectType::PathBits, _pathAdditionEntries);
AppendRequiredObjects(result, ObjectType::SceneryGroup, _sceneryGroupEntries);
AppendRequiredObjects(
result, OBJECT_TYPE_BANNERS,
result, ObjectType::Banners,
std::vector<const char*>({
"BN1 ",
"BN2 ",
@ -1960,8 +1960,8 @@ private:
"BN8 ",
"BN9 ",
}));
AppendRequiredObjects(result, OBJECT_TYPE_PARK_ENTRANCE, std::vector<const char*>({ "PKENT1 " }));
AppendRequiredObjects(result, OBJECT_TYPE_WATER, _waterEntry);
AppendRequiredObjects(result, ObjectType::ParkEntrance, std::vector<const char*>({ "PKENT1 " }));
AppendRequiredObjects(result, ObjectType::Water, _waterEntry);
return result;
}
@ -1985,7 +1985,7 @@ private:
else
{
auto object = objectRepository.LoadObject(ori);
if (object == nullptr && objectType != OBJECT_TYPE_SCENERY_GROUP)
if (object == nullptr && objectType != ObjectType::SceneryGroup)
{
missingObjects.push_back(entry);
Console::Error::WriteLine("[%s] Object could not be loaded.", objectName);
@ -2958,21 +2958,21 @@ private:
{
switch (objectType)
{
case OBJECT_TYPE_RIDE:
case ObjectType::Ride:
return &_rideEntries;
case OBJECT_TYPE_SMALL_SCENERY:
case ObjectType::SmallScenery:
return &_smallSceneryEntries;
case OBJECT_TYPE_LARGE_SCENERY:
case ObjectType::LargeScenery:
return &_largeSceneryEntries;
case OBJECT_TYPE_WALLS:
case ObjectType::Walls:
return &_wallEntries;
case OBJECT_TYPE_PATHS:
case ObjectType::Paths:
return &_pathEntries;
case OBJECT_TYPE_PATH_BITS:
case ObjectType::PathBits:
return &_pathAdditionEntries;
case OBJECT_TYPE_SCENERY_GROUP:
case ObjectType::SceneryGroup:
return &_sceneryGroupEntries;
case OBJECT_TYPE_WATER:
case ObjectType::Water:
return &_waterEntry;
}
return nullptr;

4
src/openrct2/rct2/S6Importer.cpp
View File

@ -772,7 +772,7 @@ public:
// This stall was not colourable in RCT2.
if (dst->type == RIDE_TYPE_FOOD_STALL)
{
auto entry = object_entry_get_entry(OBJECT_TYPE_RIDE, dst->subtype);
auto entry = object_entry_get_entry(ObjectType::Ride, dst->subtype);
if (entry != nullptr)
{
char name[DAT_NAME_LENGTH + 1];
@ -1679,7 +1679,7 @@ public:
std::memset(&nullEntry, 0xFF, sizeof(nullEntry));
int objectIt = 0;
for (int16_t objectType = OBJECT_TYPE_RIDE; objectType <= OBJECT_TYPE_WATER; objectType++)
for (int16_t objectType = ObjectType::Ride; objectType <= ObjectType::Water; objectType++)
{
for (int16_t i = 0; i < rct2_object_entry_group_counts[objectType]; i++, objectIt++)
{

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

@ -216,7 +216,7 @@ rct_ride_entry* get_ride_entry(ObjectEntryIndex index)
rct_ride_entry* result = nullptr;
auto& objMgr = OpenRCT2::GetContext()->GetObjectManager();
auto obj = objMgr.GetLoadedObject(OBJECT_TYPE_RIDE, index);
auto obj = objMgr.GetLoadedObject(ObjectType::Ride, index);
if (obj != nullptr)
{
result = static_cast<rct_ride_entry*>(obj->GetLegacyData());
@ -227,13 +227,13 @@ rct_ride_entry* get_ride_entry(ObjectEntryIndex index)
std::string_view get_ride_entry_name(ObjectEntryIndex index)
{
if (index >= object_entry_group_counts[OBJECT_TYPE_RIDE])
if (index >= object_entry_group_counts[ObjectType::Ride])
{
log_error("invalid index %d for ride type", index);
return {};
}
auto objectEntry = object_entry_get_entry(OBJECT_TYPE_RIDE, index);
auto objectEntry = object_entry_get_entry(ObjectType::Ride, index);
if (objectEntry != nullptr)
{
return objectEntry->GetName();
@ -7410,7 +7410,7 @@ int32_t ride_get_entry_index(int32_t rideType, int32_t rideSubType)
StationObject* ride_get_station_object(const Ride* ride)
{
auto& objManager = GetContext()->GetObjectManager();
return static_cast<StationObject*>(objManager.GetLoadedObject(OBJECT_TYPE_STATION, ride->entrance_style));
return static_cast<StationObject*>(objManager.GetLoadedObject(ObjectType::Station, ride->entrance_style));
}
// Normally, a station has at most one entrance and one exit, which are at the same height

38
src/openrct2/ride/TrackDesign.cpp
View File

@ -103,7 +103,7 @@ static void track_design_preview_clear_map();
rct_string_id TrackDesign::CreateTrackDesign(const Ride& ride)
{
type = ride.type;
auto object = object_entry_get_entry(OBJECT_TYPE_RIDE, ride.subtype);
auto object = object_entry_get_entry(ObjectType::Ride, ride.subtype);
// Note we are only copying rct_object_entry in size and
// not the extended as we don't need the chunk size.
@ -499,7 +499,7 @@ rct_string_id TrackDesign::CreateTrackDesignScenery()
{
switch (scenery.scenery_object.GetType())
{
case OBJECT_TYPE_PATHS:
case ObjectType::Paths:
{
uint8_t slope = (scenery.flags & 0x60) >> 5;
slope -= _saveDirection;
@ -516,7 +516,7 @@ rct_string_id TrackDesign::CreateTrackDesignScenery()
scenery.flags |= (direction & 0xF) | (direction >> 4);
break;
}
case OBJECT_TYPE_WALLS:
case ObjectType::Walls:
{
uint8_t direction = scenery.flags & 3;
direction -= _saveDirection;
@ -672,7 +672,7 @@ static void track_design_mirror_scenery(TrackDesign* td6)
if (!find_object_in_entry_group(&scenery.scenery_object, &entry_type, &entryIndex))
{
entry_type = scenery.scenery_object.GetType();
if (entry_type != OBJECT_TYPE_PATHS)
if (entry_type != ObjectType::Paths)
{
continue;
}
@ -683,7 +683,7 @@ static void track_design_mirror_scenery(TrackDesign* td6)
rct_scenery_entry* scenery_entry = static_cast<rct_scenery_entry*>(object_entry_get_chunk(entry_type, entryIndex));
switch (entry_type)
{
case OBJECT_TYPE_LARGE_SCENERY:
case ObjectType::LargeScenery:
{
int16_t x1 = 0, x2 = 0, y1 = 0, y2 = 0;
for (rct_large_scenery_tile* tile = scenery_entry->large_scenery.tiles; tile->x_offset != -1; tile++)
@ -727,7 +727,7 @@ static void track_design_mirror_scenery(TrackDesign* td6)
}
break;
}
case OBJECT_TYPE_SMALL_SCENERY:
case ObjectType::SmallScenery:
scenery.y = -scenery.y;
if (scenery_small_entry_has_flag(scenery_entry, SMALL_SCENERY_FLAG_DIAGONAL))
@ -747,7 +747,7 @@ static void track_design_mirror_scenery(TrackDesign* td6)
scenery.flags ^= (1 << 2);
break;
case OBJECT_TYPE_WALLS:
case ObjectType::Walls:
scenery.y = -scenery.y;
if (scenery.flags & (1 << 0))
{
@ -755,7 +755,7 @@ static void track_design_mirror_scenery(TrackDesign* td6)
}
break;
case OBJECT_TYPE_PATHS:
case ObjectType::Paths:
scenery.y = -scenery.y;
if (scenery.flags & (1 << 5))
@ -867,7 +867,7 @@ static bool TrackDesignPlaceSceneryElementGetEntry(
if (!find_object_in_entry_group(&scenery.scenery_object, &entry_type, &entry_index))
{
entry_type = scenery.scenery_object.GetType();
if (entry_type != OBJECT_TYPE_PATHS)
if (entry_type != ObjectType::Paths)
{
_trackDesignPlaceStateSceneryUnavailable = true;
return true;
@ -880,7 +880,7 @@ static bool TrackDesignPlaceSceneryElementGetEntry(
}
entry_index = 0;
for (PathSurfaceEntry* path = get_path_surface_entry(0); entry_index < object_entry_group_counts[OBJECT_TYPE_PATHS];
for (PathSurfaceEntry* path = get_path_surface_entry(0); entry_index < object_entry_group_counts[ObjectType::Paths];
path = get_path_surface_entry(entry_index), entry_index++)
{
if (path == nullptr)
@ -893,7 +893,7 @@ static bool TrackDesignPlaceSceneryElementGetEntry(
}
}
if (entry_index == object_entry_group_counts[OBJECT_TYPE_PATHS])
if (entry_index == object_entry_group_counts[ObjectType::Paths])
{
_trackDesignPlaceStateSceneryUnavailable = true;
return true;
@ -924,7 +924,7 @@ static bool TrackDesignPlaceSceneryElementRemoveGhost(
std::unique_ptr<GameAction> ga;
switch (entry_type)
{
case OBJECT_TYPE_SMALL_SCENERY:
case ObjectType::SmallScenery:
{
uint8_t quadrant = (scenery.flags >> 2) + _currentTrackPieceDirection;
quadrant &= 3;
@ -942,13 +942,13 @@ static bool TrackDesignPlaceSceneryElementRemoveGhost(
ga = std::make_unique<SmallSceneryRemoveAction>(CoordsXYZ{ mapCoord.x, mapCoord.y, z }, quadrant, entry_index);
break;
}
case OBJECT_TYPE_LARGE_SCENERY:
case ObjectType::LargeScenery:
ga = std::make_unique<LargeSceneryRemoveAction>(CoordsXYZD{ mapCoord.x, mapCoord.y, z, sceneryRotation }, 0);
break;
case OBJECT_TYPE_WALLS:
case ObjectType::Walls:
ga = std::make_unique<WallRemoveAction>(CoordsXYZD{ mapCoord.x, mapCoord.y, z, sceneryRotation });
break;
case OBJECT_TYPE_PATHS:
case ObjectType::Paths:
ga = std::make_unique<FootpathRemoveAction>(CoordsXYZ{ mapCoord.x, mapCoord.y, z });
break;
default:
@ -1011,7 +1011,7 @@ static bool TrackDesignPlaceSceneryElement(
switch (entry_type)
{
case OBJECT_TYPE_SMALL_SCENERY:
case ObjectType::SmallScenery:
{
if (mode != 0)
{
@ -1059,7 +1059,7 @@ static bool TrackDesignPlaceSceneryElement(
cost = res->Error == GameActions::Status::Ok ? res->Cost : 0;
break;
}
case OBJECT_TYPE_LARGE_SCENERY:
case ObjectType::LargeScenery:
{
if (mode != 0)
{
@ -1103,7 +1103,7 @@ static bool TrackDesignPlaceSceneryElement(
cost = res->Cost;
break;
}
case OBJECT_TYPE_WALLS:
case ObjectType::Walls:
{
if (mode != 0)
{
@ -1147,7 +1147,7 @@ static bool TrackDesignPlaceSceneryElement(
cost = res->Cost;
break;
}
case OBJECT_TYPE_PATHS:
case ObjectType::Paths:
if (_trackDesignPlaceOperation == PTD_OPERATION_GET_PLACE_Z)
{
return true;

16
src/openrct2/ride/TrackDesignSave.cpp
View File

@ -208,7 +208,7 @@ static void track_design_save_push_tile_element_desc(
static void track_design_save_add_scenery(const CoordsXY& loc, SmallSceneryElement* sceneryElement)
{
int32_t entryType = sceneryElement->GetEntryIndex();
auto entry = object_entry_get_entry(OBJECT_TYPE_SMALL_SCENERY, entryType);
auto entry = object_entry_get_entry(ObjectType::SmallScenery, entryType);
uint8_t flags = 0;
flags |= sceneryElement->GetDirection();
@ -234,7 +234,7 @@ static void track_design_save_add_large_scenery(const CoordsXY& loc, LargeScener
}
int32_t entryType = tileElement->GetEntryIndex();
auto entry = object_entry_get_entry(OBJECT_TYPE_LARGE_SCENERY, entryType);
auto entry = object_entry_get_entry(ObjectType::LargeScenery, entryType);
sceneryTiles = get_large_scenery_entry(entryType)->large_scenery.tiles;
int32_t z = tileElement->base_height;
@ -276,7 +276,7 @@ static void track_design_save_add_large_scenery(const CoordsXY& loc, LargeScener
static void track_design_save_add_wall(const CoordsXY& loc, WallElement* wallElement)
{
int32_t entryType = wallElement->GetEntryIndex();
auto entry = object_entry_get_entry(OBJECT_TYPE_WALLS, entryType);
auto entry = object_entry_get_entry(ObjectType::Walls, entryType);
uint8_t flags = 0;
flags |= wallElement->GetDirection();
@ -293,7 +293,7 @@ static void track_design_save_add_wall(const CoordsXY& loc, WallElement* wallEle
static void track_design_save_add_footpath(const CoordsXY& loc, PathElement* pathElement)
{
int32_t entryType = pathElement->GetSurfaceEntryIndex();
auto entry = object_entry_get_entry(OBJECT_TYPE_PATHS, entryType);
auto entry = object_entry_get_entry(ObjectType::Paths, entryType);
uint8_t flags = 0;
flags |= pathElement->GetEdges();
@ -395,7 +395,7 @@ static void track_design_save_pop_tile_element_desc(const rct_object_entry* entr
static void track_design_save_remove_scenery(const CoordsXY& loc, SmallSceneryElement* sceneryElement)
{
int32_t entryType = sceneryElement->GetEntryIndex();
auto entry = object_entry_get_entry(OBJECT_TYPE_SMALL_SCENERY, entryType);
auto entry = object_entry_get_entry(ObjectType::SmallScenery, entryType);
uint8_t flags = 0;
flags |= sceneryElement->GetDirection();
@ -417,7 +417,7 @@ static void track_design_save_remove_large_scenery(const CoordsXY& loc, LargeSce
}
int32_t entryType = tileElement->GetEntryIndex();
auto entry = object_entry_get_entry(OBJECT_TYPE_LARGE_SCENERY, entryType);
auto entry = object_entry_get_entry(ObjectType::LargeScenery, entryType);
sceneryTiles = get_large_scenery_entry(entryType)->large_scenery.tiles;
int32_t z = tileElement->base_height;
@ -456,7 +456,7 @@ static void track_design_save_remove_large_scenery(const CoordsXY& loc, LargeSce
static void track_design_save_remove_wall(const CoordsXY& loc, WallElement* wallElement)
{
int32_t entryType = wallElement->GetEntryIndex();
auto entry = object_entry_get_entry(OBJECT_TYPE_WALLS, entryType);
auto entry = object_entry_get_entry(ObjectType::Walls, entryType);
uint8_t flags = 0;
flags |= wallElement->GetDirection();
@ -469,7 +469,7 @@ static void track_design_save_remove_wall(const CoordsXY& loc, WallElement* wall
static void track_design_save_remove_footpath(const CoordsXY& loc, PathElement* pathElement)
{
int32_t entryType = pathElement->GetSurfaceEntryIndex();
auto entry = object_entry_get_entry(OBJECT_TYPE_PATHS, entryType);
auto entry = object_entry_get_entry(ObjectType::Paths, entryType);
uint8_t flags = 0;
flags |= pathElement->GetEdges();

2
src/openrct2/scenario/Scenario.cpp
View File

@ -323,7 +323,7 @@ static void scenario_week_update()
ride_check_all_reachable();
ride_update_favourited_stat();
auto water_type = static_cast<rct_water_type*>(object_entry_get_chunk(OBJECT_TYPE_WATER, 0));
auto water_type = static_cast<rct_water_type*>(object_entry_get_chunk(ObjectType::Water, 0));
if (month <= MONTH_APRIL && water_type != nullptr && water_type->flags & WATER_FLAGS_ALLOW_DUCKS)
{

4
src/openrct2/scripting/ScContext.hpp
View File

@ -89,9 +89,9 @@ namespace OpenRCT2::Scripting
{
switch (type)
{
case OBJECT_TYPE_RIDE:
case ObjectType::Ride:
return GetObjectAsDukValue(ctx, std::make_shared<ScRideObject>(type, index));
case OBJECT_TYPE_SMALL_SCENERY:
case ObjectType::SmallScenery:
return GetObjectAsDukValue(ctx, std::make_shared<ScSmallSceneryObject>(type, index));
default:
return GetObjectAsDukValue(ctx, std::make_shared<ScObject>(type, index));

8
src/openrct2/scripting/ScObject.hpp
View File

@ -47,7 +47,7 @@ namespace OpenRCT2::Scripting
static std::optional<uint8_t> StringToObjectType(const std::string_view& type)
{
for (uint8_t i = 0; i < OBJECT_TYPE_COUNT; i++)
for (uint8_t i = 0; i < ObjectType::Count; i++)
{
auto s = ObjectTypeToString(i);
if (s == type)
@ -120,12 +120,12 @@ namespace OpenRCT2::Scripting
class ScRideObjectVehicle
{
private:
OBJECT_TYPE _objectType{};
ObjectType _objectType{};
ObjectEntryIndex _objectIndex{};
size_t _vehicleIndex{};
public:
ScRideObjectVehicle(OBJECT_TYPE objectType, ObjectEntryIndex objectIndex, size_t vehicleIndex)
ScRideObjectVehicle(ObjectType objectType, ObjectEntryIndex objectIndex, size_t vehicleIndex)
: _objectType(objectType)
, _objectIndex(objectIndex)
, _vehicleIndex(vehicleIndex)
@ -836,7 +836,7 @@ namespace OpenRCT2::Scripting
{
for (size_t i = 0; i < std::size(entry->vehicles); i++)
{
result.push_back(std::make_shared<ScRideObjectVehicle>(static_cast<OBJECT_TYPE>(_type), _index, i));
result.push_back(std::make_shared<ScRideObjectVehicle>(static_cast<ObjectType>(_type), _index, i));
}
}
return result;

4
src/openrct2/scripting/ScRide.hpp
View File

@ -196,10 +196,10 @@ namespace OpenRCT2::Scripting
auto ride = GetRide();
if (ride != nullptr)
{
auto rideObject = GetContext()->GetObjectManager().GetLoadedObject(OBJECT_TYPE_RIDE, ride->subtype);
auto rideObject = GetContext()->GetObjectManager().GetLoadedObject(ObjectType::Ride, ride->subtype);
if (rideObject != nullptr)
{
return std::make_shared<ScRideObject>(OBJECT_TYPE_RIDE, ride->subtype);
return std::make_shared<ScRideObject>(ObjectType::Ride, ride->subtype);
}
}
return nullptr;

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

@ -2177,7 +2177,7 @@ PathSurfaceEntry* get_path_surface_entry(PathSurfaceIndex entryIndex)
PathSurfaceEntry* result = nullptr;
auto& objMgr = OpenRCT2::GetContext()->GetObjectManager();
// TODO: Change when moving to the new save format.
auto obj = objMgr.GetLoadedObject(OBJECT_TYPE_PATHS, entryIndex % MAX_PATH_OBJECTS);
auto obj = objMgr.GetLoadedObject(ObjectType::Paths, entryIndex % MAX_PATH_OBJECTS);
if (obj != nullptr)
{
if (entryIndex < MAX_PATH_OBJECTS)
@ -2192,7 +2192,7 @@ PathRailingsEntry* get_path_railings_entry(PathRailingsIndex entryIndex)
{
PathRailingsEntry* result = nullptr;
auto& objMgr = OpenRCT2::GetContext()->GetObjectManager();
auto obj = objMgr.GetLoadedObject(OBJECT_TYPE_PATHS, entryIndex);
auto obj = objMgr.GetLoadedObject(ObjectType::Paths, entryIndex);
if (obj != nullptr)
{
result = (static_cast<FootpathObject*>(obj))->GetPathRailingsEntry();

2
src/openrct2/world/LargeScenery.cpp
View File

@ -98,7 +98,7 @@ rct_scenery_entry* get_large_scenery_entry(ObjectEntryIndex entryIndex)
{
rct_scenery_entry* result = nullptr;
auto& objMgr = OpenRCT2::GetContext()->GetObjectManager();
auto obj = objMgr.GetLoadedObject(OBJECT_TYPE_LARGE_SCENERY, entryIndex);
auto obj = objMgr.GetLoadedObject(ObjectType::LargeScenery, entryIndex);
if (obj != nullptr)
{
result = static_cast<rct_scenery_entry*>(obj->GetLegacyData());

4
src/openrct2/world/MapGen.cpp
View File

@ -260,10 +260,10 @@ static void mapgen_place_trees()
std::vector<int32_t> desertTreeIds(std::size(DesertTrees), 0);
std::vector<int32_t> snowTreeIds(std::size(SnowTrees), 0);
for (int32_t i = 0; i < object_entry_group_counts[OBJECT_TYPE_SMALL_SCENERY]; i++)
for (int32_t i = 0; i < object_entry_group_counts[ObjectType::SmallScenery]; i++)
{
auto sceneryEntry = get_small_scenery_entry(i);
auto entry = object_entry_get_entry(OBJECT_TYPE_SMALL_SCENERY, i);
auto entry = object_entry_get_entry(ObjectType::SmallScenery, i);
if (sceneryEntry == nullptr)
continue;

8
src/openrct2/world/Scenery.cpp
View File

@ -233,7 +233,7 @@ rct_scenery_entry* get_wall_entry(ObjectEntryIndex entryIndex)
{
rct_scenery_entry* result = nullptr;
auto& objMgr = OpenRCT2::GetContext()->GetObjectManager();
auto obj = objMgr.GetLoadedObject(OBJECT_TYPE_WALLS, entryIndex);
auto obj = objMgr.GetLoadedObject(ObjectType::Walls, entryIndex);
if (obj != nullptr)
{
result = static_cast<rct_scenery_entry*>(obj->GetLegacyData());
@ -245,7 +245,7 @@ rct_scenery_entry* get_banner_entry(ObjectEntryIndex entryIndex)
{
rct_scenery_entry* result = nullptr;
auto& objMgr = OpenRCT2::GetContext()->GetObjectManager();
auto obj = objMgr.GetLoadedObject(OBJECT_TYPE_BANNERS, entryIndex);
auto obj = objMgr.GetLoadedObject(ObjectType::Banners, entryIndex);
if (obj != nullptr)
{
result = static_cast<rct_scenery_entry*>(obj->GetLegacyData());
@ -257,7 +257,7 @@ rct_scenery_entry* get_footpath_item_entry(ObjectEntryIndex entryIndex)
{
rct_scenery_entry* result = nullptr;
auto& objMgr = OpenRCT2::GetContext()->GetObjectManager();
auto obj = objMgr.GetLoadedObject(OBJECT_TYPE_PATH_BITS, entryIndex);
auto obj = objMgr.GetLoadedObject(ObjectType::PathBits, entryIndex);
if (obj != nullptr)
{
result = static_cast<rct_scenery_entry*>(obj->GetLegacyData());
@ -269,7 +269,7 @@ rct_scenery_group_entry* get_scenery_group_entry(ObjectEntryIndex entryIndex)
{
rct_scenery_group_entry* result = nullptr;
auto& objMgr = OpenRCT2::GetContext()->GetObjectManager();
auto obj = objMgr.GetLoadedObject(OBJECT_TYPE_SCENERY_GROUP, entryIndex);
auto obj = objMgr.GetLoadedObject(ObjectType::SceneryGroup, entryIndex);
if (obj != nullptr)
{
result = static_cast<rct_scenery_group_entry*>(obj->GetLegacyData());

2
src/openrct2/world/SmallScenery.cpp
View File

@ -177,7 +177,7 @@ rct_scenery_entry* get_small_scenery_entry(ObjectEntryIndex entryIndex)
{
rct_scenery_entry* result = nullptr;
auto& objMgr = OpenRCT2::GetContext()->GetObjectManager();
auto obj = objMgr.GetLoadedObject(OBJECT_TYPE_SMALL_SCENERY, entryIndex);
auto obj = objMgr.GetLoadedObject(ObjectType::SmallScenery, entryIndex);
if (obj != nullptr)
{
result = static_cast<rct_scenery_entry*>(obj->GetLegacyData());

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

@ -25,7 +25,7 @@ uint32_t SurfaceElement::GetSurfaceStyle() const
TerrainSurfaceObject* SurfaceElement::GetSurfaceStyleObject() const
{
auto& objManager = OpenRCT2::GetContext()->GetObjectManager();
return static_cast<TerrainSurfaceObject*>(objManager.GetLoadedObject(OBJECT_TYPE_TERRAIN_SURFACE, GetSurfaceStyle()));
return static_cast<TerrainSurfaceObject*>(objManager.GetLoadedObject(ObjectType::TerrainSurface, GetSurfaceStyle()));
}
uint32_t SurfaceElement::GetEdgeStyle() const
@ -36,7 +36,7 @@ uint32_t SurfaceElement::GetEdgeStyle() const
TerrainEdgeObject* SurfaceElement::GetEdgeStyleObject() const
{
auto& objManager = OpenRCT2::GetContext()->GetObjectManager();
return static_cast<TerrainEdgeObject*>(objManager.GetLoadedObject(OBJECT_TYPE_TERRAIN_EDGE, GetEdgeStyle()));
return static_cast<TerrainEdgeObject*>(objManager.GetLoadedObject(ObjectType::TerrainEdge, GetEdgeStyle()));
}
void SurfaceElement::SetSurfaceStyle(uint32_t newStyle)
@ -63,7 +63,7 @@ bool SurfaceElement::CanGrassGrow() const
{
auto surfaceStyle = GetSurfaceStyle();
auto& objMgr = OpenRCT2::GetContext()->GetObjectManager();
auto obj = objMgr.GetLoadedObject(OBJECT_TYPE_TERRAIN_SURFACE, surfaceStyle);
auto obj = objMgr.GetLoadedObject(ObjectType::TerrainSurface, surfaceStyle);
if (obj != nullptr)
{
auto surfaceObject = static_cast<TerrainSurfaceObject*>(obj);

2
test/testpaint/Compat.cpp
View File

@ -127,7 +127,7 @@ Ride* get_ride(ride_id_t index)
rct_ride_entry* get_ride_entry(ObjectEntryIndex index)
{
if (index >= object_entry_group_counts[OBJECT_TYPE_RIDE])
if (index >= object_entry_group_counts[ObjectType::OBJECT_TYPE_RIDE])
{
log_error("invalid index %d for ride type", index);
return nullptr;