OpenMoHAA 0.82.0
Loading...
Searching...
No Matches
vehicle.h
1/*
2===========================================================================
3Copyright (C) 2015 the OpenMoHAA team
4
5This file is part of OpenMoHAA source code.
6
7OpenMoHAA source code is free software; you can redistribute it
8and/or modify it under the terms of the GNU General Public License as
9published by the Free Software Foundation; either version 2 of the License,
10or (at your option) any later version.
11
12OpenMoHAA source code is distributed in the hope that it will be
13useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
14MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15GNU General Public License for more details.
16
17You should have received a copy of the GNU General Public License
18along with OpenMoHAA source code; if not, write to the Free Software
19Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
20===========================================================================
21*/
22
23// vehicle.h: Script controlled vehicles.
24//
25
26#pragma once
27
28#include "g_local.h"
29#include "entity.h"
30#include "sentient.h"
31#include "scriptslave.h"
32#include "spline.h"
33#include "VehicleSlot.h"
34#include "VehicleCollisionEntity.h"
35#include "VehicleSoundEntity.h"
36#include "movegrid.h"
37
38extern Event EV_Vehicle_Enter;
39extern Event EV_Vehicle_Exit;
40extern Event EV_Vehicle_Drivable;
41extern Event EV_Vehicle_UnDrivable;
42extern Event EV_Vehicle_Lock;
43extern Event EV_Vehicle_UnLock;
44extern Event EV_Vehicle_SeatAnglesOffset;
45extern Event EV_Vehicle_SeatOffset;
46extern Event EV_Vehicle_DriverAnimation;
47extern Event EV_Vehicle_SetWeapon;
48extern Event EV_Vehicle_ShowWeapon;
49extern Event EV_Vehicle_SetSpeed;
50extern Event EV_Vehicle_SetTurnRate;
51
52extern cvar_t *g_showvehiclemovedebug;
53extern cvar_t *g_showvehicleentrypoints;
54extern cvar_t *g_showvehicleslotpoints;
55extern cvar_t *g_showvehicletags;
56extern cvar_t *g_showvehiclepath;
57
58#define NUM_VEHICLE_TIRES 4
59
60using cVehicleSpline = cSpline<4, 512>;
61
62typedef struct wheel_s {
63 Vector vOrigin;
64 Vector vAcceleration;
65 Vector vVelocity;
66 Vector vLongForce;
67 Vector vLatForce;
68 Vector vForce;
69 Vector vOrientation;
70 Vector vResistance;
71 float fYawOffset;
72 float fSlipAngle;
73 float fGripCoef;
74 float fLoad;
75 float fLongForce;
76 float fLatForce;
77 float fForce;
78 float fTraction;
79 float fLongTorque;
80 float fLatTorque;
81 float fTorque;
82 float fLongDist;
83 float fLatDist;
84 qboolean bSkidding;
85 qboolean bSpinning;
86 int iPowered;
87} wheel_t;
88
89class VehicleBase : public Animate
90{
91public:
92 VehicleBase *vlink;
93 Vector offset;
94
95 CLASS_PROTOTYPE(VehicleBase);
96
97 VehicleBase(void);
98 void Archive(Archiver& arc) override;
99};
100
101inline void VehicleBase::Archive(Archiver& arc)
102{
103 Animate::Archive(arc);
104
105 arc.ArchiveObjectPointer((Class **)&vlink);
106 arc.ArchiveVector(&offset);
107}
108
109typedef enum {
110 ST_OFF,
111 ST_OFF_TRANS_IDLE,
112 ST_IDLE_TRANS_OFF,
113 ST_IDLE,
114 ST_IDLE_TRANS_RUN,
115 ST_RUN,
116 ST_RUN_TRANS_IDLE,
117 ST_IDLE_TRANS_TURN,
118 ST_TURN,
119 ST_TURN_TRANS_IDLE
120} SOUND_STATE;
121
122#define MAX_DRIVERS 1
123#define MAX_PASSENGERS 32
124#define MAX_TURRETS 8
125#define MAX_CORNERS 4
126
127#define MAX_SKIPPED_ENTITIES 64
128
129class Vehicle : public VehicleBase
130{
131 friend class VehicleSoundEntity;
132 friend class VehicleTurretGun;
133
134protected:
135 cVehicleSlot driver;
136 cVehicleSlot lastdriver;
137 cVehicleSlot Passengers[MAX_PASSENGERS];
138 cTurretSlot Turrets[MAX_TURRETS];
139 int numPassengers;
140 int numTurrets;
141 int moveresult;
142 int isBlocked;
143 int m_iFrameCtr;
144 int m_iGear;
145 int m_iRPM;
146 int m_iLastTiresUpdate;
147 cVehicleSpline *m_pAlternatePath;
148 int m_iAlternateNode;
149 cVehicleSpline *m_pCurPath;
150 int m_iCurNode;
151 cVehicleSpline *m_pNextPath;
152 int m_iNextPathStartNode;
153 float maxturnrate;
154 float currentspeed;
155 float turnangle;
156 float turnimpulse;
157 float moveimpulse;
158 float prev_moveimpulse;
159 float jumpimpulse;
160 float speed;
161 float conesize;
162 float maxtracedist;
163 float airspeed;
164 float m_fGearRatio[6];
165 float m_fMass;
166 float m_fFrontMass;
167 float m_fBackMass;
168 float m_fWheelBase;
169 float m_fWheelFrontLoad;
170 float m_fWheelFrontInnerLoad;
171 float m_fWheelFrontOutterLoad;
172 float m_fWheelFrontDist;
173 float m_fWheelFrontSuspension;
174 float m_fWheelBackLoad;
175 float m_fWheelBackInnerLoad;
176 float m_fWheelBackOutterLoad;
177 float m_fWheelBackDist;
178 float m_fWheelBackSuspension;
179 float m_fCGHeight;
180 float m_fBankAngle;
181 float m_fTread;
182 float m_fTrackWidth;
183 float m_fTireFriction;
184 float m_fDrag;
185 float m_fTireRadius;
186 float m_fFrontBrakes;
187 float m_fBackBrakes;
188 float m_fRollingResistance;
189 float m_fTireRotationalSpeed;
190 float m_fFrontBrakingForce;
191 float m_fBackBrakingForce;
192 float m_fBrakingPerformance;
193 float m_fLastTurn;
194 float m_fTangForce;
195 float m_fInertia;
196 float m_fDifferentialRatio;
197 float m_fGearEfficiency;
198 float m_fMaxTraction;
199 float m_fTractionForce;
200 float m_fAccelerator;
201 float m_fTorque;
202 float m_fDownForce;
203 float m_fUpForce;
204 float m_fLeftForce;
205 float m_fRightForce;
206 float m_fForwardForce;
207 float m_fBackForce;
208 float m_fBouncyCoef;
209 float m_fSpringyCoef;
210 float m_fYawMin;
211 float m_fYawMax;
212 float m_fRollMin;
213 float m_fRollMax;
214 float m_fZMin;
215 float m_fZMax;
216 float m_fYawCoef;
217 float m_fRollCoef;
218 float m_fZCoef;
219 float m_fShaderOffset;
220 float m_fSoundMinSpeed;
221 float m_fSoundMinPitch;
222 float m_fSoundMaxSpeed;
223 float m_fSoundMaxPitch;
224 float m_fVolumeMinSpeed;
225 float m_fVolumeMinPitch;
226 float m_fVolumeMaxSpeed;
227 float m_fVolumeMaxPitch;
228 float m_fStopStartDistance;
229 float m_fStopStartSpeed;
230 float m_fStopEndDistance;
231 float m_fSkidAngle;
232 float m_fSkidLeftForce;
233 float m_fSkidRightForce;
234 str vehicleName;
235 str weaponName;
236 str m_sAnimationSet;
237 str m_sSoundSet;
238 str m_sExplosionModel;
239 Vector last_origin;
240 Vector seatangles;
241 Vector seatoffset;
242 Vector driveroffset;
243 Vector Corners[MAX_CORNERS];
244 Vector v_angle;
245 Vector yaw_forward;
246 Vector yaw_left;
247 Vector ground_normal;
248 Vector base_angles;
249 Vector prev_velocity;
250 Vector real_velocity;
251 Vector prev_origin;
252 Vector real_acceleration;
253 Vector prev_acceleration;
254 Vector m_vOldMins;
255 Vector m_vOldMaxs;
256 Vector m_vCG;
257 Vector m_vAngularAcceleration;
258 Vector m_vAngularVelocity;
259 Vector m_vAngles;
260 Vector m_vFrontNormal;
261 Vector m_vBackNormal;
262 Vector m_vFrontAngles;
263 Vector m_vBackAngles;
264 Vector m_vBaseNormal;
265 Vector m_vBaseAngles;
266 Vector m_vPrevNormal;
267 Vector m_vResistance;
268 Vector m_vWheelForce;
269 Vector m_vTangForce;
270 Vector m_vForce;
271 Vector m_vAcceleration;
272 Vector m_vOriginOffset;
273 Vector m_vOriginOffset2;
274 Vector m_vOriginCornerOffset;
275 Vector m_vAnglesOffset;
276 Vector m_vSaveAngles;
277 Vector m_vSkidOrigin;
278 qboolean drivable;
279 qboolean pathDrivable;
280 qboolean locked;
281 qboolean hasweapon;
282 qboolean showweapon;
283 qboolean steerinplace;
284 qboolean jumpable;
285 qboolean m_bWheelSpinning;
286 qboolean m_bIsSkidding;
287 qboolean m_bIsBraking;
288 qboolean m_bBackSlipping;
289 qboolean m_bFrontSlipping;
290 qboolean m_bAutomatic;
291 qboolean m_bThinkCalled;
292 qboolean m_bMovementLocked;
293 qboolean m_bRemoveOnDeath;
294 qboolean m_bStopEnabled;
295 qboolean m_bEnableSkidding;
296 qboolean m_bAnimMove;
297 qboolean m_bDamageSounds;
298 qboolean m_bRunSounds;
299 int m_iProjectileHitsRemaining;
300 vehicleState_t vs;
301 cMoveGrid *m_sMoveGrid;
302 float m_fIdealSpeed;
303 float m_fMaxSpeed;
304 bool m_bBounceBackwards;
305 Vector m_vIdealPosition;
306 Vector m_vIdealDir;
307 float m_fIdealAccel;
308 float m_fIdealDistance;
309 float m_fLookAhead;
310 bool m_bAutoPilot;
311 SafePtr<VehicleCollisionEntity> m_pCollisionEntity;
312 SOUND_STATE m_eSoundState;
313 float m_fNextSoundState;
314 SafePtr<VehicleSoundEntity> m_pVehicleSoundEntities[MAX_CORNERS];
315 Vector m_vTireEnd[NUM_VEHICLE_TIRES];
316 bool m_bTireHit[NUM_VEHICLE_TIRES];
317 Vector m_vNormalSum;
318 int m_iNumNormals;
319 float m_fMaxUseAngle;
320 bool m_bBounceStayFullSpeed;
321
322protected:
323 virtual void WorldEffects(void);
324 virtual void CheckWater(void);
325 virtual void DriverUse(Event *ev);
326 virtual void VehicleStart(Event *ev);
327 virtual void VehicleTouched(Event *ev);
328 virtual void VehicleBlocked(Event *ev);
329 void Think(void) override;
330 void Postthink(void) override;
331 virtual void Drivable(Event *ev);
332 virtual void PathDrivable(Event *ev); // Added in 2.30
333 virtual void UnDrivable(Event *ev);
334 virtual void Jumpable(Event *ev);
335 virtual void SeatAnglesOffset(Event *ev);
336 virtual void SeatOffset(Event *ev);
337 virtual void SetDriverAngles(Vector angles);
338 virtual void Lock(Event *ev);
339 virtual void UnLock(Event *ev);
340 virtual void SetWeapon(Event *ev);
341 virtual void SetName(Event *ev); // added in 2.0
342 virtual void ShowWeaponEvent(Event *ev);
343 // added in 2.30
344 //====
345 virtual void BounceForwardsVelocity(Event *ev);
346 virtual void BounceBackwardsVelocity(Event *ev);
347 virtual void StopForwardsVelocity(Event *ev);
348 virtual void StopBackwardsVelocity(Event *ev);
349 //====
350 virtual void SetSpeed(Event *ev);
351 virtual void SetTurnRate(Event *ev);
352 virtual void SteerInPlace(Event *ev);
353 virtual void VehicleDestroyed(Event *ev);
354 virtual void SetMoveInfo(vmove_t *vm);
355 virtual void GetMoveInfo(vmove_t *vm);
356 virtual void SetCEMoveInfo(vmove_t *vm);
357 virtual void GetCEMoveInfo(vmove_t *vm);
358 virtual void SetViewAngles(Vector newViewangles);
359 virtual void SetMass(Event *ev);
360 virtual void SetFrontMass(Event *ev);
361 virtual void SetBackMass(Event *ev);
362 virtual void SetTread(Event *ev);
363 virtual void SetTireRadius(Event *ev);
364 virtual void SetRollingResistance(Event *ev);
365 virtual void SetDrag(Event *ev);
366 virtual float TorqueLookup(int rpm);
367 virtual void UpdateVariables(
368 Vector *acceleration, Vector *vpn, Vector *vup, Vector *vright, Vector *t_vpn, Vector *t_vup, Vector *t_vright
369 );
370 virtual void ModelInit(Event *ev);
371 virtual void BouncyCoef(Event *ev);
372 virtual void SpringyCoef(Event *ev);
373 virtual void YawMinMax(Event *ev);
374 virtual void RollMinMax(Event *ev);
375 virtual void ZMinMax(Event *ev);
376 virtual void SetAnimationSet(Event *ev);
377 virtual void SetSoundSet(Event *ev);
378 virtual void SpawnTurret(Event *ev);
379 void EventLockMovement(Event *ev);
380 void EventUnlockMovement(Event *ev);
381 virtual void QuerySpeed(Event *ev);
382 virtual void QueryFreePassengerSlot(Event *ev);
383 virtual void QueryFreeDriverSlot(Event *ev);
384 virtual void QueryFreeTurretSlot(Event *ev);
385 virtual void QueryPassengerSlotPosition(Event *ev);
386 virtual void QueryDriverSlotPosition(Event *ev);
387 virtual void QueryTurretSlotPosition(Event *ev);
388 virtual void QueryPassengerSlotAngles(Event *ev);
389 virtual void QueryDriverSlotAngles(Event *ev);
390 virtual void QueryTurretSlotAngles(Event *ev);
391 virtual void QueryPassengerSlotStatus(Event *ev);
392 virtual void QueryDriverSlotStatus(Event *ev);
393 virtual void QueryTurretSlotStatus(Event *ev);
394 virtual void QueryPassengerSlotEntity(Event *ev);
395 virtual void QueryDriverSlotEntity(Event *ev);
396 virtual void QueryTurretSlotEntity(Event *ev);
397 virtual void AttachPassengerSlot(Event *ev);
398 virtual void AttachDriverSlot(Event *ev);
399 virtual void AttachTurretSlot(Event *ev);
400 virtual void DetachPassengerSlot(Event *ev);
401 virtual void DetachDriverSlot(Event *ev);
402 virtual void DetachTurretSlot(Event *ev);
403 virtual void DetachRemoteOwner(); // added in 2.0
404 virtual void SetWheelCorners(Event *ev);
405 virtual void EventDriveInternal(Event *ev, bool wait);
406 virtual void EventDrive(Event *ev);
407 virtual void EventDriveNoWait(Event *ev);
408 virtual void EventStop(Event *ev);
409 virtual void EventFullStop(Event *ev);
410 virtual void EventModifyDrive(Event *ev);
411 virtual void EventNextDrive(Event *ev);
412 void EventModel(Event *ev);
413 void EventRemoveOnDeath(Event *ev);
414 void EventSetExplosionModel(Event *ev);
415 void EventSetCollisionModel(Event *ev);
416 void EventGetCollisionModel(Event *ev);
417 void EventSetSoundParameters(Event *ev);
418 void EventSetVolumeParameters(Event *ev);
419 void EventDamage(Event *ev);
420 void EventStopAtEnd(Event *ev);
421 void EventSkidding(Event *ev);
422 void EventContinueSkidding(Event *ev);
423 void EventVehicleAnim(Event *ev);
424 void EventVehicleAnimDone(Event *ev);
425 // added in 2.0
426 //====
427 void EventVehicleMoveAnim(Event *ev);
428 void EventVehicleMoveAnimDone(Event *ev);
429 void EventDamageSounds(Event *ev);
430 void EventRunSounds(Event *ev);
431 void Remove(Event *ev);
432 //====
433 void TouchStuff(vmove_t *vm);
434 virtual void ResetSlots(void);
435 virtual void OpenSlotsByModel(void);
436 virtual void MoveVehicle(void);
437 virtual void AnimMoveVehicle(void);
438 virtual bool AssertMove(Vector vNewOrigin, Vector vOldOrigin);
439 virtual bool AssertRotation(Vector vNewAngles, Vector vOldAngles);
440 virtual void NoMove(void);
441 virtual void SlidePush(Vector vPush);
442 void SetupPath(cVehicleSpline *pPath, SimpleEntity *se);
443 virtual void UpdateSound(void);
444 void SetupVehicleSoundEntities(void);
445 void RemoveVehicleSoundEntities(void);
446 void TurnOnVehicleSoundEntities(void);
447 void TurnOffVehicleSoundEntities(void);
448 void UpdateTires(void);
449 void UpdateNormals(void);
450 void UpdateBones(void);
451 void UpdateShaderOffset(void);
452 virtual void UpdateTurretSlot(int iSlot);
453 void UpdatePassengerSlot(int iSlot);
454 void UpdateDriverSlot(int iSlot);
455 float GetPathPosition(cVehicleSpline *pPath, int iNode);
456 void UpdateSkidAngle(void);
457 void FactorInSkidOrigin(void);
458 virtual void FactorInOriginOffset(void);
459 virtual void CalculateOriginOffset(void);
460 virtual void FactorOutOriginOffset(void);
461 virtual void FactorInAnglesOffset(Vector *vAddedAngles);
462 virtual void CalculateAnglesOffset(Vector acceleration);
463 virtual void FactorOutAnglesOffset(void);
464 qboolean GetTagPositionAndOrientation(str tagname, orientation_t *new_or);
465 qboolean GetTagPositionAndOrientation(int tagnum, orientation_t *new_or);
466 void CalculateAnimationData(Vector vAngles, Vector vOrigin);
467 bool IsDamagedBy(Entity *ent);
468
469public:
470 CLASS_PROTOTYPE(Vehicle);
471
472 Vehicle();
473 virtual ~Vehicle();
474
475 virtual void DriverAdded(); // added in 2.0
476 virtual qboolean Drive(usercmd_t *ucmd);
477 virtual qboolean PathDrive(usercmd_t *ucmd);
478 void AutoPilot(void);
479 virtual qboolean HasWeapon(void);
480 virtual qboolean ShowWeapon(void);
481 Entity *Driver(void);
482 virtual qboolean IsDrivable(void);
483 void Archive(Archiver& arc) override;
484 str GetSoundSet(void);
485 virtual float QuerySpeed(void);
486 virtual int QueryFreePassengerSlot(void);
487 virtual int QueryFreeDriverSlot(void);
488 virtual int QueryFreeTurretSlot(void);
489 virtual void QueryPassengerSlotPosition(int slot, float *pos);
490 virtual void QueryDriverSlotPosition(int slot, float *pos);
491 virtual void QueryTurretSlotPosition(int slot, float *pos);
492 virtual void QueryPassengerSlotAngles(int slot, float *ang);
493 virtual void QueryDriverSlotAngles(int slot, float *ang);
494 virtual void QueryTurretSlotAngles(int slot, float *ang);
495 virtual int QueryPassengerSlotStatus(int slot);
496 virtual int QueryDriverSlotStatus(int slot);
497 virtual int QueryTurretSlotStatus(int slot);
498 virtual Entity *QueryPassengerSlotEntity(int slot);
499 virtual Entity *QueryDriverSlotEntity(int slot);
500 virtual Entity *QueryTurretSlotEntity(int slot);
501 bool FindExitPosition(Entity *pEnt, const Vector& vOrigin, const Vector *vAngles); // added in 2.0
502 virtual void AttachPassengerSlot(int slot, Entity *ent, Vector vExitPosition);
503 virtual void AttachDriverSlot(int slot, Entity *ent, Vector vExitPosition);
504 virtual void AttachTurretSlot(int slot, Entity *ent, Vector vExitPosition, Vector *vExitAngles);
505 virtual void DetachPassengerSlot(int slot, Vector vExitPosition, Vector *vExitAngles);
506 virtual void DetachDriverSlot(int slot, Vector vExitPosition, Vector *vExitAngles);
507 virtual void DetachTurretSlot(int slot, Vector vExitPosition, Vector *vExitAngles);
508 virtual int FindPassengerSlotByEntity(Entity *ent);
509 virtual int FindDriverSlotByEntity(Entity *ent);
510 virtual int FindTurretSlotByEntity(Entity *ent);
511 virtual void SetSlotsNonSolid(void);
512 virtual void SetSlotsSolid(void);
513 void KickSuspension(Vector vDirection, float fForce);
514 qboolean isLocked(void);
515 void Lock(void);
516 void UnLock(void);
517 const str& getName() const; // added in 2.0
518 VehicleCollisionEntity *GetCollisionEntity(void);
519 // Added in 2.30
520 //====
521 void EventSetMaxUseAngle(Event *ev);
522 void EventCanUse(Event *ev);
523 int GetProjectileHitsRemaining() const;
524 void SetProjectileVulnerable(Event* ev);
525 void DoProjectileVulnerability(Entity* pProjectile, Entity* pOwner, meansOfDeath_t meansOfDeath);
526 //====
527};
528
529class DrivableVehicle : public Vehicle
530{
531public:
532 CLASS_PROTOTYPE(DrivableVehicle);
533
534 DrivableVehicle(void);
535
536 virtual void Killed(Event *ev) override;
537};
538
539class VehicleWheelsX4 : public DrivableVehicle
540{
541private:
542 wheel_t m_sWheels[4];
543
544public:
545 CLASS_PROTOTYPE(VehicleWheelsX4);
546
547 VehicleWheelsX4();
548
549 virtual void UpdateVariables(
550 Vector *acceleration, Vector *vpn, Vector *vup, Vector *vright, Vector *t_vpn, Vector *t_vup, Vector *t_vright
551 ) override;
552 virtual float TorqueLookup(int rpm) override;
553 virtual void Think() override;
554 virtual void Postthink() override;
555 virtual void Killed(Event *ev) override;
556};
557
558class VehicleWheelsX2 : public DrivableVehicle
559{
560private:
561 wheel_t m_sWheels[2];
562
563public:
564 CLASS_PROTOTYPE(VehicleWheelsX2);
565
566 VehicleWheelsX2();
567
568 virtual void UpdateVariables(
569 Vector *acceleration, Vector *vpn, Vector *vup, Vector *vright, Vector *t_vpn, Vector *t_vup, Vector *t_vright
570 ) override;
571 virtual float TorqueLookup(int rpm) override;
572 virtual void Think() override;
573 virtual void Postthink() override;
574 virtual void Killed(Event *ev) override;
575};
576
577class VehicleTank : public DrivableVehicle
578{
579public:
580 CLASS_PROTOTYPE(VehicleTank);
581
582 VehicleTank();
583 ~VehicleTank();
584
585 virtual void DriverAdded() override;
586 virtual qboolean Drive(usercmd_t *ucmd) override;
587 void EventDamage(Event *ev);
588 virtual void Think() override;
589 virtual void Postthink() override;
590 virtual void CalculateOriginOffset() override;
591 void UpdateSound() override;
592 //void AttachDriverSlot(Event* ev) override;
593 void AttachDriverSlot(int slot, Entity *ent, Vector vExitPosition) override;
594};
595
596class VehicleHalfTrack : public DrivableVehicle
597{
598public:
599 CLASS_PROTOTYPE(VehicleHalfTrack);
600
601 VehicleHalfTrack();
602
603 virtual void Think() override;
604 virtual void Postthink() override;
605 virtual void Killed(Event *ev) override;
606};
607
608typedef SafePtr<Vehicle> VehiclePtr;
Archiver
Definition archive.h:86
Class
Definition class.h:276
Entity
Definition entity.h:203
Event
Definition listener.h:246
SafePtr
Definition safeptr.h:160
SimpleEntity
Definition simpleentity.h:42
Vector
Definition vector.h:61
VehicleCollisionEntity
Definition VehicleCollisionEntity.h:29
cMoveGrid
Definition movegrid.h:70
cSpline
Definition spline.h:33
cTurretSlot
Definition VehicleSlot.h:78
cVehicleSlot
Definition VehicleSlot.h:37
str
Definition str.h:77
orientation_t
Definition q_shared.h:1524
wheel_s
Definition vehicle.h:62