A reimplementation of Mario Kart Wii's physics engine in C++
Loading...
Searching...
No Matches
KartParam.cc
1#include "KartParam.hh"
2
3#include "game/kart/KartParamFileManager.hh"
4
5namespace Kinoko::Kart {
6
7KartParam::KartParam(Character character, Vehicle vehicle, u8 playerIdx) {
8 initStats(character, vehicle);
9 initHitboxes(vehicle);
10 m_playerIdx = playerIdx;
11 m_isBike = vehicle >= Vehicle::Standard_Bike_S;
12 if (m_isBike) {
13 initBikeDispParams(vehicle);
14 } else {
15 initKartDispParams(vehicle);
16 }
17
18 initCameraParams(character);
19}
20
21KartParam::~KartParam() = default;
22
24void KartParam::initStats(Character character, Vehicle vehicle) {
25 auto *fileManager = KartParamFileManager::Instance();
26
27 auto vehicleStream = fileManager->getVehicleStream(vehicle);
28 auto driverStream = fileManager->getDriverStream(character);
29
30 m_stats = Stats(vehicleStream);
31 m_stats.applyCharacterBonus(driverStream);
32}
33
34void KartParam::initBikeDispParams(Vehicle vehicle) {
35 auto *fileManager = KartParamFileManager::Instance();
36
37 auto dispParamsStream = fileManager->getBikeDispParamsStream(vehicle);
38 m_bikeDisp = BikeDisp(dispParamsStream);
39}
40
41void KartParam::initKartDispParams(Vehicle vehicle) {
42 auto *fileManager = KartParamFileManager::Instance();
43
44 auto dispParamsStream = fileManager->getKartDispParamsStream(vehicle);
45 m_kartDisp = KartDisp(dispParamsStream);
46}
47
48void KartParam::initHitboxes(Vehicle vehicle) {
49 auto *fileManager = KartParamFileManager::Instance();
50
51 auto hitboxStream = fileManager->getHitboxStream(vehicle);
52 m_bsp = BSP(hitboxStream);
53}
54
55void KartParam::initCameraParams(Character character) {
56 auto *fileManager = KartParamFileManager::Instance();
57
58 auto cameraStream = fileManager->getKartCameraStream(character);
59 m_camera = KartCameraParam(cameraStream);
60}
61
62KartParam::BikeDisp::BikeDisp() = default;
63
64KartParam::BikeDisp::BikeDisp(EGG::RamStream &stream) {
65 read(stream);
66}
67
68void KartParam::BikeDisp::read(EGG::RamStream &stream) {
69 m_cameraDistY = stream.read_f32();
70 stream.skip(0x8);
71 m_handlePos.read(stream);
72 m_handleRot.read(stream);
73}
74
75KartParam::KartDisp::KartDisp() = default;
76
77KartParam::KartDisp::KartDisp(EGG::RamStream &stream) {
78 read(stream);
79}
80
81void KartParam::KartDisp::read(EGG::RamStream &stream) {
82 m_cameraDistY = stream.read_f32();
83}
84
85KartParam::Stats::Stats() = default;
86
87KartParam::Stats::Stats(EGG::RamStream &stream) {
88 read(stream);
89}
90
93void KartParam::Stats::read(EGG::RamStream &stream) {
94 body = static_cast<Body>(stream.read_s32());
95 driftType = static_cast<DriftType>(stream.read_s32());
96 weightClass = static_cast<WeightClass>(stream.read_s32());
97 _00c = stream.read_f32();
98 weight = stream.read_f32();
99 bumpDeviationLevel = stream.read_f32();
100 speed = stream.read_f32();
101 turningSpeed = stream.read_f32();
102 tilt = stream.read_f32();
103 accelerationStandardA[0] = stream.read_f32();
104 accelerationStandardA[1] = stream.read_f32();
105 accelerationStandardA[2] = stream.read_f32();
106 accelerationStandardA[3] = stream.read_f32();
107 accelerationStandardT[0] = stream.read_f32();
108 accelerationStandardT[1] = stream.read_f32();
109 accelerationStandardT[2] = stream.read_f32();
110 accelerationDriftA[0] = stream.read_f32();
111 accelerationDriftA[1] = stream.read_f32();
112 accelerationDriftT[0] = stream.read_f32();
113 handlingManualTightness = stream.read_f32();
114 handlingAutomaticTightness = stream.read_f32();
115 handlingReactivity = stream.read_f32();
116 driftManualTightness = stream.read_f32();
117 driftAutomaticTightness = stream.read_f32();
118 driftReactivity = stream.read_f32();
119 driftOutsideTargetAngle = stream.read_f32();
120 driftOutsideDecrement = stream.read_f32();
121 miniTurbo = stream.read_u32();
122
123 for (size_t i = 0; i < kclSpeed.size(); ++i) {
124 kclSpeed[i] = stream.read_f32();
125 }
126 for (size_t i = 0; i < kclRot.size(); ++i) {
127 kclRot[i] = stream.read_f32();
128 }
129
130 itemUnk170 = stream.read_f32();
131 itemUnk174 = stream.read_f32();
132 itemUnk178 = stream.read_f32();
133 itemUnk17c = stream.read_f32();
134 maxNormalAcceleration = stream.read_f32();
135 megaScale = stream.read_f32();
136 shrinkScale = stream.read_f32();
137}
138
141void KartParam::Stats::applyCharacterBonus(EGG::RamStream &stream) {
142 stream.skip(0x10);
143 weight += stream.read_f32();
144
145 stream.skip(0x4);
146 speed += stream.read_f32();
147 turningSpeed += stream.read_f32();
148
149 stream.skip(0x4);
150 accelerationStandardA[0] += stream.read_f32();
151 accelerationStandardA[1] += stream.read_f32();
152 accelerationStandardA[2] += stream.read_f32();
153 accelerationStandardA[3] += stream.read_f32();
154 accelerationStandardA[0] += stream.read_f32();
155 accelerationStandardA[1] += stream.read_f32();
156 accelerationStandardA[2] += stream.read_f32();
157 accelerationDriftA[0] += stream.read_f32();
158 accelerationDriftA[1] += stream.read_f32();
159 accelerationDriftT[0] += stream.read_f32();
160 handlingManualTightness += stream.read_f32();
161 handlingAutomaticTightness += stream.read_f32();
162 handlingReactivity += stream.read_f32();
163 driftManualTightness += stream.read_f32();
164 driftAutomaticTightness += stream.read_f32();
165 driftReactivity += stream.read_f32();
166 driftOutsideTargetAngle += stream.read_f32();
167 driftOutsideDecrement += stream.read_f32();
168 miniTurbo += stream.read_u32();
169
170 for (size_t i = 0; i < kclSpeed.size(); ++i) {
171 kclSpeed[i] += stream.read_f32();
172 }
173
174 for (size_t i = 0; i < kclRot.size(); ++i) {
175 kclRot[i] += stream.read_f32();
176 }
177}
178
179BSP::BSP() = default;
180
181BSP::BSP(EGG::RamStream &stream) {
182 read(stream);
183}
184
185void BSP::read(EGG::RamStream &stream) {
186 initialYPos = stream.read_f32();
187
188 for (auto &hitbox : hitboxes) {
189 hitbox.enable = stream.read_u16();
190 stream.skip(2);
191 hitbox.position.read(stream);
192 hitbox.radius = stream.read_f32();
193 hitbox.wallsOnly = stream.read_u16();
194 hitbox.tireCollisionIdx = stream.read_u16();
195 }
196
197 cuboids[0].read(stream);
198 cuboids[1].read(stream);
199 angVel0Factor = stream.read_f32();
200 _1a0 = stream.read_f32();
201
202 for (auto &wheel : wheels) {
203 wheel.enable = stream.read_u16();
204 stream.skip(2);
205 wheel.springStiffness = stream.read_f32();
206 wheel.dampingFactor = stream.read_f32();
207 wheel.maxTravel = stream.read_f32();
208 wheel.relPosition.read(stream);
209 wheel.xRot = stream.read_f32();
210 wheel.wheelRadius = stream.read_f32();
211 wheel.sphereRadius = stream.read_f32();
212 wheel._28 = stream.read_u32();
213 }
214
215 rumbleHeight = stream.read_f32();
216 rumbleSpeed = stream.read_f32();
217}
218
219KartParam::KartCameraParam::KartCameraParam() = default;
220
221KartParam::KartCameraParam::KartCameraParam(EGG::RamStream &stream) {
222 read(stream);
223}
224
225void KartParam::KartCameraParam::read(EGG::RamStream &stream) {
226 fov = stream.read_f32();
227 dist = stream.read_f32();
228 posY = stream.read_f32();
229 targetPosY = stream.read_f32();
230}
231
232} // namespace Kinoko::Kart
Kinoko::EGG::RamStream
A stream of data stored in memory.
Definition Stream.hh:83
Kinoko::Kart
Pertains to kart-related functionality.
Definition BoxColManager.hh:14
Kinoko::Kart::KartParam::Stats
Various character/vehicle-related handling and speed stats.
Definition KartParam.hh:79
Kinoko::Kart::KartParam::Stats::kclSpeed
std::array< f32, 32 > kclSpeed
Speed multipliers, indexed using KCL attributes.
Definition KartParam.hh:124
Kinoko::Kart::KartParam::Stats::speed
f32 speed
Base full speed of the character/vehicle combo.
Definition KartParam.hh:108
Kinoko::Kart::KartParam::Stats::read
void read(EGG::RamStream &stream)
Parses out the stats for a given KartParam.bin stream.
Definition KartParam.cc:93
Kinoko::Kart::KartParam::Stats::driftReactivity
f32 driftReactivity
A weight applied to turn radius when drifting.
Definition KartParam.hh:120
Kinoko::Kart::KartParam::Stats::kclRot
std::array< f32, 32 > kclRot
Rotation scalars, indexed using KCL attributes.
Definition KartParam.hh:125
Kinoko::Kart::KartParam::Stats::weight
f32 weight
Contrary to popular belief, this does not affect gravity.
Definition KartParam.hh:106
Kinoko::Kart::KartParam::Stats::driftManualTightness
f32 driftManualTightness
Affects turn radius when manual drifting.
Definition KartParam.hh:118
Kinoko::Kart::KartParam::Stats::applyCharacterBonus
void applyCharacterBonus(EGG::RamStream &stream)
Applies character stats on top of the kart stats.
Definition KartParam.cc:141
Kinoko::Kart::KartParam::Stats::DriftType
DriftType
The type of drift (inside/outside).
Definition KartParam.hh:89
Kinoko::Kart::KartParam::Stats::miniTurbo
u32 miniTurbo
The framecount duration of a charged mini-turbo.
Definition KartParam.hh:123
Kinoko::Kart::KartParam::Stats::driftAutomaticTightness
f32 driftAutomaticTightness
Affects turn radius when automatic drifting.
Definition KartParam.hh:119
Kinoko::Kart::KartParam::Stats::handlingManualTightness
f32 handlingManualTightness
Affects turn radius when manual and not drifting.
Definition KartParam.hh:115
Kinoko::Kart::KartParam::Stats::Body
Body
The body style of the vehicle. Basically the number of wheels.
Definition KartParam.hh:81
Kinoko::Kart::KartParam::Stats::handlingAutomaticTightness
f32 handlingAutomaticTightness
Affects turn radius when auto and not drifting.
Definition KartParam.hh:116
Kinoko::Kart::KartParam::Stats::turningSpeed
f32 turningSpeed
Speed decrement percentage of the vehicle when handling.
Definition KartParam.hh:109
Kinoko::Kart::KartParam::Stats::handlingReactivity
f32 handlingReactivity
A weight applied to turn radius when not drifting.
Definition KartParam.hh:117