2014-05-23 11:14:52 +02:00
|
|
|
/*****************************************************************************
|
2020-07-21 15:04:34 +02:00
|
|
|
* Copyright (c) 2014-2020 OpenRCT2 developers
|
2014-05-23 11:14:52 +02:00
|
|
|
*
|
2018-06-15 14:07:34 +02:00
|
|
|
* For a complete list of all authors, please refer to contributors.md
|
|
|
|
* Interested in contributing? Visit https://github.com/OpenRCT2/OpenRCT2
|
2014-05-23 11:14:52 +02:00
|
|
|
*
|
2018-06-15 14:07:34 +02:00
|
|
|
* OpenRCT2 is licensed under the GNU General Public License version 3.
|
2014-05-23 11:14:52 +02:00
|
|
|
*****************************************************************************/
|
|
|
|
|
2021-08-21 12:55:28 +02:00
|
|
|
#pragma once
|
2014-05-24 15:31:42 +02:00
|
|
|
|
2020-06-19 18:04:43 +02:00
|
|
|
#define TRACK_COLOUR_PRESETS(...) \
|
|
|
|
{ \
|
|
|
|
static_cast<uint8_t>(std::size<TrackColour>({ __VA_ARGS__ })), \
|
|
|
|
{ \
|
|
|
|
__VA_ARGS__ \
|
|
|
|
} \
|
|
|
|
}
|
|
|
|
#define DEFAULT_FLAT_RIDE_COLOUR_PRESET TRACK_COLOUR_PRESETS({ COLOUR_BRIGHT_RED, COLOUR_LIGHT_BLUE, COLOUR_YELLOW })
|
|
|
|
#define DEFAULT_STALL_COLOUR_PRESET TRACK_COLOUR_PRESETS({ COLOUR_BRIGHT_RED, COLOUR_BRIGHT_RED, COLOUR_BRIGHT_RED })
|
|
|
|
|
2021-02-23 09:30:16 +01:00
|
|
|
#include "../audio/audio.h"
|
2014-10-06 18:36:58 +02:00
|
|
|
#include "../common.h"
|
2021-12-09 22:28:04 +01:00
|
|
|
#include "../core/BitSet.hpp"
|
2022-07-27 00:33:54 +02:00
|
|
|
#include "../entity/Guest.h"
|
2020-04-18 12:12:07 +02:00
|
|
|
#include "../localisation/StringIds.h"
|
2020-07-03 22:15:11 +02:00
|
|
|
#include "../sprites.h"
|
2020-09-28 15:09:59 +02:00
|
|
|
#include "../util/Util.h"
|
2017-12-31 13:21:34 +01:00
|
|
|
#include "Ride.h"
|
2022-07-28 01:50:20 +02:00
|
|
|
#include "RideAudio.h"
|
2021-11-26 16:03:14 +01:00
|
|
|
#include "RideEntry.h"
|
2020-04-25 15:29:18 +02:00
|
|
|
#include "ShopItem.h"
|
|
|
|
#include "Track.h"
|
2020-02-22 16:43:34 +01:00
|
|
|
#include "TrackPaint.h"
|
2014-09-01 13:04:34 +02:00
|
|
|
|
2020-10-24 22:10:44 +02:00
|
|
|
enum class ResearchCategory : uint8_t;
|
|
|
|
|
2021-06-30 20:57:27 +02:00
|
|
|
using ride_ratings_calculation = void (*)(Ride* ride, RideRatingUpdateState& state);
|
|
|
|
|
2020-04-18 12:12:07 +02:00
|
|
|
struct RideComponentName
|
2018-06-22 23:14:18 +02:00
|
|
|
{
|
2017-06-06 23:24:18 +02:00
|
|
|
rct_string_id singular;
|
|
|
|
rct_string_id plural;
|
|
|
|
rct_string_id capitalised;
|
|
|
|
rct_string_id capitalised_plural;
|
|
|
|
rct_string_id count;
|
|
|
|
rct_string_id count_plural;
|
|
|
|
rct_string_id number;
|
2018-02-14 09:42:26 +01:00
|
|
|
};
|
2016-07-14 14:07:49 +02:00
|
|
|
|
2020-11-26 19:23:47 +01:00
|
|
|
enum class RideComponentType
|
2018-06-22 23:14:18 +02:00
|
|
|
{
|
2020-11-26 19:23:47 +01:00
|
|
|
Train,
|
|
|
|
Boat,
|
|
|
|
Track,
|
|
|
|
DockingPlatform,
|
|
|
|
Station,
|
|
|
|
Car,
|
|
|
|
Building,
|
|
|
|
Structure,
|
|
|
|
Ship,
|
|
|
|
Cabin,
|
|
|
|
Wheel,
|
|
|
|
Ring,
|
|
|
|
Player,
|
|
|
|
Course,
|
|
|
|
Count
|
2018-02-14 09:42:26 +01:00
|
|
|
};
|
2016-07-14 14:07:49 +02:00
|
|
|
|
2020-06-19 20:21:16 +02:00
|
|
|
enum class RideColourKey : uint8_t
|
|
|
|
{
|
|
|
|
Ride,
|
|
|
|
Food,
|
|
|
|
Drink,
|
|
|
|
Shop,
|
|
|
|
InfoKiosk,
|
|
|
|
FirstAid,
|
|
|
|
CashMachine,
|
|
|
|
Toilets
|
|
|
|
};
|
|
|
|
|
2022-06-13 13:39:37 +02:00
|
|
|
enum class TrackDesignCreateMode : uint_fast8_t
|
|
|
|
{
|
|
|
|
Default,
|
|
|
|
Maze
|
|
|
|
};
|
|
|
|
|
2020-04-18 12:12:07 +02:00
|
|
|
struct RideNameConvention
|
2018-06-22 23:14:18 +02:00
|
|
|
{
|
2020-11-26 19:23:47 +01:00
|
|
|
RideComponentType vehicle;
|
|
|
|
RideComponentType structure;
|
|
|
|
RideComponentType station;
|
2018-02-14 09:42:26 +01:00
|
|
|
};
|
2014-05-23 14:18:58 +02:00
|
|
|
|
2020-06-12 21:19:34 +02:00
|
|
|
struct RideBuildCost
|
2018-06-22 23:14:18 +02:00
|
|
|
{
|
2022-04-07 12:35:11 +02:00
|
|
|
money64 TrackPrice; // Cost of a single straight piece of track
|
|
|
|
money64 SupportPrice;
|
2020-06-12 20:51:37 +02:00
|
|
|
uint8_t PriceEstimateMultiplier;
|
2018-02-14 09:42:26 +01:00
|
|
|
};
|
2016-04-03 13:41:00 +02:00
|
|
|
|
2020-06-16 20:17:07 +02:00
|
|
|
struct RideHeights
|
2018-06-22 23:14:18 +02:00
|
|
|
{
|
2020-06-16 20:17:07 +02:00
|
|
|
uint8_t MaxHeight;
|
|
|
|
uint8_t ClearanceHeight;
|
|
|
|
int8_t VehicleZOffset;
|
|
|
|
uint8_t PlatformHeight;
|
2018-02-14 09:42:26 +01:00
|
|
|
};
|
2016-04-03 14:53:17 +02:00
|
|
|
|
2018-06-22 23:14:18 +02:00
|
|
|
struct rct_ride_lift_data
|
|
|
|
{
|
2020-10-06 23:34:42 +02:00
|
|
|
OpenRCT2::Audio::SoundId sound_id;
|
2018-06-20 17:28:51 +02:00
|
|
|
uint8_t minimum_speed;
|
|
|
|
uint8_t maximum_speed;
|
2018-02-14 09:42:26 +01:00
|
|
|
};
|
2015-11-21 16:53:56 +01:00
|
|
|
|
2020-07-03 22:15:11 +02:00
|
|
|
struct RideColourPreview
|
|
|
|
{
|
|
|
|
uint32_t Track;
|
|
|
|
uint32_t Supports;
|
|
|
|
};
|
|
|
|
|
2021-11-26 16:03:14 +01:00
|
|
|
struct RideOperatingSettings
|
|
|
|
{
|
|
|
|
uint8_t MinValue;
|
|
|
|
uint8_t MaxValue;
|
|
|
|
uint8_t MaxBrakesSpeed;
|
|
|
|
uint8_t PoweredLiftAcceleration;
|
|
|
|
uint8_t BoosterAcceleration;
|
2022-07-30 16:32:22 +02:00
|
|
|
int8_t BoosterSpeedFactor; // The factor to shift the raw booster speed with
|
|
|
|
uint8_t OperatingSettingMultiplier = 1; // Used for the Ride window, cosmetic only.
|
2021-11-26 16:03:14 +01:00
|
|
|
};
|
|
|
|
|
2020-04-19 21:00:21 +02:00
|
|
|
struct UpkeepCostsDescriptor
|
|
|
|
{
|
|
|
|
/**
|
|
|
|
* Data about ride running costs. This is widely adjusted by the upkeep
|
|
|
|
* function, so values that don't make much sense here (a roller coaster having
|
|
|
|
* cheaper upkeep than a car ride) are fixed later on.
|
|
|
|
*
|
|
|
|
* Data generation script: https://gist.github.com/kevinburke/6bcf4a8fcc95faad7bac
|
|
|
|
*/
|
|
|
|
uint8_t BaseCost;
|
|
|
|
/** rct2: 0x0097E3AC */
|
|
|
|
uint8_t TrackLengthMultiplier;
|
|
|
|
uint8_t CostPerTrackPiece;
|
|
|
|
/** rct2: 0x0097E3B4 */
|
|
|
|
uint8_t CostPerTrain;
|
|
|
|
/** rct2: 0x0097E3B6 */
|
|
|
|
uint8_t CostPerCar;
|
|
|
|
/** rct2: 0x0097E3B8 */
|
|
|
|
uint8_t CostPerStation;
|
|
|
|
};
|
|
|
|
|
2021-12-09 22:28:04 +01:00
|
|
|
using RideTrackGroup = OpenRCT2::BitSet<TRACK_GROUP_COUNT>;
|
2022-06-06 21:00:16 +02:00
|
|
|
using RideMusicUpdateFunction = void (*)(Ride*);
|
2022-07-27 00:33:54 +02:00
|
|
|
using PeepUpdateRideLeaveEntranceFunc = void (*)(Guest*, Ride*, CoordsXYZD&);
|
2022-07-28 01:50:20 +02:00
|
|
|
using StartRideMusicFunction = void (*)(const OpenRCT2::RideAudio::ViewportRideMusicInstance&);
|
2020-02-20 11:00:03 +01:00
|
|
|
struct RideTypeDescriptor
|
|
|
|
{
|
2020-04-19 18:44:38 +02:00
|
|
|
uint8_t AlternateType;
|
2020-04-18 15:19:45 +02:00
|
|
|
uint8_t Category;
|
2020-04-24 04:47:40 +02:00
|
|
|
/** rct2: 0x0097C468 (0 - 31) and 0x0097C5D4 (32 - 63) */
|
2021-12-09 22:28:04 +01:00
|
|
|
RideTrackGroup EnabledTrackPieces;
|
2020-02-22 20:13:44 +01:00
|
|
|
// Pieces that this ride type _can_ draw, but are disabled because their vehicles lack the relevant sprites,
|
|
|
|
// or because they are not realistic for the ride type (e.g. LIM boosters in Mini Roller Coasters).
|
2021-12-09 22:28:04 +01:00
|
|
|
RideTrackGroup ExtraTrackPieces;
|
|
|
|
RideTrackGroup CoveredTrackPieces;
|
2020-04-19 18:05:57 +02:00
|
|
|
/** rct2: 0x0097CC68 */
|
|
|
|
uint64_t StartTrackPiece;
|
2020-02-22 16:43:34 +01:00
|
|
|
TRACK_PAINT_FUNCTION_GETTER TrackPaintFunction;
|
2020-04-16 18:17:15 +02:00
|
|
|
uint64_t Flags;
|
2020-04-25 15:29:18 +02:00
|
|
|
/** rct2: 0x0097C8AC */
|
|
|
|
uint64_t RideModes;
|
2020-09-28 15:09:59 +02:00
|
|
|
RideMode DefaultMode;
|
2020-06-17 18:59:04 +02:00
|
|
|
/** rct2: 0x0097CF40 */
|
|
|
|
RideOperatingSettings OperatingSettings;
|
2020-06-16 22:50:58 +02:00
|
|
|
RideNaming Naming;
|
2020-04-18 12:12:07 +02:00
|
|
|
RideNameConvention NameConvention;
|
2020-06-19 23:03:24 +02:00
|
|
|
const char* EnumName;
|
2020-04-18 14:33:32 +02:00
|
|
|
uint8_t AvailableBreakdowns;
|
2020-06-16 20:57:55 +02:00
|
|
|
/** rct2: 0x0097D218 */
|
|
|
|
RideHeights Heights;
|
|
|
|
uint8_t MaxMass;
|
2020-04-24 04:47:40 +02:00
|
|
|
/** rct2: 0x0097D7C8, 0x0097D7C9, 0x0097D7CA */
|
2020-04-19 14:41:26 +02:00
|
|
|
rct_ride_lift_data LiftData;
|
2020-06-18 00:10:08 +02:00
|
|
|
// rct2: 0x0097E050
|
|
|
|
ride_ratings_calculation RatingsCalculationFunction;
|
2020-06-17 22:22:52 +02:00
|
|
|
// rct2: 0x0097CD1E
|
|
|
|
RatingTuple RatingsMultipliers;
|
2020-04-19 21:00:21 +02:00
|
|
|
UpkeepCostsDescriptor UpkeepCosts;
|
2020-06-12 21:19:34 +02:00
|
|
|
// rct2: 0x0097DD78
|
|
|
|
RideBuildCost BuildCosts;
|
2021-12-01 22:55:52 +01:00
|
|
|
money16 DefaultPrices[RCT2::ObjectLimits::MaxShopItemsPerRideEntry];
|
2021-09-01 10:16:44 +02:00
|
|
|
std::string_view DefaultMusic;
|
2020-04-24 04:47:40 +02:00
|
|
|
/** rct2: 0x0097D7CB */
|
2020-06-08 14:23:33 +02:00
|
|
|
ShopItemIndex PhotoItem;
|
2020-06-17 18:59:04 +02:00
|
|
|
/** rct2: 0x0097D21E */
|
|
|
|
uint8_t BonusValue;
|
2020-06-19 18:04:43 +02:00
|
|
|
track_colour_preset_list ColourPresets;
|
2020-07-03 22:15:11 +02:00
|
|
|
RideColourPreview ColourPreview;
|
2020-06-19 20:21:16 +02:00
|
|
|
RideColourKey ColourKey;
|
2022-07-25 00:06:37 +02:00
|
|
|
|
|
|
|
// json name lookup
|
|
|
|
std::string_view Name;
|
2022-07-28 01:50:20 +02:00
|
|
|
StartRideMusicFunction StartRideMusic = OpenRCT2::RideAudio::DefaultStartRideMusicChannel;
|
2022-07-25 00:06:37 +02:00
|
|
|
|
2022-06-13 13:39:37 +02:00
|
|
|
TrackDesignCreateMode DesignCreateMode = TrackDesignCreateMode::Default;
|
2022-06-06 21:00:16 +02:00
|
|
|
|
|
|
|
RideMusicUpdateFunction MusicUpdateFunction = DefaultMusicUpdate;
|
2022-05-04 04:32:00 +02:00
|
|
|
RideClassification Classification = RideClassification::Ride;
|
2020-04-18 15:19:45 +02:00
|
|
|
|
2022-07-27 00:33:54 +02:00
|
|
|
PeepUpdateRideLeaveEntranceFunc UpdateLeaveEntrance = PeepUpdateRideLeaveEntranceDefault;
|
|
|
|
|
2020-04-18 15:19:45 +02:00
|
|
|
bool HasFlag(uint64_t flag) const;
|
2021-12-09 22:28:04 +01:00
|
|
|
void GetAvailableTrackPieces(RideTrackGroup& res) const;
|
2020-04-19 13:32:43 +02:00
|
|
|
bool SupportsTrackPiece(const uint64_t trackPiece) const;
|
2020-10-24 22:10:44 +02:00
|
|
|
ResearchCategory GetResearchCategory() const;
|
2020-02-20 11:00:03 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
#ifdef _WIN32
|
2020-04-18 12:12:07 +02:00
|
|
|
# define SET_FIELD(fieldname, ...) __VA_ARGS__
|
2020-02-20 11:00:03 +01:00
|
|
|
#else
|
2020-04-18 12:12:07 +02:00
|
|
|
# define SET_FIELD(fieldname, ...) .fieldname = __VA_ARGS__
|
2020-02-20 11:00:03 +01:00
|
|
|
#endif
|
|
|
|
|
|
|
|
extern const RideTypeDescriptor RideTypeDescriptors[RIDE_TYPE_COUNT];
|
|
|
|
|
2018-06-22 23:14:18 +02:00
|
|
|
enum
|
|
|
|
{
|
2017-06-06 23:24:18 +02:00
|
|
|
RIDE_TYPE_NO_ALTERNATIVES = 0,
|
|
|
|
RIDE_TYPE_ALTERNATIVE_TRACK_PIECES = 1, // Dinghy slide and Water Coaster
|
|
|
|
RIDE_TYPE_ALTERNATIVE_TRACK_TYPE = 2, // Flying RC, Lay-down RC, Multi-dimension RC
|
2017-05-16 19:11:51 +02:00
|
|
|
};
|
|
|
|
|
2020-04-16 18:17:15 +02:00
|
|
|
enum ride_type_flags : uint64_t
|
|
|
|
{
|
|
|
|
RIDE_TYPE_FLAG_HAS_TRACK_COLOUR_MAIN = (1ULL << 0),
|
|
|
|
RIDE_TYPE_FLAG_HAS_TRACK_COLOUR_ADDITIONAL = (1ULL << 1),
|
|
|
|
RIDE_TYPE_FLAG_HAS_TRACK_COLOUR_SUPPORTS = (1ULL << 2),
|
|
|
|
RIDE_TYPE_FLAG_HAS_SINGLE_PIECE_STATION = (1ULL << 3), // Set by flat rides, tower rides and shops/stalls.
|
|
|
|
RIDE_TYPE_FLAG_HAS_LEAVE_WHEN_ANOTHER_VEHICLE_ARRIVES_AT_STATION = (1ULL << 4),
|
|
|
|
RIDE_TYPE_FLAG_CAN_SYNCHRONISE_ADJACENT_STATIONS = (1ULL << 5),
|
|
|
|
RIDE_TYPE_FLAG_TRACK_MUST_BE_ON_WATER = (1ULL << 6), // used only by boat Hire and submarine ride
|
|
|
|
RIDE_TYPE_FLAG_HAS_G_FORCES = (1ULL << 7),
|
|
|
|
RIDE_TYPE_FLAG_CANNOT_HAVE_GAPS = (1ULL << 8), // used by rides that can't have gaps, like those with a vertical tower, such
|
|
|
|
// as the observation tower
|
|
|
|
RIDE_TYPE_FLAG_HAS_DATA_LOGGING = (1ULL << 9),
|
|
|
|
RIDE_TYPE_FLAG_HAS_DROPS = (1ULL << 10),
|
|
|
|
RIDE_TYPE_FLAG_NO_TEST_MODE = (1ULL << 11),
|
|
|
|
RIDE_TYPE_FLAG_TRACK_ELEMENTS_HAVE_TWO_VARIETIES = (1ULL << 12), // used by rides with two varieties, like the u and o
|
|
|
|
// shapes of the dinghy slide and the dry and submerged
|
|
|
|
// track of the water coaster
|
|
|
|
RIDE_TYPE_FLAG_NO_VEHICLES = (1ULL << 13), // used only by maze, spiral slide and shops
|
|
|
|
RIDE_TYPE_FLAG_HAS_LOAD_OPTIONS = (1ULL << 14),
|
|
|
|
RIDE_TYPE_FLAG_HAS_NO_TRACK = (1ULL << 15),
|
|
|
|
RIDE_TYPE_FLAG_VEHICLE_IS_INTEGRAL = (1ULL << 16), // Set by flat rides where the vehicle is integral to the structure, like
|
|
|
|
// Merry-go-round and swinging ships. (Contrast with rides like dodgems.)
|
|
|
|
RIDE_TYPE_FLAG_IS_SHOP = (1ULL << 17),
|
|
|
|
RIDE_TYPE_FLAG_TRACK_NO_WALLS = (1ULL << 18), // if set, wall scenery can not share a tile with the ride's track
|
|
|
|
RIDE_TYPE_FLAG_FLAT_RIDE = (1ULL << 19),
|
|
|
|
RIDE_TYPE_FLAG_PEEP_WILL_RIDE_AGAIN = (1ULL << 20), // whether or not guests will go on the ride again if they liked it
|
|
|
|
// (this is
|
|
|
|
// usually applied to everything apart from transport rides)
|
|
|
|
RIDE_TYPE_FLAG_PEEP_SHOULD_GO_INSIDE_FACILITY = (1ULL << 21), // used by toilets and first aid to mark that peep should go
|
|
|
|
// inside the building (rather than 'buying' at the counter)
|
|
|
|
RIDE_TYPE_FLAG_IN_RIDE = (1ULL << 22), // peeps are "IN" (ride) rather than "ON" (ride)
|
|
|
|
RIDE_TYPE_FLAG_SELLS_FOOD = (1ULL << 23),
|
|
|
|
RIDE_TYPE_FLAG_SELLS_DRINKS = (1ULL << 24),
|
|
|
|
RIDE_TYPE_FLAG_IS_TOILET = (1ULL << 25),
|
|
|
|
RIDE_TYPE_FLAG_HAS_VEHICLE_COLOURS = (1ULL << 26), // whether or not vehicle colours can be set
|
|
|
|
RIDE_TYPE_FLAG_CHECK_FOR_STALLING = (1ULL << 27),
|
|
|
|
RIDE_TYPE_FLAG_HAS_TRACK = (1ULL << 28),
|
|
|
|
RIDE_TYPE_FLAG_ALLOW_EXTRA_TOWER_BASES = (1ULL << 29), // Only set by lift
|
|
|
|
RIDE_TYPE_FLAG_HAS_LARGE_CURVES = (1ULL << 30), // whether the ride supports large (45 degree turn) curves
|
|
|
|
RIDE_TYPE_FLAG_SUPPORTS_MULTIPLE_TRACK_COLOUR = (1ULL << 31),
|
|
|
|
|
|
|
|
RIDE_TYPE_FLAG_ALLOW_DOORS_ON_TRACK = (1ULL << 32),
|
|
|
|
RIDE_TYPE_FLAG_MUSIC_ON_DEFAULT = (1ULL << 33),
|
|
|
|
RIDE_TYPE_FLAG_ALLOW_MUSIC = (1ULL << 34),
|
|
|
|
RIDE_TYPE_FLAG_HAS_ALTERNATIVE_TRACK_TYPE = (1ULL << 35), // Used by the Flying RC, Lay-down RC, Multi-dimension RC
|
|
|
|
RIDE_TYPE_FLAG_PEEP_CHECK_GFORCES = (1ULL << 36),
|
|
|
|
RIDE_TYPE_FLAG_HAS_ENTRANCE_EXIT = (1ULL << 37),
|
|
|
|
RIDE_TYPE_FLAG_ALLOW_MORE_VEHICLES_THAN_STATION_FITS = (1ULL << 38),
|
|
|
|
RIDE_TYPE_FLAG_HAS_AIR_TIME = (1ULL << 39),
|
|
|
|
RIDE_TYPE_FLAG_SINGLE_SESSION = (1ULL << 40),
|
|
|
|
RIDE_TYPE_FLAG_ALLOW_MULTIPLE_CIRCUITS = (1ULL << 41),
|
|
|
|
RIDE_TYPE_FLAG_ALLOW_CABLE_LIFT_HILL = (1ULL << 42),
|
|
|
|
RIDE_TYPE_FLAG_SHOW_IN_TRACK_DESIGNER = (1ULL << 43),
|
|
|
|
RIDE_TYPE_FLAG_TRANSPORT_RIDE = (1ULL << 44),
|
|
|
|
RIDE_TYPE_FLAG_INTERESTING_TO_LOOK_AT = (1ULL << 45),
|
|
|
|
RIDE_TYPE_FLAG_SLIGHTLY_INTERESTING_TO_LOOK_AT = (1ULL << 46),
|
|
|
|
RIDE_TYPE_FLAG_START_CONSTRUCTION_INVERTED = (1ULL << 47), // This is only set on the Flying RC and its alternative type.
|
2020-04-18 15:19:45 +02:00
|
|
|
|
|
|
|
RIDE_TYPE_FLAG_LIST_VEHICLES_SEPARATELY = (1ULL << 48),
|
2020-04-19 13:32:43 +02:00
|
|
|
RIDE_TYPE_FLAG_SUPPORTS_LEVEL_CROSSINGS = (1ULL << 49),
|
2020-04-19 13:53:51 +02:00
|
|
|
RIDE_TYPE_FLAG_IS_SUSPENDED = (1ULL << 50),
|
2021-01-10 22:38:02 +01:00
|
|
|
RIDE_TYPE_FLAG_HAS_LANDSCAPE_DOORS = (1ULL << 51),
|
2022-03-28 21:32:42 +02:00
|
|
|
RIDE_TYPE_FLAG_UP_INCLINE_REQUIRES_LIFT = (1ULL << 52),
|
2022-03-29 04:26:56 +02:00
|
|
|
RIDE_TYPE_FLAG_PEEP_CAN_USE_UMBRELLA = (1ULL << 53),
|
2022-05-04 20:37:11 +02:00
|
|
|
RIDE_TYPE_FLAG_IS_CASH_MACHINE = (1ULL << 54),
|
2020-04-16 18:17:15 +02:00
|
|
|
};
|
|
|
|
|
2020-04-16 22:15:42 +02:00
|
|
|
// Set on ride types that have a main colour, additional colour and support colour.
|
|
|
|
constexpr const uint64_t RIDE_TYPE_FLAGS_TRACK_HAS_3_COLOURS = RIDE_TYPE_FLAG_HAS_TRACK_COLOUR_MAIN
|
|
|
|
| RIDE_TYPE_FLAG_HAS_TRACK_COLOUR_ADDITIONAL | RIDE_TYPE_FLAG_HAS_TRACK_COLOUR_SUPPORTS;
|
|
|
|
// Set on _all_ roller coaster ride types, including the _ALT types used for constructing upside down.
|
|
|
|
constexpr const uint64_t RIDE_TYPE_FLAGS_COMMON_COASTER = RIDE_TYPE_FLAG_HAS_G_FORCES | RIDE_TYPE_FLAG_HAS_DATA_LOGGING
|
|
|
|
| RIDE_TYPE_FLAG_HAS_DROPS | RIDE_TYPE_FLAG_HAS_LOAD_OPTIONS | RIDE_TYPE_FLAG_PEEP_WILL_RIDE_AGAIN
|
|
|
|
| RIDE_TYPE_FLAG_HAS_VEHICLE_COLOURS | RIDE_TYPE_FLAG_CHECK_FOR_STALLING | RIDE_TYPE_FLAG_HAS_TRACK
|
|
|
|
| RIDE_TYPE_FLAG_SUPPORTS_MULTIPLE_TRACK_COLOUR | RIDE_TYPE_FLAG_ALLOW_MUSIC | RIDE_TYPE_FLAG_INTERESTING_TO_LOOK_AT
|
|
|
|
| RIDE_TYPE_FLAG_CAN_SYNCHRONISE_ADJACENT_STATIONS;
|
|
|
|
// Set on all roller coaster ride types, excluding the _ALT types used for constructing upside down.
|
|
|
|
constexpr const uint64_t RIDE_TYPE_FLAGS_COMMON_COASTER_NON_ALT = RIDE_TYPE_FLAG_SHOW_IN_TRACK_DESIGNER
|
|
|
|
| RIDE_TYPE_FLAG_HAS_AIR_TIME | RIDE_TYPE_FLAG_HAS_ENTRANCE_EXIT;
|
|
|
|
|
2020-04-18 12:12:07 +02:00
|
|
|
// clang-format off
|
|
|
|
constexpr const RideComponentName RideComponentNames[] =
|
|
|
|
{
|
|
|
|
{ STR_RIDE_COMPONENT_TRAIN, STR_RIDE_COMPONENT_TRAIN_PLURAL, STR_RIDE_COMPONENT_TRAIN_CAPITALISED, STR_RIDE_COMPONENT_TRAIN_CAPITALISED_PLURAL, STR_RIDE_COMPONENT_TRAIN_COUNT, STR_RIDE_COMPONENT_TRAIN_COUNT_PLURAL, STR_RIDE_COMPONENT_TRAIN_NO },
|
|
|
|
{ STR_RIDE_COMPONENT_BOAT, STR_RIDE_COMPONENT_BOAT_PLURAL, STR_RIDE_COMPONENT_BOAT_CAPITALISED, STR_RIDE_COMPONENT_BOAT_CAPITALISED_PLURAL, STR_RIDE_COMPONENT_BOAT_COUNT, STR_RIDE_COMPONENT_BOAT_COUNT_PLURAL, STR_RIDE_COMPONENT_BOAT_NO },
|
|
|
|
{ STR_RIDE_COMPONENT_TRACK, STR_RIDE_COMPONENT_TRACK_PLURAL, STR_RIDE_COMPONENT_TRACK_CAPITALISED, STR_RIDE_COMPONENT_TRACK_CAPITALISED_PLURAL, STR_RIDE_COMPONENT_TRACK_COUNT, STR_RIDE_COMPONENT_TRACK_COUNT_PLURAL, STR_RIDE_COMPONENT_TRACK_NO },
|
|
|
|
{ STR_RIDE_COMPONENT_DOCKING_PLATFORM, STR_RIDE_COMPONENT_DOCKING_PLATFORM_PLURAL, STR_RIDE_COMPONENT_DOCKING_PLATFORM_CAPITALISED, STR_RIDE_COMPONENT_DOCKING_PLATFORM_CAPITALISED_PLURAL, STR_RIDE_COMPONENT_DOCKING_PLATFORM_COUNT, STR_RIDE_COMPONENT_DOCKING_PLATFORM_COUNT_PLURAL, STR_RIDE_COMPONENT_DOCKING_PLATFORM_NO },
|
|
|
|
{ STR_RIDE_COMPONENT_STATION, STR_RIDE_COMPONENT_STATION_PLURAL, STR_RIDE_COMPONENT_STATION_CAPITALISED, STR_RIDE_COMPONENT_STATION_CAPITALISED_PLURAL, STR_RIDE_COMPONENT_STATION_COUNT, STR_RIDE_COMPONENT_STATION_COUNT_PLURAL, STR_RIDE_COMPONENT_STATION_NO },
|
|
|
|
{ STR_RIDE_COMPONENT_CAR, STR_RIDE_COMPONENT_CAR_PLURAL, STR_RIDE_COMPONENT_CAR_CAPITALISED, STR_RIDE_COMPONENT_CAR_CAPITALISED_PLURAL, STR_RIDE_COMPONENT_CAR_COUNT, STR_RIDE_COMPONENT_CAR_COUNT_PLURAL, STR_RIDE_COMPONENT_CAR_NO },
|
|
|
|
{ STR_RIDE_COMPONENT_BUILDING, STR_RIDE_COMPONENT_BUILDING_PLURAL, STR_RIDE_COMPONENT_BUILDING_CAPITALISED, STR_RIDE_COMPONENT_BUILDING_CAPITALISED_PLURAL, STR_RIDE_COMPONENT_BUILDING_COUNT, STR_RIDE_COMPONENT_BUILDING_COUNT_PLURAL, STR_RIDE_COMPONENT_BUILDING_NO },
|
|
|
|
{ STR_RIDE_COMPONENT_STRUCTURE, STR_RIDE_COMPONENT_STRUCTURE_PLURAL, STR_RIDE_COMPONENT_STRUCTURE_CAPITALISED, STR_RIDE_COMPONENT_STRUCTURE_CAPITALISED_PLURAL, STR_RIDE_COMPONENT_STRUCTURE_COUNT, STR_RIDE_COMPONENT_STRUCTURE_COUNT_PLURAL, STR_RIDE_COMPONENT_STRUCTURE_NO },
|
|
|
|
{ STR_RIDE_COMPONENT_SHIP, STR_RIDE_COMPONENT_SHIP_PLURAL, STR_RIDE_COMPONENT_SHIP_CAPITALISED, STR_RIDE_COMPONENT_SHIP_CAPITALISED_PLURAL, STR_RIDE_COMPONENT_SHIP_COUNT, STR_RIDE_COMPONENT_SHIP_COUNT_PLURAL, STR_RIDE_COMPONENT_SHIP_NO },
|
|
|
|
{ STR_RIDE_COMPONENT_CABIN, STR_RIDE_COMPONENT_CABIN_PLURAL, STR_RIDE_COMPONENT_CABIN_CAPITALISED, STR_RIDE_COMPONENT_CABIN_CAPITALISED_PLURAL, STR_RIDE_COMPONENT_CABIN_COUNT, STR_RIDE_COMPONENT_CABIN_COUNT_PLURAL, STR_RIDE_COMPONENT_CABIN_NO },
|
|
|
|
{ STR_RIDE_COMPONENT_WHEEL, STR_RIDE_COMPONENT_WHEEL_PLURAL, STR_RIDE_COMPONENT_WHEEL_CAPITALISED, STR_RIDE_COMPONENT_WHEEL_CAPITALISED_PLURAL, STR_RIDE_COMPONENT_WHEEL_COUNT, STR_RIDE_COMPONENT_WHEEL_COUNT_PLURAL, STR_RIDE_COMPONENT_WHEEL_NO },
|
|
|
|
{ STR_RIDE_COMPONENT_RING, STR_RIDE_COMPONENT_RING_PLURAL, STR_RIDE_COMPONENT_RING_CAPITALISED, STR_RIDE_COMPONENT_RING_CAPITALISED_PLURAL, STR_RIDE_COMPONENT_RING_COUNT, STR_RIDE_COMPONENT_RING_COUNT_PLURAL, STR_RIDE_COMPONENT_RING_NO },
|
|
|
|
{ STR_RIDE_COMPONENT_PLAYER, STR_RIDE_COMPONENT_PLAYER_PLURAL, STR_RIDE_COMPONENT_PLAYER_CAPITALISED, STR_RIDE_COMPONENT_PLAYER_CAPITALISED_PLURAL, STR_RIDE_COMPONENT_PLAYER_COUNT, STR_RIDE_COMPONENT_PLAYER_COUNT_PLURAL, STR_RIDE_COMPONENT_PLAYER_NO },
|
|
|
|
{ STR_RIDE_COMPONENT_COURSE, STR_RIDE_COMPONENT_COURSE_PLURAL, STR_RIDE_COMPONENT_COURSE_CAPITALISED, STR_RIDE_COMPONENT_COURSE_CAPITALISED_PLURAL, STR_RIDE_COMPONENT_COURSE_COUNT, STR_RIDE_COMPONENT_COURSE_COUNT_PLURAL, STR_RIDE_COMPONENT_COURSE_NO },
|
|
|
|
};
|
|
|
|
// clang-format on
|
|
|
|
|
2021-09-01 10:16:44 +02:00
|
|
|
constexpr std::string_view MUSIC_OBJECT_DODGEMS = "rct2.music.dodgems";
|
|
|
|
constexpr std::string_view MUSIC_OBJECT_EGYPTIAN = "rct2.music.egyptian";
|
|
|
|
constexpr std::string_view MUSIC_OBJECT_FAIRGROUND = "rct2.music.fairground";
|
|
|
|
constexpr std::string_view MUSIC_OBJECT_GENTLE = "rct2.music.gentle";
|
|
|
|
constexpr std::string_view MUSIC_OBJECT_HORROR = "rct2.music.horror";
|
|
|
|
constexpr std::string_view MUSIC_OBJECT_PIRATE = "rct2.music.pirate";
|
|
|
|
constexpr std::string_view MUSIC_OBJECT_ROCK_1 = "rct2.music.rock1";
|
|
|
|
constexpr std::string_view MUSIC_OBJECT_ROCK_2 = "rct2.music.rock2";
|
|
|
|
constexpr std::string_view MUSIC_OBJECT_ROCK_3 = "rct2.music.rock3";
|
|
|
|
constexpr std::string_view MUSIC_OBJECT_SUMMER = "rct2.music.summer";
|
|
|
|
constexpr std::string_view MUSIC_OBJECT_TECHNO = "rct2.music.techno";
|
|
|
|
constexpr std::string_view MUSIC_OBJECT_WATER = "rct2.music.water";
|
|
|
|
constexpr std::string_view MUSIC_OBJECT_WILD_WEST = "rct2.music.wildwest";
|
|
|
|
|
2020-11-26 19:23:47 +01:00
|
|
|
constexpr const RideComponentName& GetRideComponentName(const RideComponentType type)
|
|
|
|
{
|
|
|
|
return RideComponentNames[EnumValue(type)];
|
|
|
|
}
|
|
|
|
|
2020-09-28 15:09:59 +02:00
|
|
|
constexpr const uint64_t AllRideModesAvailable = EnumsToFlags(
|
|
|
|
RideMode::ContinuousCircuit, RideMode::ContinuousCircuitBlockSectioned, RideMode::ReverseInclineLaunchedShuttle,
|
|
|
|
RideMode::PoweredLaunchPasstrough, RideMode::Shuttle, RideMode::Normal, RideMode::BoatHire, RideMode::UpwardLaunch,
|
|
|
|
RideMode::RotatingLift, RideMode::StationToStation, RideMode::SingleRidePerAdmission, RideMode::UnlimitedRidesPerAdmission,
|
|
|
|
RideMode::Maze, RideMode::Race, RideMode::Dodgems, RideMode::Swing, RideMode::ShopStall, RideMode::Rotation,
|
|
|
|
RideMode::ForwardRotation, RideMode::BackwardRotation, RideMode::FilmAvengingAviators, RideMode::MouseTails3DFilm,
|
|
|
|
RideMode::SpaceRings, RideMode::Beginners, RideMode::LimPoweredLaunch, RideMode::FilmThrillRiders,
|
|
|
|
RideMode::StormChasers3DFilm, RideMode::SpaceRaiders3DFilm, RideMode::Intense, RideMode::Berserk, RideMode::HauntedHouse,
|
|
|
|
RideMode::Circus, RideMode::DownwardLaunch, RideMode::CrookedHouse, RideMode::FreefallDrop, RideMode::PoweredLaunch,
|
|
|
|
RideMode::PoweredLaunchBlockSectioned);
|
2014-09-01 13:04:34 +02:00
|
|
|
|
2022-06-07 22:36:20 +02:00
|
|
|
extern const CarEntry CableLiftVehicle;
|
2015-10-18 15:01:16 +02:00
|
|
|
|
2018-06-20 17:28:51 +02:00
|
|
|
extern const uint16_t RideFilmLength[3];
|
2015-11-19 21:28:07 +01:00
|
|
|
|
2020-09-28 15:09:59 +02:00
|
|
|
extern const rct_string_id RideModeNames[static_cast<uint8_t>(RideMode::Count)];
|
2017-05-28 19:49:32 +02:00
|
|
|
|
2020-04-25 15:29:18 +02:00
|
|
|
// clang-format off
|
|
|
|
constexpr const RideTypeDescriptor DummyRTD =
|
|
|
|
{
|
|
|
|
SET_FIELD(AlternateType, RIDE_TYPE_NULL),
|
|
|
|
SET_FIELD(Category, RIDE_CATEGORY_NONE),
|
2021-12-09 22:28:04 +01:00
|
|
|
SET_FIELD(EnabledTrackPieces, {}),
|
|
|
|
SET_FIELD(ExtraTrackPieces, {}),
|
|
|
|
SET_FIELD(CoveredTrackPieces, {}),
|
2020-08-18 08:28:41 +02:00
|
|
|
SET_FIELD(StartTrackPiece, TrackElemType::EndStation),
|
2020-04-25 15:29:18 +02:00
|
|
|
SET_FIELD(TrackPaintFunction, nullptr),
|
|
|
|
SET_FIELD(Flags, 0),
|
2020-09-28 15:09:59 +02:00
|
|
|
SET_FIELD(RideModes, EnumsToFlags(RideMode::ContinuousCircuit)),
|
|
|
|
SET_FIELD(DefaultMode, RideMode::ContinuousCircuit),
|
2020-06-17 18:59:04 +02:00
|
|
|
SET_FIELD(OperatingSettings, { 0, 0, 0, 0, 0, 0 }),
|
2020-06-16 22:50:58 +02:00
|
|
|
SET_FIELD(Naming, { STR_UNKNOWN_RIDE, STR_RIDE_DESCRIPTION_UNKNOWN }),
|
2020-11-26 19:23:47 +01:00
|
|
|
SET_FIELD(NameConvention, { RideComponentType::Train, RideComponentType::Track, RideComponentType::Station }),
|
2020-06-19 23:03:24 +02:00
|
|
|
SET_FIELD(EnumName, "(INVALID)"),
|
2020-04-25 15:29:18 +02:00
|
|
|
SET_FIELD(AvailableBreakdowns, 0),
|
2020-06-16 20:57:55 +02:00
|
|
|
SET_FIELD(Heights, { 12, 64, 0, 0, }),
|
|
|
|
SET_FIELD(MaxMass, 255),
|
2020-10-06 23:34:42 +02:00
|
|
|
SET_FIELD(LiftData, { OpenRCT2::Audio::SoundId::Null, 5, 5 }),
|
2020-06-18 00:10:08 +02:00
|
|
|
SET_FIELD(RatingsCalculationFunction, nullptr),
|
2020-06-17 22:22:52 +02:00
|
|
|
SET_FIELD(RatingsMultipliers, { 0, 0, 0 }),
|
2020-04-25 15:29:18 +02:00
|
|
|
SET_FIELD(UpkeepCosts, { 50, 1, 0, 0, 0, 0 }),
|
2022-04-07 12:35:11 +02:00
|
|
|
SET_FIELD(BuildCosts, { 0.00_GBP, 0.00_GBP, 1 }),
|
2020-06-13 12:29:00 +02:00
|
|
|
SET_FIELD(DefaultPrices, { 20, 20 }),
|
2021-09-01 10:16:44 +02:00
|
|
|
SET_FIELD(DefaultMusic, MUSIC_OBJECT_GENTLE),
|
2020-12-04 01:15:59 +01:00
|
|
|
SET_FIELD(PhotoItem, ShopItem::Photo),
|
2020-06-19 18:04:43 +02:00
|
|
|
SET_FIELD(BonusValue, 0),
|
|
|
|
SET_FIELD(ColourPresets, DEFAULT_FLAT_RIDE_COLOUR_PRESET),
|
2020-07-03 22:15:11 +02:00
|
|
|
SET_FIELD(ColourPreview, { static_cast<uint32_t>(SPR_NONE), static_cast<uint32_t>(SPR_NONE) }),
|
2022-07-25 00:06:37 +02:00
|
|
|
SET_FIELD(ColourKey, RideColourKey::Ride),
|
|
|
|
SET_FIELD(Name, "invalid"),
|
2022-07-28 01:50:20 +02:00
|
|
|
SET_FIELD(StartRideMusic, OpenRCT2::RideAudio::DefaultStartRideMusicChannel),
|
2022-07-27 00:33:54 +02:00
|
|
|
SET_FIELD(DesignCreateMode, TrackDesignCreateMode::Default),
|
|
|
|
SET_FIELD(MusicUpdateFunction, DefaultMusicUpdate),
|
|
|
|
SET_FIELD(Classification, RideClassification::Ride),
|
|
|
|
SET_FIELD(UpdateLeaveEntrance, PeepUpdateRideLeaveEntranceDefault),
|
2020-04-25 15:29:18 +02:00
|
|
|
};
|
|
|
|
// clang-format on
|
|
|
|
|
2021-02-26 09:49:09 +01:00
|
|
|
constexpr const RideTypeDescriptor& GetRideTypeDescriptor(ObjectEntryIndex rideType)
|
|
|
|
{
|
|
|
|
if (rideType >= std::size(RideTypeDescriptors))
|
|
|
|
return DummyRTD;
|
|
|
|
|
|
|
|
return RideTypeDescriptors[rideType];
|
|
|
|
}
|
|
|
|
|
2021-03-06 20:57:48 +01:00
|
|
|
constexpr bool RideTypeIsValid(ObjectEntryIndex rideType)
|
|
|
|
{
|
|
|
|
return rideType < std::size(RideTypeDescriptors);
|
|
|
|
}
|
2021-12-09 22:28:04 +01:00
|
|
|
|
|
|
|
bool IsTrackEnabled(int32_t trackFlagIndex);
|
|
|
|
void UpdateEnabledRidePieces(ride_type_t rideType);
|