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

Flying coaster track additions

This commit is contained in:
spacek531 2022-08-10 15:54:33 -07:00 committed by GitHub
parent ce03c228ad
commit 48530026a2
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
10 changed files with 2308 additions and 63 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
distribution/changelog.txt
View File

@ -1,7 +1,8 @@
0.4.2 (in development)
------------------------------------------------------------------------
- Feature: [#13634] Add ability to sell merchandise in random colours.
- Feature: [#16283] Added parkinfo command line tool to list objects in a save file.
- Feature: [#16164] Add new track elements for Flying Coaster and Lay-Down Coaster and add paint code for more elements.
- Feature: [#16283] Added parkinfo command line tool to list objects in a save file.
- Feature: [#16662] Show a warning message when g2.dat is mismatched.
- Feature: [#17107] Ride operating settings can be set via text input.
- Feature: [#17638] Added Zero G rolls, medium loops and large corkscrews to the Hybrid and Single-Rail coasters.

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

@ -4908,7 +4908,7 @@ OpenRCT2::BitSet<TRACK_GROUP_COUNT> ride_entry_get_supported_track_pieces(const
{ SpriteGroupType::Slopes90, SpritePrecision::Sprites4, SpriteGroupType::SlopesLoop, SpritePrecision::Sprites4,
SpriteGroupType::SlopeInverted, SpritePrecision::Sprites4 }, // TRACK_QUARTER_LOOP
{ SpriteGroupType::SlopeFlat, SpritePrecision::Sprites4 }, // TRACK_SPINNING_TUNNEL
{ SpriteGroupType::SlopeFlat, SpritePrecision::Sprites4 }, // TRACK_ROTATION_CONTROL_TOGGLE
{ SpriteGroupType::SlopeFlat, SpritePrecision::Sprites4 }, // TRACK_BOOSTER
{ SpriteGroupType::FlatBanked22, SpritePrecision::Sprites4, SpriteGroupType::FlatBanked45, SpritePrecision::Sprites4,
SpriteGroupType::FlatBanked67, SpritePrecision::Sprites4, SpriteGroupType::FlatBanked90, SpritePrecision::Sprites4,
SpriteGroupType::InlineTwists, SpritePrecision::Sprites4, SpriteGroupType::SlopeInverted,
@ -4919,17 +4919,22 @@ OpenRCT2::BitSet<TRACK_GROUP_COUNT> ride_entry_get_supported_track_pieces(const
SpritePrecision::Sprites4 }, // TRACK_INLINE_TWIST_INVERTED
{ SpriteGroupType::Slopes25, SpritePrecision::Sprites4, SpriteGroupType::Slopes60, SpritePrecision::Sprites4,
SpriteGroupType::Slopes75, SpritePrecision::Sprites4, SpriteGroupType::Slopes90,
SpritePrecision::Sprites4 }, // TRACK_QUARTER_LOOP_UNINVERTED
SpritePrecision::Sprites4 }, // TRACK_QUARTER_LOOP_UNINVERTED_UP
{ SpriteGroupType::Slopes25, SpritePrecision::Sprites4, SpriteGroupType::Slopes60, SpritePrecision::Sprites4,
SpriteGroupType::Slopes75, SpritePrecision::Sprites4, SpriteGroupType::Slopes90,
SpritePrecision::Sprites4 }, // TRACK_QUARTER_LOOP_UNINVERTED_DOWN
{ SpriteGroupType::Slopes90, SpritePrecision::Sprites4, SpriteGroupType::SlopesLoop, SpritePrecision::Sprites4,
SpriteGroupType::SlopeInverted, SpritePrecision::Sprites4 }, // TRACK_QUARTER_LOOP_INVERTED
SpriteGroupType::SlopeInverted, SpritePrecision::Sprites4 }, // TRACK_QUARTER_LOOP_INVERTED_UP
{ SpriteGroupType::Slopes90, SpritePrecision::Sprites4, SpriteGroupType::SlopesLoop, SpritePrecision::Sprites4,
SpriteGroupType::SlopeInverted, SpritePrecision::Sprites4 }, // TRACK_QUARTER_LOOP_INVERTED_DOWN
{ SpriteGroupType::Slopes12, SpritePrecision::Sprites4 }, // TRACK_RAPIDS
{ SpriteGroupType::Slopes25, SpritePrecision::Sprites4, SpriteGroupType::Slopes60, SpritePrecision::Sprites4,
SpriteGroupType::Slopes75, SpritePrecision::Sprites4, SpriteGroupType::Slopes90,
SpritePrecision::Sprites4 }, // TRACK_HALF_LOOP_UNINVERTED
SpritePrecision::Sprites4 }, // TRACK_FLYING_HALF_LOOP_UNINVERTED_UP
{ SpriteGroupType::Slopes25, SpritePrecision::Sprites4, SpriteGroupType::Slopes60, SpritePrecision::Sprites4,
SpriteGroupType::Slopes75, SpritePrecision::Sprites4, SpriteGroupType::Slopes90, SpritePrecision::Sprites4,
SpriteGroupType::SlopesLoop, SpritePrecision::Sprites4, SpriteGroupType::SlopeInverted,
SpritePrecision::Sprites4 }, // TRACK_HALF_LOOP_INVERTED
SpritePrecision::Sprites4 }, // TRACK_FLYING_HALF_LOOP_INVERTED_DOWN
{ SpriteGroupType::SlopeFlat, SpritePrecision::Sprites4 }, // TRACK_WATERFALL
{ SpriteGroupType::SlopeFlat, SpritePrecision::Sprites4 }, // TRACK_WHIRLPOOL
{ SpriteGroupType::Slopes25, SpritePrecision::Sprites4, SpriteGroupType::Slopes60,
@ -4943,6 +4948,30 @@ OpenRCT2::BitSet<TRACK_GROUP_COUNT> ride_entry_get_supported_track_pieces(const
{}, // TRACK_MINI_GOLF_HOLE
{ SpriteGroupType::SlopeFlat, SpritePrecision::Sprites4 }, // TRACK_ROTATION_CONTROL_TOGGLE
{ SpriteGroupType::Slopes60, SpritePrecision::Sprites4 }, // TRACK_SLOPE_STEEP_UP
{}, // TRACK_CORKSCREW_LARGE
{}, // TRACK_HALF_LOOP_MEDIUM
{}, // TRACK_ZERO_G_ROLL
{}, // TRACK_ZERO_G_ROLL_LARGE
{ SpriteGroupType::Slopes25, SpritePrecision::Sprites4, SpriteGroupType::Slopes60, SpritePrecision::Sprites4,
SpriteGroupType::Slopes75, SpritePrecision::Sprites4, SpriteGroupType::Slopes90,
SpritePrecision::Sprites4 }, // TRACK_FLYING_LARGE_HALF_LOOP_UNINVERTED_UP
{ SpriteGroupType::Slopes25, SpritePrecision::Sprites4, SpriteGroupType::Slopes60, SpritePrecision::Sprites4,
SpriteGroupType::Slopes75, SpritePrecision::Sprites4, SpriteGroupType::Slopes90, SpritePrecision::Sprites4,
SpriteGroupType::SlopesLoop, SpritePrecision::Sprites4, SpriteGroupType::SlopeInverted,
SpritePrecision::Sprites4 }, // TRACK_FLYING_LARGE_HALF_LOOP_INVERTED_DOWN
{ SpriteGroupType::Slopes25, SpritePrecision::Sprites4, SpriteGroupType::Slopes60, SpritePrecision::Sprites4,
SpriteGroupType::Slopes75, SpritePrecision::Sprites4, SpriteGroupType::Slopes90, SpritePrecision::Sprites4,
SpriteGroupType::SlopesLoop, SpritePrecision::Sprites4, SpriteGroupType::SlopeInverted,
SpritePrecision::Sprites4 }, // TRACK_FLYING_LARGE_HALF_LOOP_UNINVERTED_DOWN
{ SpriteGroupType::Slopes25, SpritePrecision::Sprites4, SpriteGroupType::Slopes60, SpritePrecision::Sprites4,
SpriteGroupType::Slopes75, SpritePrecision::Sprites4, SpriteGroupType::Slopes90,
SpritePrecision::Sprites4 }, // TRACK_FLYING_LARGE_HALF_LOOP_INVERTED_UP
{ SpriteGroupType::Slopes25, SpritePrecision::Sprites4, SpriteGroupType::Slopes60, SpritePrecision::Sprites4,
SpriteGroupType::Slopes75, SpritePrecision::Sprites4, SpriteGroupType::Slopes90,
SpritePrecision::Sprites4 }, // TRACK_FLYING_HALF_LOOP_INVERTED_UP
{ SpriteGroupType::Slopes25, SpritePrecision::Sprites4, SpriteGroupType::Slopes60, SpritePrecision::Sprites4,
SpriteGroupType::Slopes75, SpritePrecision::Sprites4, SpriteGroupType::Slopes90,
SpritePrecision::Sprites4 }, // TRACK_FLYING_HALF_LOOP_UNINVERTED_DOWN
};
// Only check default vehicle; it's assumed the others will have correct sprites if this one does (I've yet to find an

46
src/openrct2/ride/Track.h
View File

@ -111,6 +111,7 @@ enum
constexpr uint16_t const MAX_TRACK_HEIGHT = 254 * COORDS_Z_STEP;
constexpr uint8_t const DEFAULT_SEAT_ROTATION = 4;
// Vehicle sprite groups required by track groups are defined in ride_entry_get_supported_track_pieces
enum
{
TRACK_NONE = 0,
@ -165,11 +166,13 @@ enum
TRACK_BOOSTER,
TRACK_INLINE_TWIST_UNINVERTED,
TRACK_INLINE_TWIST_INVERTED,
TRACK_QUARTER_LOOP_UNINVERTED,
TRACK_QUARTER_LOOP_INVERTED,
TRACK_QUARTER_LOOP_UNINVERTED_UP,
TRACK_QUARTER_LOOP_UNINVERTED_DOWN,
TRACK_QUARTER_LOOP_INVERTED_UP,
TRACK_QUARTER_LOOP_INVERTED_DOWN,
TRACK_RAPIDS,
TRACK_HALF_LOOP_UNINVERTED,
TRACK_HALF_LOOP_INVERTED,
TRACK_FLYING_HALF_LOOP_UNINVERTED_UP,
TRACK_FLYING_HALF_LOOP_INVERTED_DOWN,
TRACK_WATERFALL,
TRACK_WHIRLPOOL,
@ -186,6 +189,14 @@ enum
TRACK_ZERO_G_ROLL,
TRACK_ZERO_G_ROLL_LARGE,
TRACK_FLYING_LARGE_HALF_LOOP_UNINVERTED_UP,
TRACK_FLYING_LARGE_HALF_LOOP_INVERTED_DOWN,
TRACK_FLYING_LARGE_HALF_LOOP_UNINVERTED_DOWN,
TRACK_FLYING_LARGE_HALF_LOOP_INVERTED_UP,
TRACK_FLYING_HALF_LOOP_UNINVERTED_DOWN,
TRACK_FLYING_HALF_LOOP_INVERTED_UP,
TRACK_GROUP_COUNT,
};
@ -351,8 +362,6 @@ namespace TrackElemType
constexpr track_type_t RotationControlToggleAlias = 100;
constexpr track_type_t Booster = 100;
constexpr track_type_t Maze = 101;
// Used by the multi-dimension coaster, as TD6 cannot handle index 255.
constexpr track_type_t InvertedUp90ToFlatQuarterLoopAlias = 101;
constexpr track_type_t LeftQuarterBankedHelixLargeUp = 102;
constexpr track_type_t RightQuarterBankedHelixLargeUp = 103;
constexpr track_type_t LeftQuarterBankedHelixLargeDown = 104;
@ -442,8 +451,8 @@ namespace TrackElemType
constexpr track_type_t RightFlyerTwistUp = 188;
constexpr track_type_t LeftFlyerTwistDown = 189;
constexpr track_type_t RightFlyerTwistDown = 190;
constexpr track_type_t FlyerHalfLoopUp = 191;
constexpr track_type_t FlyerHalfLoopDown = 192;
constexpr track_type_t FlyerHalfLoopUninvertedUp = 191;
constexpr track_type_t FlyerHalfLoopInvertedDown = 192;
constexpr track_type_t LeftFlyerCorkscrewUp = 193;
constexpr track_type_t RightFlyerCorkscrewUp = 194;
constexpr track_type_t LeftFlyerCorkscrewDown = 195;
@ -520,8 +529,8 @@ namespace TrackElemType
constexpr track_type_t FlatTrack1x4C = 265;
constexpr track_type_t FlatTrack3x3 = 266;
constexpr track_type_t None = 65535;
// SV6/TD6 element aliases
constexpr track_type_t InvertedUp90ToFlatQuarterLoopAlias = 101;
constexpr track_type_t FlatTrack1x4A_Alias = 95;
constexpr track_type_t FlatTrack2x2_Alias = 110;
constexpr track_type_t FlatTrack4x4_Alias = 111;
@ -533,8 +542,10 @@ namespace TrackElemType
constexpr track_type_t FlatTrack1x4C_Alias = 122;
constexpr track_type_t FlatTrack3x3_Alias = 123;
// Highest track element ID that has a TD6 alias
constexpr track_type_t HighestAlias = 266;
// Track Elements specific to OpenRCT2
constexpr track_type_t LeftLargeCorkscrewUp = 267;
constexpr track_type_t RightLargeCorkscrewUp = 268;
constexpr track_type_t LeftLargeCorkscrewDown = 269;
@ -552,7 +563,20 @@ namespace TrackElemType
constexpr track_type_t LeftLargeZeroGRollDown = 281;
constexpr track_type_t RightLargeZeroGRollDown = 282;
constexpr track_type_t Count = 283;
constexpr track_type_t LeftFlyerLargeHalfLoopUninvertedUp = 283;
constexpr track_type_t RightFlyerLargeHalfLoopUninvertedUp = 284;
constexpr track_type_t RightFlyerLargeHalfLoopInvertedDown = 285;
constexpr track_type_t LeftFlyerLargeHalfLoopInvertedDown = 286;
constexpr track_type_t LeftFlyerLargeHalfLoopInvertedUp = 287;
constexpr track_type_t RightFlyerLargeHalfLoopInvertedUp = 288;
constexpr track_type_t RightFlyerLargeHalfLoopUninvertedDown = 289;
constexpr track_type_t LeftFlyerLargeHalfLoopUninvertedDown = 290;
constexpr track_type_t FlyerHalfLoopInvertedUp = 291;
constexpr track_type_t FlyerHalfLoopUninvertedDown = 292;
constexpr track_type_t Count = 293;
constexpr track_type_t None = 65535;
}; // namespace TrackElemType

306
src/openrct2/ride/TrackData.cpp
View File

@ -301,6 +301,16 @@ static constexpr rct_track_coordinates TrackCoordinates[TrackElemType::Count] =
{ 0, 0, 0, 152, -96, 0 }, // TrackElemType::RightLargeZeroGRollUp
{ 0, 0, 0, -152,-96, 0 }, // TrackElemType::RightLargeZeroGRollDown
{ 0, 0, 0, -152,-96, 0 }, // TrackElemType::LeftLargeZeroGRollDown
{ 0, 2, 0, 248, -64, -32 }, // TrackElemType::LeftFlyerLargeHalfLoopUninvertedUp
{ 0, 2, 0, 248, -64, 32 }, // TrackElemType::RightFlyerLargeHalfLoopUninvertedUp
{ 0, 2, 0, -248, 64, -32 }, // TrackElemType::RightFlyerLargeHalfLoopInvertedDown
{ 0, 2, 0, -248, 64, 32 }, // TrackElemType::LeftFlyerLargeHalfLoopInvertedDown
{ 0, 2, 0, 280, -64, -32 }, // TrackElemType::LeftFlyerLargeHalfLoopInvertedUp
{ 0, 2, 0, 280, -64, 32 }, // TrackElemType::RightFlyerLargeHalfLoopInvertedUp
{ 0, 2, 0, -280, 64, -32 }, // TrackElemType::RightFlyerLargeHalfLoopUninvertedDown
{ 0, 2, 0, -280, 64, 32 }, // TrackElemType::LeftFlyerLargeHalfLoopUninvertedDown
{ 0, 2, 0, 152, -32, 0 }, // TrackElemType::FlyerHalfLoopInvertedUp
{ 0, 2, 0, -152, 32, 0 }, // TrackElemType::FlyerHalfLoopUninvertedDown
};
/** rct2: 0x0099BA64 */
@ -589,6 +599,16 @@ static constexpr uint8_t TrackSequenceProperties[][MaxSequencesPerPiece] = {
{ 0 }, // TrackElemType::RightLargeZeroGRollDown
{ 0 }, // TrackElemType::LeftLargeZeroGRollDown
/* LeftFlyerLargeHalfLoopUninvertedUp */ { 0 },
/* RightFlyerLargeHalfLoopUninvertedUp */ { 0 },
/* RightFlyerLargeHalfLoopInvertedDown */ { 0 },
/* LeftFlyerLargeHalfLoopInvertedDown */ { 0 },
/* LeftFlyerLargeHalfLoopInvertedUp */ { 0 },
/* RightFlyerLargeHalfLoopInvertedUp */ { 0 },
/* RightFlyerLargeHalfLoopUninvertedDown */ { 0 },
/* LeftFlyerLargeHalfLoopUninvertedDown */ { 0 },
/* FlyerHalfLoopInvertedUp */ { 0 },
/* FlyerHalfLoopUninvertedUp */ { 0 },
};
#define TRACK_BLOCK_END { 255, 255, 255, 255, 255, {255, 255}, 255 }
@ -2716,6 +2736,110 @@ static constexpr const rct_preview_track TrackBlocksRightLargeZeroGRollDown[] =
TRACK_BLOCK_END
};
static constexpr const rct_preview_track TrackBlocksLeftFlyerLargeHalfLoopUninvertedUp[] = {
{ 0, 0, 0, 0, 24, { 0b1111, 0b1100 }, 0 },
{ 1, -32, 0, 16, 40, { 0b1111, 0b1100 }, 0 },
{ 2, -64, 0, 32, 56, { 0b1111, 0 }, 0 },
{ 3, -96, 0, 64, 192, { 0b1111, 0 }, 0 },
{ 4, -128, -32, 120, 96, { 0b1111, 0 }, 0 },
{ 5, -96, -32, 64, 192, { 0b1111, 0 }, 0 },
{ 6, -64, -32, 248, 16, { 0b1111, 0 }, 0 },
TRACK_BLOCK_END
};
static constexpr const rct_preview_track TrackBlocksRightFlyerLargeHalfLoopUninvertedUp[] = {
{ 0, 0, 0, 0, 24, { 0b1111, 0b1100 }, 0 },
{ 1, -32, 0, 16, 40, { 0b1111, 0b1100 }, 0 },
{ 2, -64, 0, 32, 56, { 0b1111, 0 }, 0 },
{ 3, -96, 0, 64, 192, { 0b1111, 0 }, 0 },
{ 4, -128, 32, 120, 96, { 0b1111, 0 }, 0 },
{ 5, -96, 32, 64, 192, { 0b1111, 0 }, 0 },
{ 6, -64, 32, 248, 16, { 0b1111, 0 }, 0 },
TRACK_BLOCK_END
};
static constexpr const rct_preview_track TrackBlocksLeftFlyerLargeHalfLoopInvertedUp[] = {
{ 0, 0, 0, 0, 24, { 0b1111, 0b1100 }, 0 },
{ 1, -32, 0, 16, 40, { 0b1111, 0b1100 }, 0 },
{ 2, -64, 0, 32, 56, { 0b1111, 0 }, 0 },
{ 3, -96, 0, 64, 192, { 0b1111, 0 }, 0 },
{ 4, -128, -32, 120, 96, { 0b1111, 0 }, 0 },
{ 5, -96, -32, 64, 192, { 0b1111, 0 }, 0 },
{ 6, -64, -32, 248, 32, { 0b1111, 0 }, 0 },
TRACK_BLOCK_END
};
static constexpr const rct_preview_track TrackBlocksRightFlyerLargeHalfLoopInvertedUp[] = {
{ 0, 0, 0, 0, 24, { 0b1111, 0b1100 }, 0 },
{ 1, -32, 0, 16, 40, { 0b1111, 0b1100 }, 0 },
{ 2, -64, 0, 32, 56, { 0b1111, 0 }, 0 },
{ 3, -96, 0, 64, 192, { 0b1111, 0 }, 0 },
{ 4, -128, 32, 120, 96, { 0b1111, 0 }, 0 },
{ 5, -96, 32, 64, 192, { 0b1111, 0 }, 0 },
{ 6, -64, 32, 248, 32, { 0b1111, 0 }, 0 },
TRACK_BLOCK_END
};
static constexpr const rct_preview_track TrackBlocksRightFlyerLargeHalfLoopInvertedDown[] = {
{ 0, 0, 0, 0, 24, { 0b1111, 0 }, 0 },
{ 1, -32, 0, -184, 192, { 0b1111, 0 }, 0 },
{ 2, -64, 0, -128, 96, { 0b1111, 0 }, 0 },
{ 3, -32, -32, -184, 192, { 0b1111, 0 }, 0 },
{ 4, 0, -32, -216, 56, { 0b1111, 0 }, 0 },
{ 5, 32, -32, -232, 40, { 0b1111, 0b1100 }, 0 },
{ 6, 64, -32, -248, 24, { 0b1111, 0b1100 }, 0 },
TRACK_BLOCK_END
};
static constexpr const rct_preview_track TrackBlocksLeftFlyerLargeHalfLoopInvertedDown[] = {
{ 0, 0, 0, 0, 24, { 0b1111, 0 }, 0 },
{ 1, -32, 0, -184, 192, { 0b1111, 0 }, 0 },
{ 2, -64, 0, -128, 96, { 0b1111, 0 }, 0 },
{ 3, -32, 32, -184, 192, { 0b1111, 0 }, 0 },
{ 4, 0, 32, -216, 56, { 0b1111, 0 }, 0 },
{ 5, 32, 32, -232, 40, { 0b1111, 0b1100 }, 0 },
{ 6, 64, 32, -248, 24, { 0b1111, 0b1100 }, 0 },
TRACK_BLOCK_END
};
static constexpr const rct_preview_track TrackBlocksRightFlyerLargeHalfLoopUninvertedDown[] = {
{ 0, 0, 0, -32, 40, { 0b1111, 0 }, 0 },
{ 1, -32, 0, -216, 192, { 0b1111, 0 }, 0 },
{ 2, -64, 0, -160, 96, { 0b1111, 0 }, 0 },
{ 3, -32, -32, -216, 192, { 0b1111, 0 }, 0 },
{ 4, 0, -32, -248, 56, { 0b1111, 0 }, 0 },
{ 5, 32, -32, -264, 40, { 0b1111, 0b1100 }, 0 },
{ 6, 64, -32, -280, 24, { 0b1111, 0b1100 }, 0 },
TRACK_BLOCK_END
};
static constexpr const rct_preview_track TrackBlocksLeftFlyerLargeHalfLoopUninvertedDown[] = {
{ 0, 0, 0, -32, 40, { 0b1111, 0 }, 0 },
{ 1, -32, 0, -216, 192, { 0b1111, 0 }, 0 },
{ 2, -64, 0, -160, 96, { 0b1111, 0 }, 0 },
{ 3, -32, 32, -216, 192, { 0b1111, 0 }, 0 },
{ 4, 0, 32, -248, 56, { 0b1111, 0 }, 0 },
{ 5, 32, 32, -264, 40, { 0b1111, 0b1100 }, 0 },
{ 6, 64, 32, -280, 24, { 0b1111, 0b1100 }, 0 },
TRACK_BLOCK_END
};
static constexpr const rct_preview_track TrackBlocksFlyerHalfLoopUpInverted[] = {
{ 0, 0, 0, 0, 32, { 0b1111, 0b1100 }, 0 },
{ 1, -32, 0, 16, 16, { 0b1111, 0b1100 }, 0 },
{ 2, -64, 0, 32, 96,{ 0b0011, 0 }, 0 },
{ 3, -32, 0, 120, 32, { 0b1111, 0 }, 0 },
TRACK_BLOCK_END
};
static constexpr const rct_preview_track TrackBlocksFlyerHalfLoopDownUpright[] = {
{ 0, 0, 0, -32, 32, { 0b1111, 0 }, 0 },
{ 1, -32, 0, -120, 96,{ 0b0011, 0 }, 0 },
{ 2, 0, 0, -136, 16, { 0b1111, 0b1100 }, 0 },
{ 3, 32, 0, -152, 16, { 0b1111, 0b1100 }, 0 },
TRACK_BLOCK_END
};
// rct2: 0x00994638
static constexpr std::array<const rct_preview_track*, TrackElemType::Count> TrackBlocks = {
@ -3003,6 +3127,17 @@ static constexpr std::array<const rct_preview_track*, TrackElemType::Count> Trac
TrackBlocksRightLargeZeroGRollUp,
TrackBlocksLeftLargeZeroGRollDown,
TrackBlocksRightLargeZeroGRollDown,
TrackBlocksLeftFlyerLargeHalfLoopUninvertedUp, // LeftFlyerLargeHalfLoopUninvertedUp
TrackBlocksRightFlyerLargeHalfLoopUninvertedUp, // RightFlyerLargeHalfLoopUninvertedUp
TrackBlocksRightFlyerLargeHalfLoopInvertedDown, // RightFlyerLargeHalfLoopInvertedDown
TrackBlocksLeftFlyerLargeHalfLoopInvertedDown, // LeftFlyerLargeHalfLoopInvertedDown
TrackBlocksLeftFlyerLargeHalfLoopInvertedUp, // TrackElemType::LeftFlyerLargeHalfLoopInvertedUp
TrackBlocksRightFlyerLargeHalfLoopInvertedUp, // TrackElemType::RightFlyerLargeHalfLoopInvertedUp
TrackBlocksRightFlyerLargeHalfLoopUninvertedDown, // TrackElemType::RightFlyerLargeHalfLoopUninvertedDown
TrackBlocksLeftFlyerLargeHalfLoopUninvertedDown, // TrackElemType::LeftFlyerLargeHalfLoopUninvertedDown
TrackBlocksFlyerHalfLoopUpInverted, // TrackElemType::FlyerHalfLoopInvertedUp
TrackBlocksFlyerHalfLoopDownUpright, // TrackElemType::FlyerHalfLoopUninvertedDown
};
static constexpr uint8_t TrackPieceLengths[TrackElemType::Count] = {
@ -3197,8 +3332,8 @@ static constexpr uint8_t TrackPieceLengths[TrackElemType::Count] = {
96, // TrackElemType::RightFlyerTwistUp
96, // TrackElemType::LeftFlyerTwistDown
96, // TrackElemType::RightFlyerTwistDown
64, // TrackElemType::FlyerHalfLoopUp
64, // TrackElemType::FlyerHalfLoopDown
64, // TrackElemType::FlyerHalfLoopUninvertedUp
64, // TrackElemType::FlyerHalfLoopInvertedDown
64, // TrackElemType::LeftFlyerCorkscrewUp
64, // TrackElemType::RightFlyerCorkscrewUp
64, // TrackElemType::LeftFlyerCorkscrewDown
@ -3288,7 +3423,17 @@ static constexpr uint8_t TrackPieceLengths[TrackElemType::Count] = {
165, // TrackElemType::LeftLargeZeroGRollUp
165, // TrackElemType::RightLargeZeroGRollUp
165, // TrackElemType::RightLargeZeroGRollDown
165 // TrackElemType::LeftLargeZeroGRollDown
165, // TrackElemType::LeftLargeZeroGRollDown
100, // TrackElemType::LeftFlyerLargeHalfLoopUninvertedUp
100, // TrackElemType::RightFlyerLargeHalfLoopUninvertedUp
100, // TrackElemType::RightFlyerLargeHalfLoopInvertedDown
100, // TrackElemType::LeftFlyerLargeHalfLoopInvertedDown
100, // TrackElemType::LeftFlyerLargeHalfLoopInvertedUp
100, // TrackElemType::RightFlyerLargeHalfLoopInvertedUp
100, // TrackElemType::RightFlyerLargeHalfLoopUninvertedDown
100, // TrackElemType::LeftFlyerLargeHalfLoopUninvertedDown
64, // TrackElemType::FlyerHalfLoopInvertedUp
64, // TrackElemType::FlyerHalfLoopUninvertedDown
};
// rct2: 0x00998C95
@ -3576,6 +3721,16 @@ static constexpr track_curve_chain gTrackCurveChain[TrackElemType::Count] = {
{ RideConstructionSpecialPieceSelected | TrackElemType::RightLargeZeroGRollDown, TRACK_CURVE_NONE }, // TrackElemType::RightLargeZeroGRollUp
{ TRACK_CURVE_NONE, RideConstructionSpecialPieceSelected | TrackElemType::LeftLargeZeroGRollUp }, // TrackElemType::LeftLargeZeroGRollDown
{ TRACK_CURVE_NONE, RideConstructionSpecialPieceSelected | TrackElemType::RightLargeZeroGRollUp }, // TrackElemType::RightLargeZeroGRollDown
{ RideConstructionSpecialPieceSelected | TrackElemType::LeftFlyerLargeHalfLoopInvertedDown, TRACK_CURVE_NONE }, // LeftFlyerLargeHalfLoopUninvertedUp
{ RideConstructionSpecialPieceSelected | TrackElemType::RightFlyerLargeHalfLoopInvertedDown, TRACK_CURVE_NONE }, // RightFlyerLargeHalfLoopUninvertedUp
{ TRACK_CURVE_NONE, RideConstructionSpecialPieceSelected | TrackElemType::RightFlyerLargeHalfLoopUninvertedUp }, // RightFlyerLargeHalfLoopInvertedDown
{ TRACK_CURVE_NONE, RideConstructionSpecialPieceSelected | TrackElemType::LeftFlyerLargeHalfLoopUninvertedUp }, // LeftFlyerLargeHalfLoopInvertedDown
{ RideConstructionSpecialPieceSelected | TrackElemType::LeftFlyerLargeHalfLoopUninvertedDown, TRACK_CURVE_NONE}, // LeftFlyerLargeHalfLoopInvertedUp
{ RideConstructionSpecialPieceSelected | TrackElemType::RightFlyerLargeHalfLoopUninvertedDown, TRACK_CURVE_NONE }, // RightFlyerLargeHalfLoopInvertedUp
{ TRACK_CURVE_NONE, RideConstructionSpecialPieceSelected | TrackElemType::RightFlyerLargeHalfLoopInvertedUp }, // RightFlyerLargeHalfLoopUninvertedDown
{ TRACK_CURVE_NONE, RideConstructionSpecialPieceSelected | TrackElemType::LeftFlyerLargeHalfLoopInvertedUp }, // LeftFlyerLargeHalfLoopUninvertedDown
{ TRACK_CURVE_NONE, TRACK_CURVE_NONE }, // FlyerHalfLoopInvertedUp
{ TRACK_CURVE_NONE, TRACK_CURVE_NONE }, // FlyerHalfLoopUninvertedUp
};
const track_descriptor gTrackDescriptors[142] = {
@ -4007,7 +4162,13 @@ static constexpr track_type_t AlternativeTrackTypes[TrackElemType::Count] = {
TrackElemType::None, // TrackElemType::LeftLargeZeroGRollUp
TrackElemType::None, // TrackElemType::RightLargeZeroGRollUp
TrackElemType::None, // TrackElemType::LeftLargeZeroGRollDown
TrackElemType::None // TrackElemType::RightLargeZeroGRollDown
TrackElemType::None, // TrackElemType::RightLargeZeroGRollDown
TrackElemType::None, // LeftFlyerLargeHalfLoopUninvertedUp
TrackElemType::None, // RightFlyerLargeHalfLoopUninvertedUp
TrackElemType::None, // RightFlyerLargeHalfLoopInvertedDown
TrackElemType::None, // LeftFlyerLargeHalfLoopInvertedDown
TrackElemType::None, // FlyerHalfLoopInvertedUp
TrackElemType::None, // FlyerHalfLoopUninvertedDown
};
/** rct2: 0x0099DA34 */
@ -4113,7 +4274,7 @@ static constexpr money32 TrackPricing[TrackElemType::Count] = {
126976, // TrackElemType::RightQuarterTurn1TileDown60
90112, // TrackElemType::Brakes
77824, // TrackElemType::Booster
65536, // TrackElemType::InvertedUp90ToFlatQuarterLoopAlias / Maze
65536, // TrackElemType::Maze
273539, // TrackElemType::LeftQuarterBankedHelixLargeUp
273539, // TrackElemType::RightQuarterBankedHelixLargeUp
273539, // TrackElemType::LeftQuarterBankedHelixLargeDown
@ -4203,8 +4364,8 @@ static constexpr money32 TrackPricing[TrackElemType::Count] = {
221184, // TrackElemType::RightFlyerTwistUp
221184, // TrackElemType::LeftFlyerTwistDown
221184, // TrackElemType::RightFlyerTwistDown
294912, // TrackElemType::FlyerHalfLoopUp
294912, // TrackElemType::FlyerHalfLoopDown
294912, // TrackElemType::FlyerHalfLoopUninvertedUp
294912, // TrackElemType::FlyerHalfLoopInvertedDown
229376, // TrackElemType::LeftFlyerCorkscrewUp
229376, // TrackElemType::RightFlyerCorkscrewUp
229376, // TrackElemType::LeftFlyerCorkscrewDown
@ -4295,6 +4456,16 @@ static constexpr money32 TrackPricing[TrackElemType::Count] = {
425984, // TrackElemType::RightLargeZeroGRollUp
425984, // TrackElemType::LeftLargeZeroGRollDown
425984, // TrackElemType::RightLargeZeroGRollDown
884736, // TrackElemType::LeftFlyerLargeHalfLoopUninvertedUp
884736, // TrackElemType::RightFlyerLargeHalfLoopUninvertedUp
884736, // TrackElemType::RightFlyerLargeHalfLoopInvertedDown
884736, // TrackElemType::LeftFlyerLargeHalfLoopInvertedDown
884736, // TrackElemType::LeftFlyerLargeHalfLoopInvertedUp
884736, // TrackElemType::RightFlyerLargeHalfLoopInvertedUp
884736, // TrackElemType::RightFlyerLargeHalfLoopUnivertedDown
884736, // TrackElemType::LeftFlyerLargeHalfLoopUninvertedDown
294912, // TrackElemType::FlyerHalfLoopInvertedUp
294912, // TrackElemType::FlyerHalfLoopUninvertedDown
};
/** rct2: 0x0099EA1C */
@ -4490,8 +4661,8 @@ static constexpr track_type_t TrackElementMirrorMap[TrackElemType::Count] = {
TrackElemType::LeftFlyerTwistUp, // TrackElemType::RightFlyerTwistUp
TrackElemType::RightFlyerTwistDown, // TrackElemType::LeftFlyerTwistDown
TrackElemType::LeftFlyerTwistDown, // TrackElemType::RightFlyerTwistDown
TrackElemType::FlyerHalfLoopUp,
TrackElemType::FlyerHalfLoopDown,
TrackElemType::FlyerHalfLoopUninvertedUp,
TrackElemType::FlyerHalfLoopInvertedDown,
TrackElemType::RightFlyerCorkscrewUp, // TrackElemType::LeftFlyerCorkscrewUp
TrackElemType::LeftFlyerCorkscrewUp, // TrackElemType::RightFlyerCorkscrewUp
TrackElemType::RightFlyerCorkscrewDown, // TrackElemType::LeftFlyerCorkscrewDown
@ -4582,6 +4753,16 @@ static constexpr track_type_t TrackElementMirrorMap[TrackElemType::Count] = {
TrackElemType::LeftLargeZeroGRollUp, // TrackElemType::RightLargeZeroGRollUp
TrackElemType::RightLargeZeroGRollDown, // TrackElemType::LeftLargeZeroGRollDown
TrackElemType::LeftLargeZeroGRollDown, // TrackElemType::RightLargeZeroGRollDown
TrackElemType::RightFlyerLargeHalfLoopUninvertedUp, // TrackElemType::LeftFlyerLargeHalfLoopUninvertedUp
TrackElemType::LeftFlyerLargeHalfLoopUninvertedUp, // TrackElemType::RightFlyerLargeHalfLoopUninvertedUp
TrackElemType::LeftFlyerLargeHalfLoopInvertedDown, // TrackElemType::RightFlyerLargeHalfLoopInvertedDown
TrackElemType::RightFlyerLargeHalfLoopInvertedDown, // TrackElemType::LeftFlyerLargeHalfLoopInvertedDown
TrackElemType::RightFlyerLargeHalfLoopInvertedUp, // TrackElemType::LeftFlyerLargeHalfLoopInvertedUp
TrackElemType::LeftFlyerLargeHalfLoopInvertedUp, // TrackElemType::RightFlyerLargeHalfLoopInvertedUp
TrackElemType::LeftFlyerLargeHalfLoopUninvertedDown, // TrackElemType::RightFlyerLargeHalfLoopUninvertedDown
TrackElemType::RightFlyerLargeHalfLoopUninvertedDown, // TrackElemType::LeftFlyerLargeHalfLoopUninvertedDown
TrackElemType::FlyerHalfLoopInvertedUp,
TrackElemType::FlyerHalfLoopUninvertedDown,
};
/** rct2: 0x00999694 */
@ -4687,7 +4868,7 @@ static constexpr uint32_t TrackHeightMarkerPositions[TrackElemType::Count] = {
(1 << 0), // TrackElemType::RightQuarterTurn1TileDown60
(1 << 0), // TrackElemType::Brakes
(1 << 0), // TrackElemType::Booster
(1 << 0) | (1 << 1) | (1 << 2) | (1 << 3) | (1 << 4) | (1 << 5) | (1 << 6) | (1 << 7) | (1 << 8) | (1 << 9) | (1 << 10) | (1 << 11) | (1 << 12) | (1 << 13) | (1 << 14) | (1 << 15), // TrackElemType::InvertedUp90ToFlatQuarterLoopAlias / Maze
(1 << 0) | (1 << 1) | (1 << 2) | (1 << 3) | (1 << 4) | (1 << 5) | (1 << 6) | (1 << 7) | (1 << 8) | (1 << 9) | (1 << 10) | (1 << 11) | (1 << 12) | (1 << 13) | (1 << 14) | (1 << 15), // Maze
(1 << 0) | (1 << 6), // TrackElemType::LeftQuarterBankedHelixLargeUp
(1 << 0) | (1 << 6), // TrackElemType::RightQuarterBankedHelixLargeUp
(1 << 0) | (1 << 6), // TrackElemType::LeftQuarterBankedHelixLargeDown
@ -4777,8 +4958,8 @@ static constexpr uint32_t TrackHeightMarkerPositions[TrackElemType::Count] = {
(1 << 0) | (1 << 2), // TrackElemType::RightFlyerTwistUp
(1 << 0) | (1 << 2), // TrackElemType::LeftFlyerTwistDown
(1 << 0) | (1 << 2), // TrackElemType::RightFlyerTwistDown
(1 << 0) | (1 << 3), // TrackElemType::FlyerHalfLoopUp
(1 << 0) | (1 << 3), // TrackElemType::FlyerHalfLoopDown
(1 << 0) | (1 << 3), // TrackElemType::FlyerHalfLoopUninvertedUp
(1 << 0) | (1 << 3), // TrackElemType::FlyerHalfLoopInvertedDown
(1 << 0) | (1 << 2), // TrackElemType::LeftFlyerCorkscrewUp
(1 << 0) | (1 << 2), // TrackElemType::RightFlyerCorkscrewUp
(1 << 0) | (1 << 2), // TrackElemType::LeftFlyerCorkscrewDown
@ -4869,6 +5050,16 @@ static constexpr uint32_t TrackHeightMarkerPositions[TrackElemType::Count] = {
(1 << 0) | (1 << 3), // TrackElemType::RightLargeZeroGRollUp
(1 << 0) | (1 << 3), // TrackElemType::LeftLargeZeroGRollDown
(1 << 0) | (1 << 3), // TrackElemType::RightLargeZeroGRollDown
(1 << 0) | (1 << 6), // TrackElemType::LeftFlyerLargeHalfLoopUninvertedUp
(1 << 0) | (1 << 6), // TrackElemType::RightFlyerLargeHalfLoopUninvertedUp
(1 << 0) | (1 << 6), // TrackElemType::RightFlyerLargeHalfLoopInvertedDown
(1 << 0) | (1 << 6), // TrackElemType::LeftFlyerLargeHalfLoopInvertedDown
(1 << 0) | (1 << 6), // TrackElemType::LeftFlyerLargeHalfLoopInvertedUp
(1 << 0) | (1 << 6), // TrackElemType::RightFlyerLargeHalfLoopInvertedUp
(1 << 0) | (1 << 6), // TrackElemType::RightFlyerLargeHalfLoopUninvertedDown
(1 << 0) | (1 << 6), // TrackElemType::LeftFlyerLargeHalfLoopUninvertedDown
(1 << 0) | (1 << 3), // TrackElemType::FlyerHalfLoopInvertedUp
(1 << 0) | (1 << 3), // TrackElemType::FlyerHalfLoopUninvertedDown
};
/** rct2: 0x00999A94 */
@ -5064,8 +5255,8 @@ static constexpr uint8_t TrackSequenceElementAllowedWallEdges[TrackElemType::Cou
{ 0b1010, 0b1010, 0b1010, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // TrackElemType::RightFlyerTwistUp
{ 0b1010, 0b1010, 0b1010, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // TrackElemType::LeftFlyerTwistDown
{ 0b1010, 0b1010, 0b1010, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // TrackElemType::RightFlyerTwistDown
{ 0b1010, 0b1010, 0b1011, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // TrackElemType::FlyerHalfLoopUp
{ 0, 0b1011, 0b1010, 0b1010, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // TrackElemType::FlyerHalfLoopDown
{ 0b1010, 0b1010, 0b1011, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // TrackElemType::FlyerHalfLoopUninvertedUp
{ 0, 0b1011, 0b1010, 0b1010, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // TrackElemType::FlyerHalfLoopInvertedDown
{ 0b1010, 0b0011, 0b0101, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // TrackElemType::LeftFlyerCorkscrewUp
{ 0b1010, 0b1001, 0b0101, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // TrackElemType::RightFlyerCorkscrewUp
{ 0b1010, 0b0011, 0b0101, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // TrackElemType::LeftFlyerCorkscrewDown
@ -5157,6 +5348,16 @@ static constexpr uint8_t TrackSequenceElementAllowedWallEdges[TrackElemType::Cou
{ 0b1010, 0b1010, 0b1010, 0b1010, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // TrackElemType::LeftLargeZeroGRollDown
{ 0b1010, 0b1010, 0b1010, 0b1010, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // TrackElemType::RightLargeZeroGRollDown
{ 0b1010, 0b1010, 0b0010, 0b0011, 0b1001, 0b1000, 0b1000, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // TrackElemType::LeftFlyerLargeHalfLoopUninvertedUp
{ 0b1010, 0b1010, 0b1000, 0b1001, 0b0011, 0b0010, 0b0010, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // TrackElemType::RightFlyerLargeHalfLoopUninvertedUp
{ 0b0010, 0b0010, 0b0011, 0b1001, 0b1000, 0b1010, 0b1010, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // TrackElemType::RightFlyerLargeHalfLoopInvertedDown
{ 0b1000, 0b1000, 0b1001, 0b0011, 0b0010, 0b1010, 0b1010, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // TrackElemType::LeftFlyerLargeHalfLoopInvertedDown
{ 0b1010, 0b1010, 0b0010, 0b0011, 0b1001, 0b1000, 0b1000, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // TrackElemType::LeftFlyerLargeHalfLoopInvertedUp
{ 0b1010, 0b1010, 0b1000, 0b1001, 0b0011, 0b0010, 0b0010, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // TrackElemType::RightFlyerLargeHalfLoopInvertedUp
{ 0b0010, 0b0010, 0b0011, 0b1001, 0b1000, 0b1010, 0b1010, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // TrackElemType::RightFlyerLargeHalfLoopUninvertedDown
{ 0b1000, 0b1000, 0b1001, 0b0011, 0b0010, 0b1010, 0b1010, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // TrackElemType::LeftFlyerLargeHalfLoopUninvertedDown
{ 0b1010, 0b1010, 0b1011, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // TrackElemType::FlyerHalfLoopInvertedUp
{ 0, 0b1011, 0b1010, 0b1010, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // TrackElemType::FlyerHalfLoopUninvertedDown
};
/** rct2: 0x0099423C */
@ -5352,8 +5553,8 @@ static constexpr uint16_t TrackFlags[TrackElemType::Count] = {
/* TrackElemType::RightFlyerTwistUp */ TRACK_ELEM_FLAG_NORMAL_TO_INVERSION | TRACK_ELEM_FLAG_INVERSION_TO_NORMAL,
/* TrackElemType::LeftFlyerTwistDown */ TRACK_ELEM_FLAG_INVERSION_TO_NORMAL,
/* TrackElemType::RightFlyerTwistDown */ TRACK_ELEM_FLAG_INVERSION_TO_NORMAL,
/* TrackElemType::FlyerHalfLoopUp */ TRACK_ELEM_FLAG_UP | TRACK_ELEM_FLAG_NORMAL_TO_INVERSION | TRACK_ELEM_FLAG_STARTS_AT_HALF_HEIGHT | TRACK_ELEM_FLAG_INVERSION_TO_NORMAL,
/* TrackElemType::FlyerHalfLoopDown */ TRACK_ELEM_FLAG_DOWN | TRACK_ELEM_FLAG_INVERSION_TO_NORMAL,
/* TrackElemType::FlyerHalfLoopUninvertedUp */ TRACK_ELEM_FLAG_UP | TRACK_ELEM_FLAG_NORMAL_TO_INVERSION | TRACK_ELEM_FLAG_STARTS_AT_HALF_HEIGHT | TRACK_ELEM_FLAG_INVERSION_TO_NORMAL,
/* TrackElemType::FlyerHalfLoopInvertedDown */ TRACK_ELEM_FLAG_DOWN | TRACK_ELEM_FLAG_INVERSION_TO_NORMAL,
/* TrackElemType::LeftFlyerCorkscrewUp */ TRACK_ELEM_FLAG_UP | TRACK_ELEM_FLAG_NORMAL_TO_INVERSION | TRACK_ELEM_FLAG_INVERSION_TO_NORMAL,
/* TrackElemType::RightFlyerCorkscrewUp */ TRACK_ELEM_FLAG_UP | TRACK_ELEM_FLAG_NORMAL_TO_INVERSION | TRACK_ELEM_FLAG_INVERSION_TO_NORMAL,
/* TrackElemType::LeftFlyerCorkscrewDown */ TRACK_ELEM_FLAG_DOWN | TRACK_ELEM_FLAG_INVERSION_TO_NORMAL,
@ -5444,6 +5645,16 @@ static constexpr uint16_t TrackFlags[TrackElemType::Count] = {
/* TrackElemType::RightLargeZeroGRollUp */ TRACK_ELEM_FLAG_UP | TRACK_ELEM_FLAG_NORMAL_TO_INVERSION | TRACK_ELEM_FLAG_STARTS_AT_HALF_HEIGHT | TRACK_ELEM_FLAG_INVERSION_TO_NORMAL,
/* TrackElemType::RightLargeZeroGRollDown */ TRACK_ELEM_FLAG_DOWN | TRACK_ELEM_FLAG_INVERSION_TO_NORMAL,
/* TrackElemType::LeftLargeZeroGRollDown */ TRACK_ELEM_FLAG_DOWN | TRACK_ELEM_FLAG_INVERSION_TO_NORMAL,
/* TrackElemType::LeftFlyerLargeHalfLoopUninvertedUp */ TRACK_ELEM_FLAG_UP | TRACK_ELEM_FLAG_NORMAL_TO_INVERSION | TRACK_ELEM_FLAG_STARTS_AT_HALF_HEIGHT | TRACK_ELEM_FLAG_INVERSION_TO_NORMAL,
/* TrackElemType::RightFlyerLargeHalfLoopUninvertedUp */ TRACK_ELEM_FLAG_UP | TRACK_ELEM_FLAG_NORMAL_TO_INVERSION | TRACK_ELEM_FLAG_STARTS_AT_HALF_HEIGHT | TRACK_ELEM_FLAG_INVERSION_TO_NORMAL,
/* TrackElemType::RightFlyerLargeHalfLoopInvertedDown */ TRACK_ELEM_FLAG_DOWN | TRACK_ELEM_FLAG_INVERSION_TO_NORMAL,
/* TrackElemType::LeftFlyerLargeHalfLoopInvertedDown */ TRACK_ELEM_FLAG_DOWN | TRACK_ELEM_FLAG_INVERSION_TO_NORMAL,
/* TrackElemType::RightFlyerLargeHalfLoopUninvertedUp */ TRACK_ELEM_FLAG_UP | TRACK_ELEM_FLAG_INVERSION_TO_NORMAL | TRACK_ELEM_FLAG_STARTS_AT_HALF_HEIGHT | TRACK_ELEM_FLAG_INVERSION_TO_NORMAL,
/* TrackElemType::LeftFlyerLargeHalfLoopUninvertedUp */ TRACK_ELEM_FLAG_UP | TRACK_ELEM_FLAG_INVERSION_TO_NORMAL | TRACK_ELEM_FLAG_STARTS_AT_HALF_HEIGHT | TRACK_ELEM_FLAG_INVERSION_TO_NORMAL,
/* TrackElemType::RightFlyerLargeHalfLoopInvertedDown */ TRACK_ELEM_FLAG_DOWN | TRACK_ELEM_FLAG_NORMAL_TO_INVERSION,
/* TrackElemType::LeftFlyerLargeHalfLoopInvertedDown */ TRACK_ELEM_FLAG_DOWN | TRACK_ELEM_FLAG_NORMAL_TO_INVERSION,
/* TrackElemType::FlyerHalfLoopInvertedUp */ TRACK_ELEM_FLAG_UP | TRACK_ELEM_FLAG_INVERSION_TO_NORMAL | TRACK_ELEM_FLAG_STARTS_AT_HALF_HEIGHT,
/* TrackElemType::FlyerHalfLoopUnivertedDown */ TRACK_ELEM_FLAG_DOWN | TRACK_ELEM_FLAG_NORMAL_TO_INVERSION,
};
// clang-format on
@ -5553,7 +5764,7 @@ static constexpr rct_trackdefinition TrackDefinitions[TrackElemType::Count] =
{ TRACK_FLAT, TRACK_SLOPE_DOWN_60, TRACK_SLOPE_DOWN_60, TRACK_BANK_NONE, TRACK_BANK_NONE, 0 }, // ELEM_RIGHT_QUARTER_TURN_1_TILE_60_DEG_DOWN
{ TRACK_BRAKES, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_NONE, 0 }, // ELEM_BRAKES
{ TRACK_BOOSTER, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_NONE, 0 }, // ELEM_BOOSTER
{ TRACK_FLAT, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_NONE, 0 }, // ELEM_INVERTED_90_DEG_UP_TO_FLAT_QUARTER_LOOP
{ TRACK_FLAT, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_NONE, 0 }, // TrackElemType::Maze
{ TRACK_HELIX_LARGE, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_LEFT, TRACK_BANK_LEFT, 0 }, // ELEM_LEFT_QUARTER_BANKED_HELIX_LARGE_UP
{ TRACK_HELIX_LARGE, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_RIGHT, TRACK_BANK_RIGHT, 0 }, // ELEM_RIGHT_QUARTER_BANKED_HELIX_LARGE_UP
{ TRACK_HELIX_LARGE, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_LEFT, TRACK_BANK_LEFT, 0 }, // ELEM_LEFT_QUARTER_BANKED_HELIX_LARGE_DOWN
@ -5643,8 +5854,8 @@ static constexpr rct_trackdefinition TrackDefinitions[TrackElemType::Count] =
{TRACK_INLINE_TWIST_UNINVERTED, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_UPSIDE_DOWN, TRACK_BANK_NONE, 0 }, // ELEM_RIGHT_FLYER_TWIST_UP
{TRACK_INLINE_TWIST_INVERTED, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_UPSIDE_DOWN, TRACK_BANK_NONE, 0 }, // ELEM_LEFT_FLYER_TWIST_DOWN
{TRACK_INLINE_TWIST_INVERTED, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_UPSIDE_DOWN, TRACK_BANK_NONE, 0 }, // ELEM_RIGHT_FLYER_TWIST_DOWN
{TRACK_HALF_LOOP_UNINVERTED, TRACK_SLOPE_NONE, TRACK_SLOPE_UP_25, TRACK_BANK_UPSIDE_DOWN, TRACK_BANK_NONE, 64 }, // ELEM_FLYER_HALF_LOOP_UP
{TRACK_HALF_LOOP_INVERTED, TRACK_SLOPE_DOWN_25, TRACK_SLOPE_NONE, TRACK_BANK_UPSIDE_DOWN, TRACK_BANK_NONE, -64 }, // ELEM_FLYER_HALF_LOOP_DOWN
{TRACK_FLYING_HALF_LOOP_UNINVERTED_UP, TRACK_SLOPE_NONE, TRACK_SLOPE_UP_25, TRACK_BANK_UPSIDE_DOWN, TRACK_BANK_NONE, 64 }, // ELEM_FLYER_HALF_LOOP_UP
{TRACK_FLYING_HALF_LOOP_INVERTED_DOWN, TRACK_SLOPE_DOWN_25, TRACK_SLOPE_NONE, TRACK_BANK_UPSIDE_DOWN, TRACK_BANK_NONE, -64 }, // ELEM_FLYER_HALF_LOOP_DOWN
{TRACK_CORKSCREW_UNINVERTED, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_UPSIDE_DOWN, TRACK_BANK_NONE, 0 }, // ELEM_LEFT_FLYER_CORKSCREW_UP
{TRACK_CORKSCREW_UNINVERTED, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_UPSIDE_DOWN, TRACK_BANK_NONE, 0 }, // ELEM_RIGHT_FLYER_CORKSCREW_UP
{TRACK_CORKSCREW_INVERTED, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_UPSIDE_DOWN, TRACK_BANK_NONE, -32 }, // ELEM_LEFT_FLYER_CORKSCREW_DOWN
@ -5658,9 +5869,9 @@ static constexpr rct_trackdefinition TrackDefinitions[TrackElemType::Count] =
{TRACK_MINI_GOLF_HOLE, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_NONE, 0 }, // ELEM_MINI_GOLF_HOLE_C
{TRACK_MINI_GOLF_HOLE, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_NONE, 0 }, // ELEM_MINI_GOLF_HOLE_D
{TRACK_MINI_GOLF_HOLE, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_NONE, 0 }, // ELEM_MINI_GOLF_HOLE_E
{TRACK_QUARTER_LOOP_INVERTED, TRACK_SLOPE_DOWN_90, TRACK_SLOPE_NONE, TRACK_BANK_UPSIDE_DOWN, TRACK_BANK_NONE, 0 }, // ELEM_MULTIDIM_INVERTED_FLAT_TO_90_DEG_QUARTER_LOOP_DOWN
{TRACK_QUARTER_LOOP, TRACK_SLOPE_NONE, TRACK_SLOPE_UP_90, TRACK_BANK_UPSIDE_DOWN, TRACK_BANK_NONE, 0 }, // ELEM_90_DEG_TO_INVERTED_FLAT_QUARTER_LOOP_UP
{TRACK_QUARTER_LOOP, TRACK_SLOPE_DOWN_90, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_UPSIDE_DOWN, 0 }, // ELEM_INVERTED_FLAT_TO_90_DEG_QUARTER_LOOP_DOWN
{ TRACK_QUARTER_LOOP_INVERTED_DOWN, TRACK_SLOPE_DOWN_90, TRACK_SLOPE_NONE, TRACK_BANK_UPSIDE_DOWN, TRACK_BANK_NONE, 0 }, // ELEM_MULTIDIM_INVERTED_FLAT_TO_90_DEG_QUARTER_LOOP_DOWN
{ TRACK_QUARTER_LOOP, TRACK_SLOPE_NONE, TRACK_SLOPE_UP_90, TRACK_BANK_UPSIDE_DOWN, TRACK_BANK_NONE, 0 }, // ELEM_90_DEG_TO_INVERTED_FLAT_QUARTER_LOOP_UP
{ TRACK_QUARTER_LOOP, TRACK_SLOPE_DOWN_90, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_UPSIDE_DOWN, 0 }, // ELEM_INVERTED_FLAT_TO_90_DEG_QUARTER_LOOP_DOWN
{ TRACK_LIFT_HILL_CURVED, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_NONE, 0 }, // ELEM_LEFT_CURVED_LIFT_HILL
{ TRACK_LIFT_HILL_CURVED, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_NONE, 0 }, // ELEM_RIGHT_CURVED_LIFT_HILL
{ TRACK_REVERSER, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_NONE, 0 }, // ELEM_LEFT_REVERSER
@ -5705,9 +5916,9 @@ static constexpr rct_trackdefinition TrackDefinitions[TrackElemType::Count] =
{ TRACK_FLAT, TRACK_SLOPE_UP_90, TRACK_SLOPE_UP_90, TRACK_BANK_NONE, TRACK_BANK_NONE, 0 }, // ELEM_RIGHT_QUARTER_TURN_1_TILE_90_DEG_UP
{ TRACK_FLAT, TRACK_SLOPE_DOWN_90, TRACK_SLOPE_DOWN_90, TRACK_BANK_NONE, TRACK_BANK_NONE, 0 }, // ELEM_LEFT_QUARTER_TURN_1_TILE_90_DEG_DOWN
{ TRACK_FLAT, TRACK_SLOPE_DOWN_90, TRACK_SLOPE_DOWN_90, TRACK_BANK_NONE, TRACK_BANK_NONE, 0 }, // ELEM_RIGHT_QUARTER_TURN_1_TILE_90_DEG_DOWN
{ TRACK_QUARTER_LOOP_UNINVERTED,TRACK_SLOPE_NONE, TRACK_SLOPE_UP_90, TRACK_BANK_UPSIDE_DOWN, TRACK_BANK_NONE, 0 }, // ELEM_MULTIDIM_90_DEG_UP_TO_INVERTED_FLAT_QUARTER_LOOP
{ TRACK_QUARTER_LOOP_UNINVERTED,TRACK_SLOPE_DOWN_90, TRACK_SLOPE_NONE, TRACK_BANK_UPSIDE_DOWN, TRACK_BANK_NONE, 0 }, // ELEM_MULTIDIM_FLAT_TO_90_DEG_DOWN_QUARTER_LOOP
{ TRACK_QUARTER_LOOP_INVERTED, TRACK_SLOPE_NONE, TRACK_SLOPE_UP_90, TRACK_BANK_UPSIDE_DOWN, TRACK_BANK_NONE, 0 }, // 255
{ TRACK_QUARTER_LOOP_UNINVERTED_UP, TRACK_SLOPE_NONE, TRACK_SLOPE_UP_90, TRACK_BANK_UPSIDE_DOWN, TRACK_BANK_NONE, 0 }, // ELEM_MULTIDIM_90_DEG_UP_TO_INVERTED_FLAT_QUARTER_LOOP
{ TRACK_QUARTER_LOOP_UNINVERTED_DOWN, TRACK_SLOPE_DOWN_90, TRACK_SLOPE_NONE, TRACK_BANK_UPSIDE_DOWN, TRACK_BANK_NONE, 0 }, // ELEM_MULTIDIM_FLAT_TO_90_DEG_DOWN_QUARTER_LOOP
{ TRACK_QUARTER_LOOP_INVERTED_UP, TRACK_SLOPE_NONE, TRACK_SLOPE_UP_90, TRACK_BANK_UPSIDE_DOWN, TRACK_BANK_NONE, 0 }, // ELEM_MULTIDIM_INVERTED_FLAT_TO_90_DEG_UP_QUARTER_LOOP
{ TRACK_ROTATION_CONTROL_TOGGLE,TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_NONE, 0 }, // ELEM_ROTATION_CONTROL_TOGGLE
{ TRACK_FLAT, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_NONE, 0 }, // TrackElemType::FlatTrack1x4A
{ TRACK_FLAT, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_NONE, 0 }, // TrackElemType::FlatTrack2x2
@ -5735,6 +5946,16 @@ static constexpr rct_trackdefinition TrackDefinitions[TrackElemType::Count] =
{ TRACK_ZERO_G_ROLL_LARGE, TRACK_SLOPE_NONE, TRACK_SLOPE_UP_60, TRACK_BANK_UPSIDE_DOWN, TRACK_BANK_NONE, 0 }, // TrackElemType::RightLargeZeroGRollUp
{ TRACK_ZERO_G_ROLL_LARGE, TRACK_SLOPE_DOWN_60, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_UPSIDE_DOWN, 0 }, // TrackElemType::LeftLargeZeroGRollDown
{ TRACK_ZERO_G_ROLL_LARGE, TRACK_SLOPE_DOWN_60, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_UPSIDE_DOWN, 0 }, // TrackElemType::RightLargeZeroGRollDown
{ TRACK_FLYING_LARGE_HALF_LOOP_UNINVERTED_UP, TRACK_SLOPE_NONE, TRACK_SLOPE_UP_25, TRACK_BANK_UPSIDE_DOWN, TRACK_BANK_NONE, 64 }, // TrackElemType::LeftFlyerLargeHalfLoopUninvertedUp
{ TRACK_FLYING_LARGE_HALF_LOOP_UNINVERTED_UP, TRACK_SLOPE_NONE, TRACK_SLOPE_UP_25, TRACK_BANK_UPSIDE_DOWN, TRACK_BANK_NONE, 64 }, // TrackElemType::RightFlyerLargeHalfLoopUninvertedUp
{ TRACK_FLYING_LARGE_HALF_LOOP_INVERTED_DOWN, TRACK_SLOPE_DOWN_25, TRACK_SLOPE_NONE, TRACK_BANK_UPSIDE_DOWN, TRACK_BANK_NONE, -64 }, // TrackElemType::RightFlyerLargeHalfLoopInvertedDown
{ TRACK_FLYING_LARGE_HALF_LOOP_INVERTED_DOWN, TRACK_SLOPE_DOWN_25, TRACK_SLOPE_NONE, TRACK_BANK_UPSIDE_DOWN, TRACK_BANK_NONE, -64 }, // TrackElemType::LeftFlyerLargeHalfLoopInvertedDown
{ TRACK_FLYING_LARGE_HALF_LOOP_INVERTED_UP, TRACK_SLOPE_NONE, TRACK_SLOPE_UP_25, TRACK_BANK_UPSIDE_DOWN, TRACK_BANK_NONE, 64 }, // TrackElemType::LeftFlyerLargeHalfLoopInvertedUp
{ TRACK_FLYING_LARGE_HALF_LOOP_INVERTED_UP, TRACK_SLOPE_NONE, TRACK_SLOPE_UP_25, TRACK_BANK_UPSIDE_DOWN, TRACK_BANK_NONE, 64 }, // TrackElemType::RightFlyerLargeHalfLoopInvertedUp
{ TRACK_FLYING_LARGE_HALF_LOOP_UNINVERTED_DOWN, TRACK_SLOPE_DOWN_25, TRACK_SLOPE_NONE, TRACK_BANK_UPSIDE_DOWN, TRACK_BANK_NONE, -64 }, // TrackElemType::RightFlyerLargeHalfLoopUninvertedDown
{ TRACK_FLYING_LARGE_HALF_LOOP_UNINVERTED_DOWN, TRACK_SLOPE_DOWN_25, TRACK_SLOPE_NONE, TRACK_BANK_UPSIDE_DOWN, TRACK_BANK_NONE, -64 }, // TrackElemType::LeftFlyerLargeHalfLoopUninvertedDown
{TRACK_FLYING_HALF_LOOP_INVERTED_UP, TRACK_SLOPE_NONE, TRACK_SLOPE_UP_25, TRACK_BANK_UPSIDE_DOWN, TRACK_BANK_NONE, 64 }, // TrackElemType::FlyerHalfLoopInvertedUp
{TRACK_FLYING_HALF_LOOP_UNINVERTED_DOWN, TRACK_SLOPE_DOWN_25, TRACK_SLOPE_NONE, TRACK_BANK_UPSIDE_DOWN, TRACK_BANK_NONE, -64 }, // TrackElemType::FlyerHalfLoopUninvertedDown
};
// clang-format on
@ -5759,7 +5980,10 @@ constexpr static uint8_t TrackTypeToSpinFunction[TrackElemType::Count] = {
NO_SPIN, L7_SPIN, R7_SPIN, NO_SPIN, NO_SPIN, NO_SPIN, NO_SPIN, NO_SPIN, NO_SPIN, L7_SPIN, R7_SPIN, L7_SPIN, R7_SPIN,
L8_SPIN, R8_SPIN, L8_SPIN, R8_SPIN, NO_SPIN, NO_SPIN, NO_SPIN, NO_SPIN, NO_SPIN, NO_SPIN, NO_SPIN, NO_SPIN, NO_SPIN,
NO_SPIN, NO_SPIN, NO_SPIN, NO_SPIN, NO_SPIN, NO_SPIN, NO_SPIN, NO_SPIN, NO_SPIN, NO_SPIN, NO_SPIN, NO_SPIN, NO_SPIN,
NO_SPIN, NO_SPIN, NO_SPIN, NO_SPIN, NO_SPIN, NO_SPIN, NO_SPIN, NO_SPIN, NO_SPIN
NO_SPIN, NO_SPIN, NO_SPIN, NO_SPIN, NO_SPIN, NO_SPIN, NO_SPIN, NO_SPIN, NO_SPIN, NO_SPIN, NO_SPIN, NO_SPIN, NO_SPIN,
NO_SPIN, NO_SPIN, NO_SPIN, NO_SPIN, NO_SPIN, NO_SPIN, NO_SPIN, NO_SPIN, NO_SPIN, NO_SPIN, NO_SPIN, NO_SPIN, NO_SPIN,
NO_SPIN, NO_SPIN, NO_SPIN, NO_SPIN, NO_SPIN, NO_SPIN, NO_SPIN, NO_SPIN, NO_SPIN, NO_SPIN, NO_SPIN, NO_SPIN, NO_SPIN,
NO_SPIN, NO_SPIN, NO_SPIN, NO_SPIN, NO_SPIN, NO_SPIN, NO_SPIN,
};
template<int32_t TConstant> static int32_t EvaluatorConst(const int16_t)
@ -6110,10 +6334,12 @@ static constexpr TrackComputeFunction GetLateralFunction(const uint16_t type)
case TrackElemType::RightQuarterTurn1Tile:
return EvaluatorConst<-45>;
case TrackElemType::HalfLoopUp:
case TrackElemType::FlyerHalfLoopUp:
case TrackElemType::FlyerHalfLoopUninvertedUp:
case TrackElemType::FlyerHalfLoopInvertedUp:
return EvaluatorConst<0>;
case TrackElemType::HalfLoopDown:
case TrackElemType::FlyerHalfLoopDown:
case TrackElemType::FlyerHalfLoopInvertedDown:
case TrackElemType::FlyerHalfLoopUninvertedDown:
return EvaluatorConst<0>;
case TrackElemType::LeftLargeCorkscrewUp:
case TrackElemType::RightLargeCorkscrewDown:
@ -6456,10 +6682,12 @@ static constexpr TrackComputeFunction GetVerticalFunction(const uint16_t type)
case TrackElemType::RightQuarterTurn1Tile:
return EvaluatorConst<0>;
case TrackElemType::HalfLoopUp:
case TrackElemType::FlyerHalfLoopUp:
case TrackElemType::FlyerHalfLoopUninvertedUp:
case TrackElemType::FlyerHalfLoopInvertedUp:
return EvaluatorHalfLoopUp;
case TrackElemType::HalfLoopDown:
case TrackElemType::FlyerHalfLoopDown:
case TrackElemType::FlyerHalfLoopInvertedDown:
case TrackElemType::FlyerHalfLoopUninvertedDown:
return EvaluatorHalfLoopDown;
case TrackElemType::LeftLargeCorkscrewUp:
case TrackElemType::RightLargeCorkscrewDown:
@ -6576,9 +6804,17 @@ static constexpr TrackComputeFunction GetVerticalFunction(const uint16_t type)
return EvaluatorMediumHalfLoopDown;
case TrackElemType::LeftLargeHalfLoopUp:
case TrackElemType::RightLargeHalfLoopUp:
case TrackElemType::LeftFlyerLargeHalfLoopUninvertedUp:
case TrackElemType::RightFlyerLargeHalfLoopUninvertedUp:
case TrackElemType::RightFlyerLargeHalfLoopInvertedUp:
case TrackElemType::LeftFlyerLargeHalfLoopInvertedUp:
return EvaluatorLargeHalfLoopUp;
case TrackElemType::RightLargeHalfLoopDown:
case TrackElemType::LeftLargeHalfLoopDown:
case TrackElemType::LeftFlyerLargeHalfLoopInvertedDown:
case TrackElemType::RightFlyerLargeHalfLoopInvertedDown:
case TrackElemType::LeftFlyerLargeHalfLoopUninvertedDown:
case TrackElemType::RightFlyerLargeHalfLoopUninvertedDown:
return EvaluatorLargeHalfLoopDown;
case TrackElemType::HeartLineTransferUp:
return EvaluatorHeartLineTransferUp;
@ -6895,6 +7131,16 @@ static constexpr const StringId RideConfigurationStringIds[] = {
STR_LARGE_ZERO_G_ROLL_RIGHT, // TrackElemType::RightLargeZeroGRollUp
STR_LARGE_ZERO_G_ROLL_LEFT, // TrackElemType::RightLargeZeroGRollDown
STR_LARGE_ZERO_G_ROLL_RIGHT, // TrackElemType::LeftLargeZeroGRollDown
STR_LARGE_HALF_LOOP_LEFT, // TrackElemType::LeftFlyerLargeHalfLoopUninvertedUp
STR_LARGE_HALF_LOOP_RIGHT, // TrackElemType::RightFlyerLargeHalfLoopUninvertedUp
STR_LARGE_HALF_LOOP_RIGHT, // TrackElemType::RightFlyerLargeHalfLoopInvertedDown
STR_LARGE_HALF_LOOP_LEFT, // TrackElemType::LeftFlyerLargeHalfLoopInvertedDown
STR_LARGE_HALF_LOOP_LEFT, // TrackElemType::LeftFlyerLargeHalfLoopInvertedUp
STR_LARGE_HALF_LOOP_RIGHT, // TrackElemType::RightFlyerLargeHalfLoopInvertedUp
STR_LARGE_HALF_LOOP_RIGHT, // TrackElemType::RightFlyerLargeHalfLoopUninvertedDown
STR_LARGE_HALF_LOOP_LEFT, // TrackElemType::LeftFlyerLargeHalfLoopUninvertedDown
STR_HALF_LOOP, // TrackElemType::FlyerHalfLoopInvertedUp
STR_HALF_LOOP, // TrackElemType::FlyerHalfLoopUninvertedDown
};
namespace OpenRCT2

1254
src/openrct2/ride/VehicleSubpositionData.cpp
View File

File diff suppressed because it is too large Load Diff

536
src/openrct2/ride/coaster/FlyingRollerCoaster.cpp
View File

@ -17953,6 +17953,500 @@ static void flying_rc_track_right_banked_25_deg_down_to_flat(
flying_rc_track_flat_to_left_banked_25_deg_up(session, ride, trackSequence, (direction + 2) & 3, height, trackElement);
}
static void flying_rc_track_90_deg_up(
paint_session& session, const Ride& ride, uint8_t trackSequence, uint8_t direction, int32_t height,
const TrackElement& trackElement)
{
if (trackElement.IsInverted())
{
direction = (direction + 2) & 3;
}
switch (trackSequence)
{
case 0:
switch (direction)
{
case 0:
PaintAddImageAsParentRotated(
session, direction, session.TrackColours[SCHEME_TRACK] | 17526, { 0, 0, height }, { 2, 20, 31 },
{ 4, 6, height + 8 });
break;
case 1:
PaintAddImageAsParentRotated(
session, direction, session.TrackColours[SCHEME_TRACK] | 17527, { 0, 0, height }, { 2, 20, 31 },
{ 24, 6, height + 8 });
break;
case 2:
PaintAddImageAsParentRotated(
session, direction, session.TrackColours[SCHEME_TRACK] | 17528, { 0, 0, height }, { 2, 20, 31 },
{ 24, 6, height + 8 });
break;
case 3:
PaintAddImageAsParentRotated(
session, direction, session.TrackColours[SCHEME_TRACK] | 17529, { 0, 0, height }, { 2, 20, 31 },
{ 4, 6, height + 8 });
break;
}
paint_util_set_vertical_tunnel(session, height + 32);
paint_util_set_segment_support_height(
session, paint_util_rotate_segments(SEGMENT_C4 | SEGMENT_CC | SEGMENT_D0, direction), 0xFFFF, 0);
paint_util_set_general_support_height(session, height + 32, 0x20);
break;
case 1:
break;
}
}
static void flying_rc_track_90_deg_down(
paint_session& session, const Ride& ride, uint8_t trackSequence, uint8_t direction, int32_t height,
const TrackElement& trackElement)
{
flying_rc_track_90_deg_up(session, ride, trackSequence, (direction + 2) & 3, height, trackElement);
}
static void flying_rc_track_60_deg_up_to_90_deg_up(
paint_session& session, const Ride& ride, uint8_t trackSequence, uint8_t direction, int32_t height,
const TrackElement& trackElement)
{
if (trackElement.IsInverted())
return;
switch (trackSequence)
{
case 0:
switch (direction)
{
case 0:
PaintAddImageAsParentRotated(
session, direction, session.TrackColours[SCHEME_TRACK] | 17518, { 0, 0, height }, { 32, 20, 3 },
{ 0, 6, height });
break;
case 1:
PaintAddImageAsParentRotated(
session, direction, session.TrackColours[SCHEME_TRACK] | 17519, { 0, 0, height }, { 2, 20, 55 },
{ 24, 6, height });
break;
case 2:
PaintAddImageAsParentRotated(
session, direction, session.TrackColours[SCHEME_TRACK] | 17520, { 0, 0, height }, { 2, 20, 55 },
{ 24, 6, height });
break;
case 3:
PaintAddImageAsParentRotated(
session, direction, session.TrackColours[SCHEME_TRACK] | 17521, { 0, 0, height }, { 32, 20, 3 },
{ 0, 6, height });
break;
}
if (direction == 0 || direction == 3)
{
paint_util_push_tunnel_rotated(session, direction, height - 8, TUNNEL_SQUARE_7);
}
paint_util_set_vertical_tunnel(session, height + 56);
paint_util_set_segment_support_height(
session, paint_util_rotate_segments(SEGMENT_C4 | SEGMENT_CC | SEGMENT_D0, direction), 0xFFFF, 0);
paint_util_set_general_support_height(session, height + 56, 0x20);
break;
case 1:
break;
}
}
static void flying_rc_track_90_deg_down_to_60_deg_down(
paint_session& session, const Ride& ride, uint8_t trackSequence, uint8_t direction, int32_t height,
const TrackElement& trackElement)
{
flying_rc_track_60_deg_up_to_90_deg_up(session, ride, trackSequence, (direction + 2) & 3, height, trackElement);
}
static void flying_rc_track_90_deg_up_to_60_deg_up(
paint_session& session, const Ride& ride, uint8_t trackSequence, uint8_t direction, int32_t height,
const TrackElement& trackElement)
{
if (trackElement.IsInverted())
return;
switch (direction)
{
case 0:
PaintAddImageAsParentRotated(
session, direction, session.TrackColours[SCHEME_TRACK] | 17522, { 0, 0, height }, { 32, 20, 3 },
{ 0, 6, height + 8 });
break;
case 1:
PaintAddImageAsParentRotated(
session, direction, session.TrackColours[SCHEME_TRACK] | 17523, { 0, 0, height }, { 2, 20, 31 },
{ 24, 6, height + 8 });
break;
case 2:
PaintAddImageAsParentRotated(
session, direction, session.TrackColours[SCHEME_TRACK] | 17524, { 0, 0, height }, { 2, 20, 31 },
{ 24, 6, height + 8 });
break;
case 3:
PaintAddImageAsParentRotated(
session, direction, session.TrackColours[SCHEME_TRACK] | 17525, { 0, 0, height }, { 32, 20, 3 },
{ 0, 6, height + 8 });
break;
}
switch (direction)
{
case 1:
paint_util_push_tunnel_right(session, height + 48, TUNNEL_SQUARE_8);
break;
case 2:
paint_util_push_tunnel_left(session, height + 48, TUNNEL_SQUARE_8);
break;
}
paint_util_set_segment_support_height(
session, paint_util_rotate_segments(SEGMENT_C4 | SEGMENT_CC | SEGMENT_D0, direction), 0xFFFF, 0);
paint_util_set_general_support_height(session, height + 80, 0x20);
}
static void flying_rc_track_60_deg_down_to_90_deg_down(
paint_session& session, const Ride& ride, uint8_t trackSequence, uint8_t direction, int32_t height,
const TrackElement& trackElement)
{
if (trackElement.IsInverted())
return;
switch (trackSequence)
{
case 0:
switch (direction)
{
case 0:
PaintAddImageAsParentRotated(
session, direction, session.TrackColours[SCHEME_TRACK] | 17524, { 0, 0, height }, { 2, 20, 31 },
{ 24, 6, height + 8 });
break;
case 1:
PaintAddImageAsParentRotated(
session, direction, session.TrackColours[SCHEME_TRACK] | 17525, { 0, 0, height }, { 32, 20, 3 },
{ 0, 6, height + 8 });
break;
case 2:
PaintAddImageAsParentRotated(
session, direction, session.TrackColours[SCHEME_TRACK] | 17522, { 0, 0, height }, { 32, 20, 3 },
{ 0, 6, height + 8 });
break;
case 3:
PaintAddImageAsParentRotated(
session, direction, session.TrackColours[SCHEME_TRACK] | 17523, { 0, 0, height }, { 2, 20, 31 },
{ 24, 6, height + 8 });
break;
}
if (direction == 0 || direction == 3)
{
paint_util_push_tunnel_rotated(session, direction, height + 48, TUNNEL_SQUARE_8);
}
paint_util_set_segment_support_height(
session, paint_util_rotate_segments(SEGMENT_C4 | SEGMENT_CC | SEGMENT_D0, direction), 0xFFFF, 0);
paint_util_set_general_support_height(session, height + 80, 0x20);
break;
case 1:
break;
}
}
static void flying_rc_track_90_deg_to_inverted_flat_quarter_loop_up(
paint_session& session, const Ride& ride, uint8_t trackSequence, uint8_t direction, int32_t height,
const TrackElement& trackElement)
{
switch (trackSequence)
{
case 0:
switch (direction)
{
case 0:
PaintAddImageAsParentRotated(
session, direction, session.TrackColours[SCHEME_TRACK] | 18062, { 0, 0, height }, { 2, 20, 31 },
{ 4, 6, height + 8 });
break;
case 1:
PaintAddImageAsParentRotated(
session, direction, session.TrackColours[SCHEME_TRACK] | 18065, { 0, 0, height }, { 2, 20, 31 },
{ 24, 6, height + 8 });
break;
case 2:
PaintAddImageAsParentRotated(
session, direction, session.TrackColours[SCHEME_TRACK] | 18068, { 0, 0, height }, { 2, 20, 31 },
{ 24, 6, height + 8 });
break;
case 3:
PaintAddImageAsParentRotated(
session, direction, session.TrackColours[SCHEME_TRACK] | 18071, { 0, 0, height }, { 2, 20, 31 },
{ 4, 6, height + 8 });
break;
}
paint_util_set_segment_support_height(
session, paint_util_rotate_segments(SEGMENT_C4 | SEGMENT_C8 | SEGMENT_D4, direction), 0xFFFF, 0);
paint_util_set_general_support_height(session, height + 88, 0x20);
break;
case 1:
switch (direction)
{
case 0:
PaintAddImageAsParentRotated(
session, direction, session.TrackColours[SCHEME_TRACK] | 18063, { 0, 0, height }, { 2, 20, 31 },
{ -8, 6, height });
break;
case 1:
PaintAddImageAsParentRotated(
session, direction, session.TrackColours[SCHEME_TRACK] | 18066, { 0, 0, height }, { 2, 20, 63 },
{ 24, 6, height + 8 });
break;
case 2:
PaintAddImageAsParentRotated(
session, direction, session.TrackColours[SCHEME_TRACK] | 18069, { 0, 0, height }, { 2, 20, 63 },
{ 24, 6, height + 8 });
break;
case 3:
PaintAddImageAsParentRotated(
session, direction, session.TrackColours[SCHEME_TRACK] | 18072, { 0, 0, height }, { 2, 20, 31 },
{ -8, 6, height });
break;
}
paint_util_set_segment_support_height(
session, paint_util_rotate_segments(SEGMENT_C4 | SEGMENT_C8 | SEGMENT_D4, direction), 0xFFFF, 0);
paint_util_set_general_support_height(session, height + 64, 0x20);
break;
case 2:
switch (direction)
{
case 0:
PaintAddImageAsParentRotated(
session, direction, session.TrackColours[SCHEME_TRACK] | 18064, { 0, 0, height }, { 32, 20, 3 },
{ 0, 6, height + 24 });
break;
case 1:
PaintAddImageAsParentRotated(
session, direction, session.TrackColours[SCHEME_TRACK] | 18067, { 0, 0, height }, { 2, 20, 31 },
{ 24, 6, height + 8 });
break;
case 2:
PaintAddImageAsParentRotated(
session, direction, session.TrackColours[SCHEME_TRACK] | 18070, { 0, 0, height }, { 2, 20, 31 },
{ 24, 6, height + 8 });
break;
case 3:
PaintAddImageAsParentRotated(
session, direction, session.TrackColours[SCHEME_TRACK] | 18073, { 0, 0, height }, { 32, 20, 3 },
{ 0, 6, height + 24 });
break;
}
if (direction == 0 || direction == 3)
{
paint_util_push_tunnel_rotated(session, direction, height + 16, TUNNEL_SQUARE_FLAT);
}
paint_util_set_segment_support_height(
session, paint_util_rotate_segments(SEGMENT_C4 | SEGMENT_C8 | SEGMENT_D4, direction), 0xFFFF, 0);
paint_util_set_general_support_height(session, height + 48, 0x20);
break;
}
}
static void flying_rc_track_inverted_flat_to_90_deg_quarter_loop_down(
paint_session& session, const Ride& ride, uint8_t trackSequence, uint8_t direction, int32_t height,
const TrackElement& trackElement)
{
flying_rc_track_90_deg_to_inverted_flat_quarter_loop_up(session, ride, 2 - trackSequence, direction, height, trackElement);
}
static void flying_rc_track_flat_to_60_deg_up_long_base(
paint_session& session, const Ride& ride, uint8_t trackSequence, uint8_t direction, int32_t height,
const TrackElement& trackElement)
{
if (trackElement.IsInverted())
return;
bolliger_mabillard_track_flat_to_60_deg_up_long_base<METAL_SUPPORTS_TUBES_INVERTED>(
session, ride, trackSequence, direction, height, trackElement);
}
static void flying_rc_track_60_deg_up_to_flat_long_base(
paint_session& session, const Ride& ride, uint8_t trackSequence, uint8_t direction, int32_t height,
const TrackElement& trackElement)
{
if (trackElement.IsInverted())
return;
bolliger_mabillard_track_60_deg_up_to_flat_long_base<METAL_SUPPORTS_TUBES_INVERTED>(
session, ride, trackSequence, direction, height, trackElement);
}
static void flying_rc_track_60_deg_down_to_flat_long_base(
paint_session& session, const Ride& ride, uint8_t trackSequence, uint8_t direction, int32_t height,
const TrackElement& trackElement)
{
if (trackElement.IsInverted())
return;
bolliger_mabillard_track_flat_to_60_deg_up_long_base<METAL_SUPPORTS_TUBES_INVERTED>(
session, ride, 3 - trackSequence, (direction + 2) & 3, height, trackElement);
}
static void flying_rc_track_flat_to_60_deg_down_long_base(
paint_session& session, const Ride& ride, uint8_t trackSequence, uint8_t direction, int32_t height,
const TrackElement& trackElement)
{
if (trackElement.IsInverted())
return;
bolliger_mabillard_track_60_deg_up_to_flat_long_base<METAL_SUPPORTS_TUBES_INVERTED>(
session, ride, 3 - trackSequence, (direction + 2) & 3, height, trackElement);
}
static void flying_rc_track_half_loop_inverted_up(
paint_session& session, const Ride& ride, uint8_t trackSequence, uint8_t direction, int32_t height,
const TrackElement& trackElement)
{
switch (trackSequence)
{
case 0:
switch (direction)
{
case 0:
PaintAddImageAsParentRotated(
session, direction, session.TrackColours[SCHEME_TRACK] | 27451, { 0, 6, height + 24 }, { 32, 20, 3 },
{ 0, 6, height + 45 });
break;
case 1:
PaintAddImageAsParentRotated(
session, direction, session.TrackColours[SCHEME_TRACK] | 27459, { 0, 6, height + 24 }, { 32, 20, 3 },
{ 0, 6, height + 45 });
break;
case 2:
PaintAddImageAsParentRotated(
session, direction, session.TrackColours[SCHEME_TRACK] | 27458, { 0, 6, height + 24 }, { 32, 20, 3 },
{ 0, 6, height + 45 });
break;
case 3:
PaintAddImageAsParentRotated(
session, direction, session.TrackColours[SCHEME_TRACK] | 27466, { 0, 6, height + 24 }, { 32, 20, 3 },
{ 0, 6, height + 45 });
break;
}
paint_util_set_segment_support_height(
session, paint_util_rotate_segments(SEGMENT_C4 | SEGMENT_CC | SEGMENT_D0, direction), 0xFFFF, 0);
switch (direction)
{
case 0:
metal_a_supports_paint_setup(
session, METAL_SUPPORTS_TUBES_INVERTED, 6, 0, height + 62, session.TrackColours[SCHEME_SUPPORTS]);
break;
case 1:
metal_a_supports_paint_setup(
session, METAL_SUPPORTS_TUBES_INVERTED, 8, 0, height + 62, session.TrackColours[SCHEME_SUPPORTS]);
break;
case 2:
metal_a_supports_paint_setup(
session, METAL_SUPPORTS_TUBES_INVERTED, 7, 0, height + 62, session.TrackColours[SCHEME_SUPPORTS]);
break;
case 3:
metal_a_supports_paint_setup(
session, METAL_SUPPORTS_TUBES_INVERTED, 5, 0, height + 62, session.TrackColours[SCHEME_SUPPORTS]);
break;
}
if (direction == 0 || direction == 3)
{
paint_util_push_tunnel_rotated(session, direction, height - 8, TUNNEL_SQUARE_7);
}
paint_util_set_general_support_height(session, height + 72, 0x20);
break;
case 1:
switch (direction)
{
case 0:
PaintAddImageAsParentRotated(
session, direction, session.TrackColours[SCHEME_TRACK] | 27452, { 0, 0, height + 24 }, { 32, 2, 3 },
{ 0, 29, height + 29 });
break;
case 1:
PaintAddImageAsParentRotated(
session, direction, session.TrackColours[SCHEME_TRACK] | 27460, { 0, 14, height + 24 }, { 32, 2, 63 },
{ 0, 29, height + 29 });
break;
case 2:
PaintAddImageAsParentRotated(
session, direction, session.TrackColours[SCHEME_TRACK] | 27457, { 0, 6, height + 24 }, { 32, 2, 3 },
{ 0, 0, height + 29 });
break;
case 3:
PaintAddImageAsParentRotated(
session, direction, session.TrackColours[SCHEME_TRACK] | 27465, { 0, 6, height + 24 }, { 2, 2, 3 },
{ 29, 20, height + 29 });
break;
}
paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0);
paint_util_set_general_support_height(session, height + 88, 0x20);
break;
case 2:
switch (direction)
{
case 0:
PaintAddImageAsParentRotated(
session, direction, session.TrackColours[SCHEME_TRACK] | 27453, { 16, 0, height - 3 }, { 5, 2, 119 },
{ 16, 29, height + 2 });
break;
case 1:
PaintAddImageAsParentRotated(
session, direction, session.TrackColours[SCHEME_TRACK] | 27461, { 12, 0, height - 3 }, { 32, 2, 119 },
{ 0, -6, height + 2 });
break;
case 2:
PaintAddImageAsParentRotated(
session, direction, session.TrackColours[SCHEME_TRACK] | 27456, { 10, 16, height - 3 }, { 4, 2, 119 },
{ 10, 0, height + 2 });
break;
case 3:
PaintAddImageAsParentRotated(
session, direction, session.TrackColours[SCHEME_TRACK] | 27464, { 16, 16, height - 3 }, { 2, 2, 119 },
{ 29, 29, height + 2 });
break;
}
paint_util_set_segment_support_height(
session,
paint_util_rotate_segments(
SEGMENT_B8 | SEGMENT_C0 | SEGMENT_C4 | SEGMENT_C8 | SEGMENT_D0 | SEGMENT_D4, direction),
0xFFFF, 0);
paint_util_set_general_support_height(session, height + 168, 0x20);
break;
case 3:
switch (direction)
{
case 0:
PaintAddImageAsParentRotated(
session, direction, session.TrackColours[SCHEME_TRACK] | 27454, { 0, 0, height + 29 }, { 32, 20, 3 },
{ 0, 6, height + 34 });
break;
case 1:
PaintAddImageAsParentRotated(
session, direction, session.TrackColours[SCHEME_TRACK] | 27462, { 0, 0, height + 29 }, { 2, 2, 3 },
{ 0, 0, height - 6 });
break;
case 2:
PaintAddImageAsParentRotated(
session, direction, session.TrackColours[SCHEME_TRACK] | 27455, { 0, 16, height + 29 }, { 32, 2, 3 },
{ 0, 0, height - 6 });
break;
case 3:
PaintAddImageAsParentRotated(
session, direction, session.TrackColours[SCHEME_TRACK] | 27463, { 0, 16, height + 29 }, { 32, 20, 3 },
{ 0, 6, height + 34 });
break;
}
if (direction == 0 || direction == 3)
{
paint_util_push_tunnel_rotated(session, direction, height + 32, TUNNEL_SQUARE_FLAT);
}
paint_util_set_segment_support_height(
session, paint_util_rotate_segments(SEGMENT_C4 | SEGMENT_CC | SEGMENT_D0, direction), 0xFFFF, 0);
paint_util_set_general_support_height(session, height + 64, 0x20);
break;
}
}
static void flying_rc_track_half_loop_uninverted_down(
paint_session& session, const Ride& ride, uint8_t trackSequence, uint8_t direction, int32_t height,
const TrackElement& trackElement)
{
flying_rc_track_half_loop_inverted_up(session, ride, 3 - trackSequence, direction, height, trackElement);
}
TRACK_PAINT_FUNCTION get_track_paint_function_flying_rc(int32_t trackType)
{
switch (trackType)
@ -18173,9 +18667,9 @@ TRACK_PAINT_FUNCTION get_track_paint_function_flying_rc(int32_t trackType)
return flying_rc_track_left_flyer_twist_down;
case TrackElemType::RightFlyerTwistDown:
return flying_rc_track_right_flyer_twist_down;
case TrackElemType::FlyerHalfLoopUp:
case TrackElemType::FlyerHalfLoopUninvertedUp:
return flying_rc_track_flyer_half_loop_up;
case TrackElemType::FlyerHalfLoopDown:
case TrackElemType::FlyerHalfLoopInvertedDown:
return flying_rc_track_flyer_half_loop_down;
case TrackElemType::BlockBrakes:
return flying_rc_track_block_brakes;
@ -18243,8 +18737,46 @@ TRACK_PAINT_FUNCTION get_track_paint_function_flying_rc(int32_t trackType)
return flying_rc_track_left_banked_25_deg_down_to_flat;
case TrackElemType::RightBankedDown25ToFlat:
return flying_rc_track_right_banked_25_deg_down_to_flat;
// OpenRCT2-specific paint code
case TrackElemType::Booster:
return flying_rc_track_booster;
case TrackElemType::Up60ToUp90:
return flying_rc_track_60_deg_up_to_90_deg_up;
case TrackElemType::Up90:
return flying_rc_track_90_deg_up;
case TrackElemType::Up90ToUp60:
return flying_rc_track_90_deg_up_to_60_deg_up;
case TrackElemType::Down60ToDown90:
return flying_rc_track_60_deg_down_to_90_deg_down;
case TrackElemType::Down90:
return flying_rc_track_90_deg_down;
case TrackElemType::Down90ToDown60:
return flying_rc_track_90_deg_down_to_60_deg_down;
case TrackElemType::MultiDimInvertedFlatToDown90QuarterLoop:
return flying_rc_track_inverted_flat_to_90_deg_quarter_loop_down;
case TrackElemType::MultiDimUp90ToInvertedFlatQuarterLoop:
return flying_rc_track_90_deg_to_inverted_flat_quarter_loop_up;
case TrackElemType::FlatToUp60LongBase:
return flying_rc_track_flat_to_60_deg_up_long_base;
case TrackElemType::Up60ToFlatLongBase:
return flying_rc_track_60_deg_up_to_flat_long_base;
case TrackElemType::FlatToDown60LongBase:
return flying_rc_track_flat_to_60_deg_down_long_base;
case TrackElemType::Down60ToFlatLongBase:
return flying_rc_track_60_deg_down_to_flat_long_base;
// OpenRCT2-specific track elements
case TrackElemType::LeftFlyerLargeHalfLoopUninvertedUp:
return bolliger_mabillard_track_left_large_half_loop_up<METAL_SUPPORTS_TUBES_INVERTED>;
case TrackElemType::RightFlyerLargeHalfLoopUninvertedUp:
return bolliger_mabillard_track_right_large_half_loop_up<METAL_SUPPORTS_TUBES_INVERTED>;
case TrackElemType::RightFlyerLargeHalfLoopInvertedDown:
return bolliger_mabillard_track_right_large_half_loop_down<METAL_SUPPORTS_TUBES_INVERTED>;
case TrackElemType::LeftFlyerLargeHalfLoopInvertedDown:
return bolliger_mabillard_track_left_large_half_loop_down<METAL_SUPPORTS_TUBES_INVERTED>;
case TrackElemType::FlyerHalfLoopInvertedUp:
return flying_rc_track_half_loop_inverted_up;
case TrackElemType::FlyerHalfLoopUninvertedDown:
return flying_rc_track_half_loop_uninverted_down;
}
return nullptr;
}

167
src/openrct2/ride/coaster/LayDownRollerCoaster.cpp
View File

@ -16096,6 +16096,164 @@ static void lay_down_rc_track_right_quarter_banked_helix_large_down(
break;
}
}
static void lay_down_rc_track_half_loop_inverted_up(
paint_session& session, const Ride& ride, uint8_t trackSequence, uint8_t direction, int32_t height,
const TrackElement& trackElement)
{
switch (trackSequence)
{
case 0:
switch (direction)
{
case 0:
PaintAddImageAsParentRotated(
session, direction, session.TrackColours[SCHEME_TRACK] | 27073, { 0, 6, height + 24 }, { 32, 20, 3 },
{ 0, 6, height + 45 });
break;
case 1:
PaintAddImageAsParentRotated(
session, direction, session.TrackColours[SCHEME_TRACK] | 27081, { 0, 6, height + 24 }, { 32, 20, 3 },
{ 0, 6, height + 45 });
break;
case 2:
PaintAddImageAsParentRotated(
session, direction, session.TrackColours[SCHEME_TRACK] | 27080, { 0, 6, height + 24 }, { 32, 20, 3 },
{ 0, 6, height + 45 });
break;
case 3:
PaintAddImageAsParentRotated(
session, direction, session.TrackColours[SCHEME_TRACK] | 27088, { 0, 6, height + 24 }, { 32, 20, 3 },
{ 0, 6, height + 45 });
break;
}
paint_util_set_segment_support_height(
session, paint_util_rotate_segments(SEGMENT_C4 | SEGMENT_CC | SEGMENT_D0, direction), 0xFFFF, 0);
switch (direction)
{
case 0:
metal_a_supports_paint_setup(
session, METAL_SUPPORTS_TUBES_INVERTED, 6, 0, height + 56, session.TrackColours[SCHEME_SUPPORTS]);
break;
case 1:
metal_a_supports_paint_setup(
session, METAL_SUPPORTS_TUBES_INVERTED, 8, 0, height + 56, session.TrackColours[SCHEME_SUPPORTS]);
break;
case 2:
metal_a_supports_paint_setup(
session, METAL_SUPPORTS_TUBES_INVERTED, 7, 0, height + 56, session.TrackColours[SCHEME_SUPPORTS]);
break;
case 3:
metal_a_supports_paint_setup(
session, METAL_SUPPORTS_TUBES_INVERTED, 5, 0, height + 56, session.TrackColours[SCHEME_SUPPORTS]);
break;
}
if (direction == 0 || direction == 3)
{
paint_util_push_tunnel_rotated(session, direction, height - 8, TUNNEL_1);
}
paint_util_set_general_support_height(session, height + 72, 0x20);
break;
case 1:
switch (direction)
{
case 0:
PaintAddImageAsParentRotated(
session, direction, session.TrackColours[SCHEME_TRACK] | 27074, { 0, 0, height + 24 }, { 32, 2, 3 },
{ 0, 29, height + 29 });
break;
case 1:
PaintAddImageAsParentRotated(
session, direction, session.TrackColours[SCHEME_TRACK] | 27082, { 0, 14, height + 24 }, { 32, 2, 63 },
{ 0, 29, height + 29 });
break;
case 2:
PaintAddImageAsParentRotated(
session, direction, session.TrackColours[SCHEME_TRACK] | 27079, { 0, 6, height + 24 }, { 32, 2, 3 },
{ 0, 0, height + 29 });
break;
case 3:
PaintAddImageAsParentRotated(
session, direction, session.TrackColours[SCHEME_TRACK] | 27087, { 0, 6, height + 24 }, { 2, 2, 3 },
{ 29, 20, height + 29 });
break;
}
paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0);
paint_util_set_general_support_height(session, height + 88, 0x20);
break;
case 2:
switch (direction)
{
case 0:
PaintAddImageAsParentRotated(
session, direction, session.TrackColours[SCHEME_TRACK] | 27075, { 16, 0, height - 3 }, { 5, 2, 119 },
{ 16, 29, height + 2 });
break;
case 1:
PaintAddImageAsParentRotated(
session, direction, session.TrackColours[SCHEME_TRACK] | 27083, { 12, 0, height - 3 }, { 32, 2, 119 },
{ 0, -6, height + 2 });
break;
case 2:
PaintAddImageAsParentRotated(
session, direction, session.TrackColours[SCHEME_TRACK] | 27078, { 10, 16, height - 3 }, { 4, 2, 119 },
{ 10, 0, height + 2 });
break;
case 3:
PaintAddImageAsParentRotated(
session, direction, session.TrackColours[SCHEME_TRACK] | 27086, { 16, 16, height - 3 }, { 2, 2, 119 },
{ 29, 29, height + 2 });
break;
}
paint_util_set_segment_support_height(
session,
paint_util_rotate_segments(
SEGMENT_B8 | SEGMENT_C0 | SEGMENT_C4 | SEGMENT_C8 | SEGMENT_D0 | SEGMENT_D4, direction),
0xFFFF, 0);
paint_util_set_general_support_height(session, height + 168, 0x20);
break;
case 3:
switch (direction)
{
case 0:
PaintAddImageAsParentRotated(
session, direction, session.TrackColours[SCHEME_TRACK] | 27076, { 0, 0, height + 29 }, { 32, 20, 3 },
{ 0, 6, height + 34 });
break;
case 1:
PaintAddImageAsParentRotated(
session, direction, session.TrackColours[SCHEME_TRACK] | 27084, { 0, 0, height + 29 }, { 2, 2, 3 },
{ 0, 0, height - 6 });
break;
case 2:
PaintAddImageAsParentRotated(
session, direction, session.TrackColours[SCHEME_TRACK] | 27077, { 0, 16, height + 29 }, { 32, 2, 3 },
{ 0, 0, height - 6 });
break;
case 3:
PaintAddImageAsParentRotated(
session, direction, session.TrackColours[SCHEME_TRACK] | 27085, { 0, 16, height + 29 }, { 32, 20, 3 },
{ 0, 6, height + 34 });
break;
}
if (direction == 0 || direction == 3)
{
paint_util_push_tunnel_rotated(session, direction, height + 32, TUNNEL_0);
}
paint_util_set_segment_support_height(
session, paint_util_rotate_segments(SEGMENT_C4 | SEGMENT_CC | SEGMENT_D0, direction), 0xFFFF, 0);
paint_util_set_general_support_height(session, height + 64, 0x20);
break;
}
}
static void lay_down_rc_track_half_loop_uninverted_down(
paint_session& session, const Ride& ride, uint8_t trackSequence, uint8_t direction, int32_t height,
const TrackElement& trackElement)
{
lay_down_rc_track_half_loop_inverted_up(session, ride, 3 - trackSequence, direction, height, trackElement);
}
TRACK_PAINT_FUNCTION get_track_paint_function_lay_down_rc(int32_t trackType)
{
@ -16305,9 +16463,9 @@ TRACK_PAINT_FUNCTION get_track_paint_function_lay_down_rc(int32_t trackType)
return lay_down_rc_track_left_flyer_twist_down;
case TrackElemType::RightFlyerTwistDown:
return lay_down_rc_track_right_flyer_twist_down;
case TrackElemType::FlyerHalfLoopUp:
case TrackElemType::FlyerHalfLoopUninvertedUp:
return lay_down_rc_track_flyer_half_loop_up;
case TrackElemType::FlyerHalfLoopDown:
case TrackElemType::FlyerHalfLoopInvertedDown:
return lay_down_rc_track_flyer_half_loop_down;
case TrackElemType::LeftFlyerCorkscrewUp:
return lay_down_rc_track_left_flyer_corkscrew_up;
@ -16328,6 +16486,11 @@ TRACK_PAINT_FUNCTION get_track_paint_function_lay_down_rc(int32_t trackType)
return lay_down_rc_track_left_quarter_banked_helix_large_down;
case TrackElemType::RightQuarterBankedHelixLargeDown:
return lay_down_rc_track_right_quarter_banked_helix_large_down;
case TrackElemType::FlyerHalfLoopInvertedUp:
return lay_down_rc_track_half_loop_inverted_up;
case TrackElemType::FlyerHalfLoopUninvertedDown:
return lay_down_rc_track_half_loop_uninverted_down;
}
return nullptr;
}

8
src/openrct2/ride/coaster/meta/FlyingRollerCoaster.h
View File

@ -20,8 +20,8 @@ constexpr const RideTypeDescriptor FlyingRollerCoasterRTD =
{
SET_FIELD(AlternateType, RIDE_TYPE_FLYING_ROLLER_COASTER_ALT),
SET_FIELD(Category, RIDE_CATEGORY_ROLLERCOASTER),
SET_FIELD(EnabledTrackPieces, {TRACK_STRAIGHT, TRACK_FLAT_ROLL_BANKING, TRACK_SLOPE, TRACK_SLOPE_STEEP_UP, TRACK_SLOPE_STEEP_DOWN, TRACK_SLOPE_CURVE, TRACK_SLOPE_CURVE_STEEP, TRACK_S_BEND, TRACK_CURVE_SMALL, TRACK_CURVE, TRACK_HELIX_SMALL, TRACK_BRAKES, TRACK_ON_RIDE_PHOTO, TRACK_BLOCK_BRAKES, TRACK_SLOPE_ROLL_BANKING, TRACK_INLINE_TWIST_UNINVERTED, TRACK_HALF_LOOP_UNINVERTED}),
SET_FIELD(ExtraTrackPieces, {TRACK_BOOSTER}),
SET_FIELD(EnabledTrackPieces, {TRACK_STRAIGHT, TRACK_FLAT_ROLL_BANKING, TRACK_SLOPE, TRACK_SLOPE_STEEP_UP, TRACK_SLOPE_STEEP_DOWN, TRACK_SLOPE_CURVE, TRACK_SLOPE_CURVE_STEEP, TRACK_S_BEND, TRACK_CURVE_SMALL, TRACK_CURVE, TRACK_HELIX_SMALL, TRACK_BRAKES, TRACK_ON_RIDE_PHOTO, TRACK_BLOCK_BRAKES, TRACK_SLOPE_ROLL_BANKING, TRACK_INLINE_TWIST_UNINVERTED, TRACK_FLYING_HALF_LOOP_UNINVERTED_UP, TRACK_QUARTER_LOOP_UNINVERTED_UP, TRACK_FLYING_LARGE_HALF_LOOP_UNINVERTED_UP, TRACK_SLOPE_VERTICAL}),
SET_FIELD(ExtraTrackPieces, {TRACK_BOOSTER, TRACK_SLOPE_STEEP_LONG, TRACK_FLYING_HALF_LOOP_UNINVERTED_DOWN}),
SET_FIELD(CoveredTrackPieces, {}),
SET_FIELD(StartTrackPiece, TrackElemType::EndStation),
SET_FIELD(TrackPaintFunction, get_track_paint_function_flying_rc),
@ -62,8 +62,8 @@ constexpr const RideTypeDescriptor FlyingRollerCoasterAltRTD =
{
SET_FIELD(AlternateType, RIDE_TYPE_NULL),
SET_FIELD(Category, RIDE_CATEGORY_NONE),
SET_FIELD(EnabledTrackPieces, {TRACK_STRAIGHT, TRACK_STATION_END, TRACK_LIFT_HILL, TRACK_FLAT_ROLL_BANKING, TRACK_SLOPE, TRACK_SLOPE_STEEP_UP, TRACK_SLOPE_STEEP_DOWN, TRACK_SLOPE_CURVE, TRACK_SLOPE_CURVE_STEEP, TRACK_S_BEND, TRACK_CURVE_SMALL, TRACK_CURVE, TRACK_HELIX_LARGE, TRACK_BRAKES, TRACK_ON_RIDE_PHOTO, TRACK_BLOCK_BRAKES, TRACK_SLOPE_ROLL_BANKING, TRACK_INLINE_TWIST_INVERTED, TRACK_HALF_LOOP_INVERTED}),
SET_FIELD(ExtraTrackPieces, {}),
SET_FIELD(EnabledTrackPieces, {TRACK_STRAIGHT, TRACK_STATION_END, TRACK_LIFT_HILL, TRACK_FLAT_ROLL_BANKING, TRACK_SLOPE, TRACK_SLOPE_STEEP_UP, TRACK_SLOPE_STEEP_DOWN, TRACK_SLOPE_CURVE, TRACK_SLOPE_CURVE_STEEP, TRACK_S_BEND, TRACK_CURVE_SMALL, TRACK_CURVE, TRACK_HELIX_LARGE, TRACK_BRAKES, TRACK_ON_RIDE_PHOTO, TRACK_BLOCK_BRAKES, TRACK_SLOPE_ROLL_BANKING, TRACK_INLINE_TWIST_INVERTED, TRACK_FLYING_HALF_LOOP_INVERTED_DOWN, TRACK_QUARTER_LOOP_INVERTED_DOWN, TRACK_FLYING_LARGE_HALF_LOOP_INVERTED_DOWN}),
SET_FIELD(ExtraTrackPieces, {TRACK_FLYING_HALF_LOOP_INVERTED_UP}),
SET_FIELD(CoveredTrackPieces, {}),
SET_FIELD(StartTrackPiece, TrackElemType::EndStation),
SET_FIELD(TrackPaintFunction, nullptr),

8
src/openrct2/ride/coaster/meta/LayDownRollerCoaster.h
View File

@ -19,8 +19,8 @@ constexpr const RideTypeDescriptor LayDownRollerCoasterRTD =
{
SET_FIELD(AlternateType, RIDE_TYPE_LAY_DOWN_ROLLER_COASTER_ALT),
SET_FIELD(Category, RIDE_CATEGORY_ROLLERCOASTER),
SET_FIELD(EnabledTrackPieces, {TRACK_STRAIGHT, TRACK_STATION_END, TRACK_LIFT_HILL, TRACK_FLAT_ROLL_BANKING, TRACK_VERTICAL_LOOP, TRACK_SLOPE, TRACK_SLOPE_STEEP_UP, TRACK_SLOPE_STEEP_DOWN, TRACK_SLOPE_CURVE, TRACK_SLOPE_CURVE_STEEP, TRACK_S_BEND, TRACK_CURVE_SMALL, TRACK_CURVE, TRACK_HELIX_SMALL, TRACK_BRAKES, TRACK_ON_RIDE_PHOTO, TRACK_BLOCK_BRAKES, TRACK_INLINE_TWIST_UNINVERTED, TRACK_HALF_LOOP_UNINVERTED, TRACK_CORKSCREW_UNINVERTED}),
SET_FIELD(ExtraTrackPieces, {}),
SET_FIELD(EnabledTrackPieces, {TRACK_STRAIGHT, TRACK_STATION_END, TRACK_LIFT_HILL, TRACK_FLAT_ROLL_BANKING, TRACK_VERTICAL_LOOP, TRACK_SLOPE, TRACK_SLOPE_STEEP_UP, TRACK_SLOPE_STEEP_DOWN, TRACK_SLOPE_CURVE, TRACK_SLOPE_CURVE_STEEP, TRACK_S_BEND, TRACK_CURVE_SMALL, TRACK_CURVE, TRACK_HELIX_SMALL, TRACK_BRAKES, TRACK_ON_RIDE_PHOTO, TRACK_BLOCK_BRAKES, TRACK_INLINE_TWIST_UNINVERTED, TRACK_FLYING_HALF_LOOP_UNINVERTED_UP, TRACK_CORKSCREW_UNINVERTED}),
SET_FIELD(ExtraTrackPieces, {TRACK_FLYING_HALF_LOOP_UNINVERTED_DOWN}),
SET_FIELD(CoveredTrackPieces, {}),
SET_FIELD(StartTrackPiece, TrackElemType::EndStation),
SET_FIELD(TrackPaintFunction, get_track_paint_function_lay_down_rc),
@ -59,8 +59,8 @@ constexpr const RideTypeDescriptor LayDownRollerCoasterAltRTD =
{
SET_FIELD(AlternateType, RIDE_TYPE_NULL),
SET_FIELD(Category, RIDE_CATEGORY_NONE),
SET_FIELD(EnabledTrackPieces, {TRACK_STRAIGHT, TRACK_FLAT_ROLL_BANKING, TRACK_SLOPE, TRACK_SLOPE_STEEP_UP, TRACK_SLOPE_STEEP_DOWN, TRACK_SLOPE_CURVE, TRACK_SLOPE_CURVE_STEEP, TRACK_S_BEND, TRACK_CURVE_SMALL, TRACK_CURVE, TRACK_HELIX_LARGE, TRACK_BRAKES, TRACK_ON_RIDE_PHOTO, TRACK_BLOCK_BRAKES, TRACK_INLINE_TWIST_INVERTED, TRACK_HALF_LOOP_INVERTED, TRACK_CORKSCREW_INVERTED}),
SET_FIELD(ExtraTrackPieces, {}),
SET_FIELD(EnabledTrackPieces, {TRACK_STRAIGHT, TRACK_FLAT_ROLL_BANKING, TRACK_SLOPE, TRACK_SLOPE_STEEP_UP, TRACK_SLOPE_STEEP_DOWN, TRACK_SLOPE_CURVE, TRACK_SLOPE_CURVE_STEEP, TRACK_S_BEND, TRACK_CURVE_SMALL, TRACK_CURVE, TRACK_HELIX_LARGE, TRACK_BRAKES, TRACK_ON_RIDE_PHOTO, TRACK_BLOCK_BRAKES, TRACK_INLINE_TWIST_INVERTED, TRACK_FLYING_HALF_LOOP_INVERTED_DOWN, TRACK_CORKSCREW_INVERTED}),
SET_FIELD(ExtraTrackPieces, {TRACK_FLYING_HALF_LOOP_INVERTED_UP}),
SET_FIELD(CoveredTrackPieces, {}),
SET_FIELD(StartTrackPiece, TrackElemType::EndStation),
SET_FIELD(TrackPaintFunction, nullptr),

4
src/openrct2/ride/coaster/meta/MultiDimensionRollerCoaster.h
View File

@ -19,7 +19,7 @@ constexpr const RideTypeDescriptor MultiDimensionRollerCoasterRTD =
{
SET_FIELD(AlternateType, RIDE_TYPE_MULTI_DIMENSION_ROLLER_COASTER_ALT),
SET_FIELD(Category, RIDE_CATEGORY_ROLLERCOASTER),
SET_FIELD(EnabledTrackPieces, { TRACK_STRAIGHT, TRACK_STATION_END, TRACK_LIFT_HILL, TRACK_FLAT_ROLL_BANKING, TRACK_SLOPE, TRACK_SLOPE_STEEP_UP, TRACK_SLOPE_STEEP_DOWN, TRACK_S_BEND, TRACK_CURVE_SMALL, TRACK_CURVE, TRACK_HELIX_SMALL, TRACK_BRAKES, TRACK_ON_RIDE_PHOTO, TRACK_SLOPE_VERTICAL, TRACK_BLOCK_BRAKES, TRACK_INLINE_TWIST_UNINVERTED, TRACK_QUARTER_LOOP_UNINVERTED}),
SET_FIELD(EnabledTrackPieces, { TRACK_STRAIGHT, TRACK_STATION_END, TRACK_LIFT_HILL, TRACK_FLAT_ROLL_BANKING, TRACK_SLOPE, TRACK_SLOPE_STEEP_UP, TRACK_SLOPE_STEEP_DOWN, TRACK_S_BEND, TRACK_CURVE_SMALL, TRACK_CURVE, TRACK_HELIX_SMALL, TRACK_BRAKES, TRACK_ON_RIDE_PHOTO, TRACK_SLOPE_VERTICAL, TRACK_BLOCK_BRAKES, TRACK_INLINE_TWIST_UNINVERTED,TRACK_QUARTER_LOOP_UNINVERTED_UP, TRACK_QUARTER_LOOP_UNINVERTED_DOWN}),
SET_FIELD(ExtraTrackPieces, {}),
SET_FIELD(CoveredTrackPieces, {}),
SET_FIELD(StartTrackPiece, TrackElemType::EndStation),
@ -60,7 +60,7 @@ constexpr const RideTypeDescriptor MultiDimensionRollerCoasterAltRTD =
{
SET_FIELD(AlternateType, RIDE_TYPE_NULL),
SET_FIELD(Category, RIDE_CATEGORY_NONE),
SET_FIELD(EnabledTrackPieces, {TRACK_STRAIGHT, TRACK_FLAT_ROLL_BANKING, TRACK_SLOPE, TRACK_SLOPE_STEEP_UP, TRACK_SLOPE_STEEP_DOWN, TRACK_S_BEND, TRACK_CURVE_SMALL, TRACK_CURVE, TRACK_BRAKES, TRACK_ON_RIDE_PHOTO, TRACK_SLOPE_VERTICAL, TRACK_BLOCK_BRAKES, TRACK_INLINE_TWIST_INVERTED, TRACK_QUARTER_LOOP_INVERTED}),
SET_FIELD(EnabledTrackPieces, {TRACK_STRAIGHT, TRACK_FLAT_ROLL_BANKING, TRACK_SLOPE, TRACK_SLOPE_STEEP_UP, TRACK_SLOPE_STEEP_DOWN, TRACK_S_BEND, TRACK_CURVE_SMALL, TRACK_CURVE, TRACK_BRAKES, TRACK_ON_RIDE_PHOTO, TRACK_SLOPE_VERTICAL, TRACK_BLOCK_BRAKES, TRACK_INLINE_TWIST_INVERTED, TRACK_QUARTER_LOOP_INVERTED_UP, TRACK_QUARTER_LOOP_INVERTED_DOWN}),
SET_FIELD(ExtraTrackPieces, {}),
SET_FIELD(CoveredTrackPieces, {}),
SET_FIELD(StartTrackPiece, TrackElemType::EndStation),