Rename scenery element names, add tertiary colour

src/openrct2/core/DataSerialiserTraits.h

@@ -749,29 +749,32 @@ template<> struct DataSerializerTraitsT<TrackDesignSceneryElement>
  {
  stream->Write(&val.loc);
  stream->Write(&val.flags);
- stream->Write(&val.primary_colour);
- stream->Write(&val.secondary_colour);
+ stream->Write(&val.primaryColour);
+ stream->Write(&val.secondaryColour);
+ stream->Write(&val.tertiaryColour);
  DataSerializerTraits<ObjectEntryDescriptor> s;
- s.encode(stream, val.scenery_object);
+ s.encode(stream, val.sceneryObject);
  }
  static void decode(OpenRCT2::IStream* stream, TrackDesignSceneryElement& val)
  {
  stream->Read(&val.loc);
  stream->Read(&val.flags);
- stream->Read(&val.primary_colour);
- stream->Read(&val.secondary_colour);
+ stream->Read(&val.primaryColour);
+ stream->Read(&val.secondaryColour);
+ stream->Read(&val.tertiaryColour);
  DataSerializerTraits<ObjectEntryDescriptor> s;
- s.decode(stream, val.scenery_object);
+ s.decode(stream, val.sceneryObject);
  }
  static void log(OpenRCT2::IStream* stream, const TrackDesignSceneryElement& val)
  {
  char msg[128] = {};
  snprintf(
- msg, sizeof(msg), "TrackDesignSceneryElement(x = %d, y = %d, z = %d, flags = %d, colour1 = %d, colour2 = %d)",
- val.loc.x, val.loc.y, val.loc.z, val.flags, val.primary_colour, val.secondary_colour);
+ msg, sizeof(msg),
+ "TrackDesignSceneryElement(x = %d, y = %d, z = %d, flags = %d, colour1 = %d, colour2 = %d, colour3 = %d)",
+ val.loc.x, val.loc.y, val.loc.z, val.flags, val.primaryColour, val.secondaryColour, val.tertiaryColour);
  stream->Write(msg, strlen(msg));
 
- auto identifier = val.scenery_object.GetName();
+ auto identifier = val.sceneryObject.GetName();
  stream->WriteArray(identifier.data(), identifier.size());
  }
 };

src/openrct2/rct2/RCT2.cpp

@@ -263,4 +263,9 @@ namespace RCT2
  return result;
  return {};
  }
+
+ colour_t TD6SceneryElement::getTertiaryWallColour() const
+ {
+ return (Flags & 0xFC) >> 2;
+ }
 } // namespace RCT2

src/openrct2/rct2/RCT2.h

@@ -323,6 +323,9 @@ namespace RCT2
  uint8_t Flags; // 0x13 direction quadrant tertiary colour
  uint8_t PrimaryColour; // 0x14
  uint8_t SecondaryColour; // 0x15
+
+ colour_t getTertiaryWallColour() const;
+ void setTertiaryWallColour(colour_t colour);
  };
  assert_struct_size(TD6SceneryElement, 0x16);
 

src/openrct2/rct2/T6Exporter.cpp

@@ -151,13 +151,21 @@ namespace RCT2
 
  for (const auto& sceneryElement : _trackDesign->sceneryElements)
  {
- tempStream.Write(&sceneryElement.scenery_object.Entry, sizeof(RCTObjectEntry));
- tempStream.WriteValue<int8_t>(sceneryElement.loc.x / COORDS_XY_STEP);
- tempStream.WriteValue<int8_t>(sceneryElement.loc.y / COORDS_XY_STEP);
- tempStream.WriteValue<int8_t>(sceneryElement.loc.z / COORDS_Z_STEP);
- tempStream.WriteValue<uint8_t>(sceneryElement.flags);
- tempStream.WriteValue<uint8_t>(sceneryElement.primary_colour);
- tempStream.WriteValue<uint8_t>(sceneryElement.secondary_colour);
+ auto flags = sceneryElement.flags;
+ if (sceneryElement.sceneryObject.Entry.GetType() == ObjectType::Walls)
+ {
+ flags &= ~0xFC;
+ flags |= (sceneryElement.tertiaryColour << 2);
+ }
+
+ tempStream.Write(&sceneryElement.sceneryObject.Entry, sizeof(RCTObjectEntry));
+ auto tileCoords = TileCoordsXYZ(sceneryElement.loc);
+ tempStream.WriteValue<int8_t>(tileCoords.x);
+ tempStream.WriteValue<int8_t>(tileCoords.y);
+ tempStream.WriteValue<int8_t>(tileCoords.z);
+ tempStream.WriteValue<uint8_t>(flags);
+ tempStream.WriteValue<uint8_t>(sceneryElement.primaryColour);
+ tempStream.WriteValue<uint8_t>(sceneryElement.secondaryColour);
  }
 
  tempStream.WriteValue<uint8_t>(0xFF);

src/openrct2/rct2/T6Importer.cpp

@@ -189,13 +189,15 @@ namespace RCT2
  TD6SceneryElement t6SceneryElement{};
  _stream.Read(&t6SceneryElement, sizeof(TD6SceneryElement));
  TrackDesignSceneryElement sceneryElement{};
- sceneryElement.scenery_object = ObjectEntryDescriptor(t6SceneryElement.SceneryObject);
- sceneryElement.loc.x = t6SceneryElement.x * COORDS_XY_STEP;
- sceneryElement.loc.y = t6SceneryElement.y * COORDS_XY_STEP;
- sceneryElement.loc.z = t6SceneryElement.z * COORDS_Z_STEP;
+ sceneryElement.sceneryObject = ObjectEntryDescriptor(t6SceneryElement.SceneryObject);
+ TileCoordsXYZ tileCoords = { t6SceneryElement.x, t6SceneryElement.y, t6SceneryElement.z };
+ sceneryElement.loc = tileCoords.ToCoordsXYZ();
  sceneryElement.flags = t6SceneryElement.Flags;
- sceneryElement.primary_colour = t6SceneryElement.PrimaryColour;
- sceneryElement.secondary_colour = t6SceneryElement.SecondaryColour;
+ sceneryElement.primaryColour = t6SceneryElement.PrimaryColour;
+ sceneryElement.secondaryColour = t6SceneryElement.SecondaryColour;
+ if (t6SceneryElement.SceneryObject.GetType() == ObjectType::Walls)
+ sceneryElement.tertiaryColour = t6SceneryElement.getTertiaryWallColour();
+
  td->sceneryElements.push_back(std::move(sceneryElement));
  }
 

src/openrct2/ride/TrackDesign.cpp

@@ -491,7 +491,7 @@ ResultWithMessage TrackDesign::CreateTrackDesignScenery(TrackDesignState& tds)
  // Run an element loop
  for (auto& scenery : sceneryElements)
  {
- switch (scenery.scenery_object.GetType())
+ switch (scenery.sceneryObject.GetType())
  {
  case ObjectType::Paths:
  {
@@ -641,9 +641,9 @@ static void TrackDesignLoadSceneryObjects(TrackDesign* td6)
  // Load scenery objects
  for (const auto& scenery : td6->sceneryElements)
  {
- if (scenery.scenery_object.HasValue())
+ if (scenery.sceneryObject.HasValue())
  {
- objectManager.LoadObject(scenery.scenery_object);
+ objectManager.LoadObject(scenery.sceneryObject);
  }
  }
 }
@@ -696,13 +696,13 @@ static std::optional<TrackSceneryEntry> TrackDesignPlaceSceneryElementGetEntry(c
  TrackSceneryEntry result;
 
  auto& objectMgr = OpenRCT2::GetContext()->GetObjectManager();
- if (scenery.scenery_object.GetType() == ObjectType::Paths)
+ if (scenery.sceneryObject.GetType() == ObjectType::Paths)
  {
- auto footpathMapping = RCT2::GetFootpathSurfaceId(scenery.scenery_object, true, scenery.IsQueue());
+ auto footpathMapping = RCT2::GetFootpathSurfaceId(scenery.sceneryObject, true, scenery.IsQueue());
  if (footpathMapping == nullptr)
  {
  // Check if legacy path object is loaded
- auto obj = objectMgr.GetLoadedObject(scenery.scenery_object);
+ auto obj = objectMgr.GetLoadedObject(scenery.sceneryObject);
  if (obj != nullptr)
  {
  result.Type = obj->GetObjectType();
@@ -734,7 +734,7 @@ static std::optional<TrackSceneryEntry> TrackDesignPlaceSceneryElementGetEntry(c
  }
  else
  {
- auto obj = objectMgr.GetLoadedObject(scenery.scenery_object);
+ auto obj = objectMgr.GetLoadedObject(scenery.sceneryObject);
  bool objectUnavailable = obj == nullptr;
  if (obj != nullptr)
  {
@@ -1096,8 +1096,8 @@ static GameActions::Result TrackDesignPlaceSceneryElement(
  }
 
  auto smallSceneryPlace = SmallSceneryPlaceAction(
- { mapCoord.x, mapCoord.y, z, rotation }, quadrant, entryInfo->Index, scenery.primary_colour,
- scenery.secondary_colour, COLOUR_DARK_BROWN);
+ { mapCoord.x, mapCoord.y, z, rotation }, quadrant, entryInfo->Index, scenery.primaryColour,
+ scenery.secondaryColour, scenery.tertiaryColour);
 
  smallSceneryPlace.SetFlags(flags);
  auto res = flags & GAME_COMMAND_FLAG_APPLY ? GameActions::ExecuteNested(&smallSceneryPlace)
@@ -1138,8 +1138,8 @@ static GameActions::Result TrackDesignPlaceSceneryElement(
  flags |= GAME_COMMAND_FLAG_REPLAY;
  }
  auto sceneryPlaceAction = LargeSceneryPlaceAction(
- { mapCoord.x, mapCoord.y, z, rotation }, entryInfo->Index, scenery.primary_colour, scenery.secondary_colour,
- COLOUR_DARK_BROWN);
+ { mapCoord.x, mapCoord.y, z, rotation }, entryInfo->Index, scenery.primaryColour, scenery.secondaryColour,
+ scenery.tertiaryColour);
  sceneryPlaceAction.SetFlags(flags);
  auto res = flags & GAME_COMMAND_FLAG_APPLY ? GameActions::ExecuteNested(&sceneryPlaceAction)
  : GameActions::QueryNested(&sceneryPlaceAction);
@@ -1178,8 +1178,8 @@ static GameActions::Result TrackDesignPlaceSceneryElement(
  flags |= GAME_COMMAND_FLAG_REPLAY;
  }
  auto wallPlaceAction = WallPlaceAction(
- entryInfo->Index, { mapCoord.x, mapCoord.y, z }, rotation, scenery.primary_colour, scenery.secondary_colour,
- (scenery.flags & 0xFC) >> 2);
+ entryInfo->Index, { mapCoord.x, mapCoord.y, z }, rotation, scenery.primaryColour, scenery.secondaryColour,
+ scenery.tertiaryColour);
  wallPlaceAction.SetFlags(flags);
  auto res = flags & GAME_COMMAND_FLAG_APPLY ? GameActions::ExecuteNested(&wallPlaceAction)
  : GameActions::QueryNested(&wallPlaceAction);

src/openrct2/ride/TrackDesign.h

@@ -46,11 +46,12 @@ struct TrackDesignEntranceElement
 
 struct TrackDesignSceneryElement
 {
- ObjectEntryDescriptor scenery_object;
+ ObjectEntryDescriptor sceneryObject;
  CoordsXYZ loc;
  uint8_t flags;
- uint8_t primary_colour;
- uint8_t secondary_colour;
+ colour_t primaryColour;
+ colour_t secondaryColour;
+ colour_t tertiaryColour = COLOUR_DARK_BROWN;
 
  bool IsQueue() const
  {

src/openrct2/ride/TrackDesignSave.cpp

@@ -209,20 +209,23 @@ static bool TrackDesignSaveIsSupportedObject(const Object* obj)
 }
 
 static void TrackDesignSavePushTileElementDesc(
- const RCTObjectEntry& entry, const CoordsXYZ& loc, uint8_t flags, uint8_t primaryColour, uint8_t secondaryColour)
+ const RCTObjectEntry& entry, const CoordsXYZ& loc, uint8_t flags, colour_t primaryColour, colour_t secondaryColour,
+ colour_t tertiaryColour)
 {
  TrackDesignSceneryElement item{};
- item.scenery_object = ObjectEntryDescriptor(entry);
+ item.sceneryObject = ObjectEntryDescriptor(entry);
  item.loc = loc;
  item.flags = flags;
- item.primary_colour = primaryColour;
- item.secondary_colour = secondaryColour;
+ item.primaryColour = primaryColour;
+ item.secondaryColour = secondaryColour;
+ item.tertiaryColour = tertiaryColour;
 
  _trackSavedTileElementsDesc.push_back(std::move(item));
 }
 
 static void TrackDesignSavePushTileElementDesc(
- const Object* obj, const CoordsXYZ& loc, uint8_t flags, uint8_t primaryColour, uint8_t secondaryColour)
+ const Object* obj, const CoordsXYZ& loc, uint8_t flags, uint8_t primaryColour, uint8_t secondaryColour,
+ colour_t tertiaryColour)
 {
  const auto& entry = obj->GetObjectEntry();
  if (entry.IsEmpty())
@@ -231,7 +234,7 @@ static void TrackDesignSavePushTileElementDesc(
  assert(false);
  }
 
- TrackDesignSavePushTileElementDesc(entry, loc, flags, primaryColour, secondaryColour);
+ TrackDesignSavePushTileElementDesc(entry, loc, flags, primaryColour, secondaryColour, tertiaryColour);
 }
 
 static TrackDesignAddStatus TrackDesignSaveAddSmallScenery(const CoordsXY& loc, SmallSceneryElement* sceneryElement)
@@ -244,12 +247,13 @@ static TrackDesignAddStatus TrackDesignSaveAddSmallScenery(const CoordsXY& loc,
  flags |= sceneryElement->GetDirection();
  flags |= sceneryElement->GetSceneryQuadrant() << 2;
 
- uint8_t primaryColour = sceneryElement->GetPrimaryColour();
- uint8_t secondaryColour = sceneryElement->GetSecondaryColour();
+ auto primaryColour = sceneryElement->GetPrimaryColour();
+ auto secondaryColour = sceneryElement->GetSecondaryColour();
+ auto tertiaryColour = sceneryElement->GetTertiaryColour();
 
  TrackDesignSavePushTileElement(loc, reinterpret_cast<TileElement*>(sceneryElement));
  TrackDesignSavePushTileElementDesc(
- obj, { loc.x, loc.y, sceneryElement->GetBaseZ() }, flags, primaryColour, secondaryColour);
+ obj, { loc.x, loc.y, sceneryElement->GetBaseZ() }, flags, primaryColour, secondaryColour, tertiaryColour);
  return TrackDesignAddStatus::Success();
  }
 
@@ -292,10 +296,11 @@ static TrackDesignAddStatus TrackDesignSaveAddLargeScenery(const CoordsXY& loc,
  if (sequence == 0)
  {
  uint8_t flags = largeElement->GetDirection();
- uint8_t primaryColour = largeElement->GetPrimaryColour();
- uint8_t secondaryColour = largeElement->GetSecondaryColour();
+ auto primaryColour = largeElement->GetPrimaryColour();
+ auto secondaryColour = largeElement->GetSecondaryColour();
+ auto tertiaryColour = largeElement->GetTertiaryColour();
 
- TrackDesignSavePushTileElementDesc(obj, tileLoc, flags, primaryColour, secondaryColour);
+ TrackDesignSavePushTileElementDesc(obj, tileLoc, flags, primaryColour, secondaryColour, tertiaryColour);
  }
  TrackDesignSavePushTileElement({ tileLoc.x, tileLoc.y }, reinterpret_cast<TileElement*>(largeElement));
  }
@@ -314,14 +319,14 @@ static TrackDesignAddStatus TrackDesignSaveAddWall(const CoordsXY& loc, WallElem
  {
  uint8_t flags = 0;
  flags |= wallElement->GetDirection();
- flags |= wallElement->GetTertiaryColour() << 2;
 
- uint8_t secondaryColour = wallElement->GetSecondaryColour();
- uint8_t primaryColour = wallElement->GetPrimaryColour();
+ auto primaryColour = wallElement->GetPrimaryColour();
+ auto secondaryColour = wallElement->GetSecondaryColour();
+ auto tertiaryColour = wallElement->GetTertiaryColour();
 
  TrackDesignSavePushTileElement(loc, reinterpret_cast<TileElement*>(wallElement));
  TrackDesignSavePushTileElementDesc(
- obj, { loc.x, loc.y, wallElement->GetBaseZ() }, flags, primaryColour, secondaryColour);
+ obj, { loc.x, loc.y, wallElement->GetBaseZ() }, flags, primaryColour, secondaryColour, tertiaryColour);
  return TrackDesignAddStatus::Success();
  }
 
@@ -371,7 +376,7 @@ static TrackDesignAddStatus TrackDesignSaveAddFootpath(const CoordsXY& loc, Path
  flags |= 1 << 7;
 
  TrackDesignSavePushTileElement(loc, reinterpret_cast<TileElement*>(pathElement));
- TrackDesignSavePushTileElementDesc(*pathEntry, { loc.x, loc.y, pathElement->GetBaseZ() }, flags, 0, 0);
+ TrackDesignSavePushTileElementDesc(*pathEntry, { loc.x, loc.y, pathElement->GetBaseZ() }, flags, 0, 0, 0);
  return TrackDesignAddStatus::Success();
 }
 
@@ -439,7 +444,7 @@ static void TrackDesignSavePopTileElementDesc(const ObjectEntryDescriptor& entry
  continue;
  if (item->flags != flags)
  continue;
- if (item->scenery_object != entry)
+ if (item->sceneryObject != entry)
  continue;
 
  removeIndex = i;