splash-damage/etqw-sdk
0
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
etqw-sdk/source/game/vehicles/Transport.h

705 lines
27 KiB
C
Raw Normal View History

as released 2008-05-29
2008-05-29 00:00:00 +00:00
// Copyright (C) 2007 Id Software, Inc.
//
#ifndef __GAME_VEHICLES_TRANSPORT_H__
#define __GAME_VEHICLES_TRANSPORT_H__
#define UPStoKPH( value ) ( InchesToMetres( value ) * 3.6f )
#define KPHtoUPS( value ) ( MetresToInches( value ) / 3.6f )
#include "../AF.h"
#include "../Player.h"
#include "TransportSystems.h"
#include "TransportExtras.h"
#include "../ScriptEntity.h"
#include "../physics/Physics_RigidBodyMultiple.h"
#include "../physics/Physics_AF.h"
#include "../proficiency/ProficiencyManager.h"
#include "../effects/Effects.h"
#include "../effects/WaterEffects.h"
#include "RouteConstraint.h"
class sdVehicleWeapon;
class sdVehicleIKSystem;
class idAFBody;
class idIK;
class sdDeclToolTip;
class sdVehiclePosition;
class sdVehicleView;
class sdTransport;
class sdVehicleControlBase;
class sdVehicleSoundControlBase;
class rvClientMoveable;
class sdBindContext;
typedef sdVehicleWeapon* sdVehicleWeaponPtr;
const int PFC_SELF_COLLISION = BITT< 0 >::VALUE;
const int PFC_CAN_DAMAGE = BITT< 1 >::VALUE;
class sdVehicleDriveObject;
#define MAX_VEHICLE_PARTS 32
#define MAX_VEHICLE_WEAPONS 8
#define MAX_VEHICLE_POSITIONS 8
#define MAX_VEHICLE_EFFECTS 32
typedef idStaticList< sdVehicleDriveObject*, MAX_VEHICLE_PARTS > vehicleDriveObjectList_t;
typedef idStaticList< sdEffect, MAX_VEHICLE_EFFECTS > vehicleEffectList_t;
class sdTransportUsableInterface : public sdUsableInterface, public sdScriptedInteractiveInterface {
public:
sdTransportUsableInterface( void ) { owner = NULL; }
void Init( sdTransport* transport );
virtual void ForcePlacement( idPlayer* other, int index, int oldIndex, bool keepCamera );
virtual void FindPositionForPlayer( idPlayer* player );
virtual bool OnExit( idPlayer* player, bool force );
virtual bool OnActivate( idPlayer* player, float distance );
virtual bool OnActivateHeld( idPlayer* player, float distance );
virtual bool OnUsed( idPlayer* player, float distance );
virtual void BecomeActiveViewProxy( idPlayer* viewPlayer );
virtual void StopActiveViewProxy( void );
virtual void UpdateProxyView( idPlayer* viewPlayer );
virtual void SwapPosition( idPlayer* player );
virtual void SwapViewMode( idPlayer* player );
virtual void SelectWeapon( idPlayer* player, int index );
virtual idPlayer* GetXPSharer( float& shareFactor );
virtual bool GetHideHud( idPlayer* player ) const;
virtual bool GetSensitivity( idPlayer* player, float& sensX, float& sensY ) const;
virtual bool GetShowPlayer( idPlayer* player ) const;
virtual bool GetShowPlayerShadow( idPlayer* player ) const;
virtual float GetFov( idPlayer* player ) const;
virtual float GetDamageScale( idPlayer* player ) const;
virtual bool GetShowCrosshair( idPlayer* player ) const;
virtual bool GetHideDecoyInfo( idPlayer* player ) const;
virtual bool GetShowTargetingInfo( idPlayer* player ) const;
virtual playerStance_t GetPlayerStance( idPlayer* player ) const;
virtual jointHandle_t GetPlayerIconJoint( idPlayer* player ) const;
virtual void UpdateHud( idPlayer* player, guiHandle_t handle );
virtual void UpdateViewAngles( idPlayer* player );
virtual void UpdateViewPos( idPlayer* player, idVec3& origin, idMat3& axis, bool fullUpdate );
virtual void CalculateRenderView( idPlayer* player, renderView_t& renderView );
virtual const idAngles GetRequiredViewAngles( idPlayer* player, idVec3& target );
virtual const sdWeaponLockInfo* GetWeaponLockInfo( idPlayer* player ) const;
virtual void ClampViewAngles( idPlayer* player, const idAngles& oldViewAngles ) const;
virtual void NextWeapon( idPlayer* player ) const;
virtual void PrevWeapon( idPlayer* player ) const;
virtual int GetDestructionEndTime( void ) const;
virtual bool GetDirectionWarning( void ) const;
virtual int GetRouteKickDistance( void ) const;
virtual const sdDeclGUI* GetOverlayGUI( void ) const;
virtual bool HasAbility( qhandle_t handle, const idPlayer* player ) const;
virtual bool GetAllowPlayerMove( idPlayer* player ) const;
virtual bool GetAllowPlayerDamage( idPlayer* player ) const;
virtual bool GetAllowPlayerWeapon( idPlayer* player ) const;
virtual bool GetAllowAdjustBodyAngles( idPlayer* player ) const;
virtual const char* GetWeaponLookupName( const idPlayer* player ) const;
virtual const sdDeclLocStr* GetWeaponName( const idPlayer* player ) const;
virtual void OnPostThink( void ) {}
virtual int GetNumPositions() const;
virtual idPlayer* GetPlayerAtPosition( int i ) const;
virtual const sdDeclLocStr* GetPositionTitle( int i ) const;
public:
sdTransport* owner;
const sdProgram::sdFunction* onActivateFunc;
const sdProgram::sdFunction* onActivateHeldFunc;
float maxEnterDistance;
};
class sdTransportBroadcastData : public sdScriptEntityBroadcastData {
public:
sdTransportBroadcastData( void ) : controlState( NULL ) { ; }
virtual ~sdTransportBroadcastData( void );
virtual void MakeDefault( void );
virtual void Write( idFile* file ) const;
virtual void Read( idFile* file );
idStaticList< int, MAX_VEHICLE_POSITIONS > positionWeapons;
bool teleporting;
bool modelDisabled;
bool deathThroes;
int careenStartTime;
int lastRepairedPart;
int lastDamageDir;
int empTime;
int weaponEmpTime;
bool weaponDisabled;
idStaticList< sdEntityStateNetworkData*, MAX_VEHICLE_PARTS > objectStates;
sdEntityStateNetworkData* controlState;
};
class sdTransportNetworkData : public sdScriptEntityNetworkData {
public:
sdTransportNetworkData( void ) : controlState( NULL ) { ; }
virtual ~sdTransportNetworkData( void );
virtual void MakeDefault( void );
virtual void Write( idFile* file ) const;
virtual void Read( idFile* file );
idStaticList< sdEntityStateNetworkData*, MAX_VEHICLE_PARTS > objectStates;
sdEntityStateNetworkData* controlState;
int routeKickDistance;
};
class sdTransport : public sdScriptEntity {
public:
ABSTRACT_PROTOTYPE( sdTransport );
enum {
EVENT_SETTELEPORTER = sdScriptEntity::EVENT_MAXEVENTS,
EVENT_CONTROLMESSAGE,
EVENT_PARTSTATE,
EVENT_DECAY,
EVENT_ROUTEWARNING,
EVENT_ROUTEMASKWARNING,
EVENT_ROUTETRACKERENTITY,
EVENT_MAXEVENTS
};
sdTransport( void );
virtual ~sdTransport( void );
sdTransportPositionManager& GetPositionManager( void ) { return positionManager; }
const sdTransportPositionManager& GetPositionManager( void ) const { return positionManager; }
virtual void Damage( idEntity *inflictor, idEntity *attacker, const idVec3 &dir, const sdDeclDamage* damage, const float damageScale, const trace_t* collision, bool forceKill = false );
virtual bool Pain( idEntity *inflictor, idEntity *attacker, int damage, const idVec3 &dir, int location, const sdDeclDamage* damageDecl );
virtual void Decayed( void );
virtual void SetOrigin( const idVec3 &org );
virtual void SetAxis( const idMat3 &org );
virtual bool StartSynced( void ) const { return true; }
const wchar_t* GetPassengerNames( void ) const;
virtual bool ClientReceiveEvent( int event, int time, const idBitMsg& msg );
virtual void OnTeleportStarted( sdTeleporter* teleporter );
virtual void OnTeleportFinished( void );
virtual bool AllowTeleport( void ) const { return gameLocal.time > nextTeleportTime; }
virtual void OnPhysicsRested( void );
void SetTrackerEntity( idEntity* trackerEntity );
void Event_SetArmor( float _armor );
void Event_GetArmor( void );
virtual sdBindContext* GetBindContext( void ) { return bindContext; }
virtual void OnInputInit( void );
virtual void OnInputShutdown( void );
int GetDestructionEndTime( void ) const { return routeMaskWarningEndTime; }
bool GetDirectionWarning( void ) const { return vehicleFlags.routeWarning; }
int GetRouteKickDistance( void ) const { return routeKickDistance; }
int BitsForPartIndex( void ) const { return idMath::BitsForInteger( driveObjects.Num() + 1 ); }
virtual void WriteDemoBaseData( idFile* file ) const;
virtual void ReadDemoBaseData( idFile* file );
void Event_Repair( int repairCount );
void Event_GetLastRepairOrigin( void );
void Event_Input_SetPlayer( idEntity* entity );
void Event_Input_GetCollective();
void Event_GetLandingGearDown();
void Event_GetNumOccupiedPositions( void );
void Event_SwapPosition( idEntity* player );
void Event_IsEmpty( void );
void Event_UpdateEngine( bool disabled );
void Event_SetLightsEnabled( int group, bool enabled );
void Event_DisableWheelSuspension( bool disable );
void Event_EnableKnockback();
void Event_DisableKnockback();
void Event_DisableTimeout( bool disable );
void Event_GetSteerAngle( void );
void Event_GetPassengerNames( void );
void Event_Lock( bool _locked );
void Event_KickPlayer( int index, int flags );
void Event_Freeze( bool freeze );
void Event_DestroyParts( int mask );
void Event_DecayParts( int mask );
void Event_DecayLeftWheels( void );
void Event_DecayRightWheels( void );
void Event_DecayNonWheels( void );
void Event_ResetDecayTime( void );
void Event_HasHiddenParts( void );
void Event_SelectWeapon( idEntity* other, const char* name );
void Event_GetObject( const char* objectName );
void Event_DisableModel( bool disabled );
void Event_SetDeathThroeHealth( int health );
void Event_GetMinDisplayHealth( void );
void Event_GetSurfaceType( void );
void Event_IsEMPed( void );
void Event_IsWeaponEMPed( void );
void Event_GetRemainingEMP( void );
void Event_ApplyEMPDamage( float time, float weaponTime );
void Event_IsWeaponDisabled( void );
void Event_SetWeaponDisabled( bool disabled );
bool IsWeaponDisabled( void ) const;
void Event_SetLockAlarmActive( bool active );
void Event_SetImmobilized( bool immobile );
void Event_SetActive( bool active );
void Event_InSiegeMode( void );
void Event_GetNumWeapons( void );
void Event_GetWeapon( int index );
void Event_SetTrackerEntity( idEntity* trackerEntity );
void Event_IsPlayerBanned( idEntity* entity );
void Event_BanPlayer( idEntity* entity, float time );
void Event_ClearLastAttacker();
void Event_EMPChanged( void );
void Event_WeaponEMPChanged( void );
void Event_DisablePart( const char* name );
void Event_EnablePart( const char* name );
void Event_DestructionTime();
void Event_DirectionWarning();
void Event_IsTeleporting( void );
virtual int GetMinDisplayHealth( void ) const;
const playerVehicleTypes_t& GetVehicleType( void ) const { return playerVehicleType; }
const playerTeamTypes_t& GetVehicleTeam( void ) const { return playerVehicleTeam; }
int GetVehicleFlags( void ) const { return playerVehicleFlags; }
bool HasLockonDanger( void );
bool IsDeployed( void );
int GetDestroyedCriticalDriveParts() const { return damagedCriticalDriveParts; }
void RemoveCriticalDrivePart() { damagedCriticalDriveParts++; }
void AddCriticalDrivePart() { damagedCriticalDriveParts--; }
int GetRouteActionNumber() const { return routeActionNumber; }
bool IsEMPed( void );
bool IsWeaponEMPed( void );
void SetEMPTime( int newTime, int newWeaponTime );
void OnEMPStateChanged( void );
void OnWeaponEMPStateChanged( void );
float GetRemainingEMP( void );
float GetRemainingWeaponEMP( void );
void DestroyParts( int mask );
void DecayParts( int mask );
void DecayLeftWheels( void );
void DecayRightWheels( void );
void DecayNonWheels( void );
bool CanUse( idPlayer *other, const sdDeclToolTip** tip );
void OnUsed( idPlayer *other );
void ForcePlacement( idPlayer* other, int index, int oldIndex, bool keepCamera );
virtual void FindPositionForPlayer( idPlayer* player );
void PlacePlayerInPosition( idPlayer *other, sdVehiclePosition &position, sdVehiclePosition* oldPosition, bool keepCamera );
bool Exit( idPlayer* player, bool force );
void CancelDriverBackupVote( idPlayer* player );
void CancelAllDriverBackupVotes();
virtual void OnPlayerEntered( idPlayer* player, int position, int oldPosition );
virtual void OnPlayerExited( idPlayer* player, int position );
const sdDeclGUI* GetOverlayGUI( void ) const { return overlayGUI; }
void ClearDriveObjects( void );
void AddDriveObject( sdVehicleDriveObject* part );
bool IsTeleporting( void ) const { return teleportEntity.IsValid(); }
bool IsAmphibious( void ) const { return vehicleFlags.amphibious; }
bool IsLocked( void ) const { return vehicleFlags.locked; }
bool IsFlipped( void );
void AutoRight( idPlayer* other );
void SelectWeapon( idPlayer* player, int index );
void UpdateEngine( bool disabled );
void RunObjectPrePhysics( void );
void RunObjectPostPhysics( void );
virtual void UpdateVisibility( void );
virtual void OnUpdateVisuals( void );
virtual void SetDefaultMode( sdVehiclePosition& position, idPlayer* other );
void LoadVehicleScript( void );
virtual void DoLoadVehicleScript( void ) = 0;
void ParseVehicleScript( void );
virtual void FreezePhysics( bool freeze ) = 0;
virtual void SetLastAttacker( idEntity *attacker, const sdDeclDamage* damage ) { lastAttacker = attacker; lastDamage = damage; }
idEntity* GetLastAttacker( void ) const { return lastAttacker; }
const sdDeclDamage* GetLastDamage( void ) const { return lastDamage; }
idPlayer* GetLastOccupant( void ) const { return lastOccupant; }
const sdDeclDamage* GetKillPlayerDamage( void ) const { return killPlayerDamage; }
void PrevWeapon( idPlayer* player );
void NextWeapon( idPlayer* player );
sdVehicleWeapon* GetActiveWeapon( idPlayer* player );
virtual void ApplyNetworkState( networkStateMode_t mode, const sdEntityStateNetworkData& newState );
virtual void ReadNetworkState( networkStateMode_t mode, const sdEntityStateNetworkData& baseState, sdEntityStateNetworkData& newState, const idBitMsg& msg ) const;
virtual void WriteNetworkState( networkStateMode_t mode, const sdEntityStateNetworkData& baseState, sdEntityStateNetworkData& newState, idBitMsg& msg ) const;
virtual bool CheckNetworkStateChanges( networkStateMode_t mode, const sdEntityStateNetworkData& baseState ) const;
virtual sdEntityStateNetworkData* CreateNetworkStructure( networkStateMode_t mode ) const;
virtual sdTransportNetworkData* CreateTransportNetworkStructure( void ) const;
virtual void ResetNetworkState( networkStateMode_t mode, const sdEntityStateNetworkData& newState );
virtual void WriteInitialReliableMessages( const sdReliableMessageClientInfoBase& target ) const;
void SendFullPartStates( const sdReliableMessageClientInfoBase& target ) const;
virtual void UpdateHud( idPlayer* player, guiHandle_t handle );
virtual void UpdateViewAngles( idPlayer* player );
virtual void ClampViewAngles( idPlayer* player, const idAngles& oldAngles );
virtual idIK* GetIK( void ) { return NULL; }
virtual void LoadParts( int partTypes ) = 0;
virtual bool DoRadiusPush( void ) const { return !vehicleFlags.disableKnockback; }
virtual bool WantsToThink( void );
virtual void Think( void );
virtual void PostThink( void );
virtual idLinkList<idEntity>* GetPostThinkNode( void );
void Spawn( void );
virtual void PostMapSpawn( void );
// jrad - fill a list with sdEffects specific to each type of surfacetype
// effectname should be of the form "fx_prefix_<surfacetypename>"
void InitEffectList( vehicleEffectList_t& list, const char* effectName, int& numSurfaceTypes );
virtual void CheckWater( const idVec3& waterBodyOrg, const idMat3& waterBodyAxis, idCollisionModel* waterBodyModel );
void SetupCockpit( idPlayer* viewPlayer );
static bool CheckVisibility( renderEntity_t* renderEntity, const renderView_t* renderView );
static void ReloadVehicleScripts( idDecl* decl );
vehicleDriveObjectList_t& GetDriveObjects( void ) { return driveObjects; }
const vehicleDriveObjectList_t& GetDriveObjects( void ) const { return driveObjects; }
sdVehicleDriveObject* GetDriveObject( const char* objectName ) const;
void DisableWheelSuspension( bool disable );
sdVehicleDriveObject* PartForCollisionByPosition( const trace_t& collision, int flags ) const;
sdVehicleDriveObject* PartForCollisionById( const trace_t& collision, int flags ) const;
sdVehicleDriveObject* PartForCollision( const trace_t& collision, int flags ) const;
int Repair( int repair );
virtual bool NeedsRepair();
void SelfDestruct( void );
const sdVehicleControlBase* GetVehicleControl( void ) const { return vehicleControl; }
sdVehicleControlBase* GetVehicleControl( void ) { return vehicleControl; }
bool IsModelDisabled( void ) { return vehicleFlags.modelDisabled; }
bool CycleAllPositions( void ) { return vehicleFlags.cycleAllPositions; }
void DisableModel( bool hide );
virtual int EvaluateContacts( contactInfo_t* list, contactInfoExt_t* extList, int max );
virtual int AddCustomConstraints( constraintInfo_t* list, int max );
int PrevWeaponIndex( idPlayer* player, int index );
int NextWeaponIndex( idPlayer* player, int index );
sdVehicleWeapon* GetWeapon( const char* name );
sdVehicleWeapon* GetWeapon( int index ) { return weapons[ index ]; }
int GetWeaponIndex( const char* name );
void AddWeapon( sdVehicleWeapon* weapon ) { weapons.Append( weapon ); }
int NumWeapons( void ) const { return weapons.Num(); }
void SortWeapons( void );
sdVehicleView& GetViewForPlayer( const idPlayer* player );
void UpdateViews( sdVehicleWeapon* weapon );
const idMaterial* GetAttitudeMaterial( void ) const { return attitudeMaterial; }
const sdDeclVehicleScript* GetVehicleScript() const { return vehicleScript; }
const sdTransportEngine& GetEngine() const { return engine; }
const sdVehicleInput& GetInput( void ) const { return input; }
float GetSteerVisualAngle( void ) const { return steerVisualAngle; }
void SetSteerVisualAngle( float angle ) { steerVisualAngle = angle; }
virtual sdUsableInterface* GetUsableInterface( void ) { return &usableInterface; }
virtual sdInteractiveInterface* GetInteractiveInterface( void ) { return &usableInterface; }
virtual void UpdateModelTransform( void );
void UpdatePlayZoneInfo( void );
void UpdateDecay( void );
void SetInteriorSound( idPlayer* player );
virtual bool ShowFirstPersonPlayer() { return false; }
virtual bool UnbindOnEject() { return true; }
virtual bool GetAllowPlayerMove( idPlayer* player ) const { return true; }
void CheckFlipped( void );
bool InDeathThroes() const { return vehicleFlags.deathThroes; }
void SetDeathThroes( bool enabled );
bool IsCareening() const { return careenStartTime > 0; }
int GetCareeningTime() const { return gameLocal.time - careenStartTime; }
void SetCareening( int startTime );
void RemoveActiveDriveObject( sdVehicleDriveObject* object );
void AddActiveDriveObject( sdVehicleDriveObject* object );
void SetLightsEnabled( int group, bool enabled );
virtual void SetDamageDealtScale( float scale ) {}
virtual cheapDecalUsage_t GetDecalUsage( void );
virtual void SetTeleportEntity( sdTeleporter* teleporter );
sdTeleporter* GetTeleportEntity( void ) { return teleportEntity; }
virtual int PlayHitBeep( idPlayer* player, bool headshot ) const;
virtual bool OnKeyMove( char forward, char right, char up, usercmd_t& cmd );
virtual void OnControllerMove( bool doGameCallback, const int numControllers, const int* controllerNumbers,
const float** controllerAxis, idVec3& viewAngles, usercmd_t& cmd );
void SetMasterDestroyedPart( rvClientMoveable* part );
rvClientMoveable* GetMasterDestroyedPart( void );
bool IsInPlayzone( void ) const { return vehicleFlags.inPlayZone; }
void SetRouteWarning( bool value );
void SetRouteMaskWarning( bool value );
virtual float GetDamageXPScale( void ) const { return damageXPScale; }
bool AreTracksOnGround( void ) const;
float AreWheelsOnGround( void ) const;
protected:
virtual bool OnApplyPain( idEntity *inflictor, idEntity *attacker, int damage, const idVec3 &dir, int location, const sdDeclDamage* damageDecl );
virtual void BindPlayerToPosition( idPlayer *other, sdVehiclePosition &position );
void SendPartState( sdVehicleDriveObject* object ) const;
void UpdateWaterDamage();
void UpdateLockAlarm();
virtual void UpdateScrapeEffects( void ) {}
void UpdateShaderParms( void );
sdTransportPositionManager positionManager;
vehicleDriveObjectList_t driveObjects;
vehicleDriveObjectList_t activeObjects;
vehicleDriveObjectList_t physicsObjects;
vehicleDriveObjectList_t networkObjects;
int lastEnteredTime;
int lastOccupiedTime;
idEntityPtr< idPlayer > lastOccupant;
int decayTime;
int decayDistance;
float steerVisualAngle;
float lastSpeed;
sdBindContext* bindContext;
idEntityPtr< sdTeleporter > teleportEntity;
int nextTeleportTime;
const sdDeclSurfaceType* surfaceType;
int nextFlippedDamageTime;
int flippedTime;
int lastMovedTime;
const sdDeclVehicleScript* vehicleScript;
const sdDeclDamage* killPlayerDamage;
const sdDeclDamage* flippedDamage;
float damageXPScale;
sdVehicleInput input;
const sdProgram::sdFunction* weaponSelectedFunction;
const sdProgram::sdFunction* surfaceTypeChangedFunction;
const sdDeclGUI* overlayGUI;
struct vehicleFlags_t {
bool modelDisabled : 1;
bool locked : 1;
bool timeoutEnabled : 1;
bool tryKeepDriver : 1;
bool decaying : 1;
bool disableKnockback : 1;
bool showedDecayTooltip : 1;
bool deathThroes : 1;
bool inPlayZone : 1;
bool lastDamageDirValid : 1;
bool lockAlarmActive : 1;
bool cycleAllPositions : 1;
bool routeWarning : 1;
bool routeWarningTimeout : 1;
bool disablePartStateUpdate : 1;
bool weaponDisabled : 1;
// these are more like type-specific data, but this is a handy location to store them
bool amphibious : 1;
bool decals : 1;
};
vehicleFlags_t vehicleFlags;
const sdDeclToolTip* toolTipEnter;
const sdDeclToolTip* toolTipAbandon;
const idMaterial* attitudeMaterial;
playerVehicleTypes_t playerVehicleType;
playerTeamTypes_t playerVehicleTeam;
int playerVehicleFlags;
sdTransportEngine engine;
sdVehicleLightSystem lights;
sdTransportUsableInterface usableInterface;
sdVehicleControlBase* vehicleControl;
sdVehicleSoundControlBase* vehicleSoundControl;
idStaticList< sdVehicleWeapon*, MAX_VEHICLE_WEAPONS > weapons;
idLinkList< idEntity > postThinkEntNode;
idEntityPtr< idEntity > lastAttacker;
const sdDeclDamage* lastDamage;
idVec3 lastDamageDir;
const sdProgram::sdFunction* updateHudFunc;
const sdProgram::sdFunction* enemyLockedOnUsFunc;
const sdProgram::sdFunction* isDeployedFunc;
int routeActionNumber;
sdWaterEffects* waterEffects;
int lastRepairedPart;
int empTime;
int weaponEmpTime;
int submergeTime;
int lastWaterDamageTime;
const sdDeclDamage* waterDamageDecl;
int lockAlarmTime;
int careenStartTime;
int routeMaskWarningEndTime;
sdRouteConstraintTracker routeTracker;
rvClientEntityPtr< rvClientMoveable > masterDestroyedPart;
int damagedCriticalDriveParts;
int routeKickDistance;
};
class sdTransport_AF : public sdTransport {
public:
ABSTRACT_PROTOTYPE( sdTransport_AF );
sdTransport_AF( void );
virtual ~sdTransport_AF( void );
idPhysics_AF* GetAFPhysics( void ) { return af.GetPhysics(); }
const idPhysics_AF* GetAFPhysics( void ) const { return af.GetPhysics(); }
virtual bool UpdateAnimationControllers( void );
virtual int BodyId( idAFBody* body ) const { return af.GetPhysics()->GetBodyId( body ); }
virtual idAFBody* BodyForName( const char* name ) const { return af.GetPhysics()->GetBody( name ); }
virtual idAFBody* BodyForId( int id ) const { return af.GetPhysics()->GetBody( id ); }
virtual int BodyForClipModelId( int id ) const { return af.BodyForClipModelId( id ); }
virtual const idVec3& GetCenterOfMass( void ) const { return af.GetPhysics()->GetCenterOfMass(); }
virtual void DisableClip( bool activateContacting = true );
virtual void EnableClip( void );
virtual void LoadParts( int partTypes );
protected:
idAF af;
};
class sdTransport_RB : public sdTransport {
public:
ABSTRACT_PROTOTYPE( sdTransport_RB );
sdTransport_RB( void );
virtual ~sdTransport_RB( void );
void Spawn( void );
sdPhysics_RigidBodyMultiple* GetRBPhysics( void ) { return &physicsObj; }
const sdPhysics_RigidBodyMultiple* GetRBPhysics( void ) const { return &physicsObj; }
virtual const idVec3& GetCenterOfMass( void ) const { return physicsObj.GetMainCenterOfMass(); }
virtual void DisableClip( bool activateContacting = true );
virtual void EnableClip( void );
virtual void LoadParts( int partTypes );
protected:
virtual void UpdateScrapeEffects( void );
sdPhysics_RigidBodyMultiple physicsObj;
float lightScrapeSpeed;
float mediumScrapeSpeed;
float heavyScrapeSpeed;
vehicleEffectList_t lightScrapeEffects;
vehicleEffectList_t mediumScrapeEffects;
vehicleEffectList_t heavyScrapeEffects;
idLinkList< sdEffect > activeEffects;
};
#endif // __GAME
Reference in a new issue Copy permalink