Modify object loading for JSON-only objects

src/openrct2/object/ObjectFactory.cpp

@@ -255,7 +255,8 @@ namespace ObjectFactory
 
             if (entry.GetType() != ObjectType::ScenarioText)
             {
-                result = CreateObject(entry);
+                result = CreateObject(entry.GetType());
+                result->SetDescriptor(ObjectEntryDescriptor(entry));
 
                 utf8 objectName[DAT_NAME_LENGTH + 1] = { 0 };
                 object_entry_get_name_fixed(objectName, sizeof(objectName), &entry);
@@ -287,9 +288,11 @@ namespace ObjectFactory
         Guard::ArgumentNotNull(entry, GUARD_LINE);
         Guard::ArgumentNotNull(data, GUARD_LINE);
 
-        auto result = CreateObject(*entry);
+        auto result = CreateObject(entry->GetType());
         if (result != nullptr)
         {
+            result->SetDescriptor(ObjectEntryDescriptor(*entry));
+
             utf8 objectName[DAT_NAME_LENGTH + 1];
             object_entry_get_name_fixed(objectName, sizeof(objectName), entry);
 
@@ -309,60 +312,60 @@ namespace ObjectFactory
         return result;
     }
 
-    std::unique_ptr<Object> CreateObject(const rct_object_entry& entry)
+    std::unique_ptr<Object> CreateObject(ObjectType type)
     {
         std::unique_ptr<Object> result;
-        switch (entry.GetType())
+        switch (type)
         {
             case ObjectType::Ride:
-                result = std::make_unique<RideObject>(entry);
+                result = std::make_unique<RideObject>();
                 break;
             case ObjectType::SmallScenery:
-                result = std::make_unique<SmallSceneryObject>(entry);
+                result = std::make_unique<SmallSceneryObject>();
                 break;
             case ObjectType::LargeScenery:
-                result = std::make_unique<LargeSceneryObject>(entry);
+                result = std::make_unique<LargeSceneryObject>();
                 break;
             case ObjectType::Walls:
-                result = std::make_unique<WallObject>(entry);
+                result = std::make_unique<WallObject>();
                 break;
             case ObjectType::Banners:
-                result = std::make_unique<BannerObject>(entry);
+                result = std::make_unique<BannerObject>();
                 break;
             case ObjectType::Paths:
-                result = std::make_unique<FootpathObject>(entry);
+                result = std::make_unique<FootpathObject>();
                 break;
             case ObjectType::PathBits:
-                result = std::make_unique<FootpathItemObject>(entry);
+                result = std::make_unique<FootpathItemObject>();
                 break;
             case ObjectType::SceneryGroup:
-                result = std::make_unique<SceneryGroupObject>(entry);
+                result = std::make_unique<SceneryGroupObject>();
                 break;
             case ObjectType::ParkEntrance:
-                result = std::make_unique<EntranceObject>(entry);
+                result = std::make_unique<EntranceObject>();
                 break;
             case ObjectType::Water:
-                result = std::make_unique<WaterObject>(entry);
+                result = std::make_unique<WaterObject>();
                 break;
             case ObjectType::ScenarioText:
                 break;
             case ObjectType::TerrainSurface:
-                result = std::make_unique<TerrainSurfaceObject>(entry);
+                result = std::make_unique<TerrainSurfaceObject>();
                 break;
             case ObjectType::TerrainEdge:
-                result = std::make_unique<TerrainEdgeObject>(entry);
+                result = std::make_unique<TerrainEdgeObject>();
                 break;
             case ObjectType::Station:
-                result = std::make_unique<StationObject>(entry);
+                result = std::make_unique<StationObject>();
                 break;
             case ObjectType::Music:
-                result = std::make_unique<MusicObject>(entry);
+                result = std::make_unique<MusicObject>();
                 break;
             case ObjectType::FootpathSurface:
-                result = std::make_unique<FootpathSurfaceObject>(entry);
+                result = std::make_unique<FootpathSurfaceObject>();
                 break;
             case ObjectType::FootpathRailings:
-                result = std::make_unique<FootpathRailingsObject>(entry);
+                result = std::make_unique<FootpathRailingsObject>();
                 break;
             default:
                 throw std::runtime_error("Invalid object type");
@@ -497,22 +500,28 @@ namespace ObjectFactory
         {
             auto id = Json::GetString(jRoot["id"]);
 
-            rct_object_entry entry = {};
+            ObjectEntryDescriptor descriptor;
             auto originalId = Json::GetString(jRoot["originalId"]);
-            auto originalName = originalId;
             if (originalId.length() == 8 + 1 + 8 + 1 + 8)
             {
-                entry.flags = std::stoul(originalId.substr(0, 8), nullptr, 16);
-                originalName = originalId.substr(9, 8);
-                entry.checksum = std::stoul(originalId.substr(18, 8), nullptr, 16);
-            }
-            // Always set, since originalId might be missing or incorrect.
-            entry.SetType(objectType);
-            auto minLength = std::min<size_t>(8, originalName.length());
-            std::memcpy(entry.name, originalName.c_str(), minLength);
+                auto originalName = originalId.substr(9, 8);
 
-            result = CreateObject(entry);
+                rct_object_entry entry = {};
+                entry.flags = std::stoul(originalId.substr(0, 8), nullptr, 16);
+                entry.checksum = std::stoul(originalId.substr(18, 8), nullptr, 16);
+                entry.SetType(objectType);
+                auto minLength = std::min<size_t>(8, originalName.length());
+                std::memcpy(entry.name, originalName.c_str(), minLength);
+                descriptor = ObjectEntryDescriptor(entry);
+            }
+            else
+            {
+                descriptor = ObjectEntryDescriptor(objectType, id);
+            }
+
+            result = CreateObject(objectType);
             result->SetIdentifier(id);
+            result->SetDescriptor(descriptor);
             result->MarkAsJsonObject();
             auto readContext = ReadObjectContext(objectRepository, id, !gOpenRCT2NoGraphics, fileRetriever);
             result->ReadJson(&readContext, jRoot);