mirror of
https://github.com/maciejpedzich/f1-game-packet-parser.git
synced 2025-04-18 18:51:11 +02:00
1680 lines
32 KiB
Rust
1680 lines
32 KiB
Rust
/// Unique identifiers of drivers.
|
|
pub mod driver_id;
|
|
/// Unique identifiers of session types.
|
|
pub mod session_type;
|
|
/// Unique identifiers of teams.
|
|
pub mod team_id;
|
|
/// Indexes of wheels in wheel-oriented arrays.
|
|
/// The order is:
|
|
/// [`REAR_LEFT`](const@wheel_index::REAR_LEFT),
|
|
/// [`REAR_RIGHT`](const@wheel_index::REAR_RIGHT),
|
|
/// [`FRONT_LEFT`](const@wheel_index::FRONT_LEFT),
|
|
/// [`FRONT_RIGHT`](const@wheel_index::FRONT_RIGHT).
|
|
pub mod wheel_index;
|
|
|
|
use binrw::BinRead;
|
|
use bitflags::bitflags;
|
|
use serde::{Deserialize, Serialize};
|
|
|
|
pub(crate) const MAX_NUM_CARS: usize = 22;
|
|
|
|
/// Unique identifier of the type of this packet.
|
|
/// Represents a [`u8`].
|
|
#[non_exhaustive]
|
|
#[derive(
|
|
BinRead,
|
|
Eq,
|
|
PartialEq,
|
|
Ord,
|
|
PartialOrd,
|
|
Copy,
|
|
Clone,
|
|
Debug,
|
|
Hash,
|
|
Serialize,
|
|
Deserialize,
|
|
)]
|
|
#[br(little, repr(u8))]
|
|
pub enum PacketId {
|
|
Motion = 0,
|
|
Session = 1,
|
|
Laps = 2,
|
|
Event = 3,
|
|
Participants = 4,
|
|
CarSetups = 5,
|
|
CarTelemetry = 6,
|
|
CarStatus = 7,
|
|
FinalClassification = 8,
|
|
LobbyInfo = 9,
|
|
CarDamage = 10,
|
|
SessionHistory = 11,
|
|
TyreSets = 12,
|
|
MotionEx = 13,
|
|
TimeTrial = 14,
|
|
}
|
|
|
|
/// Flag that's currently being waved in
|
|
/// a [`MarshalZone`](crate::packets::session::MarshalZone).
|
|
/// Represents an [`i8`].
|
|
#[non_exhaustive]
|
|
#[derive(
|
|
BinRead,
|
|
Eq,
|
|
PartialEq,
|
|
Ord,
|
|
PartialOrd,
|
|
Copy,
|
|
Clone,
|
|
Debug,
|
|
Hash,
|
|
Serialize,
|
|
Deserialize,
|
|
)]
|
|
#[br(little, repr(i8))]
|
|
pub enum MarshalZoneFlag {
|
|
Unknown = -1,
|
|
None = 0,
|
|
Green = 1,
|
|
Blue = 2,
|
|
Yellow = 3,
|
|
Red = 4,
|
|
}
|
|
|
|
/// Session/forecast weather type. Represents a [`u8`].
|
|
#[non_exhaustive]
|
|
#[derive(
|
|
BinRead,
|
|
Eq,
|
|
PartialEq,
|
|
Ord,
|
|
PartialOrd,
|
|
Copy,
|
|
Clone,
|
|
Debug,
|
|
Hash,
|
|
Serialize,
|
|
Deserialize,
|
|
)]
|
|
#[br(little, repr(u8))]
|
|
pub enum Weather {
|
|
Clear = 0,
|
|
LightCloud = 1,
|
|
Overcast = 2,
|
|
LightRain = 3,
|
|
HeavyRain = 4,
|
|
Storm = 5,
|
|
}
|
|
|
|
/// Temperature change direction. Represents a [`u8`].
|
|
#[non_exhaustive]
|
|
#[derive(
|
|
BinRead,
|
|
Eq,
|
|
PartialEq,
|
|
Ord,
|
|
PartialOrd,
|
|
Copy,
|
|
Clone,
|
|
Debug,
|
|
Hash,
|
|
Serialize,
|
|
Deserialize,
|
|
)]
|
|
#[br(little, repr(i8))]
|
|
pub enum TemperatureChange {
|
|
Up = 0,
|
|
Down = 1,
|
|
NoChange = 2,
|
|
}
|
|
|
|
/// Unique circuit ID. Represents an [`i8`].
|
|
#[non_exhaustive]
|
|
#[derive(
|
|
BinRead,
|
|
Eq,
|
|
PartialEq,
|
|
Ord,
|
|
PartialOrd,
|
|
Copy,
|
|
Clone,
|
|
Debug,
|
|
Hash,
|
|
Serialize,
|
|
Deserialize,
|
|
)]
|
|
#[br(little, repr(i8))]
|
|
pub enum TrackId {
|
|
/// Unknown circuit.
|
|
Unknown = -1,
|
|
/// Australian Grand Prix.
|
|
AlbertPark = 0,
|
|
/// French Grand Prix.
|
|
PaulRicard = 1,
|
|
/// Chinese Grand Prix.
|
|
Shanghai = 2,
|
|
/// Bahrain Grand Prix.
|
|
Sakhir = 3,
|
|
/// Spanish Grand Prix.
|
|
Catalunya = 4,
|
|
/// Monaco Grand Prix.
|
|
MonteCarlo = 5,
|
|
/// Canadian Grand Prix.
|
|
Montreal = 6,
|
|
/// British Grand Prix.
|
|
Silverstone = 7,
|
|
/// German Grand Prix.
|
|
Hockenheim = 8,
|
|
/// Hungarian Grand Prix.
|
|
Hungaroring = 9,
|
|
/// Belgian Grand Prix.
|
|
Spa = 10,
|
|
/// Italian Grand Prix.
|
|
Monza = 11,
|
|
/// Singapore Grand Prix.
|
|
MarinaBay = 12,
|
|
/// Japanese Grand Prix.
|
|
Suzuka = 13,
|
|
/// Abu Dhabi Grand Prix.
|
|
YasMarina = 14,
|
|
/// Circuit of the Americas. United States (Texas) Grand Prix.
|
|
Cota = 15,
|
|
/// Brazilian (Sao Paulo) Grand Prix.
|
|
Interlagos = 16,
|
|
/// Austrian Grand Prix.
|
|
RedBullRing = 17,
|
|
/// Russian Grand Prix.
|
|
Sochi = 18,
|
|
/// Mexican Grand Prix.
|
|
MexicoCity = 19,
|
|
/// Azerbaijan Grand Prix.
|
|
Baku = 20,
|
|
/// Short variant of the [`Sakhir`](TrackId::Sakhir) circuit.
|
|
SakhirShort = 21,
|
|
/// Short variant of the [`Silverstone`](TrackId::Silverstone) circuit.
|
|
SilverstoneShort = 22,
|
|
/// Short variant of the [`Cota`](TrackId::Cota) circuit.
|
|
CotaShort = 23,
|
|
/// Short variant of the [`Suzuka`](TrackId::Suzuka) circuit.
|
|
SuzukaShort = 24,
|
|
/// Vietnamese Grand Prix.
|
|
Hanoi = 25,
|
|
/// Dutch Grand Prix.
|
|
Zandvoort = 26,
|
|
/// ~~San Marino~~ Emilia-Romagna Grand Prix.
|
|
Imola = 27,
|
|
/// Portuguese Grand Prix.
|
|
Portimao = 28,
|
|
/// Saudi Arabian Grand Prix.
|
|
Jeddah = 29,
|
|
/// Miami Grand Prix.
|
|
Miami = 30,
|
|
/// Las Vegas Grand Prix.
|
|
LasVegas = 31,
|
|
/// Qatar Grand Prix.
|
|
Losail = 32,
|
|
}
|
|
|
|
/// Type of cars being raced in
|
|
/// [`F1PacketSession`](struct@crate::F1PacketSession).
|
|
/// Represents a [`u8`].
|
|
#[non_exhaustive]
|
|
#[derive(
|
|
BinRead,
|
|
Eq,
|
|
PartialEq,
|
|
Ord,
|
|
PartialOrd,
|
|
Copy,
|
|
Clone,
|
|
Debug,
|
|
Hash,
|
|
Serialize,
|
|
Deserialize,
|
|
)]
|
|
#[br(little, repr(u8))]
|
|
pub enum Formula {
|
|
F1Modern = 0,
|
|
F1Classic = 1,
|
|
F2 = 2,
|
|
F1Generic = 3,
|
|
Beta = 4,
|
|
Supercars = 5,
|
|
Esports = 6,
|
|
F22021 = 7,
|
|
F1World = 8,
|
|
F1Elimination = 9,
|
|
}
|
|
|
|
/// Safety car deployment status in [`F1PacketSession`](struct@crate::F1PacketSession).
|
|
/// Represents a [`u8`].
|
|
#[non_exhaustive]
|
|
#[derive(
|
|
BinRead,
|
|
Eq,
|
|
PartialEq,
|
|
Ord,
|
|
PartialOrd,
|
|
Copy,
|
|
Clone,
|
|
Debug,
|
|
Hash,
|
|
Serialize,
|
|
Deserialize,
|
|
)]
|
|
#[br(little, repr(u8))]
|
|
pub enum SafetyCarStatus {
|
|
None = 0,
|
|
Virtual = 1,
|
|
Full = 2,
|
|
FormationLap = 3,
|
|
}
|
|
|
|
/// Accuracy of a
|
|
/// [`WeatherForecastSample`](struct@crate::packets::session::WeatherForecastSample).
|
|
/// Represents a [`u8`].
|
|
#[non_exhaustive]
|
|
#[derive(
|
|
BinRead,
|
|
Eq,
|
|
PartialEq,
|
|
Ord,
|
|
PartialOrd,
|
|
Copy,
|
|
Clone,
|
|
Debug,
|
|
Hash,
|
|
Serialize,
|
|
Deserialize,
|
|
)]
|
|
#[br(little, repr(u8))]
|
|
pub enum ForecastAccuracy {
|
|
Perfect = 0,
|
|
Approximate = 1,
|
|
}
|
|
|
|
/// Type of enabled braking assist. Represents a [`u8`].
|
|
#[non_exhaustive]
|
|
#[derive(
|
|
BinRead,
|
|
Eq,
|
|
PartialEq,
|
|
Ord,
|
|
PartialOrd,
|
|
Copy,
|
|
Clone,
|
|
Debug,
|
|
Hash,
|
|
Serialize,
|
|
Deserialize,
|
|
)]
|
|
#[br(little, repr(u8))]
|
|
pub enum BrakingAssist {
|
|
Off = 0,
|
|
Low = 1,
|
|
Medium = 2,
|
|
High = 3,
|
|
}
|
|
|
|
/// Type of enabled gearbox assist. Represents a [`u8`].
|
|
#[non_exhaustive]
|
|
#[derive(
|
|
BinRead,
|
|
Eq,
|
|
PartialEq,
|
|
Ord,
|
|
PartialOrd,
|
|
Copy,
|
|
Clone,
|
|
Debug,
|
|
Hash,
|
|
Serialize,
|
|
Deserialize,
|
|
)]
|
|
#[br(little, repr(u8))]
|
|
pub enum GearboxAssist {
|
|
Unknown = 0,
|
|
Manual = 1,
|
|
ManualWithSuggestedGear = 2,
|
|
Automatic = 3,
|
|
}
|
|
|
|
/// Type of enabled racing line assist. Represents a [`u8`].
|
|
#[non_exhaustive]
|
|
#[derive(
|
|
BinRead,
|
|
Eq,
|
|
PartialEq,
|
|
Ord,
|
|
PartialOrd,
|
|
Copy,
|
|
Clone,
|
|
Debug,
|
|
Hash,
|
|
Serialize,
|
|
Deserialize,
|
|
)]
|
|
#[br(little, repr(u8))]
|
|
pub enum DynamicRacingLine {
|
|
Off = 0,
|
|
CornersOnly = 1,
|
|
Full = 2,
|
|
}
|
|
|
|
/// Shape of the racing line. Represents a [`u8`].
|
|
#[non_exhaustive]
|
|
#[derive(
|
|
BinRead,
|
|
Eq,
|
|
PartialEq,
|
|
Ord,
|
|
PartialOrd,
|
|
Copy,
|
|
Clone,
|
|
Debug,
|
|
Hash,
|
|
Serialize,
|
|
Deserialize,
|
|
)]
|
|
#[br(little, repr(u8))]
|
|
pub enum DynamicRacingLineType {
|
|
TwoDimensional = 0,
|
|
ThreeDimensional = 1,
|
|
}
|
|
|
|
/// Game mode that's currently in use. Represents a [`u8`].
|
|
#[non_exhaustive]
|
|
#[derive(
|
|
BinRead,
|
|
Eq,
|
|
PartialEq,
|
|
Ord,
|
|
PartialOrd,
|
|
Copy,
|
|
Clone,
|
|
Debug,
|
|
Hash,
|
|
Serialize,
|
|
Deserialize,
|
|
)]
|
|
#[br(little, repr(u8))]
|
|
pub enum GameMode {
|
|
EventMode = 0,
|
|
GrandPrix = 3,
|
|
GrandPrix2023 = 4,
|
|
TimeTrial = 5,
|
|
Splitscreen = 6,
|
|
OnlineCustom = 7,
|
|
OnlineLeague = 8,
|
|
CareerInvitational = 11,
|
|
ChampionshipInvitational = 12,
|
|
Championship = 13,
|
|
OnlineChampionship = 14,
|
|
OnlineWeeklyEvent = 15,
|
|
BrakingPoint2023 = 17,
|
|
Career2022 = 19,
|
|
OnlineCareer2022 = 20,
|
|
Career2023 = 21,
|
|
OnlineCareer2023 = 22,
|
|
DriverCareer2024 = 23,
|
|
OnlineCareer2024 = 24,
|
|
MyTeamCareer2024 = 25,
|
|
CuratedCareer2024 = 26,
|
|
Benchmark = 127,
|
|
}
|
|
|
|
/// Set of rules that's in use for this session. Represents a [`u8`].
|
|
#[non_exhaustive]
|
|
#[derive(
|
|
BinRead,
|
|
Eq,
|
|
PartialEq,
|
|
Ord,
|
|
PartialOrd,
|
|
Copy,
|
|
Clone,
|
|
Debug,
|
|
Hash,
|
|
Serialize,
|
|
Deserialize,
|
|
)]
|
|
#[br(little, repr(u8))]
|
|
pub enum RuleSet {
|
|
PracticeAndQualifying = 0,
|
|
Race = 1,
|
|
TimeTrial = 2,
|
|
TimeAttack = 4,
|
|
CheckpointChallenge = 6,
|
|
Autocross = 8,
|
|
Drift = 9,
|
|
AverageSpeedZone = 10,
|
|
RivalDuel = 11,
|
|
}
|
|
|
|
/// Length of the ongoing session. Represents a [`u8`].
|
|
#[non_exhaustive]
|
|
#[derive(
|
|
BinRead,
|
|
Eq,
|
|
PartialEq,
|
|
Ord,
|
|
PartialOrd,
|
|
Copy,
|
|
Clone,
|
|
Debug,
|
|
Hash,
|
|
Serialize,
|
|
Deserialize,
|
|
)]
|
|
#[br(little, repr(u8))]
|
|
pub enum SessionLength {
|
|
None = 0,
|
|
VeryShort = 2,
|
|
Short = 3,
|
|
Medium = 4,
|
|
MediumLong = 5,
|
|
Long = 6,
|
|
Full = 7,
|
|
}
|
|
|
|
/// Whether the car is outside/entering/in the pit lane. Represents a [`u8`].
|
|
#[non_exhaustive]
|
|
#[derive(
|
|
BinRead,
|
|
Eq,
|
|
PartialEq,
|
|
Ord,
|
|
PartialOrd,
|
|
Copy,
|
|
Clone,
|
|
Debug,
|
|
Hash,
|
|
Serialize,
|
|
Deserialize,
|
|
)]
|
|
#[br(little, repr(u8))]
|
|
pub enum PitStatus {
|
|
None = 0,
|
|
Pitting = 1,
|
|
InPitArea = 2,
|
|
}
|
|
|
|
/// Zero-based sector number. Represents a [`u8`].
|
|
#[non_exhaustive]
|
|
#[derive(
|
|
BinRead,
|
|
Eq,
|
|
PartialEq,
|
|
Ord,
|
|
PartialOrd,
|
|
Copy,
|
|
Clone,
|
|
Debug,
|
|
Hash,
|
|
Serialize,
|
|
Deserialize,
|
|
)]
|
|
#[br(little, repr(u8))]
|
|
pub enum Sector {
|
|
First = 0,
|
|
Second = 1,
|
|
Third = 2,
|
|
}
|
|
|
|
/// Status of a driver in the current session. Represents a [`u8`].
|
|
#[non_exhaustive]
|
|
#[derive(
|
|
BinRead,
|
|
Eq,
|
|
PartialEq,
|
|
Ord,
|
|
PartialOrd,
|
|
Copy,
|
|
Clone,
|
|
Debug,
|
|
Hash,
|
|
Serialize,
|
|
Deserialize,
|
|
)]
|
|
#[br(little, repr(u8))]
|
|
pub enum DriverStatus {
|
|
InGarage = 0,
|
|
FlyingLap = 1,
|
|
InLap = 2,
|
|
OutLap = 3,
|
|
OnTrack = 4,
|
|
}
|
|
|
|
/// Status of a driver's result in the current session and final classification.
|
|
/// Represents a [`u8`].
|
|
#[non_exhaustive]
|
|
#[derive(
|
|
BinRead,
|
|
Eq,
|
|
PartialEq,
|
|
Ord,
|
|
PartialOrd,
|
|
Copy,
|
|
Clone,
|
|
Debug,
|
|
Hash,
|
|
Serialize,
|
|
Deserialize,
|
|
)]
|
|
#[br(little, repr(u8))]
|
|
pub enum ResultStatus {
|
|
Unknown = 0,
|
|
Inactive = 1,
|
|
Active = 2,
|
|
Finished = 3,
|
|
DidNotFinish = 4,
|
|
Disqualified = 5,
|
|
NotClassified = 6,
|
|
Retired = 7,
|
|
}
|
|
|
|
/// Type of penalty awarded to a driver. Represents a [`u8`].
|
|
#[non_exhaustive]
|
|
#[derive(
|
|
BinRead,
|
|
Eq,
|
|
PartialEq,
|
|
Ord,
|
|
PartialOrd,
|
|
Copy,
|
|
Clone,
|
|
Debug,
|
|
Hash,
|
|
Serialize,
|
|
Deserialize,
|
|
)]
|
|
#[br(little, repr(u8))]
|
|
pub enum PenaltyType {
|
|
DriveThrough = 0,
|
|
StopGo = 1,
|
|
GridPenalty = 2,
|
|
PenaltyReminder = 3,
|
|
TimePenalty = 4,
|
|
Warning = 5,
|
|
Disqualified = 6,
|
|
RemovedFromFormationLap = 7,
|
|
ParkedTooLongTimer = 8,
|
|
TyreRegulations = 9,
|
|
ThisLapInvalidated = 10,
|
|
ThisAndNextLapInvalidated = 11,
|
|
ThisLapInvalidatedWithoutReason = 12,
|
|
ThisAndNextLapInvalidatedWithoutReason = 13,
|
|
ThisAndPreviousLapInvalidated = 14,
|
|
ThisAndPreviousLapInvalidatedWithoutReason = 15,
|
|
Retired = 16,
|
|
BlackFlagTimer = 17,
|
|
}
|
|
|
|
/// Type of offence commited by a driver. Represents a [`u8`].
|
|
#[non_exhaustive]
|
|
#[derive(
|
|
BinRead,
|
|
Eq,
|
|
PartialEq,
|
|
Ord,
|
|
PartialOrd,
|
|
Copy,
|
|
Clone,
|
|
Debug,
|
|
Hash,
|
|
Serialize,
|
|
Deserialize,
|
|
)]
|
|
#[br(little, repr(u8))]
|
|
pub enum InfringementType {
|
|
BlockingBySlowDriving = 0,
|
|
BlockingByWrongWayDriving = 1,
|
|
ReversingOffTheStartLine = 2,
|
|
BigCollision = 3,
|
|
SmallCollision = 4,
|
|
CollisionFailedToHandBackPositionSingle = 5,
|
|
CollisionFailedToHandBackPositionMultiple = 6,
|
|
CornerCuttingGainedTime = 7,
|
|
CornerCuttingOvertakeSingle = 8,
|
|
CornerCuttingOvertakeMultiple = 9,
|
|
CrossedPitExitLane = 10,
|
|
IgnoringBlueFlags = 11,
|
|
IgnoringYellowFlags = 12,
|
|
IgnoringDriveThrough = 13,
|
|
TooManyDriveThroughs = 14,
|
|
DriveThroughReminderServeWithinNLaps = 15,
|
|
DriveThroughReminderServeThisLap = 16,
|
|
PitLaneSpeeding = 17,
|
|
ParkedForTooLong = 18,
|
|
IgnoringTyreRegulations = 19,
|
|
TooManyPenalties = 20,
|
|
MultipleWarnings = 21,
|
|
ApproachingDisqualification = 22,
|
|
TyreRegulationsSelectSingle = 23,
|
|
TyreRegulationsSelectMultiple = 24,
|
|
LapInvalidatedCornerCutting = 25,
|
|
LapInvalidatedRunningWide = 26,
|
|
CornerCuttingRanWideMinorTimeGain = 27,
|
|
CornerCuttingRanWideSignificantTimeGain = 28,
|
|
CornerCuttingRanWideExtremeTimeGain = 29,
|
|
LapInvalidatedWallRiding = 30,
|
|
LapInvalidatedFlashbackUsed = 31,
|
|
LapInvalidatedResetToTrack = 32,
|
|
BlockingThePitLane = 33,
|
|
JumpStart = 34,
|
|
SafetyCarCollision = 35,
|
|
SafetyCarIllegalOvertake = 36,
|
|
SafetyCarExceedingAllowedPace = 37,
|
|
VirtualSafetyCarExceedingAllowedPace = 38,
|
|
FormationLapBelowAllowedSpeed = 39,
|
|
RetiredMechanicalFailure = 40,
|
|
RetiredTerminallyDamaged = 41,
|
|
SafetyCarFallingTooFarBack = 42,
|
|
BlackFlagTimer = 43,
|
|
UnservedStopGoPenalty = 44,
|
|
UnservedDriveThroughPenalty = 45,
|
|
EngineComponentChange = 46,
|
|
GearboxChange = 47,
|
|
LeagueGridPenalty = 48,
|
|
RetryPenalty = 49,
|
|
IllegalTimeGain = 50,
|
|
MandatoryPitStop = 51,
|
|
AttributeAssigned = 54,
|
|
}
|
|
|
|
/// Bit flags of specific controller buttons being pressed
|
|
/// in a [`Buttons` event](variant@crate::packets::event::EventDetails::Buttons).
|
|
/// Represents a [`u32`].
|
|
#[derive(
|
|
Debug, Clone, Copy, PartialEq, Eq, Ord, PartialOrd, Hash, Serialize, Deserialize,
|
|
)]
|
|
pub struct ButtonStatus(u32);
|
|
|
|
bitflags! {
|
|
impl ButtonStatus: u32 {
|
|
/// The "A" button on an Xbox controller
|
|
/// or the cross button on a PlayStation controller.
|
|
/// Has a value of `0x00000001`.
|
|
const A_OR_CROSS = 0x00000001;
|
|
/// The "Y" button on an Xbox controller
|
|
/// or the triangle button on a PlayStation controller.
|
|
/// Has a value of `0x00000002`.
|
|
const Y_OR_TRIANGLE = 0x00000002;
|
|
/// The "B" button on an Xbox controller
|
|
/// or the circle button on a PlayStation controller.
|
|
/// Has a value of `0x00000004`.
|
|
const B_OR_CIRCLE = 0x00000004;
|
|
/// The "X" button on an Xbox controller
|
|
/// or the square button on a PlayStation controller.
|
|
/// Has a value of `0x00000008`.
|
|
const X_OR_SQUARE = 0x00000008;
|
|
/// Left directional pad button. Has a value of `0x00000010`.
|
|
const DPAD_LEFT = 0x00000010;
|
|
/// Right directional pad button. Has a value of `0x00000020`.
|
|
const DPAD_RIGHT = 0x00000020;
|
|
/// Up directional pad button. Has a value of `0x00000040`.
|
|
const DPAD_UP = 0x00000040;
|
|
/// Down directional pad button. Has a value of `0x00000080`.
|
|
const DPAD_DOWN = 0x00000080;
|
|
/// The "Menu" button on an Xbox controller
|
|
/// or the "Options" button on a PlayStation controller.
|
|
/// Has a value of `0x00000100`.
|
|
const MENU_OR_OPTIONS = 0x00000100;
|
|
/// Left bumper. Has a value of `0x00000200`.
|
|
const LEFT_BUMPER = 0x00000200;
|
|
/// Right bumper. Has a value of `0x00000400`.
|
|
const RIGHT_BUMPER = 0x00000400;
|
|
/// Left trigger. Has a value of `0x00000800`.
|
|
const LEFT_TRIGGER = 0x00000800;
|
|
/// Right trigger. Has a value of `0x00001000`.
|
|
const RIGHT_TRIGGER = 0x00001000;
|
|
/// Left analog stick click. Has a value of `0x00002000`.
|
|
const LEFT_STICK_CLICK = 0x00002000;
|
|
/// Right analog stick click. Has a value of `0x00004000`.
|
|
const RIGHT_STICK_CLICK = 0x00004000;
|
|
/// Right analog stick left. Has a value of `0x00008000`.
|
|
const RIGHT_STICK_LEFT = 0x00008000;
|
|
/// Right analog stick right. Has a value of `0x00010000`
|
|
const RIGHT_STICK_RIGHT = 0x00010000;
|
|
/// Right analog stick up. Has a value of `0x00020000`
|
|
const RIGHT_STICK_UP = 0x00020000;
|
|
/// Right analog stick down. Has a value of `0x00040000`
|
|
const RIGHT_STICK_DOWN = 0x00040000;
|
|
/// Special button. Has a value of `0x00080000`.
|
|
const SPECIAL = 0x00080000;
|
|
/// UDP Action 1. Has a value of `0x00100000`.
|
|
const UDP_ACTION_1 = 0x00100000;
|
|
/// UDP Action 2. Has a value of `0x00200000`.
|
|
const UDP_ACTION_2 = 0x00200000;
|
|
/// UDP Action 3. Has a value of `0x00400000`.
|
|
const UDP_ACTION_3 = 0x00400000;
|
|
/// UDP Action 4. Has a value of `0x00800000`.
|
|
const UDP_ACTION_4 = 0x00800000;
|
|
/// UDP Action 5. Has a value of `0x01000000`.
|
|
const UDP_ACTION_5 = 0x01000000;
|
|
/// UDP Action 6. Has a value of `0x02000000`.
|
|
const UDP_ACTION_6 = 0x02000000;
|
|
/// UDP Action 7. Has a value of `0x04000000`.
|
|
const UDP_ACTION_7 = 0x04000000;
|
|
/// UDP Action 8. Has a value of `0x08000000`.
|
|
const UDP_ACTION_8 = 0x08000000;
|
|
/// UDP Action 9. Has a value of `0x10000000`.
|
|
const UDP_ACTION_9 = 0x10000000;
|
|
/// UDP Action 10. Has a value of `0x20000000`.
|
|
const UDP_ACTION_10 = 0x20000000;
|
|
/// UDP Action 11. Has a value of `0x40000000`.
|
|
const UDP_ACTION_11 = 0x40000000;
|
|
/// UDP Action 12. Has a value of `0x80000000`.
|
|
const UDP_ACTION_12 = 0x80000000;
|
|
}
|
|
}
|
|
|
|
/// Unique identifier of a driver's nationality. Represents a [`u8`].
|
|
#[non_exhaustive]
|
|
#[derive(
|
|
BinRead,
|
|
Eq,
|
|
PartialEq,
|
|
Ord,
|
|
PartialOrd,
|
|
Copy,
|
|
Clone,
|
|
Debug,
|
|
Hash,
|
|
Serialize,
|
|
Deserialize,
|
|
)]
|
|
#[br(little, repr(u8))]
|
|
pub enum Nationality {
|
|
Unknown = 0,
|
|
American = 1,
|
|
Argentinian = 2,
|
|
Australian = 3,
|
|
Austrian = 4,
|
|
Azerbaijani = 5,
|
|
Bahraini = 6,
|
|
Belgian = 7,
|
|
Bolivian = 8,
|
|
Brazilian = 9,
|
|
British = 10,
|
|
Bulgarian = 11,
|
|
Cameroonian = 12,
|
|
Canadian = 13,
|
|
Chilean = 14,
|
|
Chinese = 15,
|
|
Colombian = 16,
|
|
CostaRican = 17,
|
|
Croatian = 18,
|
|
Cypriot = 19,
|
|
Czech = 20,
|
|
Danish = 21,
|
|
Dutch = 22,
|
|
Ecuadorian = 23,
|
|
English = 24,
|
|
Emirian = 25,
|
|
Estonian = 26,
|
|
Finnish = 27,
|
|
French = 28,
|
|
German = 29,
|
|
Ghanaian = 30,
|
|
Greek = 31,
|
|
Guatemalan = 32,
|
|
Honduran = 33,
|
|
HongKonger = 34,
|
|
Hungarian = 35,
|
|
Icelander = 36,
|
|
Indian = 37,
|
|
Indonesian = 38,
|
|
Irish = 39,
|
|
Israeli = 40,
|
|
Italian = 41,
|
|
Jamaican = 42,
|
|
Japanese = 43,
|
|
Jordanian = 44,
|
|
Kuwaiti = 45,
|
|
Latvian = 46,
|
|
Lebanese = 47,
|
|
Lithuanian = 48,
|
|
Luxembourger = 49,
|
|
Malaysian = 50,
|
|
Maltese = 51,
|
|
Mexican = 52,
|
|
Monegasque = 53,
|
|
NewZealander = 54,
|
|
Nicaraguan = 55,
|
|
NorthernIrish = 56,
|
|
Norwegian = 57,
|
|
Omani = 58,
|
|
Pakistani = 59,
|
|
Panamanian = 60,
|
|
Paraguayan = 61,
|
|
Peruvian = 62,
|
|
Polish = 63,
|
|
Portuguese = 64,
|
|
Qatari = 65,
|
|
Romanian = 66,
|
|
Russian = 67,
|
|
Salvadoran = 68,
|
|
Saudi = 69,
|
|
Scottish = 70,
|
|
Serbian = 71,
|
|
Singaporean = 72,
|
|
Slovakian = 73,
|
|
Slovenian = 74,
|
|
SouthKorean = 75,
|
|
SouthAfrican = 76,
|
|
Spanish = 77,
|
|
Swedish = 78,
|
|
Swiss = 79,
|
|
Thai = 80,
|
|
Turkish = 81,
|
|
Uruguayan = 82,
|
|
Ukrainian = 83,
|
|
Venezuelan = 84,
|
|
Welsh = 85,
|
|
Barbadian = 86,
|
|
Vietnamese = 87,
|
|
Algerian = 88,
|
|
Bosnian = 89,
|
|
Filipino = 90,
|
|
}
|
|
|
|
/// "Your telemetry" UDP setting value. Represents a [`u8`].
|
|
#[non_exhaustive]
|
|
#[derive(
|
|
BinRead,
|
|
Eq,
|
|
PartialEq,
|
|
Ord,
|
|
PartialOrd,
|
|
Copy,
|
|
Clone,
|
|
Debug,
|
|
Hash,
|
|
Serialize,
|
|
Deserialize,
|
|
)]
|
|
#[br(little, repr(u8))]
|
|
pub enum YourTelemetry {
|
|
Restricted = 0,
|
|
Public = 1,
|
|
}
|
|
|
|
/// Type of surface a tyre is on. Represents a [`u8`].
|
|
#[non_exhaustive]
|
|
#[derive(
|
|
BinRead,
|
|
Eq,
|
|
PartialEq,
|
|
Ord,
|
|
PartialOrd,
|
|
Copy,
|
|
Clone,
|
|
Debug,
|
|
Hash,
|
|
Serialize,
|
|
Deserialize,
|
|
)]
|
|
#[br(little, repr(u8))]
|
|
pub enum Surface {
|
|
Tarmac = 0,
|
|
RumbleStrip = 1,
|
|
Concrete = 2,
|
|
Rock = 3,
|
|
Gravel = 4,
|
|
Mud = 5,
|
|
Sand = 6,
|
|
Grass = 7,
|
|
Water = 8,
|
|
Cobblestone = 9,
|
|
Metal = 10,
|
|
Ridged = 11,
|
|
}
|
|
|
|
/// Bit flags of lit rev lights on a steering wheel.
|
|
/// Represents a [`u16`].
|
|
#[derive(
|
|
Debug, Clone, Copy, PartialEq, Eq, Ord, PartialOrd, Hash, Serialize, Deserialize,
|
|
)]
|
|
pub struct RevLights(u16);
|
|
|
|
bitflags! {
|
|
impl RevLights: u16 {
|
|
/// 1st left (1st leftmost) LED. Has a value of `0x0001`.
|
|
const LEFT_1 = 0x0001;
|
|
/// 2nd left (2nd leftmost) LED. Has a value of `0x0002`.
|
|
const LEFT_2 = 0x0002;
|
|
/// 3rd left (3rd leftmost) LED. Has a value of `0x0004`.
|
|
const LEFT_3 = 0x0004;
|
|
/// 4th left (4th leftmost) LED. Has a value of `0x0008`.
|
|
const LEFT_4 = 0x0008;
|
|
/// 5th left (5th leftmost) LED. Has a value of `0x0010`.
|
|
const LEFT_5 = 0x0010;
|
|
/// 1st middle (6th leftmost) LED. Has a value of `0x0020`.
|
|
const MIDDLE_1 = 0x0020;
|
|
/// 2nd middle (7th leftmost) LED. Has a value of `0x0040`.
|
|
const MIDDLE_2 = 0x0040;
|
|
/// 3rd middle (8th leftmost) LED. Has a value of `0x0080`.
|
|
const MIDDLE_3 = 0x0080;
|
|
/// 4th middle (9th leftmost) LED . Has a value of `0x0100`.
|
|
const MIDDLE_4 = 0x0100;
|
|
/// 5th middle (10th leftmost) LED . Has a value of `0x0200`.
|
|
const MIDDLE_5 = 0x0200;
|
|
/// 1st right (11th leftmost) LED. Has a value of `0x0400`.
|
|
const RIGHT_1 = 0x0400;
|
|
/// 2nd right (12th leftmost) LED. Has a value of `0x0800`.
|
|
const RIGHT_2 = 0x0800;
|
|
/// 3rd right (13th leftmost) LED. Has a value of `0x1000`.
|
|
const RIGHT_3 = 0x1000;
|
|
/// 4th right (14th leftmost) LED. Has a value of `0x2000`.
|
|
const RIGHT_4 = 0x2000;
|
|
/// 5th right (15th leftmost) LED. Has a value of `0x4000`.
|
|
const RIGHT_5 = 0x4000;
|
|
}
|
|
}
|
|
|
|
/// Index of currently open multi-function display panel. Represents a [`u8`].
|
|
#[non_exhaustive]
|
|
#[derive(
|
|
BinRead,
|
|
Eq,
|
|
PartialEq,
|
|
Ord,
|
|
PartialOrd,
|
|
Copy,
|
|
Clone,
|
|
Debug,
|
|
Hash,
|
|
Serialize,
|
|
Deserialize,
|
|
)]
|
|
#[br(little, repr(u8))]
|
|
pub enum MfdPanelIndex {
|
|
CarSetup = 0,
|
|
Pits = 1,
|
|
Damage = 2,
|
|
Engine = 3,
|
|
Temperatures = 4,
|
|
Closed = 255,
|
|
}
|
|
|
|
/// Type of enabled traction control assist. Represents a [`u8`].
|
|
#[non_exhaustive]
|
|
#[derive(
|
|
BinRead,
|
|
Eq,
|
|
PartialEq,
|
|
Ord,
|
|
PartialOrd,
|
|
Copy,
|
|
Clone,
|
|
Debug,
|
|
Hash,
|
|
Serialize,
|
|
Deserialize,
|
|
)]
|
|
#[br(little, repr(u8))]
|
|
pub enum TractionControl {
|
|
Off = 0,
|
|
Medium = 1,
|
|
Full = 2,
|
|
}
|
|
|
|
/// Type of fuel mix that's currently in use. Represents a [`u8`].
|
|
#[non_exhaustive]
|
|
#[derive(
|
|
BinRead,
|
|
Eq,
|
|
PartialEq,
|
|
Ord,
|
|
PartialOrd,
|
|
Copy,
|
|
Clone,
|
|
Debug,
|
|
Hash,
|
|
Serialize,
|
|
Deserialize,
|
|
)]
|
|
#[br(little, repr(u8))]
|
|
pub enum FuelMix {
|
|
Lean = 0,
|
|
Standard = 1,
|
|
Rich = 2,
|
|
Max = 3,
|
|
}
|
|
|
|
/// ERS deployment mode that's currently in use. Represents a [`u8`].
|
|
#[non_exhaustive]
|
|
#[derive(
|
|
BinRead,
|
|
Eq,
|
|
PartialEq,
|
|
Ord,
|
|
PartialOrd,
|
|
Copy,
|
|
Clone,
|
|
Debug,
|
|
Hash,
|
|
Serialize,
|
|
Deserialize,
|
|
)]
|
|
#[br(little, repr(u8))]
|
|
pub enum ErsDeployMode {
|
|
None = 0,
|
|
Medium = 1,
|
|
Overtake = 2,
|
|
Hotlap = 3,
|
|
}
|
|
|
|
/// Flag the driver is currently being shown. Represents a [`u8`].
|
|
#[non_exhaustive]
|
|
#[derive(
|
|
BinRead,
|
|
Eq,
|
|
PartialEq,
|
|
Ord,
|
|
PartialOrd,
|
|
Copy,
|
|
Clone,
|
|
Debug,
|
|
Hash,
|
|
Serialize,
|
|
Deserialize,
|
|
)]
|
|
#[br(little, repr(i8))]
|
|
pub enum VehicleFiaFlag {
|
|
Unknown = -1,
|
|
None = 0,
|
|
Green = 1,
|
|
Blue = 2,
|
|
Yellow = 3,
|
|
Red = 4,
|
|
}
|
|
|
|
/// Global DRS activation permission status. Represents an [`i8`].
|
|
#[non_exhaustive]
|
|
#[derive(
|
|
BinRead,
|
|
Eq,
|
|
PartialEq,
|
|
Ord,
|
|
PartialOrd,
|
|
Copy,
|
|
Clone,
|
|
Debug,
|
|
Hash,
|
|
Serialize,
|
|
Deserialize,
|
|
)]
|
|
#[br(little, repr(i8))]
|
|
pub enum DrsAllowed {
|
|
Unknown = -1,
|
|
NotAllowed = 0,
|
|
Allowed = 1,
|
|
}
|
|
|
|
/// Session-independent tyre compound type. Represents a [`u8`].
|
|
#[non_exhaustive]
|
|
#[derive(
|
|
BinRead,
|
|
Eq,
|
|
PartialEq,
|
|
Ord,
|
|
PartialOrd,
|
|
Copy,
|
|
Clone,
|
|
Debug,
|
|
Hash,
|
|
Serialize,
|
|
Deserialize,
|
|
)]
|
|
#[br(little, repr(u8))]
|
|
pub enum ActualTyreCompound {
|
|
Unknown = 0,
|
|
C5 = 16,
|
|
C4 = 17,
|
|
C3 = 18,
|
|
C2 = 19,
|
|
C1 = 20,
|
|
C0 = 21,
|
|
Inter = 7,
|
|
Wet = 8,
|
|
ClassicDry = 9,
|
|
ClassicWet = 10,
|
|
F2SuperSoft = 11,
|
|
F2Soft = 12,
|
|
F2Medium = 13,
|
|
F2Hard = 14,
|
|
F2Wet = 15,
|
|
}
|
|
|
|
/// Visual indicator of a tyre compound's type in a given session.
|
|
/// Represents a [`u8`].
|
|
#[non_exhaustive]
|
|
#[derive(
|
|
BinRead,
|
|
Eq,
|
|
PartialEq,
|
|
Ord,
|
|
PartialOrd,
|
|
Copy,
|
|
Clone,
|
|
Debug,
|
|
Hash,
|
|
Serialize,
|
|
Deserialize,
|
|
)]
|
|
#[br(little, repr(u8))]
|
|
pub enum VisualTyreCompound {
|
|
Unknown = 0,
|
|
F1Soft = 16,
|
|
F1Medium = 17,
|
|
F1Hard = 18,
|
|
F1Inter = 7,
|
|
F1Wet = 8,
|
|
ClassicDry = 9,
|
|
ClassicWet = 10,
|
|
F2SuperSoft = 19,
|
|
F2Soft = 20,
|
|
F2Medium = 21,
|
|
F2Hard = 22,
|
|
F2Wet = 15,
|
|
}
|
|
|
|
/// Readiness of a player in an online lobby. Represents a [`u8`].
|
|
#[non_exhaustive]
|
|
#[derive(
|
|
BinRead,
|
|
Eq,
|
|
PartialEq,
|
|
Ord,
|
|
PartialOrd,
|
|
Copy,
|
|
Clone,
|
|
Debug,
|
|
Hash,
|
|
Serialize,
|
|
Deserialize,
|
|
)]
|
|
#[br(little, repr(u8))]
|
|
pub enum ReadyStatus {
|
|
NotReady = 0,
|
|
Ready = 1,
|
|
Spectating = 2,
|
|
}
|
|
|
|
/// Bit flags of lap validity across all three sectors and overall.
|
|
/// Represents a [`u8`].
|
|
#[derive(
|
|
Debug, Clone, Copy, PartialEq, Eq, Ord, PartialOrd, Hash, Serialize, Deserialize,
|
|
)]
|
|
pub struct LapValid(u8);
|
|
|
|
bitflags! {
|
|
impl LapValid: u8 {
|
|
/// Whether the whole lap is valid. Has a value of `0x01`.
|
|
const OVERALL = 0x01;
|
|
/// Whether the sector 1 run is valid. Has a value of `0x02`.
|
|
const SECTOR_1 = 0x02;
|
|
/// Whether the sector 2 run is valid. Has a value of `0x04`.
|
|
const SECTOR_2 = 0x04;
|
|
/// Whether the sector 3 run is valid. Has a value of `0x08`.
|
|
const SECTOR_3 = 0x08;
|
|
}
|
|
}
|
|
|
|
/// Speed unit used by a player. Represents a [`u8`].
|
|
#[non_exhaustive]
|
|
#[derive(
|
|
BinRead,
|
|
Eq,
|
|
PartialEq,
|
|
Ord,
|
|
PartialOrd,
|
|
Copy,
|
|
Clone,
|
|
Debug,
|
|
Hash,
|
|
Serialize,
|
|
Deserialize,
|
|
)]
|
|
#[br(little, repr(u8))]
|
|
pub enum SpeedUnit {
|
|
MilesPerHour = 0,
|
|
KilometresPerHour = 1,
|
|
}
|
|
|
|
/// Temperature unit used by a player. Represents a [`u8`].
|
|
#[non_exhaustive]
|
|
#[derive(
|
|
BinRead,
|
|
Eq,
|
|
PartialEq,
|
|
Ord,
|
|
PartialOrd,
|
|
Copy,
|
|
Clone,
|
|
Debug,
|
|
Hash,
|
|
Serialize,
|
|
Deserialize,
|
|
)]
|
|
#[br(little, repr(u8))]
|
|
pub enum TemperatureUnit {
|
|
Celsius = 0,
|
|
Fahrenheit = 1,
|
|
}
|
|
|
|
/// Console or PC game distribution platform used by a player.
|
|
/// Represents a [`u8`].
|
|
#[non_exhaustive]
|
|
#[derive(
|
|
BinRead,
|
|
Eq,
|
|
PartialEq,
|
|
Ord,
|
|
PartialOrd,
|
|
Copy,
|
|
Clone,
|
|
Debug,
|
|
Hash,
|
|
Serialize,
|
|
Deserialize,
|
|
)]
|
|
#[br(little, repr(u8))]
|
|
pub enum Platform {
|
|
Invalid = 0,
|
|
Steam = 1,
|
|
PlayStation = 3,
|
|
Xbox = 4,
|
|
Origin = 6,
|
|
Unknown = 255,
|
|
}
|
|
|
|
/// Recovery mode assist that's currently enabled.
|
|
/// Represents a [`u8`].
|
|
#[non_exhaustive]
|
|
#[derive(
|
|
BinRead,
|
|
Eq,
|
|
PartialEq,
|
|
Ord,
|
|
PartialOrd,
|
|
Copy,
|
|
Clone,
|
|
Debug,
|
|
Hash,
|
|
Serialize,
|
|
Deserialize,
|
|
)]
|
|
#[br(little, repr(u8))]
|
|
pub enum RecoveryMode {
|
|
None = 0,
|
|
Flashbacks = 1,
|
|
AutoRecovery = 2,
|
|
}
|
|
|
|
/// Flashback usage limit that's currently enabled.
|
|
/// Represents a [`u8`].
|
|
#[non_exhaustive]
|
|
#[derive(
|
|
BinRead,
|
|
Eq,
|
|
PartialEq,
|
|
Ord,
|
|
PartialOrd,
|
|
Copy,
|
|
Clone,
|
|
Debug,
|
|
Hash,
|
|
Serialize,
|
|
Deserialize,
|
|
)]
|
|
#[br(little, repr(u8))]
|
|
pub enum FlashbackLimit {
|
|
Low = 0,
|
|
Medium = 1,
|
|
High = 2,
|
|
Unlimited = 3,
|
|
}
|
|
|
|
/// Type of surface simulation that's currently enabled.
|
|
/// Represents a [`u8`].
|
|
#[non_exhaustive]
|
|
#[derive(
|
|
BinRead,
|
|
Eq,
|
|
PartialEq,
|
|
Ord,
|
|
PartialOrd,
|
|
Copy,
|
|
Clone,
|
|
Debug,
|
|
Hash,
|
|
Serialize,
|
|
Deserialize,
|
|
)]
|
|
#[br(little, repr(u8))]
|
|
pub enum SurfaceSimType {
|
|
Simplified = 0,
|
|
Realistic = 1,
|
|
}
|
|
|
|
/// Difficulty of driving with low fuel. Represent a [`u8`].
|
|
#[non_exhaustive]
|
|
#[derive(
|
|
BinRead,
|
|
Eq,
|
|
PartialEq,
|
|
Ord,
|
|
PartialOrd,
|
|
Copy,
|
|
Clone,
|
|
Debug,
|
|
Hash,
|
|
Serialize,
|
|
Deserialize,
|
|
)]
|
|
#[br(little, repr(u8))]
|
|
pub enum LowFuelMode {
|
|
Easy = 0,
|
|
Hard = 1,
|
|
}
|
|
|
|
/// Race starts assist that's currently in use.
|
|
/// Represents a [`u8`].
|
|
#[non_exhaustive]
|
|
#[derive(
|
|
BinRead,
|
|
Eq,
|
|
PartialEq,
|
|
Ord,
|
|
PartialOrd,
|
|
Copy,
|
|
Clone,
|
|
Debug,
|
|
Hash,
|
|
Serialize,
|
|
Deserialize,
|
|
)]
|
|
#[br(little, repr(u8))]
|
|
pub enum RaceStarts {
|
|
Manual = 0,
|
|
Assisted = 1,
|
|
}
|
|
|
|
/// Type of tyre temperature simulation that's currently in use.
|
|
/// Represents a [`u8`].
|
|
#[non_exhaustive]
|
|
#[derive(
|
|
BinRead,
|
|
Eq,
|
|
PartialEq,
|
|
Ord,
|
|
PartialOrd,
|
|
Copy,
|
|
Clone,
|
|
Debug,
|
|
Hash,
|
|
Serialize,
|
|
Deserialize,
|
|
)]
|
|
#[br(little, repr(u8))]
|
|
pub enum TyreTemperature {
|
|
SurfaceOnly = 0,
|
|
SurfaceAndCarcass = 1,
|
|
}
|
|
|
|
/// Type of car damage simulation that's currently in use.
|
|
/// Represents a [`u8`].
|
|
#[non_exhaustive]
|
|
#[derive(
|
|
BinRead,
|
|
Eq,
|
|
PartialEq,
|
|
Ord,
|
|
PartialOrd,
|
|
Copy,
|
|
Clone,
|
|
Debug,
|
|
Hash,
|
|
Serialize,
|
|
Deserialize,
|
|
)]
|
|
#[br(little, repr(u8))]
|
|
pub enum CarDamage {
|
|
Off = 0,
|
|
Reduced = 1,
|
|
Standard = 2,
|
|
Simulation = 3,
|
|
}
|
|
|
|
/// Car damage severity. Represents a [`u8`].
|
|
#[non_exhaustive]
|
|
#[derive(
|
|
BinRead,
|
|
Eq,
|
|
PartialEq,
|
|
Ord,
|
|
PartialOrd,
|
|
Copy,
|
|
Clone,
|
|
Debug,
|
|
Hash,
|
|
Serialize,
|
|
Deserialize,
|
|
)]
|
|
#[br(little, repr(u8))]
|
|
pub enum CarDamageRate {
|
|
Reduced = 0,
|
|
Standard = 1,
|
|
Simulation = 2,
|
|
}
|
|
|
|
/// Type of collision simulation that's currently enabled.
|
|
/// Represents a [`u8`].
|
|
#[non_exhaustive]
|
|
#[derive(
|
|
BinRead,
|
|
Eq,
|
|
PartialEq,
|
|
Ord,
|
|
PartialOrd,
|
|
Copy,
|
|
Clone,
|
|
Debug,
|
|
Hash,
|
|
Serialize,
|
|
Deserialize,
|
|
)]
|
|
#[br(little, repr(u8))]
|
|
pub enum Collisions {
|
|
Off = 0,
|
|
PlayerToPlayerOff = 1,
|
|
On = 2,
|
|
}
|
|
|
|
/// Type of corner cutting and track limits punishability.
|
|
/// Represents a [`u8`].
|
|
#[non_exhaustive]
|
|
#[derive(
|
|
BinRead,
|
|
Eq,
|
|
PartialEq,
|
|
Ord,
|
|
PartialOrd,
|
|
Copy,
|
|
Clone,
|
|
Debug,
|
|
Hash,
|
|
Serialize,
|
|
Deserialize,
|
|
)]
|
|
#[br(little, repr(u8))]
|
|
pub enum CornerCuttingStringency {
|
|
Regular = 0,
|
|
Strict = 1,
|
|
}
|
|
|
|
/// The way the game handles pit stops. Represents a [`u8`].
|
|
#[non_exhaustive]
|
|
#[derive(
|
|
BinRead,
|
|
Eq,
|
|
PartialEq,
|
|
Ord,
|
|
PartialOrd,
|
|
Copy,
|
|
Clone,
|
|
Debug,
|
|
Hash,
|
|
Serialize,
|
|
Deserialize,
|
|
)]
|
|
#[br(little, repr(u8))]
|
|
pub enum PitStopExperience {
|
|
Automatic = 0,
|
|
Broadcast = 1,
|
|
Immersive = 2,
|
|
}
|
|
|
|
/// The likelihood of safety car getting deployed with hazard on track.
|
|
/// Represents a [`u8`].
|
|
#[non_exhaustive]
|
|
#[derive(
|
|
BinRead,
|
|
Eq,
|
|
PartialEq,
|
|
Ord,
|
|
PartialOrd,
|
|
Copy,
|
|
Clone,
|
|
Debug,
|
|
Hash,
|
|
Serialize,
|
|
Deserialize,
|
|
)]
|
|
#[br(little, repr(u8))]
|
|
pub enum SafetyCarIntensity {
|
|
Off = 0,
|
|
Reduced = 1,
|
|
Standard = 2,
|
|
Increased = 3,
|
|
}
|
|
|
|
/// The way the game handles safety car periods. Represents a [`u8`].
|
|
#[non_exhaustive]
|
|
#[derive(
|
|
BinRead,
|
|
Eq,
|
|
PartialEq,
|
|
Ord,
|
|
PartialOrd,
|
|
Copy,
|
|
Clone,
|
|
Debug,
|
|
Hash,
|
|
Serialize,
|
|
Deserialize,
|
|
)]
|
|
#[br(little, repr(u8))]
|
|
pub enum SafetyCarExperience {
|
|
Broadcast = 0,
|
|
Immersive = 1,
|
|
Unknown = 255,
|
|
}
|
|
|
|
/// The way the game handles formation laps. Represents a [`u8`].
|
|
#[non_exhaustive]
|
|
#[derive(
|
|
BinRead,
|
|
Eq,
|
|
PartialEq,
|
|
Ord,
|
|
PartialOrd,
|
|
Copy,
|
|
Clone,
|
|
Debug,
|
|
Hash,
|
|
Serialize,
|
|
Deserialize,
|
|
)]
|
|
#[br(little, repr(u8))]
|
|
pub enum FormationLapExperience {
|
|
Broadcast = 0,
|
|
Immersive = 1,
|
|
Unknown = 255,
|
|
}
|
|
|
|
/// The likelihood of the game using a red flag after a serious incident.
|
|
/// Represents a [`u8`].
|
|
#[non_exhaustive]
|
|
#[derive(
|
|
BinRead,
|
|
Eq,
|
|
PartialEq,
|
|
Ord,
|
|
PartialOrd,
|
|
Copy,
|
|
Clone,
|
|
Debug,
|
|
Hash,
|
|
Serialize,
|
|
Deserialize,
|
|
)]
|
|
#[br(little, repr(u8))]
|
|
pub enum RedFlagIntensity {
|
|
Off = 0,
|
|
Reduced = 1,
|
|
Standard = 2,
|
|
Increased = 3,
|
|
}
|
|
|
|
/// Type of safety car being deployed in a
|
|
/// [`SafetyCar` event](variant@crate::packets::event::EventDetails::SafetyCar).
|
|
/// Represents a [`u8`].
|
|
#[non_exhaustive]
|
|
#[derive(
|
|
BinRead,
|
|
Eq,
|
|
PartialEq,
|
|
Ord,
|
|
PartialOrd,
|
|
Copy,
|
|
Clone,
|
|
Debug,
|
|
Hash,
|
|
Serialize,
|
|
Deserialize,
|
|
)]
|
|
#[br(little, repr(u8))]
|
|
pub enum SafetyCarType {
|
|
None = 0,
|
|
Full = 1,
|
|
Virtual = 2,
|
|
FormationLap = 3,
|
|
}
|
|
|
|
/// Type of [`SafetyCar` event](variant@crate::packets::event::EventDetails::SafetyCar).
|
|
/// Represents a [`u8`].
|
|
#[non_exhaustive]
|
|
#[derive(
|
|
BinRead,
|
|
Eq,
|
|
PartialEq,
|
|
Ord,
|
|
PartialOrd,
|
|
Copy,
|
|
Clone,
|
|
Debug,
|
|
Hash,
|
|
Serialize,
|
|
Deserialize,
|
|
)]
|
|
#[br(little, repr(u8))]
|
|
pub enum SafetyCarEventType {
|
|
Deployed = 0,
|
|
Returning = 1,
|
|
Returned = 2,
|
|
ResumeRace = 3,
|
|
}
|