Lots of CPlayer implementations

Runtime/World/CPlayer.cpp

@@ -11,6 +11,10 @@
 #include "Camera/CCinematicCamera.hpp"
 #include "TCastTo.hpp"
 #include "CScriptGrapplePoint.hpp"
+#include "CPatterned.hpp"
+#include "CScriptWater.hpp"
+#include "Weapon/CEnergyProjectile.hpp"
+#include "MP1/World/CThardusRockProjectile.hpp"
 
 namespace urde
 {
@@ -28,6 +32,8 @@ CPlayer::CPlayer(TUniqueId uid, const zeus::CTransform& xf, const zeus::CAABox&
                 stepDown), x7d0_animRes(resId, 0, playerScale, 0, true)
 {
     x490_gun.reset(new CPlayerGun(uid));
+    x49c_gunNotFiringTimeout = g_tweakPlayerGun->GetGunNotFiringTime();
+    x4a0_inputFilter.reset(new CInputFilter());
     x768_morphball.reset(new CMorphBall(*this, f4));
     x76c_cameraBob.reset(new CPlayerCameraBob(CPlayerCameraBob::ECameraBobType::One,
                                               zeus::CVector2f{CPlayerCameraBob::kCameraBobExtentX,
@@ -45,6 +51,31 @@ bool CPlayer::IsTransparent() const { return x588_alpha < 1.f; }
 
 void CPlayer::Update(float, CStateManager& mgr) {}
 
+bool CPlayer::StartSamusVoiceSfx(u16 sfx, float vol, int prio)
+{
+    if (x2f8_morphTransState == EPlayerMorphBallState::Morphed)
+        return false;
+    bool started = true;
+    if (x77c_samusVoiceSfx)
+    {
+        if (CSfxManager::IsPlaying(x77c_samusVoiceSfx))
+        {
+            started = false;
+            if (prio > x780_samusVoicePriority)
+            {
+                CSfxManager::SfxStop(x77c_samusVoiceSfx);
+                started = true;
+            }
+        }
+        if (started)
+        {
+            x77c_samusVoiceSfx = CSfxManager::SfxStart(sfx, vol, 0.f, false, 0x7f, false, kInvalidAreaId);
+            x780_samusVoicePriority = prio;
+        }
+    }
+    return started;
+}
+
 bool CPlayer::IsPlayerDeadEnough() const
 {
     if (x2f8_morphTransState == CPlayer::EPlayerMorphBallState::Unmorphed)
@@ -140,6 +171,40 @@ void CPlayer::UpdateFreeLook(float dt) {}
 
 float CPlayer::GetMaximumPlayerPositiveVerticalVelocity(CStateManager&) const { return 0.f; }
 
+void CPlayer::StartLandingControlFreeze()
+{
+    x760_controlsFrozen = true;
+    x764_controlsFrozenTimeout = 0.75f;
+}
+
+void CPlayer::EndLandingControlFreeze()
+{
+    x760_controlsFrozen = false;
+    x764_controlsFrozenTimeout = 0.f;
+}
+
+void CPlayer::ProcessFrozenInput(float dt, CStateManager& mgr)
+{
+    x764_controlsFrozenTimeout -= dt;
+    if (x764_controlsFrozenTimeout <= 0.f)
+    {
+        EndLandingControlFreeze();
+    }
+    else
+    {
+        CFinalInput dummy;
+        if (x2f8_morphTransState == EPlayerMorphBallState::Morphed)
+        {
+            x768_morphball->ComputeBallMovement(dummy, mgr, dt);
+            x768_morphball->UpdateBallDynamics(mgr, dt);
+        }
+        else
+        {
+            ComputeMovement(dummy, mgr, dt);
+        }
+    }
+}
+
 void CPlayer::ProcessInput(const CFinalInput&, CStateManager&) {}
 
 void CPlayer::Stop(CStateManager& stateMgr)
@@ -160,13 +225,218 @@ void CPlayer::PreThink(float dt, CStateManager& mgr)
     xa04_ = dt;
 }
 
-void CPlayer::AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&) {}
+static const u16 skPlayerLandSfxSoft[] =
+{
+    0xFFFF, 0x05E4, 0x05D2, 0x0621, 0x0658, 0xFFFF, 0x05E3, 0x0606,
+    0x05C0, 0x088E, 0x0694, 0x0638, 0x062B, 0xFFFF, 0x0621, 0x05D2,
+    0x05D2, 0x05C0, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x05FB, 0x0625
+};
+
+static const u16 skPlayerLandSfxHard[] =
+{
+    0xFFFF, 0x0651, 0x064B, 0x0647, 0x065A, 0xFFFF, 0x0648, 0x064E,
+    0x064F, 0x08D7, 0x0696, 0x0650, 0x064C, 0xFFFF, 0x0647, 0x064B,
+    0x064B, 0x064F, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x0652, 0x064D
+};
+
+static const CMaterialFilter SolidMaterialFilter =
+    CMaterialFilter::MakeInclude(CMaterialList(EMaterialTypes::Solid));
+
+void CPlayer::AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId sender, CStateManager& mgr)
+{
+    switch (msg)
+    {
+    case EScriptObjectMessage::OnGround:
+        if (x258_movementState != EPlayerMovementState::OnGround &&
+            x2f8_morphTransState != EPlayerMorphBallState::Morphed &&
+            x300_fallingTime > 0.3f)
+        {
+            if (x258_movementState != EPlayerMovementState::Falling)
+            {
+                float hardThres = 30.f * 2.f * -g_tweakPlayer->GetHardLandingVelocityThreshold();
+                hardThres = (hardThres != 0.f) ? hardThres * std::sqrt(hardThres) : 0.f;
+                float landVol = zeus::clamp(95.f, 1.6f * -x794_.z + 95.f, 127.f) / 127.f;
+                u16 landSfx;
+                if (-x794_.z < hardThres)
+                {
+                    landSfx = GetMaterialSoundUnderPlayer(mgr, skPlayerLandSfxSoft, 24, 0xffff);
+                }
+                else
+                {
+                    landSfx = GetMaterialSoundUnderPlayer(mgr, skPlayerLandSfxHard, 24, 0xffff);
+                    StartSamusVoiceSfx(1550, 1.f, 5);
+                    x55c_ = 0.f;
+                    x560_ = 10.f;
+                    x564_ = x34_transform.origin;
+                    x558_ = true;
+                    mgr.GetCameraManager()->AddCameraShaker(
+                        CCameraShakeData::BuildLandingCameraShakeData(0.3f, 1.25f), false);
+                    StartLandingControlFreeze();
+                }
+                CSfxHandle handle =
+                    CSfxManager::SfxStart(landSfx, landVol, 0.f, false, 0x7f, false, kInvalidAreaId);
+                ApplySubmergedPitchBend(handle);
+
+                float rumbleMag = -x794_.z / 110.f;
+                if (rumbleMag > 0.f)
+                {
+                    if (std::fabs(rumbleMag) > 0.8f)
+                        rumbleMag = (rumbleMag > 0.f) ? 0.8f : -0.8f;
+                    mgr.GetRumbleManager().Rumble(mgr, ERumbleFxId::Fifteen, rumbleMag, ERumblePriority::One);
+                }
+
+                x2a0_ = 0.f;
+            }
+        }
+        else if (x258_movementState != EPlayerMovementState::OnGround &&
+                 x2f8_morphTransState == EPlayerMorphBallState::Morphed)
+        {
+            if (x138_velocity.z < -40.f && !x768_morphball->GetIsInHalfPipeMode() &&
+                x258_movementState == EPlayerMovementState::StartingJump &&
+                x300_fallingTime > 0.75f)
+                SetCoefficientOfRestitutionModifier(0.2f);
+            x768_morphball->StartLandingSfx();
+            if (x138_velocity.z < -5.f)
+            {
+                float rumbleMag = -x138_velocity.z / 110.f * 0.5f;
+                if (std::fabs(rumbleMag) > 0.8f)
+                    rumbleMag = (rumbleMag > 0.f) ? 0.8f : -0.8f;
+                mgr.GetRumbleManager().Rumble(mgr, ERumbleFxId::Fifteen, rumbleMag, ERumblePriority::One);
+                x2a0_ = 0.f;
+            }
+            if (x138_velocity.z < -30.f)
+            {
+                float rumbleMag = -x138_velocity.z / 110.f;
+                if (std::fabs(rumbleMag) > 0.8f)
+                    rumbleMag = (rumbleMag > 0.f) ? 0.8f : -0.8f;
+                mgr.GetRumbleManager().Rumble(mgr, ERumbleFxId::Fifteen, rumbleMag, ERumblePriority::One);
+                x2a0_ = 0.f;
+            }
+        }
+        x300_fallingTime = 0.f;
+        SetMoveState(EPlayerMovementState::OnGround, mgr);
+        break;
+    case EScriptObjectMessage::Falling:
+        if (x2f8_morphTransState == EPlayerMorphBallState::Morphed)
+            if (x768_morphball->GetX187c() == 1)
+                break;
+        if (x2f8_morphTransState != EPlayerMorphBallState::Morphed)
+            SetMoveState(EPlayerMovementState::Falling, mgr);
+        else if (x258_movementState == EPlayerMovementState::OnGround)
+            SetMoveState(EPlayerMovementState::FallingMorphed, mgr);
+        break;
+    case EScriptObjectMessage::LandOnNotFloor:
+        if (x2f8_morphTransState == EPlayerMorphBallState::Morphed &&
+            x768_morphball->GetX187c() == 1 &&
+            x258_movementState != EPlayerMovementState::StartingJump)
+            SetMoveState(EPlayerMovementState::StartingJump, mgr);
+        break;
+    case EScriptObjectMessage::OnIceSurface:
+        x2ac_movementSurface = EPlayerMovementSurface::Ice;
+        break;
+    case EScriptObjectMessage::OnMudSlowSurface:
+        x2ac_movementSurface = EPlayerMovementSurface::MudSlow;
+        break;
+    case EScriptObjectMessage::OnNormalSurface:
+        x2ac_movementSurface = EPlayerMovementSurface::Normal;
+        break;
+    case EScriptObjectMessage::InSnakeWeed:
+        x2ac_movementSurface = EPlayerMovementSurface::SnakeWeed;
+        break;
+    case EScriptObjectMessage::AddSplashInhabitant:
+    {
+        SetInFluid(true, sender);
+        UpdateSubmerged(mgr);
+        CRayCastResult result =
+            mgr.RayStaticIntersection(x34_transform.origin, zeus::CVector3f::skDown,
+                                      0.5f * GetEyeHeight(), SolidMaterialFilter);
+        if (result.IsInvalid())
+        {
+            SetVelocityWR(x138_velocity * 0.095f);
+            xfc_constantForce *= 0.095f;
+        }
+        break;
+    }
+    case EScriptObjectMessage::UpdateSplashInhabitant:
+        UpdateSubmerged(mgr);
+        if (CheckSubmerged() && !mgr.GetPlayerState()->HasPowerUp(CPlayerState::EItemType::GravitySuit))
+        {
+            if (TCastToPtr<CScriptWater> water = mgr.ObjectById(xc4_fluidId))
+            {
+                switch (water->GetFluidPlane().GetFluidType())
+                {
+                case CFluidPlane::EFluidType::Zero:
+                    x2b0_ = 0;
+                    break;
+                case CFluidPlane::EFluidType::Two:
+                case CFluidPlane::EFluidType::Five:
+                    x2ac_movementSurface = EPlayerMovementSurface::Fluid2Or5;
+                    break;
+                case CFluidPlane::EFluidType::One:
+                    x2b0_ = 0;
+                    break;
+                case CFluidPlane::EFluidType::Three:
+                    x2ac_movementSurface = EPlayerMovementSurface::Fluid3;
+                    break;
+                default: break;
+                }
+            }
+        }
+        x9c5_25_splashUpdated = true;
+        break;
+    case EScriptObjectMessage::RemoveSplashInhabitant:
+        SetInFluid(false, kInvalidUniqueId);
+        UpdateSubmerged(mgr);
+        break;
+    case EScriptObjectMessage::ProjectileCollide:
+        x378_ = g_tweakPlayer->GetX1fc();
+        SetOrbitRequest(EPlayerOrbitRequest::Nine, mgr);
+        break;
+    case EScriptObjectMessage::AddPlatformRider:
+        x82e_ridingPlatform = sender;
+        break;
+    case EScriptObjectMessage::Damage:
+        if (TCastToPtr<CEnergyProjectile> energ = mgr.ObjectById(sender))
+        {
+            if ((energ->GetAttribField() & CWeapon::EProjectileAttrib::StaticInterference) !=
+                 CWeapon::EProjectileAttrib::None)
+            {
+                mgr.GetPlayerState()->GetStaticInterference().
+                    AddSource(GetUniqueId(), 0.3f, energ->GetInterferenceDuration());
+            }
+        }
+        break;
+    case EScriptObjectMessage::Deleted:
+        mgr.GetPlayerState()->ResetVisor();
+        x730_.clear();
+        break;
+    default: break;
+    }
+
+    x490_gun->AcceptScriptMessage(msg, sender, mgr);
+    x768_morphball->AcceptScriptMessage(msg, sender, mgr);
+    CActor::AcceptScriptMsg(msg, sender, mgr);
+}
 
 void CPlayer::SetVisorSteam(float, float, float, u32, bool) {}
 
 void CPlayer::UpdateFootstepBounds(const CFinalInput& input, CStateManager&, float) {}
 
-u16 CPlayer::GetMaterialSoundUnderPlayer(CStateManager& mgr, const u16*, int, u16) { return 0; }
+u16 CPlayer::GetMaterialSoundUnderPlayer(CStateManager& mgr, const u16* table, u32 length, u16 defId)
+{
+    u16 ret = defId;
+    zeus::CAABox aabb = GetBoundingBox();
+    aabb.accumulateBounds(x34_transform.origin + zeus::CVector3f::skDown);
+    rstl::reserved_vector<TUniqueId, 1024> nearList;
+    mgr.BuildNearList(nearList, aabb, SolidMaterialFilter, nullptr);
+    TUniqueId collideId = kInvalidUniqueId;
+    CRayCastResult result = mgr.RayWorldIntersection(collideId, x34_transform.origin,
+                                                     zeus::CVector3f::skDown,
+                                                     1.5f, SolidMaterialFilter, nearList);
+    if (result.IsValid())
+        ret = SfxIdFromMaterial(result.GetMaterial(), table, length, defId);
+    return ret;
+}
 
 u16 CPlayer::SfxIdFromMaterial(const CMaterialList& mat, const u16* idList, u32 tableLen, u16 defId)
 {
@@ -231,6 +501,24 @@ void CPlayer::BeginGrapple(zeus::CVector3f&, CStateManager& mgr) {}
 
 void CPlayer::BreakGrapple(CStateManager& mgr) {}
 
+void CPlayer::SetOrbitRequest(EPlayerOrbitRequest req, CStateManager& mgr)
+{
+    x30c_orbitRequest = req;
+    switch (req)
+    {
+    case EPlayerOrbitRequest::Eight:
+
+    case EPlayerOrbitRequest::Seven:
+        SetOrbitState(EPlayerOrbitState::Two, mgr);
+        x314_orbitPoint = g_tweakPlayer->GetX164(int(x308_orbitType)) *
+            x34_transform.basis[1] + x34_transform.origin;
+        break;
+    default:
+        SetOrbitState(EPlayerOrbitState::Zero, mgr);
+        break;
+    }
+}
+
 void CPlayer::PreventFallingCameraPitch() {}
 
 void CPlayer::OrbitCarcass(CStateManager&) {}
@@ -241,15 +529,66 @@ zeus::CVector3f CPlayer::GetHUDOrbitTargetPosition() const { return {}; }
 
 void CPlayer::SetOrbitState(EPlayerOrbitState, CStateManager& mgr) {}
 
-void CPlayer::SetOrbitTargetId(TUniqueId, CStateManager& mgr) {}
+void CPlayer::SetOrbitTargetId(TUniqueId id, CStateManager& mgr)
+{
+    if (id != kInvalidUniqueId)
+    {
+        x394_ = (TCastToPtr<CPatterned>(mgr.ObjectById(id)) ||
+                 TCastToPtr<CWallCrawlerSwarm>(mgr.ObjectById(id)) ||
+                 CPatterned::CastTo<CThardusRockProjectile>(mgr.ObjectById(id)) ||
+                 TCastToPtr<CScriptGunTurret>(mgr.ObjectById(id)));
+    }
 
-void CPlayer::UpdateOrbitPosition(float, CStateManager& mgr) {}
+    x310_orbitTargetId = id;
+    if (x310_orbitTargetId == kInvalidUniqueId)
+        x374_ = false;
+}
 
-void CPlayer::UpdateOrbitZPosition() {}
+void CPlayer::UpdateOrbitPosition(float pos, CStateManager& mgr)
+{
+    switch (x304_orbitState)
+    {
+    case EPlayerOrbitState::Two:
+    case EPlayerOrbitState::Three:
+        SetOrbitPosition(pos, mgr);
+        break;
+    case EPlayerOrbitState::One:
+    case EPlayerOrbitState::Four:
+    case EPlayerOrbitState::Five:
+        if (TCastToPtr<CActor> act = mgr.ObjectById(x310_orbitTargetId))
+            if (x310_orbitTargetId != kInvalidUniqueId)
+                x314_orbitPoint = act->GetOrbitPosition(mgr);
+        break;
+    default: break;
+    }
+}
 
-void CPlayer::UpdateOrbitFixedPosition() {}
+void CPlayer::UpdateOrbitZPosition()
+{
+    if (x304_orbitState == EPlayerOrbitState::Two)
+    {
+        if (std::fabs(x320_orbitVector.z) < g_tweakPlayer->GetOrbitZRange())
+            x314_orbitPoint.z = x320_orbitVector.z + x34_transform.origin.z + GetEyeHeight();
+    }
+}
 
-void CPlayer::SetOrbitPosition(float, CStateManager& mgr) {}
+void CPlayer::UpdateOrbitFixedPosition()
+{
+    x314_orbitPoint = x34_transform.rotate(x320_orbitVector) + GetEyePosition();
+}
+
+void CPlayer::SetOrbitPosition(float pos, CStateManager& mgr)
+{
+    zeus::CTransform camXf = GetFirstPersonCameraTransform(mgr);
+    if (x304_orbitState == EPlayerOrbitState::Two && x30c_orbitRequest == EPlayerOrbitRequest::Seven)
+        camXf = x34_transform;
+    zeus::CVector3f fwd = camXf.basis[1];
+    float dot = fwd.normalized().dot(fwd);
+    if (std::fabs(dot) > 1.f)
+        dot = (dot > 0.f) ? 1.f : -1.f;
+    x314_orbitPoint = camXf.rotate(zeus::CVector3f(0.f, pos / dot, 0.f)) + camXf.origin;
+    x320_orbitVector = zeus::CVector3f(0.f, pos, x314_orbitPoint.z - camXf.origin.z);
+}
 
 void CPlayer::UpdateAimTarget(CStateManager& mgr) {}
 
@@ -272,7 +611,10 @@ TUniqueId CPlayer::CheckEnemiesAgainstOrbitZone(const std::vector<TUniqueId>&, E
     return {};
 }
 
-TUniqueId CPlayer::FindOrbitTargetId(CStateManager& mgr) { return {}; }
+TUniqueId CPlayer::FindOrbitTargetId(CStateManager& mgr)
+{
+    return FindBestOrbitableObject(x354_onScreenOrbitObjects, x330_orbitZone, mgr);
+}
 
 static zeus::CAABox BuildNearListBox(bool cropBottom, const zeus::CTransform& xf, float x, float z, float y)
 {
@@ -425,7 +767,7 @@ void CPlayer::AddOrbitDisableSource(CStateManager& mgr, TUniqueId addId)
             return;
     x9e4_orbitDisableList.push_back(addId);
     ResetAimTargetPrediction(kInvalidUniqueId);
-    if (!TCastToConstPtr<CScriptGrapplePoint>(mgr.GetObjectById(x310_lockonObjectId)))
+    if (!TCastToConstPtr<CScriptGrapplePoint>(mgr.GetObjectById(x310_orbitTargetId)))
         SetOrbitTargetId(kInvalidUniqueId, mgr);
 }
 
@@ -437,6 +779,25 @@ void CPlayer::UpdateOrbitZone(CStateManager& mgr) {}
 
 void CPlayer::UpdateOrbitInput(const CFinalInput& input, CStateManager& mgr) {}
 
+void CPlayer::ActivateOrbitSource(CStateManager& mgr)
+{
+    switch (x390_orbitSource)
+    {
+    default:
+        OrbitCarcass(mgr);
+        break;
+    case 1:
+        SetOrbitRequest(EPlayerOrbitRequest::Six, mgr);
+        break;
+    case 2:
+        if (x394_)
+            OrbitPoint(EPlayerOrbitType::One, mgr);
+        else
+            OrbitCarcass(mgr);
+        break;
+    }
+}
+
 void CPlayer::UpdateOrbitSelection(const CFinalInput& input, CStateManager& mgr) {}
 
 void CPlayer::UpdateOrbitOrientation(CStateManager& mgr) {}
@@ -610,22 +971,85 @@ void CPlayer::CVisorSteam::Update(float dt)
     x24_ = 0.1f;
 }
 
+void CPlayer::CInputFilter::Reset()
+{
+    x0_stateSamples.clear();
+    x54_posSamples.clear();
+    x148_velSamples.clear();
+    x23c_inputSamples.clear();
+}
+
+void CPlayer::CInputFilter::AddSample(EInputState state, const zeus::CVector3f& pos,
+                                      const zeus::CVector3f& vel, const zeus::CVector2f& input)
+{
+    if (x0_stateSamples.size() >= 20)
+        x0_stateSamples.resize(19);
+    x0_stateSamples.insert(x0_stateSamples.begin(), state);
+    if (x54_posSamples.size() >= 20)
+        x54_posSamples.resize(19);
+    x54_posSamples.insert(x54_posSamples.begin(), pos);
+    if (x148_velSamples.size() >= 20)
+        x148_velSamples.resize(19);
+    x148_velSamples.insert(x148_velSamples.begin(), vel);
+    if (x23c_inputSamples.size() >= 20)
+        x23c_inputSamples.resize(19);
+    x23c_inputSamples.insert(x23c_inputSamples.begin(), input);
+}
+
+bool CPlayer::CInputFilter::Passes() const
+{
+    // TODO: Do
+    return false;
+}
+
 void CPlayer::SetSpawnedMorphBallState(CPlayer::EPlayerMorphBallState, CStateManager&) {}
 
 void CPlayer::DecrementPhazon()
 {
-    if (xa10_ == 0)
+    if (xa10_phazonCounter == 0)
         return;
 
-    xa10_--;
+    xa10_phazonCounter--;
 }
 
 void CPlayer::IncrementPhazon()
 {
-    if (xa10_ != 0)
-        xa10_++;
+    if (xa10_phazonCounter != 0)
+        xa10_phazonCounter++;
     else
         xa14_ = 0.f;
 }
 
+bool CPlayer::CheckSubmerged() const
+{
+    if (!xe6_24_fluidCounter)
+        return false;
+
+    return x828_waterLevelOnPlayer >= (x2f8_morphTransState == EPlayerMorphBallState::Morphed ?
+        2.f * g_tweakPlayer->GetPlayerBallHalfExtent() : 0.5f * GetEyeHeight());
+}
+
+void CPlayer::UpdateSubmerged(CStateManager& mgr)
+{
+    x82c_ = false;
+    x828_waterLevelOnPlayer = 0.f;
+    if (xe6_24_fluidCounter)
+    {
+        if (TCastToPtr<CScriptWater> water = mgr.ObjectById(xc4_fluidId))
+        {
+            x828_waterLevelOnPlayer =
+                -(zeus::CVector3f::skUp.dot(x34_transform.origin) - water->GetTriggerBoundsWR().max.z);
+            CFluidPlane::EFluidType fluidType = water->GetFluidPlane().GetFluidType();
+            x82c_ = (fluidType == CFluidPlane::EFluidType::Two || fluidType == CFluidPlane::EFluidType::Five);
+            CheckSubmerged();
+        }
+    }
+}
+
+void CPlayer::ApplySubmergedPitchBend(CSfxHandle& sfx)
+{
+    if (CheckSubmerged())
+        CSfxManager::PitchBend(sfx, -1.f);
+}
+
 }