mirrors/OpenRCT2
1
0
Fork 0
mirror of https://github.com/OpenRCT2/OpenRCT2 synced 2026-01-04 13:42:55 +01:00
Code Issues Releases Wiki Activity

Remove now-unused RCT12 setters (#16109)

Browse Source
This commit is contained in:
Michael Steenbeek
2021-12-04 10:56:49 +01:00
committed by GitHub
parent c455fe84e6
commit 66bf0aa1a6
2 changed files with 0 additions and 603 deletions
Download Patch File Download Diff File Expand all files Collapse all files

521
src/openrct2/rct12/RCT12.cpp
View File

@@ -40,12 +40,6 @@ uint8_t RCT12TileElementBase::GetOccupiedQuadrants() const
return flags & TILE_ELEMENT_OCCUPIED_QUADRANTS_MASK;
}
void RCT12TileElementBase::SetOccupiedQuadrants(uint8_t quadrants)
{
flags &= ~TILE_ELEMENT_OCCUPIED_QUADRANTS_MASK;
flags |= (quadrants & TILE_ELEMENT_OCCUPIED_QUADRANTS_MASK);
}
bool RCT12TileElementBase::IsLastForTile() const
{
return (this->flags & RCT12_TILE_ELEMENT_FLAG_LAST_TILE) != 0;
@@ -56,26 +50,6 @@ bool RCT12TileElementBase::IsGhost() const
return (this->flags & RCT12_TILE_ELEMENT_FLAG_GHOST) != 0;
}
void RCT12TileElementBase::SetLastForTile(bool on)
{
if (on)
flags |= RCT12_TILE_ELEMENT_FLAG_LAST_TILE;
else
flags &= ~RCT12_TILE_ELEMENT_FLAG_LAST_TILE;
}
void RCT12TileElementBase::SetGhost(bool isGhost)
{
if (isGhost)
{
this->flags |= RCT12_TILE_ELEMENT_FLAG_GHOST;
}
else
{
this->flags &= ~RCT12_TILE_ELEMENT_FLAG_GHOST;
}
}
uint8_t RCT12SurfaceElement::GetSlope() const
{
return (slope & TILE_ELEMENT_SURFACE_SLOPE_MASK);
@@ -295,35 +269,11 @@ uint8_t RCT12TrackElement::GetDoorBState() const
return (colour & RCT12_TRACK_ELEMENT_DOOR_B_MASK) >> 5;
}
void RCT12TrackElement::SetDoorAState(uint8_t newState)
{
colour &= ~RCT12_TRACK_ELEMENT_DOOR_B_MASK;
colour |= ((newState << 2) & RCT12_TRACK_ELEMENT_DOOR_B_MASK);
}
void RCT12TrackElement::SetDoorBState(uint8_t newState)
{
colour &= ~RCT12_TRACK_ELEMENT_DOOR_B_MASK;
colour |= ((newState << 5) & RCT12_TRACK_ELEMENT_DOOR_B_MASK);
}
bool RCT12TrackElement::IsIndestructible() const
{
return (flags & RCT12_TILE_ELEMENT_FLAG_INDESTRUCTIBLE_TRACK_PIECE) != 0;
}
void RCT12TrackElement::SetIsIndestructible(bool isIndestructible)
{
if (isIndestructible)
{
flags |= RCT12_TILE_ELEMENT_FLAG_INDESTRUCTIBLE_TRACK_PIECE;
}
else
{
flags &= ~RCT12_TILE_ELEMENT_FLAG_INDESTRUCTIBLE_TRACK_PIECE;
}
}
uint8_t RCT12SmallSceneryElement::GetEntryIndex() const
{
return this->entryIndex;
@@ -523,492 +473,21 @@ uint8_t RCT12TileElement::GetBannerIndex()
}
}
void RCT12TileElementBase::SetDirection(uint8_t direction)
{
this->type &= ~TILE_ELEMENT_DIRECTION_MASK;
this->type |= (direction & TILE_ELEMENT_DIRECTION_MASK);
}
void RCT12TileElement::ClearAs(uint8_t newType)
{
type = newType;
flags = 0;
base_height = MINIMUM_LAND_HEIGHT;
clearance_height = MINIMUM_LAND_HEIGHT;
std::fill_n(pad_04, sizeof(pad_04), 0x00);
}
void RCT12LargeSceneryElement::SetEntryIndex(uint32_t newIndex)
{
entryIndex &= ~RCT12_TILE_ELEMENT_LARGE_TYPE_MASK;
entryIndex |= (newIndex & RCT12_TILE_ELEMENT_LARGE_TYPE_MASK);
}
void RCT12LargeSceneryElement::SetSequenceIndex(uint16_t sequence)
{
entryIndex &= RCT12_TILE_ELEMENT_LARGE_TYPE_MASK;
entryIndex |= (sequence << 10);
}
void RCT12LargeSceneryElement::SetPrimaryColour(colour_t newColour)
{
assert(newColour <= 31);
colour[0] &= ~TILE_ELEMENT_COLOUR_MASK;
colour[0] |= newColour;
}
void RCT12LargeSceneryElement::SetSecondaryColour(colour_t newColour)
{
assert(newColour <= 31);
colour[1] &= ~TILE_ELEMENT_COLOUR_MASK;
colour[1] |= newColour;
}
void RCT12LargeSceneryElement::SetBannerIndex(uint8_t newIndex)
{
type |= newIndex & 0xC0;
colour[0] |= (newIndex & 0x38) << 2;
colour[1] |= (newIndex & 7) << 5;
}
void RCT12SurfaceElement::SetSurfaceStyle(uint32_t newStyle)
{
// Bits 3, 4 for terrain are stored in element.type bit 0, 1
type &= ~RCT12_SURFACE_ELEMENT_TYPE_SURFACE_MASK;
type |= (newStyle >> 3) & RCT12_SURFACE_ELEMENT_TYPE_SURFACE_MASK;
// Bits 0, 1, 2 for terrain are stored in element.terrain bit 5, 6, 7
terrain &= ~0xE0;
terrain |= (newStyle & 7) << 5;
}
void RCT12SurfaceElement::SetEdgeStyle(uint32_t newStyle)
{
// Bit 3 for terrain is stored in element.type bit 7
if (newStyle & 8)
type |= 128;
else
type &= ~128;
// Bits 0, 1, 2 for terrain are stored in element.slope bit 5, 6, 7
slope &= ~RCT12_TILE_ELEMENT_SURFACE_EDGE_STYLE_MASK;
slope |= (newStyle & 7) << 5;
}
void RCT12SurfaceElement::SetWaterHeight(uint32_t newWaterHeight)
{
newWaterHeight >>= 4;
newWaterHeight &= 0x1F;
terrain &= ~RCT12_TILE_ELEMENT_SURFACE_WATER_HEIGHT_MASK;
terrain |= newWaterHeight;
}
void RCT12SurfaceElement::SetGrassLength(uint8_t newLength)
{
grass_length = newLength;
}
void RCT12SurfaceElement::SetOwnership(uint8_t newOwnership)
{
ownership &= ~TILE_ELEMENT_SURFACE_OWNERSHIP_MASK;
ownership |= (newOwnership & TILE_ELEMENT_SURFACE_OWNERSHIP_MASK);
}
void RCT12SurfaceElement::SetParkFences(uint8_t newParkFences)
{
ownership &= ~TILE_ELEMENT_SURFACE_PARK_FENCE_MASK;
ownership |= (newParkFences & TILE_ELEMENT_SURFACE_PARK_FENCE_MASK);
}
void RCT12SurfaceElement::SetSlope(uint8_t newSlope)
{
slope &= ~TILE_ELEMENT_SURFACE_SLOPE_MASK;
slope |= (newSlope & TILE_ELEMENT_SURFACE_SLOPE_MASK);
}
void RCT12SurfaceElement::SetHasTrackThatNeedsWater(bool on)
{
type &= ~SURFACE_ELEMENT_HAS_TRACK_THAT_NEEDS_WATER;
if (on)
type |= SURFACE_ELEMENT_HAS_TRACK_THAT_NEEDS_WATER;
}
void RCT12PathElement::SetPathEntryIndex(uint8_t newEntryIndex)
{
entryIndex &= ~RCT12_FOOTPATH_PROPERTIES_TYPE_MASK;
entryIndex |= (newEntryIndex << 4);
}
void RCT12PathElement::SetQueueBannerDirection(uint8_t direction)
{
type &= ~FOOTPATH_ELEMENT_TYPE_DIRECTION_MASK;
type |= (direction << 6);
}
void RCT12PathElement::SetRideIndex(uint8_t newRideIndex)
{
rideIndex = newRideIndex;
}
void RCT12PathElement::SetAdditionStatus(uint8_t newStatus)
{
additionStatus = newStatus;
}
void RCT12PathElement::SetEdges(uint8_t newEdges)
{
edges &= ~FOOTPATH_PROPERTIES_EDGES_EDGES_MASK;
edges |= (newEdges & FOOTPATH_PROPERTIES_EDGES_EDGES_MASK);
}
void RCT12PathElement::SetCorners(uint8_t newCorners)
{
edges &= ~FOOTPATH_PROPERTIES_EDGES_CORNERS_MASK;
edges |= (newCorners << 4);
}
void RCT12PathElement::SetSloped(bool isSloped)
{
entryIndex &= ~RCT12_FOOTPATH_PROPERTIES_FLAG_IS_SLOPED;
if (isSloped)
entryIndex |= RCT12_FOOTPATH_PROPERTIES_FLAG_IS_SLOPED;
}
void RCT12PathElement::SetSlopeDirection(uint8_t newSlope)
{
entryIndex &= ~RCT12_FOOTPATH_PROPERTIES_SLOPE_DIRECTION_MASK;
entryIndex |= newSlope & RCT12_FOOTPATH_PROPERTIES_SLOPE_DIRECTION_MASK;
}
void RCT12PathElement::SetStationIndex(uint8_t newStationIndex)
{
additions &= ~RCT12_FOOTPATH_PROPERTIES_ADDITIONS_STATION_INDEX_MASK;
additions |= ((newStationIndex << 4) & RCT12_FOOTPATH_PROPERTIES_ADDITIONS_STATION_INDEX_MASK);
}
void RCT12PathElement::SetWide(bool isWide)
{
type &= ~FOOTPATH_ELEMENT_TYPE_FLAG_IS_WIDE;
if (isWide)
type |= FOOTPATH_ELEMENT_TYPE_FLAG_IS_WIDE;
}
void RCT12PathElement::SetIsQueue(bool isQueue)
{
type &= ~FOOTPATH_ELEMENT_TYPE_FLAG_IS_QUEUE;
if (isQueue)
type |= FOOTPATH_ELEMENT_TYPE_FLAG_IS_QUEUE;
}
void RCT12PathElement::SetHasQueueBanner(bool hasQueueBanner)
{
entryIndex &= ~RCT12_FOOTPATH_PROPERTIES_FLAG_HAS_QUEUE_BANNER;
if (hasQueueBanner)
entryIndex |= RCT12_FOOTPATH_PROPERTIES_FLAG_HAS_QUEUE_BANNER;
}
void RCT12PathElement::SetAddition(uint8_t newAddition)
{
additions &= ~RCT12_FOOTPATH_PROPERTIES_ADDITIONS_TYPE_MASK;
additions |= newAddition;
}
void RCT12PathElement::SetAdditionIsGhost(bool isGhost)
{
additions &= ~RCT12_FOOTPATH_PROPERTIES_ADDITIONS_FLAG_GHOST;
if (isGhost)
additions |= RCT12_FOOTPATH_PROPERTIES_ADDITIONS_FLAG_GHOST;
}
bool RCT12PathElement::IsBroken() const
{
return (flags & RCT12_TILE_ELEMENT_FLAG_BROKEN) != 0;
}
void RCT12PathElement::SetIsBroken(bool isBroken)
{
if (isBroken)
{
flags |= RCT12_TILE_ELEMENT_FLAG_BROKEN;
}
else
{
flags &= ~RCT12_TILE_ELEMENT_FLAG_BROKEN;
}
}
bool RCT12PathElement::IsBlockedByVehicle() const
{
return (flags & RCT12_TILE_ELEMENT_FLAG_BLOCKED_BY_VEHICLE) != 0;
}
void RCT12PathElement::SetIsBlockedByVehicle(bool isBlocked)
{
if (isBlocked)
{
flags |= RCT12_TILE_ELEMENT_FLAG_BLOCKED_BY_VEHICLE;
}
else
{
flags &= ~RCT12_TILE_ELEMENT_FLAG_BLOCKED_BY_VEHICLE;
}
}
void RCT12TrackElement::SetTrackType(uint8_t newType)
{
trackType = newType;
}
void RCT12TrackElement::SetSequenceIndex(uint8_t newSequenceIndex)
{
sequence &= ~RCT12_TRACK_ELEMENT_SEQUENCE_SEQUENCE_MASK;
sequence |= (newSequenceIndex & RCT12_TRACK_ELEMENT_SEQUENCE_SEQUENCE_MASK);
}
void RCT12TrackElement::SetStationIndex(uint8_t newStationIndex)
{
if (track_type_is_station(trackType) || trackType == TrackElemType::TowerBase)
{
sequence &= ~RCT12_TRACK_ELEMENT_SEQUENCE_STATION_INDEX_MASK;
sequence |= (newStationIndex << 4);
}
}
void RCT12TrackElement::SetRideIndex(uint8_t newRideIndex)
{
rideIndex = newRideIndex;
}
void RCT12TrackElement::SetColourScheme(uint8_t newColourScheme)
{
colour &= ~0x3;
colour |= (newColourScheme & 0x3);
}
void RCT12TrackElement::SetHasCableLift(bool on)
{
colour &= ~RCT12_TRACK_ELEMENT_COLOUR_FLAG_CABLE_LIFT;
if (on)
colour |= RCT12_TRACK_ELEMENT_COLOUR_FLAG_CABLE_LIFT;
}
void RCT12TrackElement::SetInverted(bool inverted)
{
if (inverted)
{
colour |= RCT12_TRACK_ELEMENT_COLOUR_FLAG_INVERTED;
}
else
{
colour &= ~RCT12_TRACK_ELEMENT_COLOUR_FLAG_INVERTED;
}
}
void RCT12TrackElement::SetBrakeBoosterSpeed(uint8_t speed)
{
if (TrackTypeHasSpeedSetting(GetTrackType()))
{
sequence &= ~0b11110000;
sequence |= ((speed >> 1) << 4);
}
}
bool RCT12TrackElement::BlockBrakeClosed() const
{
return (flags & RCT12_TILE_ELEMENT_FLAG_BLOCK_BRAKE_CLOSED) != 0;
}
void RCT12TrackElement::SetBlockBrakeClosed(bool isClosed)
{
if (isClosed)
{
flags |= RCT12_TILE_ELEMENT_FLAG_BLOCK_BRAKE_CLOSED;
}
else
{
flags &= ~RCT12_TILE_ELEMENT_FLAG_BLOCK_BRAKE_CLOSED;
}
}
void RCT12TrackElement::SetHasGreenLight(uint8_t greenLight)
{
if (track_type_is_station(trackType))
{
sequence &= ~MAP_ELEM_TRACK_SEQUENCE_GREEN_LIGHT;
if (greenLight)
{
sequence |= MAP_ELEM_TRACK_SEQUENCE_GREEN_LIGHT;
}
}
}
void RCT12TrackElement::SetHasChain(bool on)
{
if (on)
{
type |= RCT12_TRACK_ELEMENT_TYPE_FLAG_CHAIN_LIFT;
}
else
{
type &= ~RCT12_TRACK_ELEMENT_TYPE_FLAG_CHAIN_LIFT;
}
}
void RCT12TrackElement::SetSeatRotation(uint8_t newSeatRotation)
{
colour &= 0x0F;
colour |= (newSeatRotation << 4);
}
void RCT12TrackElement::SetMazeEntry(uint16_t newMazeEntry)
{
mazeEntry = newMazeEntry;
}
void RCT12TrackElement::SetPhotoTimeout(uint8_t value)
{
if (GetTrackType() == TrackElemType::OnRidePhoto)
{
sequence &= RCT12_TRACK_ELEMENT_SEQUENCE_SEQUENCE_MASK;
sequence |= (value << 4);
}
}
void RCT12SmallSceneryElement::SetEntryIndex(uint8_t newIndex)
{
this->entryIndex = newIndex;
}
void RCT12SmallSceneryElement::SetAge(uint8_t newAge)
{
this->age = newAge;
}
void RCT12SmallSceneryElement::SetPrimaryColour(colour_t colour)
{
assert(colour <= 31);
colour_1 &= ~TILE_ELEMENT_COLOUR_MASK;
colour_1 |= colour;
}
void RCT12SmallSceneryElement::SetSecondaryColour(colour_t colour)
{
assert(colour <= 31);
colour_2 &= ~TILE_ELEMENT_COLOUR_MASK;
colour_2 |= colour;
}
void RCT12SmallSceneryElement::SetSceneryQuadrant(uint8_t newQuadrant)
{
type &= ~TILE_ELEMENT_QUADRANT_MASK;
type |= (newQuadrant << 6);
}
void RCT12SmallSceneryElement::SetNeedsSupports()
{
colour_1 |= MAP_ELEM_SMALL_SCENERY_COLOUR_FLAG_NEEDS_SUPPORTS;
}
void RCT12WallElement::SetEntryIndex(uint8_t newIndex)
{
entryIndex = newIndex;
}
void RCT12WallElement::SetBannerIndex(uint8_t newIndex)
{
banner_index = newIndex;
}
void RCT12WallElement::SetAcrossTrack(bool acrossTrack)
{
animation &= ~WALL_ANIMATION_FLAG_ACROSS_TRACK;
if (acrossTrack)
animation |= WALL_ANIMATION_FLAG_ACROSS_TRACK;
}
void RCT12WallElement::SetAnimationIsBackwards(bool isBackwards)
{
animation &= ~WALL_ANIMATION_FLAG_DIRECTION_BACKWARD;
if (isBackwards)
animation |= WALL_ANIMATION_FLAG_DIRECTION_BACKWARD;
}
void RCT12WallElement::SetSlope(uint8_t newSlope)
{
type &= ~TILE_ELEMENT_QUADRANT_MASK;
type |= (newSlope << 6);
}
void RCT12WallElement::SetPrimaryColour(colour_t newColour)
{
assert(newColour <= 31);
colour_1 &= ~TILE_ELEMENT_COLOUR_MASK;
colour_1 |= newColour;
}
void RCT12WallElement::SetSecondaryColour(colour_t newColour)
{
colour_1 &= TILE_ELEMENT_COLOUR_MASK;
colour_1 |= (newColour & 0x7) << 5;
flags &= ~0x60;
flags |= (newColour & 0x18) << 2;
}
void RCT12WallElement::SetTertiaryColour(colour_t newColour)
{
assert(newColour <= 31);
colour_3 &= ~TILE_ELEMENT_COLOUR_MASK;
colour_3 |= newColour;
}
void RCT12WallElement::SetAnimationFrame(uint8_t frameNum)
{
animation &= WALL_ANIMATION_FLAG_ALL_FLAGS;
animation |= (frameNum & 0xF) << 3;
}
void RCT12EntranceElement::SetEntranceType(uint8_t newType)
{
entranceType = newType;
}
void RCT12EntranceElement::SetRideIndex(uint8_t newRideIndex)
{
rideIndex = newRideIndex;
}
void RCT12EntranceElement::SetPathType(uint8_t newPathType)
{
pathType = newPathType;
}
void RCT12EntranceElement::SetSequenceIndex(uint8_t newSequenceIndex)
{
index &= ~0xF;
index |= (newSequenceIndex & 0xF);
}
void RCT12EntranceElement::SetStationIndex(uint8_t stationIndex)
{
index &= ~RCT12_TRACK_ELEMENT_SEQUENCE_STATION_INDEX_MASK;
index |= (stationIndex << 4);
}
void RCT12BannerElement::SetIndex(uint8_t newIndex)
{
index = newIndex;
}
void RCT12BannerElement::SetPosition(uint8_t newPosition)
{
position = newPosition;
}
void RCT12BannerElement::SetAllowedEdges(uint8_t newEdges)
{
AllowedEdges &= ~0b00001111;
AllowedEdges |= (newEdges & 0b00001111);
}
bool RCT12ResearchItem::IsInventedEndMarker() const
{
return rawValue == RCT12_RESEARCHED_ITEMS_SEPARATOR;

82
src/openrct2/rct12/RCT12.h
View File

@@ -288,15 +288,11 @@ struct RCT12TileElementBase
uint8_t clearance_height; // 3
uint8_t GetType() const;
uint8_t GetDirection() const;
void SetDirection(uint8_t direction);
uint8_t GetOccupiedQuadrants() const;
void SetOccupiedQuadrants(uint8_t quadrants);
bool IsLastForTile() const;
void SetLastForTile(bool on);
bool IsGhost() const;
void SetGhost(bool isGhost);
};
/**
* Map element structure
@@ -378,7 +374,6 @@ struct RCT12TileElement : public RCT12TileElementBase
{
return as<RCT12BannerElement, RCT12TileElementType::Banner>();
}
void ClearAs(uint8_t newType);
uint8_t GetBannerIndex();
};
assert_struct_size(RCT12TileElement, 8);
@@ -398,15 +393,6 @@ public:
uint32_t GetWaterHeight() const;
uint8_t GetParkFences() const;
bool HasTrackThatNeedsWater() const;
void SetSlope(uint8_t newSlope);
void SetSurfaceStyle(uint32_t newStyle);
void SetEdgeStyle(uint32_t newStyle);
void SetGrassLength(uint8_t newLength);
void SetOwnership(uint8_t newOwnership);
void SetWaterHeight(uint32_t newWaterHeight);
void SetParkFences(uint8_t newParkFences);
void SetHasTrackThatNeedsWater(bool on);
};
assert_struct_size(RCT12SurfaceElement, 8);
struct RCT12PathElement : RCT12TileElementBase
@@ -439,26 +425,9 @@ public:
uint8_t GetRCT1PathType() const;
uint8_t GetRCT1SupportType() const;
void SetPathEntryIndex(RCT12ObjectEntryIndex newIndex);
void SetQueueBannerDirection(uint8_t direction);
void SetSloped(bool isSloped);
void SetSlopeDirection(uint8_t newSlope);
void SetRideIndex(uint8_t newRideIndex);
void SetStationIndex(uint8_t newStationIndex);
void SetWide(bool isWide);
void SetIsQueue(bool isQueue);
void SetHasQueueBanner(bool hasQueueBanner);
void SetEdges(uint8_t newEdges);
void SetCorners(uint8_t newCorners);
void SetAddition(uint8_t newAddition);
void SetAdditionIsGhost(bool isGhost);
void SetAdditionStatus(uint8_t newStatus);
bool IsBroken() const;
void SetIsBroken(bool isBroken);
bool IsBlockedByVehicle() const;
void SetIsBlockedByVehicle(bool isBlocked);
};
assert_struct_size(RCT12PathElement, 8);
struct RCT12TrackElement : RCT12TileElementBase
@@ -503,27 +472,9 @@ public:
// RCT1 feature, reintroduced by OpenRCT2. See https://github.com/OpenRCT2/OpenRCT2/issues/7059
uint8_t GetDoorAState() const;
uint8_t GetDoorBState() const;
void SetDoorAState(uint8_t newState);
void SetDoorBState(uint8_t newState);
void SetTrackType(uint8_t newEntryIndex);
void SetSequenceIndex(uint8_t newSequenceIndex);
void SetRideIndex(uint8_t newRideIndex);
void SetColourScheme(uint8_t newColourScheme);
void SetStationIndex(uint8_t newStationIndex);
void SetHasChain(bool on);
void SetHasCableLift(bool on);
void SetInverted(bool inverted);
bool BlockBrakeClosed() const;
void SetBlockBrakeClosed(bool isClosed);
void SetBrakeBoosterSpeed(uint8_t speed);
void SetHasGreenLight(uint8_t greenLight);
void SetSeatRotation(uint8_t newSeatRotation);
void SetMazeEntry(uint16_t newMazeEntry);
void SetPhotoTimeout(uint8_t newValue);
bool IsIndestructible() const;
void SetIsIndestructible(bool isIndestructible);
};
assert_struct_size(RCT12TrackElement, 8);
struct RCT12SmallSceneryElement : RCT12TileElementBase
@@ -540,13 +491,6 @@ public:
colour_t GetPrimaryColour() const;
colour_t GetSecondaryColour() const;
bool NeedsSupports() const;
void SetEntryIndex(RCT12ObjectEntryIndex newIndex);
void SetAge(uint8_t newAge);
void SetSceneryQuadrant(uint8_t newQuadrant);
void SetPrimaryColour(colour_t colour);
void SetSecondaryColour(colour_t colour);
void SetNeedsSupports();
};
assert_struct_size(RCT12SmallSceneryElement, 8);
struct RCT12LargeSceneryElement : RCT12TileElementBase
@@ -560,12 +504,6 @@ public:
colour_t GetPrimaryColour() const;
colour_t GetSecondaryColour() const;
uint8_t GetBannerIndex() const;
void SetEntryIndex(uint32_t newIndex);
void SetSequenceIndex(uint16_t sequence);
void SetPrimaryColour(colour_t colour);
void SetSecondaryColour(colour_t colour);
void SetBannerIndex(uint8_t newIndex);
};
assert_struct_size(RCT12LargeSceneryElement, 8);
struct RCT12WallElement : RCT12TileElementBase
@@ -592,16 +530,6 @@ public:
int32_t GetRCT1WallType(int32_t edge) const;
colour_t GetRCT1WallColour() const;
uint8_t GetRCT1Slope() const;
void SetEntryIndex(RCT12ObjectEntryIndex newIndex);
void SetSlope(uint8_t newslope);
void SetPrimaryColour(colour_t newColour);
void SetSecondaryColour(colour_t newColour);
void SetTertiaryColour(colour_t newColour);
void SetAnimationFrame(uint8_t frameNum);
void SetBannerIndex(uint8_t newIndex);
void SetAcrossTrack(bool acrossTrack);
void SetAnimationIsBackwards(bool isBackwards);
};
assert_struct_size(RCT12WallElement, 8);
struct RCT12EntranceElement : RCT12TileElementBase
@@ -617,12 +545,6 @@ public:
uint8_t GetStationIndex() const;
uint8_t GetSequenceIndex() const;
uint8_t GetPathType() const;
void SetEntranceType(uint8_t newType);
void SetRideIndex(uint8_t newRideIndex);
void SetStationIndex(uint8_t stationIndex);
void SetSequenceIndex(uint8_t newSequenceIndex);
void SetPathType(uint8_t newPathType);
};
assert_struct_size(RCT12EntranceElement, 8);
struct RCT12BannerElement : RCT12TileElementBase
@@ -639,10 +561,6 @@ public:
uint8_t GetIndex() const;
uint8_t GetPosition() const;
uint8_t GetAllowedEdges() const;
void SetIndex(uint8_t newIndex);
void SetPosition(uint8_t newPosition);
void SetAllowedEdges(uint8_t newEdges);
};
assert_struct_size(RCT12BannerElement, 8);