mirror of https://github.com/PrimeDecomp/prime.git
573 lines
21 KiB
C++
573 lines
21 KiB
C++
#ifndef _CPLAYER
|
|
#define _CPLAYER
|
|
|
|
#include "rstl/reserved_vector.hpp"
|
|
#include "types.h"
|
|
|
|
#include "MetroidPrime/CAnimRes.hpp"
|
|
#include "MetroidPrime/CPhysicsActor.hpp"
|
|
#include "MetroidPrime/Player/CPlayerEnergyDrain.hpp"
|
|
#include "MetroidPrime/Player/CPlayerState.hpp"
|
|
|
|
#include "Kyoto/TReservedAverage.hpp"
|
|
#include "Kyoto/Math/CRelAngle.hpp"
|
|
|
|
#include "rstl/auto_ptr.hpp"
|
|
#include "rstl/vector.hpp"
|
|
|
|
class CPlayerGun;
|
|
class CMorphBall;
|
|
class CPlayerCameraBob;
|
|
|
|
namespace NPlayer {
|
|
enum EPlayerMovementState {
|
|
kMS_OnGround,
|
|
kMS_Jump,
|
|
kMS_ApplyJump,
|
|
kMS_Falling,
|
|
kMS_FallingMorphed,
|
|
};
|
|
};
|
|
|
|
class CPlayer : public CPhysicsActor, public TOneStatic< CPlayer > {
|
|
struct CVisorSteam {
|
|
float x0_curTargetAlpha;
|
|
float x4_curAlphaInDur;
|
|
float x8_curAlphaOutDur;
|
|
CAssetId xc_tex;
|
|
float x10_nextTargetAlpha;
|
|
float x14_nextAlphaInDur;
|
|
float x18_nextAlphaOutDur;
|
|
CAssetId x1c_txtr;
|
|
float x20_alpha;
|
|
float x24_delayTimer;
|
|
bool x28_affectsThermal;
|
|
|
|
public:
|
|
CVisorSteam();
|
|
CVisorSteam(float targetAlpha, float alphaInDur, float alphaOutDur, CAssetId tex);
|
|
// : x0_curTargetAlpha(targetAlpha)
|
|
// , x4_curAlphaInDur(alphaInDur)
|
|
// , x8_curAlphaOutDur(alphaOutDur)
|
|
// , xc_tex(tex) {}
|
|
CAssetId GetTextureId() const { return xc_tex; }
|
|
void SetSteam(float targetAlpha, float alphaInDur, float alphaOutDur, CAssetId txtr,
|
|
bool affectsThermal);
|
|
void Update(float dt);
|
|
float GetAlpha() const { return x20_alpha; }
|
|
bool AffectsThermal() const { return x28_affectsThermal; }
|
|
};
|
|
|
|
class CPlayerStuckTracker {
|
|
public:
|
|
enum EPlayerState {
|
|
kPS_Jump,
|
|
kPS_StartingJump,
|
|
kPS_Moving,
|
|
};
|
|
|
|
CPlayerStuckTracker();
|
|
void AddState(EPlayerState, const CVector3f&, const CVector3f&, const CVector2f&);
|
|
bool IsPlayerStuck();
|
|
void ResetStats();
|
|
|
|
private:
|
|
rstl::reserved_vector< EPlayerState, 20 > x0_;
|
|
rstl::reserved_vector< CVector3f, 20 > x54_;
|
|
rstl::reserved_vector< CVector3f, 20 > x148_;
|
|
rstl::reserved_vector< CVector2f, 20 > x23c_;
|
|
};
|
|
|
|
public:
|
|
enum EPlayerOrbitState {
|
|
kOS_NoOrbit,
|
|
kOS_OrbitObject,
|
|
kOS_OrbitPoint,
|
|
kOS_OrbitCarcass,
|
|
kOS_ForcedOrbitObject, // For CMetroidBeta attack
|
|
kOS_Grapple,
|
|
};
|
|
enum ESurfaceRestraints {
|
|
kSR_Normal,
|
|
kSR_Air,
|
|
kSR_Ice,
|
|
kSR_Organic,
|
|
kSR_Water,
|
|
kSR_Lava,
|
|
kSR_Phazon,
|
|
kSR_Shrubbery,
|
|
};
|
|
enum EPlayerCameraState {
|
|
kCS_FirstPerson,
|
|
kCS_Ball,
|
|
kCS_Two,
|
|
kCS_Transitioning,
|
|
kCS_Spawned,
|
|
};
|
|
enum EPlayerMorphBallState {
|
|
kMS_Unmorphed,
|
|
kMS_Morphed,
|
|
kMS_Morphing,
|
|
kMS_Unmorphing,
|
|
};
|
|
enum EPlayerOrbitType {
|
|
kOT_Close,
|
|
kOT_Far,
|
|
kOT_Default,
|
|
};
|
|
enum EPlayerZoneInfo {
|
|
kZI_Targeting,
|
|
kZI_Scan,
|
|
};
|
|
enum EPlayerZoneType {
|
|
kZT_Always = -1,
|
|
kZT_Box,
|
|
kZT_Ellipse,
|
|
};
|
|
enum EPlayerScanState {
|
|
kSS_NotScanning,
|
|
kSS_Scanning,
|
|
kSS_ScanComplete,
|
|
};
|
|
enum EGrappleState {
|
|
kGS_None,
|
|
kGS_Firing,
|
|
kGS_Pull,
|
|
kGS_Swinging,
|
|
kGS_JumpOff,
|
|
};
|
|
enum EFootstepSfx {
|
|
kFS_None,
|
|
kFS_Left,
|
|
kFS_Right,
|
|
};
|
|
enum EGunHolsterState {
|
|
kGH_Holstered,
|
|
kGH_Drawing,
|
|
kGH_Drawn,
|
|
kGH_Holstering,
|
|
};
|
|
enum EOrbitBrokenType {
|
|
kOB_StopOrbit,
|
|
kOB_Respawn,
|
|
kOB_EnterMorphBall,
|
|
kOB_Default,
|
|
kOB_Four,
|
|
kOB_Five,
|
|
kOB_InvalidateTarget,
|
|
kOB_BadVerticalAngle,
|
|
kOB_ActivateOrbitSource,
|
|
kOB_ProjectileCollide,
|
|
kOB_Freeze,
|
|
kOB_DamageOnGrapple,
|
|
kOB_LostGrappleLineOfSight,
|
|
};
|
|
|
|
CPlayer(TUniqueId uid, const CTransform4f& xf, const CAABox& aabb, CAssetId resId,
|
|
const CVector3f& playerScale, float mass, float stepUp, float stepDown, float ballRadius,
|
|
const CMaterialList& ml);
|
|
|
|
// CEntity
|
|
~CPlayer() override;
|
|
void Accept(IVisitor& visitor) override;
|
|
void PreThink(float dt, CStateManager& mgr) override;
|
|
void Think(float dt, CStateManager& mgr) override;
|
|
void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId uid, CStateManager& mgr) override;
|
|
|
|
// CActor
|
|
void PreRender(CStateManager&, const CFrustumPlanes&) override;
|
|
void AddToRenderer(const CFrustumPlanes&, const CStateManager&) const override;
|
|
void Render(const CStateManager&) const override;
|
|
bool CanRenderUnsorted(const CStateManager&) const override;
|
|
void CalculateRenderBounds() override;
|
|
CHealthInfo* HealthInfo(CStateManager&) override;
|
|
const CDamageVulnerability* GetDamageVulnerability() const override;
|
|
const CDamageVulnerability* GetDamageVulnerability(const CVector3f&, const CVector3f&,
|
|
const CDamageInfo&) const override;
|
|
rstl::optional_object< CAABox > GetTouchBounds() const override;
|
|
void Touch(CActor&, CStateManager&) override;
|
|
CVector3f GetAimPosition(const CStateManager&, float) const override;
|
|
CVector3f GetHomingPosition(const CStateManager&, float) const override;
|
|
void FluidFXThink(EFluidState, CScriptWater&, CStateManager&) override;
|
|
|
|
// CPhysicsActor
|
|
const CCollisionPrimitive* GetCollisionPrimitive() const override;
|
|
CTransform4f GetPrimitiveTransform() const override;
|
|
void CollidedWith(const TUniqueId& id, const CCollisionInfoList& list,
|
|
CStateManager& mgr) override;
|
|
float GetStepDownHeight() const override;
|
|
float GetStepUpHeight() const override;
|
|
float GetWeight() const override;
|
|
|
|
// CPlayer
|
|
virtual bool IsTransparent();
|
|
|
|
CVector3f GetBallPosition() const;
|
|
CVector3f GetEyePosition() const;
|
|
float GetEyeHeight() const;
|
|
CTransform4f CreateTransformFromMovementDirection() const;
|
|
EPlayerOrbitState GetOrbitState() const { return x304_orbitState; }
|
|
const CVector3f& GetMovementDirection() const { return x50c_moveDir; }
|
|
EPlayerMorphBallState GetMorphballTransitionState() const { return x2f8_morphBallState; }
|
|
|
|
static float skDefaultHudFadeOutSpeed;
|
|
static float skDefaultHudFadeInSpeed;
|
|
void SetHudDisable(float staticTimer, float outSpeed = skDefaultHudFadeOutSpeed,
|
|
float inSpeed = skDefaultHudFadeInSpeed);
|
|
|
|
void IncrementPhazon();
|
|
void DecrementPhazon();
|
|
// GetMovementDirection2D__7CPlayerCFv ??
|
|
void SetOrbitTargetId(TUniqueId id, CStateManager& mgr);
|
|
void TryToBreakOrbit(TUniqueId id, EOrbitBrokenType type, CStateManager& mgr);
|
|
void BreakOrbit(EOrbitBrokenType type, CStateManager& mgr);
|
|
void BreakGrapple(EOrbitBrokenType type, CStateManager& mgr);
|
|
void AddOrbitDisableSource(CStateManager& mgr, TUniqueId addId);
|
|
void RemoveOrbitDisableSource(TUniqueId uid);
|
|
void SetAimTargetId(TUniqueId target);
|
|
void DoSfxEffects(CSfxHandle sfx);
|
|
bool GetFrozenState() const;
|
|
void SetFrozenState(CStateManager& stateMgr, CAssetId steamTxtr, ushort sfx, CAssetId iceTxtr);
|
|
void BreakFrozenState(CStateManager& mgr);
|
|
void UpdateCinematicState(CStateManager& mgr);
|
|
bool IsMorphBallTransitioning() const;
|
|
void InitialiseAnimation();
|
|
void LoadAnimationTokens();
|
|
void HolsterGun(CStateManager& mgr);
|
|
void ResetGun(CStateManager& mgr);
|
|
void DrawGun(CStateManager& mgr);
|
|
bool CheckPostGrapple() const;
|
|
void UpdateGunState(const CFinalInput& input, CStateManager& mgr);
|
|
void UpdateAimTargetPrediction(const CTransform4f& xf, CStateManager& mgr);
|
|
void UpdateAssistedAiming(const CTransform4f& xf, CStateManager& mgr);
|
|
void UpdateGunTransform(const CVector3f& gunPos, CStateManager& mgr);
|
|
const CTransform4f& GetFirstPersonCameraTransform(CStateManager& mgr) const;
|
|
void UpdateDebugCamera(CStateManager& mgr);
|
|
void UpdateArmAndGunTransforms(float dt, CStateManager& mgr);
|
|
void UpdateGrappleArmTransform(const CVector3f& offset, CStateManager& mgr, float dt);
|
|
void ForceGunOrientation(const CTransform4f& xf, CStateManager& mgr);
|
|
void Update(float dt, CStateManager& mgr);
|
|
void UpdateMorphBallTransition(float dt, CStateManager& mgr);
|
|
void UpdateAimTarget(CStateManager& mgr);
|
|
void UpdateAimTargetTimer(float dt);
|
|
void UpdateOrbitModeTimer(float dt);
|
|
void UpdateOrbitPreventionTimer(float dt);
|
|
void UpdateGunAlpha();
|
|
void UpdateVisorTransition(float dt, CStateManager& mgr);
|
|
void UpdatePlayerSounds(float dt);
|
|
bool ShouldSampleFailsafe(CStateManager& mgr) const;
|
|
bool IsEnergyLow(CStateManager& mgr);
|
|
bool StartSamusVoiceSfx(ushort sfx, short vol, int prio);
|
|
void UpdateVisorState(const CFinalInput& input, float dt, CStateManager& mgr);
|
|
void UpdateCrosshairsState(const CFinalInput& input);
|
|
ushort GetMaterialSoundUnderPlayer(CStateManager& mgr, const ushort* table, int length,
|
|
ushort defId);
|
|
void UpdateFootstepSounds(const CFinalInput& input, CStateManager& mgr, float dt);
|
|
float JumpInput(const CFinalInput& input, CStateManager& mgr);
|
|
float TurnInput(const CFinalInput& input) const;
|
|
float StrafeInput(const CFinalInput& input) const;
|
|
float ForwardInput(const CFinalInput& input, float turnInput) const;
|
|
float GetActualFirstPersonMaxVelocity(float dt) const;
|
|
const CScriptWater* GetVisorRunoffEffect(const CStateManager& mgr) const;
|
|
void SetMorphBallState(EPlayerMorphBallState state, CStateManager& mgr);
|
|
bool CanEnterMorphBallState(CStateManager& mgr, float dt) const;
|
|
bool CanLeaveMorphBallState(CStateManager& mgr, CVector3f& pos) const;
|
|
void LeaveMorphBallState(CStateManager& mgr);
|
|
void EnterMorphBallState(CStateManager& mgr);
|
|
void ResetBallCamera(CStateManager& mgr);
|
|
void UpdateCameraState(CStateManager& mgr);
|
|
void UpdateFreeLookState(const CFinalInput& input, float dt, CStateManager& mgr);
|
|
void UpdateCameraTimers(float dt, const CFinalInput& input);
|
|
void UpdateSubmerged(const CStateManager& mgr);
|
|
bool CheckSubmerged();
|
|
void SetMoveState(NPlayer::EPlayerMovementState state, CStateManager& mgr);
|
|
void StartLandingControlFreeze(); // name?
|
|
void EndLandingControlFreeze(); // name?
|
|
void AdjustEyeOffset(CStateManager& mgr);
|
|
void SetEyeOffset(float bias);
|
|
float GetEyeOffset() const { return x9c8_eyeZBias; }
|
|
void UpdateStepUpSmoothing(float dt);
|
|
void UpdateEnvironmentDamageCameraShake(float dt, CStateManager& mgr);
|
|
void UpdatePhazonDamage(float dt, CStateManager& mgr);
|
|
void UpdateFreeLook(float dt);
|
|
void UpdatePlayerHints(CStateManager& mgr);
|
|
void UpdateBombJumpStuff();
|
|
void UpdateTransitionFilter(float dt, CStateManager& mgr);
|
|
void CalculatePlayerMovementDirection(float dt);
|
|
void UpdatePlayerControlDirection(float dt, CStateManager& mgr);
|
|
void UpdateFrozenState(const CFinalInput& input, CStateManager& mgr);
|
|
void UpdateControlLostState(float dt, CStateManager& mgr);
|
|
void ComputeMovement(const CFinalInput& input, CStateManager& mgr, float dt);
|
|
void ProcessInput(const CFinalInput& input, CStateManager& mgr);
|
|
void UpdateScanningState(const CFinalInput& input, CStateManager& mgr, float dt);
|
|
bool IsUnderBetaMetroidAttack(CStateManager& mgr) const;
|
|
void UpdateGrappleState(const CFinalInput& input, CStateManager& mgr);
|
|
void ApplyGrappleForces(const CFinalInput& input, CStateManager& mgr, float dt);
|
|
void ComputeFreeLook(const CFinalInput& input);
|
|
void UpdateOrbitInput(const CFinalInput& input, CStateManager& mgr);
|
|
void UpdateOrbitZone(CStateManager& mgr);
|
|
void UpdateMorphBallState(float dt, const CFinalInput& input, CStateManager& mgr);
|
|
void CalculateLeaveMorphBallDirection(const CFinalInput& input);
|
|
void TransitionToMorphBallState(float dt, CStateManager& mgr);
|
|
void TransitionFromMorphBallState(float dt, CStateManager& mgr);
|
|
float GetMaximumPlayerPositiveVerticalVelocity(const CStateManager& mgr) const;
|
|
CVector3f CalculateLeftStickEdgePosition(float strafeInput, float forwardInput) const;
|
|
bool AttachActorToPlayer(TUniqueId id, bool disableGun);
|
|
void DetachActorFromPlayer();
|
|
|
|
CPlayerGun* PlayerGun() { return x490_gun.get(); }
|
|
const CPlayerGun* GetPlayerGun() const { return x490_gun.get(); }
|
|
|
|
CMorphBall* MorphBall() { return x768_morphball.get(); }
|
|
const CMorphBall* GetMorphBall() const { return x768_morphball.get(); }
|
|
|
|
float GetStaticTimer() const { return x740_staticTimer; }
|
|
|
|
ESurfaceRestraints GetCurrentSurfaceRestraint() const { return x2ac_surfaceRestraint; }
|
|
ESurfaceRestraints GetSurfaceRestraint() const {
|
|
return x2b0_outOfWaterTicks == 2 ? GetCurrentSurfaceRestraint() : kSR_Water;
|
|
}
|
|
|
|
TUniqueId GetOrbitTargetId() const { return x310_orbitTargetId; }
|
|
const CVector3f& GetOrbitPoint() const { return x314_orbitPoint; }
|
|
TUniqueId GetOrbitNextTargetId() const { return x33c_orbitNextTargetId; }
|
|
TUniqueId GetScanningObjectId() const { return x3b4_scanningObject; }
|
|
EGrappleState GetGrappleState() const { return x3b8_grappleState; }
|
|
bool IsInFreeLook() const { return x3dc_inFreeLook; }
|
|
bool GetFreeLookStickState() const { return x3de_lookAnalogHeld; }
|
|
TUniqueId GetAimTargetId() const { return x3f4_aimTarget; }
|
|
EPlayerCameraState GetCameraState() const { return x2f4_cameraState; }
|
|
void SetCameraState(EPlayerCameraState state, CStateManager& mgr);
|
|
EGunHolsterState GetGunHolsterState() const { return x498_gunHolsterState; }
|
|
NPlayer::EPlayerMovementState GetPlayerMovementState() const { return x258_movementState; }
|
|
const CVector3f& GetAssistedTargetAim() const { return x480_assistedTargetAim; }
|
|
// CPlayer::GetFlipSpiderBallControlY() const weak
|
|
// CPlayer::GetFlipSpiderBallControlX() const weak
|
|
|
|
bool IsInsideFluid() const { return x9c4_31_inWaterMovement; }
|
|
|
|
void Teleport(const CTransform4f& xf, CStateManager& mgr, bool resetBallCam);
|
|
void SetSpawnedMorphBallState(EPlayerMorphBallState state, CStateManager& mgr);
|
|
const CVisorSteam& GetVisorSteam() const { return x7a0_visorSteam; }
|
|
void SetVisorSteam(float targetAlpha, float alphaInDur, float alphaOutDir, CAssetId txtr,
|
|
bool affectsThermal);
|
|
|
|
CVector3f GetDampedClampedVelocityWR() const;
|
|
float GetAverageSpeed() const;
|
|
float GetGravity() const;
|
|
|
|
float GetAttachedActorStruggle() const { return xa28_attachedActorStruggle; }
|
|
void SetAttachedActorStruggle(float struggle) { xa28_attachedActorStruggle = struggle; }
|
|
|
|
// PlayerHint
|
|
// bool SetAreaPlayerHint(const CScriptPlayerHint& hint, CStateManager& mgr);
|
|
void AddToPlayerHintRemoveList(TUniqueId id, CStateManager& mgr);
|
|
void AddToPlayerHintAddList(TUniqueId id, CStateManager& mgr);
|
|
// void DeactivatePlayerHint(TUniqueId id, CStateManager& mgr);
|
|
// void UpdatePlayerHints(CStateManager& mgr);
|
|
|
|
static int SfxIdFromMaterial(const CMaterialList& mat, const ushort* idList, int tableLen,
|
|
ushort defId);
|
|
|
|
private:
|
|
NPlayer::EPlayerMovementState x258_movementState;
|
|
rstl::vector< CToken > x25c_ballTransitionsRes;
|
|
TUniqueId x26c_attachedActor;
|
|
float x270_attachedActorTime;
|
|
CPlayerEnergyDrain x274_energyDrain;
|
|
float x288_startingJumpTimeout;
|
|
float x28c_sjTimer;
|
|
float x290_minJumpTimeout;
|
|
float x294_jumpCameraTimer;
|
|
int x298_jumpPresses;
|
|
float x29c_fallCameraTimer;
|
|
float x2a0_;
|
|
bool x2a4_cancelCameraPitch;
|
|
float x2a8_timeSinceJump;
|
|
ESurfaceRestraints x2ac_surfaceRestraint;
|
|
int x2b0_outOfWaterTicks;
|
|
rstl::reserved_vector< float, 6 > x2b4_accelerationTable;
|
|
uint x2d0_curAcceleration;
|
|
float x2d4_accelerationChangeTimer;
|
|
CAABox x2d8_fpBounds;
|
|
float x2f0_ballTransHeight;
|
|
EPlayerCameraState x2f4_cameraState;
|
|
EPlayerMorphBallState x2f8_morphBallState;
|
|
EPlayerMorphBallState x2fc_spawnedMorphBallState;
|
|
float x300_fallingTime;
|
|
EPlayerOrbitState x304_orbitState;
|
|
EPlayerOrbitType x308_orbitType;
|
|
EOrbitBrokenType x30c_orbitBrokenType;
|
|
TUniqueId x310_orbitTargetId;
|
|
CVector3f x314_orbitPoint;
|
|
CVector3f x320_orbitVector;
|
|
float x32c_orbitModeTimer;
|
|
EPlayerZoneInfo x330_orbitZoneMode;
|
|
EPlayerZoneType x334_orbitType;
|
|
uint x338_;
|
|
TUniqueId x33c_orbitNextTargetId;
|
|
bool m_deferredOrbitObject;
|
|
float x340_;
|
|
rstl::vector< TUniqueId > x344_nearbyOrbitObjects;
|
|
rstl::vector< TUniqueId > x354_onScreenOrbitObjects;
|
|
rstl::vector< TUniqueId > x364_offScreenOrbitObjects;
|
|
bool x374_orbitLockEstablished;
|
|
float x378_orbitPreventionTimer;
|
|
bool x37c_sidewaysDashing;
|
|
float x380_strafeInputAtDash;
|
|
float x384_dashTimer;
|
|
float x388_dashButtonHoldTime;
|
|
bool x38c_doneSidewaysDashing;
|
|
uint x390_orbitSource;
|
|
bool x394_orbitingEnemy;
|
|
float x398_dashSpeedMultiplier;
|
|
bool x39c_noStrafeDashBlend;
|
|
float x3a0_dashDuration;
|
|
float x3a4_strafeDashBlendDuration;
|
|
EPlayerScanState x3a8_scanState;
|
|
float x3ac_scanningTime;
|
|
float x3b0_curScanTime;
|
|
TUniqueId x3b4_scanningObject;
|
|
EGrappleState x3b8_grappleState;
|
|
float x3bc_grappleSwingTimer;
|
|
CVector3f x3c0_grappleSwingAxis;
|
|
float x3cc_;
|
|
float x3d0_;
|
|
float x3d4_;
|
|
float x3d8_grappleJumpTimeout;
|
|
bool x3dc_inFreeLook;
|
|
bool x3dd_lookButtonHeld;
|
|
bool x3de_lookAnalogHeld;
|
|
float x3e0_curFreeLookCenteredTime;
|
|
float x3e4_freeLookYawAngle;
|
|
float x3e8_horizFreeLookAngleVel;
|
|
float x3ec_freeLookPitchAngle;
|
|
float x3f0_vertFreeLookAngleVel;
|
|
TUniqueId x3f4_aimTarget;
|
|
CVector3f x3f8_targetAimPosition;
|
|
TReservedAverage< CVector3f, 10 > x404_aimTargetAverage;
|
|
CVector3f x480_assistedTargetAim;
|
|
float x48c_aimTargetTimer;
|
|
rstl::single_ptr< CPlayerGun > x490_gun;
|
|
float x494_gunAlpha;
|
|
EGunHolsterState x498_gunHolsterState;
|
|
float x49c_gunHolsterRemTime;
|
|
rstl::single_ptr< CPlayerStuckTracker > x4a0_playerStuckTracker;
|
|
TReservedAverage< float, 20 > x4a4_moveSpeedAvg;
|
|
float x4f8_moveSpeed;
|
|
float x4fc_flatMoveSpeed;
|
|
CVector3f x500_lookDir;
|
|
CVector3f x50c_moveDir;
|
|
CVector3f x518_leaveMorphDir;
|
|
CVector3f x524_lastPosForDirCalc;
|
|
CVector3f x530_gunDir;
|
|
float x53c_timeMoving;
|
|
CVector3f x540_controlDir;
|
|
CVector3f x54c_controlDirFlat;
|
|
bool x558_wasDamaged;
|
|
float x55c_damageAmt;
|
|
float x560_prevDamageAmt;
|
|
CVector3f x564_damageLocation;
|
|
float x570_immuneTimer;
|
|
float x574_morphTime;
|
|
float x578_morphDuration;
|
|
uint x57c_;
|
|
uint x580_;
|
|
int x584_ballTransitionAnim;
|
|
float x588_alpha;
|
|
float x58c_transitionVel;
|
|
bool x590_leaveMorphballAllowed;
|
|
TReservedAverage< CTransform4f, 4 > x594_transisionBeamXfs;
|
|
TReservedAverage< CTransform4f, 4 > x658_transitionModelXfs;
|
|
TReservedAverage< float, 4 > x71c_transitionModelAlphas;
|
|
rstl::vector< rstl::auto_ptr< CModelData > > x730_transitionModels;
|
|
float x740_staticTimer;
|
|
float x744_staticOutSpeed;
|
|
float x748_staticInSpeed;
|
|
float x74c_visorStaticAlpha;
|
|
float x750_frozenTimeout;
|
|
int x754_iceBreakJumps;
|
|
float x758_frozenTimeoutBias;
|
|
int x75c_additionalIceBreakJumps;
|
|
bool x760_controlsFrozen;
|
|
float x764_controlsFrozenTimeout;
|
|
rstl::single_ptr< CMorphBall > x768_morphball;
|
|
rstl::single_ptr< CPlayerCameraBob > x76c_cameraBob;
|
|
CSfxHandle x770_damageLoopSfx;
|
|
float x774_samusVoiceTimeout;
|
|
CSfxHandle x778_dashSfx;
|
|
CSfxHandle x77c_samusVoiceSfx;
|
|
int x780_samusVoicePriority;
|
|
float x784_damageSfxTimer;
|
|
ushort x788_damageLoopSfxId;
|
|
float x78c_footstepSfxTimer;
|
|
EFootstepSfx x790_footstepSfxSel;
|
|
CVector3f x794_lastVelocity;
|
|
CVisorSteam x7a0_visorSteam;
|
|
CPlayerState::EPlayerSuit x7cc_transitionSuit;
|
|
CAnimRes x7d0_animRes;
|
|
CPlayerState::EBeamId x7ec_beam;
|
|
rstl::single_ptr< CModelData > x7f0_ballTransitionBeamModel;
|
|
CTransform4f x7f4_gunWorldXf;
|
|
float x824_transitionFilterTimer;
|
|
float x828_distanceUnderWater;
|
|
bool x82c_inLava;
|
|
TUniqueId x82e_ridingPlatform;
|
|
TUniqueId x830_playerHint;
|
|
uint x834_playerHintPriority;
|
|
rstl::reserved_vector< rstl::pair< uint, TUniqueId >, 32 > x838_playerHints;
|
|
rstl::reserved_vector< TUniqueId, 32 > x93c_playerHintsToRemove;
|
|
rstl::reserved_vector< TUniqueId, 32 > x980_playerHintsToAdd;
|
|
bool x9c4_24_visorChangeRequested : 1;
|
|
bool x9c4_25_showCrosshairs : 1;
|
|
bool x9c4_26_ : 1;
|
|
bool x9c4_27_canEnterMorphBall : 1;
|
|
bool x9c4_28_canLeaveMorphBall : 1;
|
|
bool x9c4_29_spiderBallControlXY : 1;
|
|
bool x9c4_30_controlDirOverride : 1;
|
|
bool x9c4_31_inWaterMovement : 1;
|
|
bool x9c5_24_ : 1;
|
|
bool x9c5_25_splashUpdated : 1;
|
|
bool x9c5_26_ : 1;
|
|
bool x9c5_27_camSubmerged : 1;
|
|
bool x9c5_28_slidingOnWall : 1;
|
|
bool x9c5_29_hitWall : 1;
|
|
bool x9c5_30_selectFluidBallSound : 1;
|
|
bool x9c5_31_stepCameraZBiasDirty : 1;
|
|
bool x9c6_24_extendTargetDistance : 1;
|
|
bool x9c6_25_interpolatingControlDir : 1;
|
|
bool x9c6_26_outOfBallLookAtHint : 1;
|
|
bool x9c6_27_aimingAtProjectile : 1;
|
|
bool x9c6_28_aligningGrappleSwingTurn : 1;
|
|
bool x9c6_29_disableInput : 1;
|
|
bool x9c6_30_newScanScanning : 1;
|
|
bool x9c6_31_overrideRadarRadius : 1;
|
|
bool x9c7_24_noDamageLoopSfx : 1;
|
|
bool x9c7_25_outOfBallLookAtHintActor : 1;
|
|
float x9c8_eyeZBias;
|
|
float x9cc_stepCameraZBias;
|
|
uint x9d0_bombJumpCount;
|
|
int x9d4_bombJumpCheckDelayFrames;
|
|
CVector3f x9d8_controlDirOverrideDir;
|
|
rstl::reserved_vector< TUniqueId, 5 > x9e4_orbitDisableList;
|
|
float x9f4_deathTime;
|
|
float x9f8_controlDirInterpTime;
|
|
float x9fc_controlDirInterpDur;
|
|
TUniqueId xa00_deathPowerBomb;
|
|
float xa04_preThinkDt;
|
|
CAssetId xa08_steamTextureId;
|
|
CAssetId xa0c_iceTextureId;
|
|
uint xa10_envDmgCounter;
|
|
float xa14_envDmgCameraShakeTimer;
|
|
float xa18_phazonDamageLag;
|
|
float xa1c_threatOverride;
|
|
float xa20_radarXYRadiusOverride;
|
|
float xa24_radarZRadiusOverride;
|
|
float xa28_attachedActorStruggle;
|
|
int xa2c_damageLoopSfxDelayTicks;
|
|
float xa30_samusExhaustedVoiceTimer;
|
|
};
|
|
CHECK_SIZEOF(CPlayer, 0xa38)
|
|
|
|
#endif // _CPLAYER
|