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

refactor: changed ObjectType enum to strong enum 

code does not compile yet
This commit is contained in:
Łukasz Pękalski 2020-11-09 11:53:29 +01:00
parent 6e5105ab3b
commit 832fd69822
26 changed files with 209 additions and 104 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -176,8 +176,8 @@ static bool window_editor_bottom_toolbar_check_object_selection()
{
rct_window* w;
int32_t missingObjectType = Editor::CheckObjectSelection();
if (missingObjectType < 0)
ObjectType missingObjectType = Editor::CheckObjectSelection();
if (missingObjectType == ObjectType::None)
{
window_close_by_class(WC_EDITOR_OBJECT_SELECTION);
return true;

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

@ -126,12 +126,12 @@ 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 = ObjectType::Ride; objectType < ObjectType::Count; objectType++)
for (uint8_t objectType = EnumValue(ObjectType::Ride); objectType < EnumValue(ObjectType::Count); objectType++)
{
auto maxObjects = object_entry_group_counts[objectType];
for (int32_t i = 0; i < maxObjects; i++)
{
Editor::ClearSelectedObject(objectType, i, OBJECT_SELECTION_FLAG_ALL);
Editor::ClearSelectedObject(static_cast<ObjectType>(objectType), i, OBJECT_SELECTION_FLAG_ALL);
}
}
@ -531,7 +531,7 @@ static void window_editor_inventions_list_paint(rct_window* w, rct_drawpixelinfo
return;
// Preview image
int32_t objectEntryType = ObjectType::SceneryGroup;
ObjectType objectEntryType = ObjectType::SceneryGroup;
if (researchItem->type == Research::EntryType::Ride)
objectEntryType = ObjectType::Ride;

37
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[ObjectType::Count];
static uint16_t _filter_object_counts[EnumValue(ObjectType::Count)];
static char _filter_string[MAX_PATH];
@ -222,7 +222,7 @@ static bool filter_chunks(const ObjectRepositoryItem* item);
static void filter_update_counts();
static std::string object_get_description(const Object* object);
static int32_t get_selected_object_type(rct_window* w);
static ObjectType get_selected_object_type(rct_window* w);
enum
{
@ -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 == ObjectType::Ride)
if (page == EnumValue(ObjectType::Ride))
{
_listSortType = RIDE_SORT_TYPE;
_listSortDescending = false;
@ -1314,7 +1314,7 @@ static void editor_load_selected_objects()
else if (!(gScreenFlags & SCREEN_FLAGS_EDITOR))
{
// Defaults selected items to researched (if in-game)
uint8_t objectType = entry->GetType();
ObjectType objectType = entry->GetType();
auto entryIndex = object_manager_get_loaded_object_entry_index(loadedObject);
if (objectType == ObjectType::Ride)
{
@ -1474,7 +1474,7 @@ static bool filter_chunks(const ObjectRepositoryItem* item)
switch (item->ObjectEntry.GetType())
{
case ObjectType::Ride:
{
uint8_t rideType = 0;
for (int32_t i = 0; i < MAX_RIDE_TYPES_PER_RIDE_ENTRY; i++)
{
@ -1485,6 +1485,25 @@ static bool filter_chunks(const ObjectRepositoryItem* item)
}
}
return (_filter_flags & (1 << (RideTypeDescriptors[rideType].Category + _numSourceGameItems))) != 0;
}
case ObjectType::SmallScenery:
case ObjectType::LargeScenery:
case ObjectType::Walls:
case ObjectType::Banners:
case ObjectType::Paths:
case ObjectType::PathBits:
case ObjectType::SceneryGroup:
case ObjectType::ParkEntrance:
case ObjectType::Water:
case ObjectType::ScenarioText:
case ObjectType::TerrainSurface:
case ObjectType::TerrainEdge:
case ObjectType::Station:
case ObjectType::Music:
case ObjectType::Count:
case ObjectType::None:
//This function works only with ObjectType::Ride.
break;
}
return true;
}
@ -1539,11 +1558,11 @@ static std::string object_get_description(const Object* object)
}
}
static int32_t get_selected_object_type(rct_window* w)
static ObjectType get_selected_object_type(rct_window* w)
{
auto tab = w->selected_tab;
if (tab >= ObjectType::ScenarioText)
return tab + 1;
if (tab >= EnumValue(ObjectType::ScenarioText))
return static_cast<ObjectType>(tab + 1);
else
return tab;
return static_cast<ObjectType>(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[ObjectType::Paths]; i++)
for (int32_t i = 0; i < object_entry_group_counts[EnumValue(ObjectType::Paths)]; i++)
{
PathSurfaceEntry* pathEntry = get_path_surface_entry(i);
if (pathEntry != nullptr)

2
src/openrct2/CmdlineSprite.cpp
View File

@ -468,7 +468,7 @@ int32_t cmdline_for_sprite(const char** argv, int32_t argc)
return -1;
}
auto entryIndex = object_manager_get_loaded_object_entry_index(loadedObject);
uint8_t objectType = entry->GetType();
ObjectType objectType = entry->GetType();
auto& objManager = context->GetObjectManager();
auto metaObject = objManager.GetLoadedObject(objectType, entryIndex);

8
src/openrct2/Editor.cpp
View File

@ -445,7 +445,7 @@ namespace Editor
*
* rct2: 0x006AB9B8
*/
int32_t CheckObjectSelection()
ObjectType CheckObjectSelection()
{
bool isTrackDesignerManager = gScreenFlags & (SCREEN_FLAGS_TRACK_DESIGNER | SCREEN_FLAGS_TRACK_MANAGER);
@ -479,7 +479,7 @@ namespace Editor
}
}
return -1;
return ObjectType::None;
}
/**
@ -541,7 +541,7 @@ namespace Editor
return result;
}
void ClearSelectedObject(int32_t objectType, size_t index, uint32_t flags)
void ClearSelectedObject(ObjectType objectType, size_t index, uint32_t flags)
{
auto& list = _editorSelectedObjectFlags[objectType];
if (list.size() <= index)
@ -551,7 +551,7 @@ namespace Editor
list[index] &= ~flags;
}
void SetSelectedObject(int32_t objectType, size_t index, uint32_t flags)
void SetSelectedObject(ObjectType objectType, size_t index, uint32_t flags)
{
auto& list = _editorSelectedObjectFlags[objectType];
if (list.size() <= index)

8
src/openrct2/Editor.h
View File

@ -12,6 +12,8 @@
#include "common.h"
#include <src/openrct2/object/Object.h>
namespace Editor
{
void Load();
@ -21,13 +23,13 @@ namespace Editor
bool LoadLandscape(const utf8* path);
bool CheckPark();
int32_t CheckObjectSelection();
ObjectType CheckObjectSelection();
void OpenWindowsForCurrentStep();
uint8_t GetSelectedObjectFlags(int32_t objectType, size_t index);
void ClearSelectedObject(int32_t objectType, size_t index, uint32_t flags);
void SetSelectedObject(int32_t objectType, size_t index, uint32_t flags);
void ClearSelectedObject(ObjectType objectType, size_t index, uint32_t flags);
void SetSelectedObject(ObjectType objectType, size_t index, uint32_t flags);
} // namespace Editor
enum RCT2_EDITOR_STEP

52
src/openrct2/EditorObjectSelectionSession.cpp
View File

@ -30,8 +30,8 @@
bool _maxObjectsWasHit;
std::vector<uint8_t> _objectSelectionFlags;
int32_t _numSelectedObjectsForType[ObjectType::Count];
static int32_t _numAvailableObjectsForType[ObjectType::Count];
int32_t _numSelectedObjectsForType[EnumValue(ObjectType::Count)];
static int32_t _numAvailableObjectsForType[EnumValue(ObjectType::Count)];
static void setup_in_use_selection_flags();
static void setup_track_designer_objects();
@ -50,7 +50,7 @@ static void setup_track_manager_objects()
{
uint8_t* selectionFlags = &_objectSelectionFlags[i];
const ObjectRepositoryItem* item = &items[i];
uint8_t object_type = item->ObjectEntry.GetType();
ObjectType object_type = item->ObjectEntry.GetType();
if (object_type == ObjectType::Ride)
{
*selectionFlags |= OBJECT_SELECTION_FLAG_6;
@ -79,7 +79,7 @@ static void setup_track_designer_objects()
{
uint8_t* selectionFlags = &_objectSelectionFlags[i];
const ObjectRepositoryItem* item = &items[i];
uint8_t objectType = item->ObjectEntry.GetType();
ObjectType objectType = item->ObjectEntry.GetType();
if (objectType == ObjectType::Ride)
{
*selectionFlags |= OBJECT_SELECTION_FLAG_6;
@ -107,16 +107,16 @@ void setup_in_use_selection_flags()
{
auto& objectMgr = OpenRCT2::GetContext()->GetObjectManager();
for (uint8_t objectType = 0; objectType < ObjectType::Count; objectType++)
for (uint8_t objectType = 0; objectType < EnumValue(ObjectType::Count); objectType++)
{
for (int32_t i = 0; i < object_entry_group_counts[objectType]; i++)
{
Editor::ClearSelectedObject(objectType, i, OBJECT_SELECTION_FLAG_ALL);
Editor::ClearSelectedObject(static_cast<ObjectType>(objectType), i, OBJECT_SELECTION_FLAG_ALL);
auto loadedObj = objectMgr.GetLoadedObject(objectType, i);
auto loadedObj = objectMgr.GetLoadedObject(static_cast<ObjectType>(objectType), i);
if (loadedObj != nullptr)
{
Editor::SetSelectedObject(objectType, i, OBJECT_SELECTION_FLAG_2);
Editor::SetSelectedObject(static_cast<ObjectType>(objectType), i, OBJECT_SELECTION_FLAG_2);
}
}
}
@ -135,7 +135,7 @@ void setup_in_use_selection_flags()
break;
case TILE_ELEMENT_TYPE_PATH:
type = iter.element->AsPath()->GetSurfaceEntryIndex();
assert(type < object_entry_group_counts[ObjectType::Paths]);
assert(type < object_entry_group_counts[EnumValue(ObjectType::Paths)]);
Editor::SetSelectedObject(ObjectType::Paths, type, OBJECT_SELECTION_FLAG_SELECTED);
if (iter.element->AsPath()->HasAddition())
@ -146,7 +146,7 @@ void setup_in_use_selection_flags()
break;
case TILE_ELEMENT_TYPE_SMALL_SCENERY:
type = iter.element->AsSmallScenery()->GetEntryIndex();
assert(type < object_entry_group_counts[ObjectType::SmallScenery]);
assert(type < object_entry_group_counts[EnumValue(ObjectType::SmallScenery)]);
Editor::SetSelectedObject(ObjectType::SmallScenery, type, OBJECT_SELECTION_FLAG_SELECTED);
break;
case TILE_ELEMENT_TYPE_ENTRANCE:
@ -159,17 +159,17 @@ void setup_in_use_selection_flags()
Editor::SetSelectedObject(ObjectType::ParkEntrance, 0, OBJECT_SELECTION_FLAG_SELECTED);
type = iter.element->AsEntrance()->GetPathType();
assert(type < object_entry_group_counts[ObjectType::Paths]);
assert(type < object_entry_group_counts[EnumValue(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[ObjectType::Walls]);
assert(type < object_entry_group_counts[EnumValue(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[ObjectType::LargeScenery]);
assert(type < object_entry_group_counts[EnumValue(ObjectType::LargeScenery)]);
Editor::SetSelectedObject(ObjectType::LargeScenery, type, OBJECT_SELECTION_FLAG_SELECTED);
break;
case TILE_ELEMENT_TYPE_BANNER:
@ -178,7 +178,7 @@ void setup_in_use_selection_flags()
if (banner != nullptr)
{
type = banner->type;
assert(type < object_entry_group_counts[ObjectType::Banners]);
assert(type < object_entry_group_counts[EnumValue(ObjectType::Banners)]);
Editor::SetSelectedObject(ObjectType::Banners, type, OBJECT_SELECTION_FLAG_SELECTED);
}
break;
@ -204,7 +204,7 @@ void setup_in_use_selection_flags()
const ObjectRepositoryItem* item = &items[i];
*selectionFlags &= ~OBJECT_SELECTION_FLAG_IN_USE;
uint8_t entryType;
ObjectType entryType;
ObjectEntryIndex entryIndex;
if (find_object_in_entry_group(&item->ObjectEntry, &entryType, &entryIndex))
{
@ -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 < ObjectType::Count; objectType++)
for (uint8_t objectType = 0; objectType < EnumValue(ObjectType::Count); objectType++)
{
_numSelectedObjectsForType[objectType] = 0;
_numAvailableObjectsForType[objectType] = 0;
@ -239,7 +239,7 @@ void sub_6AB211()
const ObjectRepositoryItem* items = object_repository_get_items();
for (int32_t i = 0; i < numObjects; i++)
{
uint8_t objectType = items[i].ObjectEntry.GetType();
ObjectType objectType = items[i].ObjectEntry.GetType();
_numAvailableObjectsForType[objectType]++;
}
@ -284,7 +284,7 @@ void editor_object_flags_free()
*/
static void remove_selected_objects_from_research(const rct_object_entry* installedObject)
{
uint8_t entry_type;
ObjectType entry_type;
ObjectEntryIndex entry_index;
if (!find_object_in_entry_group(installedObject, &entry_type, &entry_index))
return;
@ -450,7 +450,7 @@ bool window_editor_object_selection_select_object(uint8_t isMasterObject, int32_
return false;
}
uint8_t objectType = item->ObjectEntry.GetType();
ObjectType objectType = item->ObjectEntry.GetType();
if (objectType == ObjectType::SceneryGroup && (flags & INPUT_FLAG_EDITOR_OBJECT_SELECT_OBJECTS_IN_SCENERY_GROUP))
{
for (const auto& sgEntry : item->SceneryGroupInfo.Entries)
@ -459,7 +459,7 @@ bool window_editor_object_selection_select_object(uint8_t isMasterObject, int32_
}
}
_numSelectedObjectsForType[objectType]--;
_numSelectedObjectsForType[EnumValue(objectType)]--;
*selectionFlags &= ~OBJECT_SELECTION_FLAG_SELECTED;
return true;
}
@ -477,8 +477,8 @@ bool window_editor_object_selection_select_object(uint8_t isMasterObject, int32_
return true;
}
uint8_t objectType = item->ObjectEntry.GetType();
uint16_t maxObjects = object_entry_group_counts[objectType];
ObjectType objectType = item->ObjectEntry.GetType();
uint16_t maxObjects = object_entry_group_counts[EnumValue(objectType)];
if (gScreenFlags & SCREEN_FLAGS_TRACK_DESIGNER)
{
maxObjects = 4;
@ -517,7 +517,7 @@ bool window_editor_object_selection_select_object(uint8_t isMasterObject, int32_
return false;
}
_numSelectedObjectsForType[objectType]++;
_numSelectedObjectsForType[EnumValue(objectType)]++;
*selectionFlags |= OBJECT_SELECTION_FLAG_SELECTED;
return true;
@ -537,14 +537,14 @@ bool window_editor_object_selection_select_object(uint8_t isMasterObject, int32_
return window_editor_object_selection_select_object(isMasterObject, flags, item);
}
bool editor_check_object_group_at_least_one_selected(int32_t checkObjectType)
bool editor_check_object_group_at_least_one_selected(ObjectType checkObjectType)
{
int32_t numObjects = static_cast<int32_t>(object_repository_get_items_count());
const ObjectRepositoryItem* items = object_repository_get_items();
for (int32_t i = 0; i < numObjects; i++)
{
uint8_t objectType = items[i].ObjectEntry.GetType();
ObjectType objectType = items[i].ObjectEntry.GetType();
if (checkObjectType == objectType && (_objectSelectionFlags[i] & OBJECT_SELECTION_FLAG_SELECTED))
{
return true;
@ -570,7 +570,7 @@ int32_t editor_remove_unused_objects()
&& !(_objectSelectionFlags[i] & OBJECT_SELECTION_FLAG_ALWAYS_REQUIRED))
{
const ObjectRepositoryItem* item = &items[i];
uint8_t objectType = item->ObjectEntry.GetType();
ObjectType objectType = item->ObjectEntry.GetType();
if (objectType >= ObjectType::SceneryGroup)
{

5
src/openrct2/EditorObjectSelectionSession.h
View File

@ -11,6 +11,7 @@
#include "common.h"
#include "object/Object.h"
#include "util/Util.h"
#include <vector>
@ -24,9 +25,9 @@ enum EDITOR_INPUT_FLAGS
extern bool _maxObjectsWasHit;
extern std::vector<uint8_t> _objectSelectionFlags;
extern int32_t _numSelectedObjectsForType[ObjectType::Count];
extern int32_t _numSelectedObjectsForType[EnumValue(ObjectType::Count)];
bool editor_check_object_group_at_least_one_selected(int32_t objectType);
bool editor_check_object_group_at_least_one_selected(ObjectType checkObjectType);
void editor_object_flags_free();
void unload_unselected_objects();
void sub_6AB211();

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

@ -1073,7 +1073,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();
ObjectType objectType = entry->GetType();
if (objectType == ObjectType::Ride)
{
// Automatically research the ride so it's supported by the game.

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

@ -23,7 +23,7 @@ using ObjectEntryIndex = uint16_t;
constexpr const ObjectEntryIndex OBJECT_ENTRY_INDEX_NULL = std::numeric_limits<ObjectEntryIndex>::max();
// First 0xF of rct_object_entry->flags
enum ObjectType : uint8_t
enum class ObjectType : uint8_t
{
Ride,
SmallScenery,
@ -41,7 +41,8 @@ enum ObjectType : uint8_t
Station,
Music,
Count
Count,
None=255
};
enum OBJECT_SELECTION_FLAGS
@ -100,9 +101,9 @@ struct rct_object_entry
void SetName(const std::string_view& value);
uint8_t GetType() const
ObjectType GetType() const
{
return flags & 0x0F;
return static_cast<ObjectType>(flags & 0x0F);
}
std::optional<uint8_t> GetSceneryType() const;
@ -264,7 +265,7 @@ public:
{
}
virtual uint8_t GetObjectType() const final
virtual ObjectType GetObjectType() const final
{
return _objectEntry.GetType();
}
@ -304,12 +305,12 @@ extern int32_t object_entry_group_encoding[];
bool object_entry_is_empty(const rct_object_entry* entry);
bool object_entry_compare(const rct_object_entry* a, const rct_object_entry* b);
int32_t object_calculate_checksum(const rct_object_entry* entry, const void* data, size_t dataLength);
bool find_object_in_entry_group(const rct_object_entry* entry, uint8_t* entry_type, ObjectEntryIndex* entryIndex);
bool find_object_in_entry_group(const rct_object_entry* entry, ObjectType* entry_type, ObjectEntryIndex* entryIndex);
void object_create_identifier_name(char* string_buffer, size_t size, const rct_object_entry* object);
const rct_object_entry* object_list_find(rct_object_entry* entry);
void object_entry_get_name_fixed(utf8* buffer, size_t bufferSize, const rct_object_entry* entry);
void* object_entry_get_chunk(int32_t objectType, ObjectEntryIndex index);
const rct_object_entry* object_entry_get_entry(int32_t objectType, ObjectEntryIndex index);
void* object_entry_get_chunk(ObjectType objectType, ObjectEntryIndex index);
const rct_object_entry* object_entry_get_entry(ObjectType objectType, ObjectEntryIndex index);

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

@ -320,7 +320,7 @@ namespace ObjectFactory
return result;
}
static uint8_t ParseObjectType(const std::string& s)
static ObjectType ParseObjectType(const std::string& s)
{
if (s == "ride")
return ObjectType::Ride;
@ -348,7 +348,7 @@ namespace ObjectFactory
return ObjectType::TerrainEdge;
if (s == "station")
return ObjectType::Station;
return 0xFF;
return ObjectType::None;
}
std::unique_ptr<Object> CreateObjectFromZipFile(IObjectRepository& objectRepository, const std::string_view& path)

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

@ -84,16 +84,16 @@ void object_create_identifier_name(char* string_buffer, size_t size, const rct_o
* bl = entry_index
* ecx = entry_type
*/
bool find_object_in_entry_group(const rct_object_entry* entry, uint8_t* entry_type, ObjectEntryIndex* entryIndex)
bool find_object_in_entry_group(const rct_object_entry* entry, ObjectType* entry_type, ObjectEntryIndex* entryIndex)
{
int32_t objectType = entry->GetType();
ObjectType objectType = entry->GetType();
if (objectType >= ObjectType::Count)
{
return false;
}
auto& objectMgr = OpenRCT2::GetContext()->GetObjectManager();
auto maxObjects = object_entry_group_counts[objectType];
auto maxObjects = object_entry_group_counts[EnumValue(objectType)];
for (int32_t i = 0; i < maxObjects; i++)
{
auto loadedObj = objectMgr.GetLoadedObject(objectType, i);
@ -111,9 +111,9 @@ bool find_object_in_entry_group(const rct_object_entry* entry, uint8_t* entry_ty
return false;
}
void get_type_entry_index(size_t index, uint8_t* outObjectType, ObjectEntryIndex* outEntryIndex)
void get_type_entry_index(size_t index, ObjectType* outObjectType, ObjectEntryIndex* outEntryIndex)
{
uint8_t objectType = ObjectType::Ride;
uint8_t objectType = EnumValue(ObjectType::Ride);
for (size_t groupCount : object_entry_group_counts)
{
if (index >= groupCount)
@ -128,14 +128,14 @@ void get_type_entry_index(size_t index, uint8_t* outObjectType, ObjectEntryIndex
}
if (outObjectType != nullptr)
*outObjectType = objectType;
*outObjectType = static_cast<ObjectType>(objectType);
if (outEntryIndex != nullptr)
*outEntryIndex = static_cast<ObjectEntryIndex>(index);
}
const rct_object_entry* get_loaded_object_entry(size_t index)
{
uint8_t objectType;
ObjectType objectType;
ObjectEntryIndex entryIndex;
get_type_entry_index(index, &objectType, &entryIndex);
@ -144,7 +144,7 @@ const rct_object_entry* get_loaded_object_entry(size_t index)
void* get_loaded_object_chunk(size_t index)
{
uint8_t objectType;
ObjectType objectType;
ObjectEntryIndex entryIndex;
get_type_entry_index(index, &objectType, &entryIndex);
return object_entry_get_chunk(objectType, entryIndex);
@ -157,10 +157,10 @@ void object_entry_get_name_fixed(utf8* buffer, size_t bufferSize, const rct_obje
buffer[bufferSize - 1] = 0;
}
void* object_entry_get_chunk(int32_t objectType, ObjectEntryIndex index)
void* object_entry_get_chunk(ObjectType objectType, ObjectEntryIndex index)
{
ObjectEntryIndex objectIndex = index;
for (int32_t i = 0; i < objectType; i++)
for (int32_t i = 0; i < EnumValue(objectType); i++)
{
objectIndex += object_entry_group_counts[i];
}
@ -175,7 +175,7 @@ void* object_entry_get_chunk(int32_t objectType, ObjectEntryIndex index)
return result;
}
const rct_object_entry* object_entry_get_entry(int32_t objectType, ObjectEntryIndex index)
const rct_object_entry* object_entry_get_entry(ObjectType objectType, ObjectEntryIndex index)
{
const rct_object_entry* result = nullptr;
auto& objectMgr = OpenRCT2::GetContext()->GetObjectManager();

2
src/openrct2/object/ObjectList.h
View File

@ -17,6 +17,6 @@
#include "../world/Water.h"
#include "ObjectLimits.h"
void get_type_entry_index(size_t index, uint8_t* outObjectType, ObjectEntryIndex* outEntryIndex);
void get_type_entry_index(size_t index, ObjectType* outObjectType, ObjectEntryIndex* outEntryIndex);
const rct_object_entry* get_loaded_object_entry(size_t index);
void* get_loaded_object_chunk(size_t index);

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

@ -14,6 +14,7 @@
#include "../core/Console.hpp"
#include "../core/Memory.hpp"
#include "../localisation/StringIds.h"
#include "../util/Util.h"
#include "FootpathItemObject.h"
#include "LargeSceneryObject.h"
#include "Object.h"
@ -65,7 +66,7 @@ public:
return _loadedObjects[index].get();
}
Object* GetLoadedObject(int32_t objectType, size_t index) override
Object* GetLoadedObject(ObjectType objectType, size_t index) override
{
if (index >= static_cast<size_t>(object_entry_group_counts[objectType]))
{
@ -684,7 +685,7 @@ private:
}
// Build object lists
auto maxRideObjects = static_cast<size_t>(object_entry_group_counts[ObjectType::Ride]);
auto maxRideObjects = static_cast<size_t>(object_entry_group_counts[EnumValue(ObjectType::Ride)]);
for (size_t i = 0; i < maxRideObjects; i++)
{
auto rideObject = static_cast<RideObject*>(GetLoadedObject(ObjectType::Ride, i));

2
src/openrct2/object/ObjectManager.h
View File

@ -25,7 +25,7 @@ struct IObjectManager
}
virtual Object* GetLoadedObject(size_t index) abstract;
virtual Object* GetLoadedObject(int32_t objectType, size_t index) abstract;
virtual Object* GetLoadedObject(ObjectType objectType, size_t index) abstract;
virtual Object* GetLoadedObject(const rct_object_entry* entry) abstract;
virtual ObjectEntryIndex GetLoadedObjectEntryIndex(const Object* object) abstract;
virtual std::vector<rct_object_entry> GetInvalidObjects(const rct_object_entry* entries) abstract;

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

@ -166,6 +166,23 @@ protected:
stream->WriteValue<rct_object_entry>(entry);
}
break;
case ObjectType::SmallScenery:
case ObjectType::LargeScenery:
case ObjectType::Walls:
case ObjectType::Banners:
case ObjectType::Paths:
case ObjectType::PathBits:
case ObjectType::ParkEntrance:
case ObjectType::Water:
case ObjectType::ScenarioText:
case ObjectType::TerrainSurface:
case ObjectType::TerrainEdge:
case ObjectType::Station:
case ObjectType::Music:
case ObjectType::Count:
case ObjectType::None:
//Switch processes only ObjectType::Ride and ObjectType::SceneryGroup
break;
}
}
@ -215,6 +232,23 @@ protected:
}
break;
}
case ObjectType::SmallScenery:
case ObjectType::LargeScenery:
case ObjectType::Walls:
case ObjectType::Banners:
case ObjectType::Paths:
case ObjectType::PathBits:
case ObjectType::ParkEntrance:
case ObjectType::Water:
case ObjectType::ScenarioText:
case ObjectType::TerrainSurface:
case ObjectType::TerrainEdge:
case ObjectType::Station:
case ObjectType::Music:
case ObjectType::Count:
case ObjectType::None:
//Switch processes only ObjectType::Ride and ObjectType::SceneryGroup
break;
}
return item;
}

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

@ -529,7 +529,7 @@ private:
auto foundObject = objectRepository.FindObjectLegacy(objectName);
if (foundObject != nullptr)
{
uint8_t objectType = foundObject->ObjectEntry.GetType();
ObjectType objectType = foundObject->ObjectEntry.GetType();
switch (objectType)
{
case ObjectType::SmallScenery:
@ -537,6 +537,7 @@ private:
case ObjectType::Walls:
case ObjectType::Paths:
case ObjectType::PathBits:
{
EntryList* entries = GetEntryList(objectType);
// Check if there are spare entries available
@ -546,6 +547,21 @@ private:
entries->GetOrAddEntry(objectName);
}
break;
}
case ObjectType::Ride:
case ObjectType::Banners:
case ObjectType::SceneryGroup:
case ObjectType::ParkEntrance:
case ObjectType::Water:
case ObjectType::ScenarioText:
case ObjectType::TerrainSurface:
case ObjectType::TerrainEdge:
case ObjectType::Station:
case ObjectType::Music:
case ObjectType::Count:
case ObjectType::None:
//This switch processes only ObjectTypes valid for scenery
break;
}
}
}
@ -1892,12 +1908,12 @@ private:
LoadObjects(ObjectType::Water, _waterEntry);
}
void LoadObjects(uint8_t objectType, const EntryList& entries)
void LoadObjects(ObjectType objectType, const EntryList& entries)
{
LoadObjects(objectType, entries.GetEntries());
}
void LoadObjects(uint8_t objectType, const std::vector<const char*>& entries)
void LoadObjects(ObjectType objectType, const std::vector<const char*>& entries)
{
auto& objectManager = OpenRCT2::GetContext()->GetObjectManager();
@ -1920,13 +1936,13 @@ private:
}
}
void AppendRequiredObjects(std::vector<rct_object_entry>& entries, uint8_t objectType, const EntryList& entryList)
void AppendRequiredObjects(std::vector<rct_object_entry>& entries, ObjectType objectType, const EntryList& entryList)
{
AppendRequiredObjects(entries, objectType, entryList.GetEntries());
}
void AppendRequiredObjects(
std::vector<rct_object_entry>& entries, uint8_t objectType, const std::vector<const char*>& objectNames)
std::vector<rct_object_entry>& entries, ObjectType objectType, const std::vector<const char*>& objectNames)
{
for (const auto objectName : objectNames)
{
@ -1966,7 +1982,7 @@ private:
}
void GetInvalidObjects(
uint8_t objectType, const std::vector<const char*>& entries, std::vector<rct_object_entry>& missingObjects)
ObjectType objectType, const std::vector<const char*>& entries, std::vector<rct_object_entry>& missingObjects)
{
auto& objectRepository = OpenRCT2::GetContext()->GetObjectRepository();
for (const char* objectName : entries)
@ -2954,7 +2970,7 @@ private:
}
}
EntryList* GetEntryList(uint8_t objectType)
EntryList* GetEntryList(ObjectType objectType)
{
switch (objectType)
{
@ -2974,6 +2990,17 @@ private:
return &_sceneryGroupEntries;
case ObjectType::Water:
return &_waterEntry;
case ObjectType::Banners:
case ObjectType::ParkEntrance:
case ObjectType::ScenarioText:
case ObjectType::TerrainSurface:
case ObjectType::TerrainEdge:
case ObjectType::Station:
case ObjectType::Music:
case ObjectType::Count:
case ObjectType::None:
//This switch processes only ObjectType for for Entries
break;
}
return nullptr;
}

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

@ -1679,7 +1679,7 @@ public:
std::memset(&nullEntry, 0xFF, sizeof(nullEntry));
int objectIt = 0;
for (int16_t objectType = ObjectType::Ride; objectType <= ObjectType::Water; objectType++)
for (int16_t objectType = EnumValue(ObjectType::Ride); objectType <= EnumValue(ObjectType::Water); objectType++)
{
for (int16_t i = 0; i < rct2_object_entry_group_counts[objectType]; i++, objectIt++)
{

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

@ -227,7 +227,7 @@ rct_ride_entry* get_ride_entry(ObjectEntryIndex index)
std::string_view get_ride_entry_name(ObjectEntryIndex index)
{
if (index >= object_entry_group_counts[ObjectType::Ride])
if (index >= object_entry_group_counts[EnumValue(ObjectType::Ride)])
{
log_error("invalid index %d for ride type", index);
return {};

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

@ -667,7 +667,7 @@ static void track_design_mirror_scenery(TrackDesign* td6)
{
for (auto& scenery : td6->scenery_elements)
{
uint8_t entry_type{ 0 };
ObjectType entry_type{ 0 };
ObjectEntryIndex entryIndex{ 0 };
if (!find_object_in_entry_group(&scenery.scenery_object, &entry_type, &entryIndex))
{
@ -728,6 +728,7 @@ static void track_design_mirror_scenery(TrackDesign* td6)
break;
}
case ObjectType::SmallScenery:
{
scenery.y = -scenery.y;
if (scenery_small_entry_has_flag(scenery_entry, SMALL_SCENERY_FLAG_DIAGONAL))
@ -746,16 +747,18 @@ static void track_design_mirror_scenery(TrackDesign* td6)
scenery.flags ^= (1 << 2);
break;
}
case ObjectType::Walls:
{
scenery.y = -scenery.y;
if (scenery.flags & (1 << 0))
{
scenery.flags ^= (1 << 1);
}
break;
}
case ObjectType::Paths:
{
scenery.y = -scenery.y;
if (scenery.flags & (1 << 5))
@ -767,6 +770,23 @@ static void track_design_mirror_scenery(TrackDesign* td6)
flags = ((flags & (1 << 3)) >> 2) | ((flags & (1 << 1)) << 2);
scenery.flags &= 0xF5;
scenery.flags |= flags;
break;
}
case ObjectType::Ride:
case ObjectType::Banners:
case ObjectType::PathBits:
case ObjectType::SceneryGroup:
case ObjectType::ParkEntrance:
case ObjectType::Water:
case ObjectType::ScenarioText:
case ObjectType::TerrainSurface:
case ObjectType::TerrainEdge:
case ObjectType::Station:
case ObjectType::Music:
case ObjectType::Count:
case ObjectType::None:
//This switch processes only ObjectType for Scenery items.
break;
}
}
}
@ -862,7 +882,7 @@ static void track_design_update_max_min_coordinates(const CoordsXYZ& coords)
}
static bool TrackDesignPlaceSceneryElementGetEntry(
uint8_t& entry_type, ObjectEntryIndex& entry_index, const TrackDesignSceneryElement& scenery)
ObjectType& entry_type, ObjectEntryIndex& entry_index, const TrackDesignSceneryElement& scenery)
{
if (!find_object_in_entry_group(&scenery.scenery_object, &entry_type, &entry_index))
{
@ -893,7 +913,7 @@ static bool TrackDesignPlaceSceneryElementGetEntry(
}
}
if (entry_index == object_entry_group_counts[ObjectType::Paths])
if (entry_index == object_entry_group_counts[EnumValue(ObjectType::Paths)])
{
_trackDesignPlaceStateSceneryUnavailable = true;
return true;
@ -905,7 +925,7 @@ static bool TrackDesignPlaceSceneryElementGetEntry(
static bool TrackDesignPlaceSceneryElementRemoveGhost(
CoordsXY mapCoord, const TrackDesignSceneryElement& scenery, uint8_t rotation, int32_t originZ)
{
uint8_t entry_type;
ObjectType entry_type;
ObjectEntryIndex entry_index;
if (TrackDesignPlaceSceneryElementGetEntry(entry_type, entry_index, scenery))
{
@ -997,7 +1017,7 @@ static bool TrackDesignPlaceSceneryElement(
|| _trackDesignPlaceOperation == PTD_OPERATION_PLACE_GHOST
|| _trackDesignPlaceOperation == PTD_OPERATION_PLACE_TRACK_PREVIEW)
{
uint8_t entry_type;
ObjectType entry_type;
ObjectEntryIndex entry_index;
if (TrackDesignPlaceSceneryElementGetEntry(entry_type, entry_index, scenery))
{

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

@ -85,16 +85,16 @@ namespace OpenRCT2::Scripting
}
}
static DukValue CreateScObject(duk_context* ctx, uint8_t type, int32_t index)
static DukValue CreateScObject(duk_context* ctx, ObjectType type, int32_t index)
{
switch (type)
{
case ObjectType::Ride:
return GetObjectAsDukValue(ctx, std::make_shared<ScRideObject>(type, index));
return GetObjectAsDukValue(ctx, std::make_shared<ScRideObject>(EnumValue(type), index));
case ObjectType::SmallScenery:
return GetObjectAsDukValue(ctx, std::make_shared<ScSmallSceneryObject>(type, index));
return GetObjectAsDukValue(ctx, std::make_shared<ScSmallSceneryObject>(EnumValue(type), index));
default:
return GetObjectAsDukValue(ctx, std::make_shared<ScObject>(type, index));
return GetObjectAsDukValue(ctx, std::make_shared<ScObject>(EnumValue(type), index));
}
}

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

@ -45,17 +45,17 @@ namespace OpenRCT2::Scripting
dukglue_register_property(ctx, &ScObject::name_get, nullptr, "name");
}
static std::optional<uint8_t> StringToObjectType(const std::string_view& type)
static std::optional<ObjectType> StringToObjectType(const std::string_view& type)
{
for (uint8_t i = 0; i < ObjectType::Count; i++)
for (uint8_t i = 0; i < EnumValue(ObjectType::Count); i++)
{
auto s = ObjectTypeToString(i);
if (s == type)
{
return i;
return static_cast<ObjectType>(i);
}
}
return std::nullopt;
return ObjectType::None;
}
static std::string_view ObjectTypeToString(uint8_t type)

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

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

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

@ -260,7 +260,7 @@ 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[ObjectType::SmallScenery]; i++)
for (int32_t i = 0; i < object_entry_group_counts[EnumValue(ObjectType::SmallScenery)]; i++)
{
auto sceneryEntry = get_small_scenery_entry(i);
auto entry = object_entry_get_entry(ObjectType::SmallScenery, i);

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[ObjectType::OBJECT_TYPE_RIDE])
if (index >= object_entry_group_counts[ObjectType::Ride])
{
log_error("invalid index %d for ride type", index);
return nullptr;