#include <Runtime/MP1/World/CMetroidBeta.hpp>
#include <Runtime/MP1/CSamusHud.hpp>
#include "CSimplePool.hpp"
#include "Character/CPrimitive.hpp"
#include "CEnergyProjectile.hpp"
#include "World/CScriptWater.hpp"
#include "World/CGameLight.hpp"
#include "World/CScriptPlatform.hpp"
#include "Input/ControlMapper.hpp"
#include "CBomb.hpp"
#include "CPowerBomb.hpp"
#include "Graphics/CBooRenderer.hpp"
#include "Camera/CGameCamera.hpp"

namespace urde
{

static const zeus::CVector3f sGunScale(2.f);

static float kVerticalAngleTable[] = { -30.f, 0.f, 30.f };
static float kHorizontalAngleTable[] = { 30.f, 30.f, 30.f };
static float kVerticalVarianceTable[] = { 30.f, 30.f, 30.f };

float CPlayerGun::CMotionState::gGunExtendDistance = 0.125f;

CPlayerGun::CPlayerGun(TUniqueId playerId)
: x0_lights(8, zeus::CVector3f{-30.f, 0.f, 30.f}, 4, 4, 0, 0, 0, 0.1f), x538_playerId(playerId),
  x550_camBob(CPlayerCameraBob::ECameraBobType::One,
              zeus::CVector2f(CPlayerCameraBob::kCameraBobExtentX, CPlayerCameraBob::kCameraBobExtentY),
              CPlayerCameraBob::kCameraBobPeriod),
  x678_morph(g_tweakPlayerGun->GetGunTransformTime(), g_tweakPlayerGun->GetHoloHoldTime()),
  x6c8_hologramClipCube(zeus::CVector3f(-0.29329199f, 0.f, -0.2481945f),
        zeus::CVector3f(0.29329199f, 1.292392f, 0.2481945f)),
  x6e0_rightHandModel(CAnimRes(g_tweakGunRes->xc_rightHand, 0, zeus::CVector3f(3.f), 0, true))
{
    x354_bombFuseTime = g_tweakPlayerGun->GetBombFuseTime();
    x358_bombDropDelayTime = g_tweakPlayerGun->GetBombDropDelayTime();
    x668_aimVerticalSpeed = g_tweakPlayerGun->GetAimVerticalSpeed();
    x66c_aimHorizontalSpeed = g_tweakPlayerGun->GetAimHorizontalSpeed();

    x73c_gunMotion = std::make_unique<CGunMotion>(g_tweakGunRes->x4_gunMotion, sGunScale);
    x740_grappleArm = std::make_unique<CGrappleArm>(sGunScale);
    x744_auxWeapon = std::make_unique<CAuxWeapon>(playerId);
    x748_rainSplashGenerator = std::make_unique<CRainSplashGenerator>(sGunScale, 20, 2, 0.f, 0.125f);
    x74c_powerBeam = std::make_unique<CPowerBeam>(g_tweakGunRes->x10_powerBeam, EWeaponType::Power,
                                                  playerId, EMaterialTypes::Player, sGunScale);
    x750_iceBeam = std::make_unique<CIceBeam>(g_tweakGunRes->x14_iceBeam, EWeaponType::Ice,
                                              playerId, EMaterialTypes::Player, sGunScale);
    x754_waveBeam = std::make_unique<CWaveBeam>(g_tweakGunRes->x18_waveBeam, EWeaponType::Wave,
                                                playerId, EMaterialTypes::Player, sGunScale);
    x758_plasmaBeam = std::make_unique<CPlasmaBeam>(g_tweakGunRes->x1c_plasmaBeam, EWeaponType::Plasma,
                                                    playerId, EMaterialTypes::Player, sGunScale);
    x75c_phazonBeam = std::make_unique<CPhazonBeam>(g_tweakGunRes->x20_phazonBeam, EWeaponType::Phazon,
                                                    playerId, EMaterialTypes::Player, sGunScale);
    x774_holoTransitionGen = std::make_unique<CElementGen>(
        g_SimplePool->GetObj(SObjectTag{FOURCC('PART'), g_tweakGunRes->x24_holoTransition}));
    x82c_shadow = std::make_unique<CWorldShadow>(32, 32, true);

    x832_31_inRestPose = true;
    x833_24_isFidgeting = true;
    x833_30_canShowAuxMuzzleEffect = true;
    x6e0_rightHandModel.SetSortThermal(true);

    kVerticalAngleTable[2] = g_tweakPlayerGun->GetUpLookAngle();
    kVerticalAngleTable[0] = g_tweakPlayerGun->GetDownLookAngle();
    kHorizontalAngleTable[1] = g_tweakPlayerGun->GetHorizontalSpread();
    kHorizontalAngleTable[2] = g_tweakPlayerGun->GetHighHorizontalSpread();
    kHorizontalAngleTable[0] = g_tweakPlayerGun->GetLowHorizontalSpread();
    kVerticalVarianceTable[1] = g_tweakPlayerGun->GetVerticalSpread();
    kVerticalVarianceTable[2] = g_tweakPlayerGun->GetHighVerticalSpread();
    kVerticalVarianceTable[0] = g_tweakPlayerGun->GetLowVerticalSpread();
    CMotionState::SetExtendDistance(g_tweakPlayerGun->GetGunExtendDistance());

    InitBeamData();
    InitBombData();
    InitMuzzleData();
    InitCTData();
    LoadHandAnimTokens();
    x550_camBob.SetPlayerVelocity(zeus::CVector3f::skZero);
    x550_camBob.SetBobMagnitude(0.f);
    x550_camBob.SetBobTimeScale(0.f);

    m_aaboxShader.setAABB(x6c8_hologramClipCube);
}

void CPlayerGun::InitBeamData()
{
    x760_selectableBeams[0] = x74c_powerBeam.get();
    x760_selectableBeams[1] = x750_iceBeam.get();
    x760_selectableBeams[2] = x754_waveBeam.get();
    x760_selectableBeams[3] = x758_plasmaBeam.get();
    x72c_currentBeam = x760_selectableBeams[0];
    x738_nextBeam = x72c_currentBeam;
    x774_holoTransitionGen->SetParticleEmission(true);
}

void CPlayerGun::InitBombData()
{
    x784_bombEffects.resize(2);
    x784_bombEffects[0].push_back(g_SimplePool->GetObj(SObjectTag{FOURCC('PART'), g_tweakGunRes->x28_bombSet}));
    x784_bombEffects[0].push_back(g_SimplePool->GetObj(SObjectTag{FOURCC('PART'), g_tweakGunRes->x2c_bombExplode}));
    TLockedToken<CGenDescription> pbExplode =
        g_SimplePool->GetObj(SObjectTag{FOURCC('PART'), g_tweakGunRes->x30_powerBombExplode});
    x784_bombEffects[1].push_back(pbExplode);
    x784_bombEffects[1].push_back(pbExplode);
}

void CPlayerGun::InitMuzzleData()
{
    for (int i=0 ; i<5 ; ++i)
    {
        x7c0_auxMuzzleEffects.push_back(g_SimplePool->GetObj(SObjectTag{FOURCC('PART'),
                                        g_tweakGunRes->xa4_auxMuzzle[i]}));
        x800_auxMuzzleGenerators.emplace_back(new CElementGen(x7c0_auxMuzzleEffects.back()));
        x800_auxMuzzleGenerators.back()->SetParticleEmission(false);
    }
}

void CPlayerGun::InitCTData()
{
    x77c_comboXferGen.reset();
}

void CPlayerGun::LoadHandAnimTokens()
{
    std::set<CPrimitive> prims;
    for (int i=0 ; i<3 ; ++i)
    {
        CAnimPlaybackParms parms(i, -1, 1.f, true);
        x6e0_rightHandModel.GetAnimationData()->GetAnimationPrimitives(parms, prims);
    }
    CAnimData::PrimitiveSetToTokenVector(prims, x540_handAnimTokens, true);
}

void CPlayerGun::TakeDamage(bool bigStrike, bool notFromMetroid, CStateManager& mgr)
{
    bool hasStrikeAngle = false;
    float angle = 0.f;
    if (x398_damageAmt >= 10.f && !bigStrike && (x2f8_stateFlags & 0x10) != 0x10 &&
        !x832_26_comboFiring && x384_gunStrikeDelayTimer <= 0.f)
    {
        x384_gunStrikeDelayTimer = 20.f;
        x364_gunStrikeCoolTimer = 0.75f;
        if (x678_morph.GetGunState() == CGunMorph::EGunState::OutWipeDone)
        {
            zeus::CVector3f localDamageLoc = mgr.GetPlayer().GetTransform().transposeRotate(x3dc_damageLocation);
            angle = zeus::CRelAngle(std::atan2(localDamageLoc.y, localDamageLoc.x)).asDegrees();
            hasStrikeAngle = true;
        }
    }

    if (hasStrikeAngle || bigStrike)
    {
        if (mgr.GetPlayerState()->GetCurrentVisor() != CPlayerState::EPlayerVisor::Scan)
        {
            x73c_gunMotion->PlayPasAnim(SamusGun::EAnimationState::Struck, mgr, angle, bigStrike);
            if ((bigStrike && notFromMetroid) || x833_31_inFreeLook)
                x740_grappleArm->EnterStruck(mgr, angle, bigStrike, !x833_31_inFreeLook);
        }
    }

    x398_damageAmt = 0.f;
    x3dc_damageLocation = zeus::CVector3f::skZero;
}

void CPlayerGun::CreateGunLight(CStateManager& mgr)
{
    if (x53c_lightId != kInvalidUniqueId)
        return;
    x53c_lightId = mgr.AllocateUniqueId();
    CGameLight* light = new CGameLight(x53c_lightId, kInvalidAreaId, false, "GunLite", x3e8_xf, x538_playerId,
                                       CLight::BuildDirectional(zeus::CVector3f::skForward, zeus::CColor::skBlack),
                                       x53c_lightId.Value(), 0, 0.f);
    mgr.AddObject(light);
}

void CPlayerGun::DeleteGunLight(CStateManager& mgr)
{
    if (x53c_lightId == kInvalidUniqueId)
        return;
    mgr.FreeScriptObject(x53c_lightId);
    x53c_lightId = kInvalidUniqueId;
}

void CPlayerGun::UpdateGunLight(const zeus::CTransform& xf, CStateManager& mgr)
{
    if (x53c_lightId == kInvalidUniqueId || x32c_chargePhase == EChargePhase::NotCharging)
        return;

    if (TCastToPtr<CGameLight> light = mgr.ObjectById(x53c_lightId))
    {
        if (light->GetActive())
        {
            CElementGen* chargeFx = x72c_currentBeam->GetChargeMuzzleFx();
            light->SetTransform(xf);
            light->SetTranslation(xf.origin);
            if (chargeFx && chargeFx->SystemHasLight())
            {
                CLight l = chargeFx->GetLight();
                l.SetColor(zeus::CColor::lerp(zeus::CColor::skClear, l.GetColor(), x340_chargeBeamFactor));
                light->SetLight(l);
            }
        }
    }
}

void CPlayerGun::SetGunLightActive(bool active, CStateManager& mgr)
{
    if (x53c_lightId == kInvalidUniqueId)
        return;

    if (TCastToPtr<CGameLight> light = mgr.ObjectById(x53c_lightId))
    {
        light->SetActive(active);
        if (active)
        {
            if (CElementGen* gen = x72c_currentBeam->GetChargeMuzzleFx())
            {
                if (gen->SystemHasLight())
                {
                    CLight genLight = gen->GetLight();
                    genLight.SetColor(zeus::CColor::skBlack);
                    light->SetLight(genLight);
                }
            }
        }
    }
}

static const u32 skBeamAnimIds[] = { 0, 1, 2, 1 };

void CPlayerGun::AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId sender, CStateManager& mgr)
{
    const CPlayer& player = mgr.GetPlayer();
    bool isUnmorphed = player.GetMorphballTransitionState() == CPlayer::EPlayerMorphBallState::Unmorphed;
    switch (msg)
    {
    case EScriptObjectMessage::Registered:
    {
        CreateGunLight(mgr);
        x320_currentAuxBeam = x314_nextBeam = x310_currentBeam = mgr.GetPlayerState()->GetCurrentBeam();
        x72c_currentBeam = x738_nextBeam = x760_selectableBeams[int(x310_currentBeam)];
        x72c_currentBeam->Load(mgr, true);
        x72c_currentBeam->SetRainSplashGenerator(x748_rainSplashGenerator.get());
        x744_auxWeapon->Load(x310_currentBeam, mgr);
        CAnimPlaybackParms parms(skBeamAnimIds[int(mgr.GetPlayerState()->GetCurrentBeam())], -1, 1.f, true);
        x6e0_rightHandModel.AnimationData()->SetAnimation(parms, false);
        break;
    }
    case EScriptObjectMessage::Deleted:
        DeleteGunLight(mgr);
        break;
    case EScriptObjectMessage::UpdateSplashInhabitant:
        if (mgr.GetPlayerState()->HasPowerUp(CPlayerState::EItemType::PhazonSuit) && isUnmorphed)
        {
            if (TCastToConstPtr<CScriptWater> water = mgr.GetObjectById(sender))
            {
                if (water->GetFluidPlane().GetFluidType() == CFluidPlane::EFluidType::PhazonFluid)
                {
                    x835_24_canFirePhazon = true;
                    x835_25_inPhazonBeam = true;
                }
            }
        }
        if (player.GetDistanceUnderWater() > player.GetEyeHeight())
        {
            x834_27_underwater = true;
            if (x744_auxWeapon->IsComboFxActive(mgr) && x310_currentBeam != CPlayerState::EBeamId::Wave)
                StopContinuousBeam(mgr, false);
        }
        else
        {
            x834_27_underwater = false;
        }
        break;
    case EScriptObjectMessage::RemoveSplashInhabitant:
        x834_27_underwater = false;
        x835_24_canFirePhazon = false;
        break;
    case EScriptObjectMessage::AddPhazonPoolInhabitant:
        x835_30_inPhazonPool = true;
        if (mgr.GetPlayerState()->HasPowerUp(CPlayerState::EItemType::PhazonSuit) && isUnmorphed)
            x835_24_canFirePhazon = true;
        break;
    case EScriptObjectMessage::UpdatePhazonPoolInhabitant:
        x835_30_inPhazonPool = true;
        if (mgr.GetPlayerState()->HasPowerUp(CPlayerState::EItemType::PhazonSuit) && isUnmorphed)
        {
            x835_24_canFirePhazon = true;
            x835_25_inPhazonBeam = true;
            if (x833_28_phazonBeamActive && static_cast<CPhazonBeam*>(x72c_currentBeam)->IsFiring())
                if (TCastToPtr<CEntity> ent = mgr.ObjectById(sender))
                    mgr.SendScriptMsg(ent.GetPtr(), x538_playerId, EScriptObjectMessage::Decrement);
        }
        break;
    case EScriptObjectMessage::RemovePhazonPoolInhabitant:
        x835_30_inPhazonPool = false;
        x835_24_canFirePhazon = false;
        break;
    case EScriptObjectMessage::Damage:
    {
        bool bigStrike = false;
        bool metroidAttached = false;
        if (TCastToConstPtr<CEnergyProjectile> proj = mgr.GetObjectById(sender))
        {
            if ((proj->GetAttribField() & CGameProjectile::EProjectileAttrib::BigStrike) !=
                CGameProjectile::EProjectileAttrib::None)
            {
                x394_damageTimer = proj->GetDamageDuration();
                bigStrike = true;
            }
        }
        else if (TCastToConstPtr<CPatterned> ai = mgr.GetObjectById(sender))
        {
            if (ai->GetX402_28())
            {
                x394_damageTimer = ai->GetDamageDuration();
                bigStrike = true;
                if (player.GetAttachedActor() != kInvalidUniqueId)
                    metroidAttached = CPatterned::CastTo<MP1::CMetroid>(
                        mgr.GetObjectById(player.GetAttachedActor())) != nullptr;
            }
        }
        if (!x834_30_inBigStrike)
        {
            if (bigStrike)
            {
                x834_31_gunMotionInFidgetBasePosition = false;
                CancelFiring(mgr);
            }
            TakeDamage(bigStrike, !metroidAttached, mgr);
            x834_30_inBigStrike = bigStrike;
        }
        break;
    }
    case EScriptObjectMessage::OnFloor:
        if (player.GetControlsFrozen() && !x834_30_inBigStrike)
        {
            x2f4_fireButtonStates = 0;
            x2ec_lastFireButtonStates = 0;
            CancelFiring(mgr);
            TakeDamage(true, false, mgr);
            x394_damageTimer = 0.75f;
            x834_30_inBigStrike = true;
        }
        break;
    default:
        break;
    }

    x740_grappleArm->AcceptScriptMsg(msg, sender, mgr);
    x758_plasmaBeam->AcceptScriptMsg(msg, sender, mgr);
    x75c_phazonBeam->AcceptScriptMsg(msg, sender, mgr);
    x744_auxWeapon->AcceptScriptMsg(msg, sender, mgr);
}

void CPlayerGun::AsyncLoadSuit(CStateManager& mgr)
{
    x72c_currentBeam->AsyncLoadSuitArm(mgr);
    x740_grappleArm->AsyncLoadSuit(mgr);
}

void CPlayerGun::TouchModel(const CStateManager& mgr)
{
    if (mgr.GetPlayer().GetMorphballTransitionState() != CPlayer::EPlayerMorphBallState::Morphed)
    {
        x73c_gunMotion->GetModelData().Touch(mgr, 0);
        switch (x33c_phazonBeamState)
        {
        case EPhazonBeamState::Entering:
            if (x75c_phazonBeam)
                x75c_phazonBeam->Touch(mgr);
            break;
        case EPhazonBeamState::Exiting:
            if (x738_nextBeam)
                x738_nextBeam->Touch(mgr);
            break;
        default:
            if (!x833_28_phazonBeamActive)
                x72c_currentBeam->Touch(mgr);
            else
                x75c_phazonBeam->Touch(mgr);
            break;
        }
        x72c_currentBeam->TouchHolo(mgr);
        x740_grappleArm->TouchModel(mgr);
        x6e0_rightHandModel.Touch(mgr, 0);
    }

    if (x734_loadingBeam)
    {
        x734_loadingBeam->Touch(mgr);
        x734_loadingBeam->TouchHolo(mgr);
    }
}

void CPlayerGun::DamageRumble(const zeus::CVector3f& location, float damage, const CStateManager& mgr)
{
    x398_damageAmt = damage;
    x3dc_damageLocation = location;
}

void CPlayerGun::StopChargeSound(CStateManager& mgr)
{
    if (x2e0_chargeSfx)
    {
        CSfxManager::SfxStop(x2e0_chargeSfx);
        x2e0_chargeSfx.reset();
    }
    if (x830_chargeRumbleHandle != -1)
    {
        mgr.GetRumbleManager().StopRumble(x830_chargeRumbleHandle);
        x830_chargeRumbleHandle = -1;
    }
}

void CPlayerGun::ResetCharge(CStateManager& mgr, bool b1)
{
    if (x32c_chargePhase != EChargePhase::NotCharging)
        StopChargeSound(mgr);

    if ((x2f8_stateFlags & 0x8) != 0x8 && (x2f8_stateFlags & 0x10) != 0x10)
    {
        bool r30 = !(mgr.GetPlayer().GetMorphballTransitionState() != CPlayer::EPlayerMorphBallState::Morphed && !b1);
        if (x832_27_chargeAnimStarted || r30)
            PlayAnim(NWeaponTypes::EGunAnimType::BasePosition, false);
        if (r30)
            x72c_currentBeam->EnableSecondaryFx(CGunWeapon::ESecondaryFxType::None);
        if ((x2f8_stateFlags & 0x2) != 0x2 || x330_chargeState != EChargeState::Normal)
        {
            if ((x2f8_stateFlags & 0x8) != 0x8)
            {
                x2f8_stateFlags |= 0x1;
                x2f8_stateFlags &= 0xFFE9;
            }
            x318_comboAmmoIdx = 0;
            x31c_missileMode = EMissleMode::Inactive;
        }
    }

    x32c_chargePhase = EChargePhase::NotCharging;
    x330_chargeState = EChargeState::Normal;
    x320_currentAuxBeam = x310_currentBeam;
    x833_30_canShowAuxMuzzleEffect = true;
    x832_27_chargeAnimStarted = false;
    x832_26_comboFiring = false;
    x344_comboXferTimer = 0.f;
}

bool CPlayerGun::ExitMissile()
{
    if ((x2f8_stateFlags & 0x1) == 0x1)
        return true;
    if ((x2f8_stateFlags & 0x10) == 0x10 || x338_nextState == ENextState::ExitMissile)
        return false;
    x338_nextState = ENextState::ExitMissile;
    PlayAnim(NWeaponTypes::EGunAnimType::FromMissile, false);
    return false;
}

static const CPlayerState::EItemType skBeamArr[] =
{
    CPlayerState::EItemType::PowerBeam,
    CPlayerState::EItemType::IceBeam,
    CPlayerState::EItemType::WaveBeam,
    CPlayerState::EItemType::PlasmaBeam
};

static const CPlayerState::EItemType skBeamComboArr[] =
{
    CPlayerState::EItemType::SuperMissile,
    CPlayerState::EItemType::IceSpreader,
    CPlayerState::EItemType::Wavebuster,
    CPlayerState::EItemType::Flamethrower
};

static const ControlMapper::ECommands mBeamCtrlCmd[] =
{
    ControlMapper::ECommands::PowerBeam,
    ControlMapper::ECommands::IceBeam,
    ControlMapper::ECommands::WaveBeam,
    ControlMapper::ECommands::PlasmaBeam,
};

void CPlayerGun::HandleBeamChange(const CFinalInput& input, CStateManager& mgr)
{
    CPlayerState& playerState = *mgr.GetPlayerState();
    float maxBeamInput = 0.f;
    CPlayerState::EBeamId selectBeam = CPlayerState::EBeamId::Invalid;
    for (int i=0 ; i<4 ; ++i)
    {
        if (playerState.HasPowerUp(skBeamArr[i]))
        {
            float inputVal = ControlMapper::GetAnalogInput(mBeamCtrlCmd[i], input);
            if (inputVal > 0.65f && inputVal > maxBeamInput)
            {
                maxBeamInput = inputVal;
                selectBeam = CPlayerState::EBeamId(i);
            }
        }
    }

    if (selectBeam == CPlayerState::EBeamId::Invalid)
        return;

    x833_25_ = true;
    if (x310_currentBeam != selectBeam && playerState.HasPowerUp(skBeamArr[int(selectBeam)]))
    {
        x314_nextBeam = selectBeam;
        u32 flags = 0;
        if ((x2f8_stateFlags & 0x10) == 0x10)
            flags = 0x10;
        flags |= 0x8;
        x2f8_stateFlags = flags;
        PlayAnim(NWeaponTypes::EGunAnimType::FromBeam, false);
        if (x833_31_inFreeLook || x744_auxWeapon->IsComboFxActive(mgr) || x832_26_comboFiring)
        {
            x832_30_requestReturnToDefault = true;
            x740_grappleArm->EnterIdle(mgr);
        }
        x72c_currentBeam->EnableSecondaryFx(CGunWeapon::ESecondaryFxType::None);
        x338_nextState = ENextState::ChangeWeapon;
        x2e4_invalidSfx.reset();
    }
    else if (playerState.HasPowerUp(skBeamArr[int(selectBeam)]))
    {
        if (ExitMissile())
        {
            if (!CSfxManager::IsPlaying(x2e4_invalidSfx))
                x2e4_invalidSfx = NWeaponTypes::play_sfx(1763, x834_27_underwater, false, 0.165f);
        }
        else
        {
            x2e4_invalidSfx.reset();
        }
    }
}

void CPlayerGun::SetPhazonBeamMorph(bool intoPhazonBeam)
{
    x39c_phazonMorphT = intoPhazonBeam ? 0.f : 1.f;
    x835_27_intoPhazonBeam = intoPhazonBeam;
    x835_26_phazonBeamMorphing = true;
}

void CPlayerGun::Reset(CStateManager& mgr, bool b1)
{
    x72c_currentBeam->Reset(mgr);
    x832_25_chargeEffectVisible = false;
    x832_24_cancellingCharge = false;
    x833_26_ = false;
    x348_chargeCancelTimer = 0.f;
    SetGunLightActive(false, mgr);
    if ((x2f8_stateFlags & 0x10) != 0x10)
    {
        if (!b1 && (x2f8_stateFlags & 0x2) != 0x2)
        {
            if ((x2f8_stateFlags & 0x8) != 0x8)
            {
                x2f8_stateFlags |= 0x1;
                x2f8_stateFlags &= 0xFFE9;
            }
            x318_comboAmmoIdx = 0;
            x31c_missileMode = EMissleMode::Inactive;
        }
    }
    else
    {
        x2f8_stateFlags &= ~0x7;
    }
}

void CPlayerGun::ResetBeamParams(CStateManager& mgr, const CPlayerState& playerState, bool playSelectionSfx)
{
    StopContinuousBeam(mgr, true);
    if (playerState.ItemEnabled(CPlayerState::EItemType::ChargeBeam))
        ResetCharge(mgr, false);
    CAnimPlaybackParms parms(skBeamAnimIds[int(x314_nextBeam)], -1, 1.f, true);
    x6e0_rightHandModel.AnimationData()->SetAnimation(parms, false);
    Reset(mgr, false);
    if (playSelectionSfx)
        CSfxManager::SfxStart(1774, 1.f, 0.f, true, 0x7f, false, kInvalidAreaId);
    x2ec_lastFireButtonStates &= ~0x1;
    x320_currentAuxBeam = x310_currentBeam;
    x833_30_canShowAuxMuzzleEffect = true;
}

static const u16 skFromMissileSound[] = { 1824, 1849, 1851, 1853 };
static const u16 skFromBeamSound[] = { 0, 1822, 1828, 1826 };
static const u16 skToMissileSound[] = { 1823, 1829, 1850, 1852 };

void CPlayerGun::PlayAnim(NWeaponTypes::EGunAnimType type, bool loop)
{
    if (x338_nextState != ENextState::ChangeWeapon)
        x72c_currentBeam->PlayAnim(type, loop);

    u16 sfx = 0xffff;
    switch (type)
    {
    case NWeaponTypes::EGunAnimType::FromMissile:
        x2f8_stateFlags &= ~0x4;
        sfx = skFromMissileSound[int(x310_currentBeam)];
        break;
    case NWeaponTypes::EGunAnimType::MissileReload:
        sfx = 1769;
        break;
    case NWeaponTypes::EGunAnimType::FromBeam:
        sfx = skFromBeamSound[int(x310_currentBeam)];
        break;
    case NWeaponTypes::EGunAnimType::ToMissile:
        x2f8_stateFlags &= ~0x1;
        sfx = skToMissileSound[int(x310_currentBeam)];
        break;
    default:
        break;
    }

    if (sfx != 0xffff)
        NWeaponTypes::play_sfx(sfx, x834_27_underwater, false, 0.165f);
}

void CPlayerGun::CancelCharge(CStateManager& mgr, bool withEffect)
{
    if (withEffect)
    {
        x32c_chargePhase = EChargePhase::ChargeCancelled;
        x72c_currentBeam->EnableSecondaryFx(CGunWeapon::ESecondaryFxType::CancelCharge);
    }
    else
    {
        x72c_currentBeam->EnableSecondaryFx(CGunWeapon::ESecondaryFxType::None);
    }

    x834_24_charging = false;
    x348_chargeCancelTimer = 0.f;
    x72c_currentBeam->ActivateCharge(false, false);
    SetGunLightActive(false, mgr);
}

void CPlayerGun::HandlePhazonBeamChange(CStateManager& mgr)
{
    bool inMorph = false;
    switch (x33c_phazonBeamState)
    {
    case EPhazonBeamState::Inactive:
        SetPhazonBeamMorph(true);
        x338_nextState = ENextState::EnterPhazonBeam;
        inMorph = true;
        break;
    case EPhazonBeamState::Active:
        if (!x835_25_inPhazonBeam)
        {
            SetPhazonBeamMorph(true);
            x338_nextState = ENextState::ExitPhazonBeam;
            inMorph = true;
            if (x75c_phazonBeam)
            {
                x75c_phazonBeam->SetClipWipeActive(false);
                x75c_phazonBeam->SetVeinsAlphaActive(true);
            }
        }
        break;
    default:
        break;
    }

    if (inMorph)
    {
        ResetBeamParams(mgr, *mgr.GetPlayerState(), true);
        x2f8_stateFlags = 0x8;
        PlayAnim(NWeaponTypes::EGunAnimType::FromBeam, false);
        if (x833_31_inFreeLook)
        {
            x832_30_requestReturnToDefault = true;
            x740_grappleArm->EnterIdle(mgr);
        }
        CancelCharge(mgr, false);
    }
}

void CPlayerGun::HandleWeaponChange(const CFinalInput& input, CStateManager& mgr)
{
    x833_25_ = false;
    if (ControlMapper::GetPressInput(ControlMapper::ECommands::Morph, input))
        StopContinuousBeam(mgr, true);
    if ((x2f8_stateFlags & 0x8) != 0x8)
    {
        if (!x835_25_inPhazonBeam)
            HandleBeamChange(input, mgr);
        else
            HandlePhazonBeamChange(mgr);
    }
}

void CPlayerGun::ProcessInput(const CFinalInput& input, CStateManager& mgr)
{
    CPlayerState& state = *mgr.GetPlayerState();
    bool damageNotMorphed = (x834_30_inBigStrike &&
        mgr.GetPlayer().GetMorphballTransitionState() != CPlayer::EPlayerMorphBallState::Morphed);
    if (x832_24_cancellingCharge || damageNotMorphed || (x2f8_stateFlags & 0x8) == 0x8)
        return;
    if (state.HasPowerUp(CPlayerState::EItemType::ChargeBeam))
    {
        if (!state.ItemEnabled(CPlayerState::EItemType::ChargeBeam))
            state.EnableItem(CPlayerState::EItemType::ChargeBeam);
    }
    else if (state.ItemEnabled(CPlayerState::EItemType::ChargeBeam))
    {
        state.DisableItem(CPlayerState::EItemType::ChargeBeam);
        ResetCharge(mgr, false);
    }
    switch (mgr.GetPlayer().GetMorphballTransitionState())
    {
    default:
        x2f4_fireButtonStates = 0;
        break;
    case CPlayer::EPlayerMorphBallState::Unmorphed:
        if ((x2f8_stateFlags & 0x10) != 0x10)
            HandleWeaponChange(input, mgr);
    case CPlayer::EPlayerMorphBallState::Morphed:
        x2f4_fireButtonStates =
            ControlMapper::GetDigitalInput(ControlMapper::ECommands::FireOrBomb, input) ? 1 : 0;
        x2f4_fireButtonStates |=
            ControlMapper::GetDigitalInput(ControlMapper::ECommands::MissileOrPowerBomb, input) ? 2 : 0;
        break;
    }
}

void CPlayerGun::UnLoadFidget()
{
    if ((x2fc_fidgetAnimBits & 0x1) == 0x1)
        x73c_gunMotion->GunController().UnLoadFidget();
    if ((x2fc_fidgetAnimBits & 0x2) == 0x2)
        x72c_currentBeam->UnLoadFidget();
    if ((x2fc_fidgetAnimBits & 0x4) == 0x4)
        if (CGunController* gc = x740_grappleArm->GunController())
            gc->UnLoadFidget();
    x2fc_fidgetAnimBits = 0;
}

void CPlayerGun::ReturnArmAndGunToDefault(CStateManager& mgr, bool returnToDefault)
{
    if (returnToDefault || !x833_31_inFreeLook)
    {
        x73c_gunMotion->ReturnToDefault(mgr, false);
        x740_grappleArm->ReturnToDefault(mgr, 0.f, false);
    }
    if (!x834_25_gunMotionFidgeting)
        x72c_currentBeam->ReturnToDefault(mgr);
    x834_25_gunMotionFidgeting = false;
}

void CPlayerGun::ReturnToRestPose()
{
    if (x832_31_inRestPose)
        return;
    if ((x2f8_stateFlags & 0x1) == 0x1)
        PlayAnim(NWeaponTypes::EGunAnimType::BasePosition, false);
    else if ((x2f8_stateFlags & 0x4) == 0x4)
        PlayAnim(NWeaponTypes::EGunAnimType::ToMissile, false);
    x832_31_inRestPose = true;
}

void CPlayerGun::ResetIdle(CStateManager& mgr)
{
    x550_camBob.SetState(CPlayerCameraBob::ECameraBobState::GunFireNoBob, mgr);
    if (x3a4_fidget.GetState() != CFidget::EState::NoFidget)
    {
        if (x3a4_fidget.GetState() == CFidget::EState::Loading)
            UnLoadFidget();
        ReturnArmAndGunToDefault(mgr, true);
    }
    x3a4_fidget.ResetAll();
    ReturnToRestPose();
    if (x324_idleState != EIdleState::NotIdle)
        x324_idleState = EIdleState::NotIdle;
    if (!x740_grappleArm->GetActive())
        x834_26_animPlaying = false;
}

void CPlayerGun::CancelFiring(CStateManager& mgr)
{
    if (x32c_chargePhase == EChargePhase::ComboFireDone)
        ReturnArmAndGunToDefault(mgr, true);
    if ((x2f8_stateFlags & 0x10) == 0x10)
    {
        StopContinuousBeam(mgr, true);
        if ((x2f8_stateFlags & 0x8) == 0x8)
        {
            x2f8_stateFlags |= 0x1;
            x2f8_stateFlags &= 0xFFE9;
        }
        x318_comboAmmoIdx = 0;
        x31c_missileMode = EMissleMode::Inactive;
    }
    if (x32c_chargePhase != EChargePhase::NotCharging)
    {
        x72c_currentBeam->ActivateCharge(false, false);
        SetGunLightActive(false, mgr);
        ResetCharge(mgr, true);
    }
    Reset(mgr, (x2f8_stateFlags & 0x2) == 0x2);
}

float CPlayerGun::GetBeamVelocity() const
{
    if (x72c_currentBeam->IsLoaded())
        return x72c_currentBeam->GetVelocityInfo().GetVelocity(int(x330_chargeState)).y;
    return 10.f;
}

void CPlayerGun::StopContinuousBeam(CStateManager& mgr, bool b1)
{
    if ((x2f8_stateFlags & 0x10) == 0x10)
    {
        ReturnArmAndGunToDefault(mgr, false);
        x744_auxWeapon->StopComboFx(mgr, b1);
        switch (x310_currentBeam)
        {
        case CPlayerState::EBeamId::Power:
        case CPlayerState::EBeamId::Wave:
        case CPlayerState::EBeamId::Plasma:
            // All except ice
            if (x310_currentBeam != CPlayerState::EBeamId::Power || x833_28_phazonBeamActive)
            {
                x72c_currentBeam->EnableSecondaryFx(
                    b1 ? CGunWeapon::ESecondaryFxType::None : CGunWeapon::ESecondaryFxType::CancelCharge);
            }
            break;
        default:
            break;
        }
    }
    else if (x833_28_phazonBeamActive)
    {
        if (static_cast<CPhazonBeam*>(x72c_currentBeam)->IsFiring())
            static_cast<CPhazonBeam*>(x72c_currentBeam)->StopBeam(mgr, b1);
    }
    else if (x310_currentBeam == CPlayerState::EBeamId::Plasma) // Plasma
    {
        if (static_cast<CPlasmaBeam*>(x72c_currentBeam)->IsFiring())
            static_cast<CPlasmaBeam*>(x72c_currentBeam)->StopBeam(mgr, b1);
    }
}

void CPlayerGun::CMotionState::Update(bool firing, float dt, zeus::CTransform& xf, CStateManager& mgr)
{
    if (firing)
    {
        x24_fireState = EFireState::StartFire;
        x8_fireTime = 0.f;
    }
    else if (x24_fireState != EFireState::NotFiring)
    {
        if (x8_fireTime > dt)
            x24_fireState = EFireState::Firing;
        x8_fireTime += dt;
    }

    if (x0_24_extendParabola && x20_state == EMotionState::LockOn)
    {
        float extendT = xc_curExtendDist / gGunExtendDistance;
        xf = xf * zeus::CTransform::RotateZ(zeus::degToRad(extendT * -4.f * (extendT - 1.f) * 15.f));
    }
    else
    {
        if (x24_fireState == EFireState::StartFire || x24_fireState == EFireState::Firing)
        {
            if (std::fabs(x14_rotationT - 1.f) < 0.1f)
            {
                x18_startRotation = x1c_endRotation;
                x14_rotationT = 0.f;
                if (x24_fireState == EFireState::StartFire)
                {
                    x1c_endRotation = mgr.GetActiveRandom()->Next() % 15;
                    x1c_endRotation *= (mgr.GetActiveRandom()->Next() % 100) > 45 ? 1.f : -1.f;
                }
                else
                {
                    x1c_endRotation = 0.f;
                    if (x18_startRotation == x1c_endRotation)
                    {
                        x10_curRotation = x1c_endRotation;
                        x24_fireState = EFireState::NotFiring;
                    }
                }
            }
            else
            {
                x10_curRotation = (x1c_endRotation - x18_startRotation) * x14_rotationT + x18_startRotation;
            }

            x14_rotationT += (1.f - x14_rotationT) * 0.8f * (10.f * dt);
            zeus::CTransform tmpXf =
                zeus::CQuaternion::fromAxisAngle(xf.basis[1], zeus::degToRad(x10_curRotation)).toTransform() *
                    xf.getRotation();
            tmpXf.basis = xf.basis;
            xf = tmpXf * zeus::CTransform::Translate(0.f, xc_curExtendDist, 0.f);
        }
        else
        {
            xf = xf * zeus::CTransform::Translate(0.f, xc_curExtendDist, 0.f);
        }
    }

    switch (x20_state)
    {
    case EMotionState::LockOn:
        xc_curExtendDist += 3.f * dt;
        if (xc_curExtendDist > gGunExtendDistance)
        {
            xc_curExtendDist = gGunExtendDistance;
            x20_state = EMotionState::One;
            x0_24_extendParabola = false;
        }
        break;
    case EMotionState::CancelLockOn:
        xc_curExtendDist -= 3.f * dt;
        if (xc_curExtendDist < 0.f)
        {
            xc_curExtendDist = 0.f;
            x20_state = EMotionState::Zero;
        }
        break;
    default:
        break;
    }

    if (!x0_24_extendParabola)
    {
        if (x4_extendParabolaDelayTimer < 30.f)
        {
            x4_extendParabolaDelayTimer += dt;
        }
        else
        {
            x0_24_extendParabola = true;
            x4_extendParabolaDelayTimer = 0.f;
        }
    }
}

void CPlayerGun::ChangeWeapon(const CPlayerState& playerState, CStateManager& mgr)
{
    if (x730_outgoingBeam != nullptr && x72c_currentBeam != x730_outgoingBeam)
        x730_outgoingBeam->Unload(mgr);

    x734_loadingBeam = x760_selectableBeams[int(x314_nextBeam)];
    if (x734_loadingBeam && x72c_currentBeam != x734_loadingBeam)
    {
        x734_loadingBeam->Load(mgr, false);
        x744_auxWeapon->Load(x314_nextBeam, mgr);
    }

    x72c_currentBeam->EnableFx(false);
    x834_28_requestImmediateRecharge = x32c_chargePhase != EChargePhase::NotCharging;
    ResetBeamParams(mgr, playerState, true);
    x678_morph.StartWipe(CGunMorph::EDir::In);
}

void CPlayerGun::GetLctrWithShake(zeus::CTransform& xfOut, const CModelData& mData, const std::string& lctrName,
                                  bool shake, bool dyn)
{
    if (dyn)
        xfOut = mData.GetScaledLocatorTransformDynamic(lctrName, nullptr);
    else
        xfOut = mData.GetScaledLocatorTransform(lctrName);

    if (x834_24_charging && shake)
        xfOut.origin += zeus::CVector3f(x34c_shakeX, 0.f, x350_shakeZ);
}

void CPlayerGun::UpdateLeftArmTransform(const CModelData& mData, const CStateManager& mgr)
{
    if (x834_26_animPlaying)
        x740_grappleArm->AuxTransform() = zeus::CTransform::Identity();
    else
        GetLctrWithShake(x740_grappleArm->AuxTransform(), mData, "elbow", true, false);

    x740_grappleArm->AuxTransform().origin = x740_grappleArm->AuxTransform() * zeus::CVector3f(-0.9f, -0.4f, 0.4f);
    x740_grappleArm->SetTransform(x3e8_xf);
}

CPlayerGun::CGunMorph::EMorphEvent CPlayerGun::CGunMorph::Update(float inY, float outY, float dt)
{
    EMorphEvent ret = EMorphEvent::None;

    if (x20_gunState == EGunState::InWipeDone)
    {
        x14_remHoldTime -= dt;
        if (x14_remHoldTime <= 0.f && x24_25_weaponChanged)
        {
            StartWipe(EDir::Out);
            x24_25_weaponChanged = false;
            x14_remHoldTime = 0.f;
            ret = EMorphEvent::InWipeDone;
        }
    }

    if (x24_24_morphing)
    {
        float omt = x8_remTime * xc_speed;
        float t = 1.f - omt;
        if (x1c_dir == EDir::In)
        {
            x0_yLerp = omt * outY + t * inY;
            x18_transitionFactor = omt;
        }
        else
        {
            x0_yLerp = omt * inY + t * outY;
            x18_transitionFactor = t;
        }

        if (x8_remTime <= 0.f)
        {
            x24_24_morphing = false;
            x8_remTime = 0.f;
            if (x1c_dir == EDir::In)
            {
                x20_gunState = EGunState::InWipeDone;
                x18_transitionFactor = 0.f;
            }
            else
            {
                x18_transitionFactor = 1.f;
                x20_gunState = EGunState::OutWipeDone;
                x1c_dir = EDir::Done;
                ret = EMorphEvent::OutWipeDone;
            }
        }
        else
        {
            x8_remTime -= dt;
        }
    }

    return ret;
}

void CPlayerGun::CGunMorph::StartWipe(EDir dir)
{
    x14_remHoldTime = x10_holoHoldTime;
    if (dir == EDir::In && x20_gunState == EGunState::InWipeDone)
        return;

    if (dir != x1c_dir && x20_gunState != EGunState::OutWipe)
    {
        x8_remTime = x4_gunTransformTime;
        xc_speed = 1.f / x4_gunTransformTime;
    }
    else if (x20_gunState != EGunState::InWipe)
    {
        x8_remTime = x4_gunTransformTime - x8_remTime;
    }

    x1c_dir = dir;
    x20_gunState = x1c_dir == EDir::In ? EGunState::InWipe : EGunState::OutWipe;
    x24_24_morphing = true;
}

static const u16 skIntoBeamSound[] = { 0, 1821, 1827, 1825 };

void CPlayerGun::ProcessGunMorph(float dt, CStateManager& mgr)
{
    bool isUnmorphed = mgr.GetPlayer().GetMorphballTransitionState() == CPlayer::EPlayerMorphBallState::Unmorphed;
    switch (x678_morph.GetGunState())
    {
    case CGunMorph::EGunState::InWipeDone:
        if (x310_currentBeam != x314_nextBeam && x734_loadingBeam != nullptr)
        {
            if (!isUnmorphed)
                x734_loadingBeam->Touch(mgr);
            if (x734_loadingBeam->IsLoaded() && x744_auxWeapon->IsLoaded())
            {
                x730_outgoingBeam = (x734_loadingBeam == x72c_currentBeam ? nullptr : x72c_currentBeam);
                x734_loadingBeam = nullptr;
                x310_currentBeam = x314_nextBeam;
                x320_currentAuxBeam = x314_nextBeam;
                x833_30_canShowAuxMuzzleEffect = true;
                x72c_currentBeam = x760_selectableBeams[int(x314_nextBeam)];
                x738_nextBeam = x72c_currentBeam;
                x678_morph.SetWeaponChanged();
                mgr.GetPlayerState()->SetCurrentBeam(x314_nextBeam);
            }
        }
        break;
    case CGunMorph::EGunState::InWipe:
    case CGunMorph::EGunState::OutWipe:
        x774_holoTransitionGen->SetGlobalTranslation(zeus::CVector3f(0.f, x678_morph.GetYLerp(), 0.f));
        x774_holoTransitionGen->Update(dt);
        break;
    default:
        break;
    }

    switch (x678_morph.Update(0.2f, 1.292392f, dt))
    {
    case CGunMorph::EMorphEvent::InWipeDone:
        CSfxManager::SfxStart(1775, 1.f, 0.f, true, 0x74, false, kInvalidAreaId);
        break;
    case CGunMorph::EMorphEvent::OutWipeDone:
        if (x730_outgoingBeam != nullptr && x72c_currentBeam != x730_outgoingBeam)
        {
            x730_outgoingBeam->Unload(mgr);
            x730_outgoingBeam = nullptr;
        }
        if (isUnmorphed)
            NWeaponTypes::play_sfx(skIntoBeamSound[int(x310_currentBeam)], x834_27_underwater, false, 0.165f);
        x72c_currentBeam->SetRainSplashGenerator(x748_rainSplashGenerator.get());
        x72c_currentBeam->EnableFx(true);
        PlayAnim(NWeaponTypes::EGunAnimType::ToBeam, false);
        if (x833_31_inFreeLook)
            EnterFreeLook(mgr);
        else if (x832_30_requestReturnToDefault)
            ReturnArmAndGunToDefault(mgr, false);
        if (x834_28_requestImmediateRecharge || (x2ec_lastFireButtonStates & 0x1) != 0)
        {
            if (mgr.GetPlayerState()->GetCurrentVisor() != CPlayerState::EPlayerVisor::Scan)
                x32c_chargePhase = EChargePhase::ChargeRequested;
            x834_28_requestImmediateRecharge = false;
        }
        x832_30_requestReturnToDefault = false;
        x338_nextState = ENextState::SetupBeam;
        break;
    default:
        break;
    }
}

void CPlayerGun::SetPhazonBeamFeedback(bool active)
{
    const char16_t* str = g_MainStringTable->GetString(21); // Hyper-mode
    CHUDMemoParms parms(5.f, true, !active, false);
    MP1::CSamusHud::DisplayHudMemo(str, parms);
    if (CSfxManager::IsPlaying(x2e8_phazonBeamSfx))
        CSfxManager::SfxStop(x2e8_phazonBeamSfx);
    x2e8_phazonBeamSfx.reset();
    if (active)
        x2e8_phazonBeamSfx = NWeaponTypes::play_sfx(3141, x834_27_underwater, false, 0.165f);
}

void CPlayerGun::StartPhazonBeamTransition(bool active, CStateManager& mgr, CPlayerState& playerState)
{
    if (x833_28_phazonBeamActive == active)
        return;
    x760_selectableBeams[int(x310_currentBeam)]->Unload(mgr);
    x760_selectableBeams[int(x310_currentBeam)] = active ? x75c_phazonBeam.get() : x738_nextBeam;
    ResetBeamParams(mgr, playerState, false);
    x72c_currentBeam = x760_selectableBeams[int(x310_currentBeam)];
    x833_28_phazonBeamActive = active;
    SetPhazonBeamFeedback(active);
    x72c_currentBeam->SetRainSplashGenerator(x748_rainSplashGenerator.get());
    x72c_currentBeam->EnableFx(true);
    x72c_currentBeam->SetDrawHologram(false);
    PlayAnim(NWeaponTypes::EGunAnimType::ToBeam, false);
    if (x833_31_inFreeLook)
        EnterFreeLook(mgr);
    else if (x832_30_requestReturnToDefault)
        ReturnArmAndGunToDefault(mgr, false);
    x832_30_requestReturnToDefault = false;
}

void CPlayerGun::ProcessPhazonGunMorph(float dt, CStateManager& mgr)
{
    if (x835_26_phazonBeamMorphing)
    {
        if (x835_27_intoPhazonBeam)
        {
            x39c_phazonMorphT += 15.f * dt;
            if (x39c_phazonMorphT > 1.f)
                x39c_phazonMorphT = 1.f;
        }
        else
        {
            x39c_phazonMorphT -= 2.f * dt;
            if (x39c_phazonMorphT < 0.f)
            {
                x835_26_phazonBeamMorphing = false;
                x39c_phazonMorphT = 0.f;
            }
        }
    }

    switch (x33c_phazonBeamState)
    {
    case EPhazonBeamState::Entering:
        if (x75c_phazonBeam)
        {
            x75c_phazonBeam->Update(dt, mgr);
            if (x75c_phazonBeam->IsLoaded())
            {
                StartPhazonBeamTransition(true, mgr, *mgr.GetPlayerState());
                SetPhazonBeamMorph(false);
                x33c_phazonBeamState = EPhazonBeamState::Active;
                x338_nextState = ENextState::SetupBeam;
            }
        }
        break;
    case EPhazonBeamState::Exiting:
        if (x738_nextBeam)
        {
            x738_nextBeam->Update(dt, mgr);
            if (x738_nextBeam->IsLoaded())
            {
                x835_25_inPhazonBeam = false;
                StartPhazonBeamTransition(false, mgr, *mgr.GetPlayerState());
                SetPhazonBeamMorph(false);
                x33c_phazonBeamState = EPhazonBeamState::Inactive;
                x338_nextState = ENextState::SetupBeam;
            }
        }
        break;
    default:
        break;
    }
}

void CPlayerGun::EnableChargeFx(EChargeState state, CStateManager& mgr)
{
    x72c_currentBeam->ActivateCharge(true, false);
    SetGunLightActive(true, mgr);
    x72c_currentBeam->EnableSecondaryFx(CGunWeapon::ESecondaryFxType::Charge);
    StopContinuousBeam(mgr, false);

    switch (x310_currentBeam)
    {
    case CPlayerState::EBeamId::Plasma:
    case CPlayerState::EBeamId::Power:
        x832_25_chargeEffectVisible = true;
    default:
        break;
    }

    x2f8_stateFlags |= 0x7;
    x318_comboAmmoIdx = 1;
    x338_nextState = ENextState::StatusQuo;
    x833_30_canShowAuxMuzzleEffect = true;

    x800_auxMuzzleGenerators[int(x320_currentAuxBeam)] =
        std::make_unique<CElementGen>(x7c0_auxMuzzleEffects[int(x320_currentAuxBeam)]);

    x800_auxMuzzleGenerators[int(x320_currentAuxBeam)]->SetParticleEmission(true);
}

static constexpr float kChargeSpeed = 1.f / CPlayerState::GetMissileComboChargeFactor();
static constexpr float kChargeFxStart = 1.f / CPlayerState::GetMissileComboChargeFactor();
static constexpr float kChargeAnimStart = 0.25f / CPlayerState::GetMissileComboChargeFactor();
static constexpr float kChargeStart = 0.025f / CPlayerState::GetMissileComboChargeFactor();

static const u16 skBeamChargeUpSound[] = { 1766, 1759, 1844, 1839 };

void CPlayerGun::UpdateChargeState(float dt, CStateManager& mgr)
{
    switch (x32c_chargePhase)
    {
    case EChargePhase::ChargeRequested:
        x340_chargeBeamFactor = 0.f;
        x330_chargeState = EChargeState::Normal;
        x832_27_chargeAnimStarted = false;
        x834_24_charging = true;
        x32c_chargePhase = EChargePhase::AnimAndSfx;
        break;
    case EChargePhase::AnimAndSfx:
        if (!x832_27_chargeAnimStarted)
        {
            if (x340_chargeBeamFactor > kChargeStart && x832_25_chargeEffectVisible)
                x832_25_chargeEffectVisible = false;
            if (x340_chargeBeamFactor > kChargeAnimStart)
            {
                PlayAnim(NWeaponTypes::EGunAnimType::ChargeUp, false);
                if (!x2e0_chargeSfx)
                    x2e0_chargeSfx = NWeaponTypes::play_sfx(skBeamChargeUpSound[int(x310_currentBeam)],
                                             x834_27_underwater, true, 0.165f);
                if (x830_chargeRumbleHandle == -1)
                    x830_chargeRumbleHandle = mgr.GetRumbleManager().Rumble(mgr, ERumbleFxId::Twelve, 1.f,
                                                                            ERumblePriority::Three);
                x832_27_chargeAnimStarted = true;
            }
        }
        else
        {
            if (x340_chargeBeamFactor >= kChargeFxStart && (x2f8_stateFlags & 0x8) != 0x8)
            {
                x832_25_chargeEffectVisible = true;
                x832_27_chargeAnimStarted = false;
                x32c_chargePhase = EChargePhase::FxGrowing;
                x330_chargeState = EChargeState::Charged;
                EnableChargeFx(EChargeState::Charged, mgr);
                PlayAnim(NWeaponTypes::EGunAnimType::ChargeLoop, true);
            }
        }
        break;
    case EChargePhase::FxGrowing:
        if (x340_chargeBeamFactor >= 1.f)
            x32c_chargePhase = EChargePhase::FxGrown;
        break;
    case EChargePhase::ComboXfer:
        if (x344_comboXferTimer >= 1.f)
        {
            x32c_chargePhase = EChargePhase::ComboXferDone;
            x832_25_chargeEffectVisible = false;
        }
        break;
    case EChargePhase::ComboXferDone:
        x32c_chargePhase = EChargePhase::ComboFire;
        x348_chargeCancelTimer = 0.f;
        break;
    case EChargePhase::ComboFire:
        x740_grappleArm->EnterComboFire(s32(x310_currentBeam), mgr);
        x73c_gunMotion->PlayPasAnim(SamusGun::EAnimationState::ComboFire, mgr, 0.f, false);
        x72c_currentBeam->PlayPasAnim(SamusGun::EAnimationState::ComboFire, mgr, 0.f);
        x833_31_inFreeLook = false;
        x32c_chargePhase = EChargePhase::ComboFireDone;
        break;
    case EChargePhase::ChargeCancelled:
        if ((x2f8_stateFlags & 0x10) != 0x10)
        {
            x348_chargeCancelTimer += dt;
            if (x348_chargeCancelTimer >= 0.3f && x72c_currentBeam->IsChargeAnimOver())
                x32c_chargePhase = EChargePhase::ChargeDone;
        }
        else
        {
            x832_24_cancellingCharge = false;
        }
        break;
    case EChargePhase::ChargeDone:
        ResetCharge(mgr, false);
        Reset(mgr, false);
        break;
    default:
        break;
    }

    if (x2e0_chargeSfx)
        CSfxManager::PitchBend(x2e0_chargeSfx, x834_27_underwater ? -1.f : 0.f);
    if (x32c_chargePhase > EChargePhase::NotCharging && x32c_chargePhase < EChargePhase::FxGrown)
    {
        x340_chargeBeamFactor += kChargeSpeed * dt;
        if (x340_chargeBeamFactor > 1.f)
            x340_chargeBeamFactor = 1.f;
    }
}

void CPlayerGun::UpdateAuxWeapons(float dt, const zeus::CTransform& targetXf, CStateManager& mgr)
{
    zeus::CVector3f firePoint =
        x4a8_gunWorldXf * x418_beamLocalXf.origin + mgr.GetCameraManager()->GetGlobalCameraTranslation(mgr);
    bool done = x744_auxWeapon->UpdateComboFx(dt, sGunScale, firePoint, targetXf, mgr);
    if ((x2f8_stateFlags & 0x10) == 0x10)
    {
        if (x310_currentBeam == CPlayerState::EBeamId::Wave && x744_auxWeapon->HasTarget(mgr) == kInvalidUniqueId)
        {
            TUniqueId targetId = GetTargetId(mgr);
            if (targetId == kInvalidUniqueId)
                targetId = mgr.GetPlayer().GetAimTarget();
            x744_auxWeapon->SetNewTarget(targetId, mgr);
        }
        if (done)
            return;
        done = x310_currentBeam == CPlayerState::EBeamId::Wave || x310_currentBeam == CPlayerState::EBeamId::Plasma;
        if (!done)
            if (x72c_currentBeam->ComboFireOver())
                done = true;
        x72c_currentBeam->EnableSecondaryFx(CGunWeapon::ESecondaryFxType::CancelCharge);
        if (done)
        {
            x32c_chargePhase = EChargePhase::ChargeDone;
            ReturnArmAndGunToDefault(mgr, false);
            if ((x2f8_stateFlags & 0x8) != 0x8)
            {
                x2f8_stateFlags |= 0x1;
                x2f8_stateFlags &= 0xFFE9;
            }
            x318_comboAmmoIdx = 0;
            x31c_missileMode = EMissleMode::Inactive;
        }
    }
    else if (x833_28_phazonBeamActive)
    {
        static_cast<CPhazonBeam*>(x72c_currentBeam)->UpdateBeam(dt, targetXf, x418_beamLocalXf.origin, mgr);
    }
    else if (x310_currentBeam == CPlayerState::EBeamId::Plasma)
    {
        static_cast<CPlasmaBeam*>(x72c_currentBeam)->UpdateBeam(dt, targetXf, x418_beamLocalXf.origin, mgr);
    }
}

void CPlayerGun::DoUserAnimEvent(float dt, CStateManager& mgr, const CInt32POINode& node, EUserEventType type)
{
    switch (type)
    {
    case EUserEventType::Projectile:
        if (x32c_chargePhase != EChargePhase::ComboFireDone)
            return;
        bool doFireSecondary;
        if (x310_currentBeam != CPlayerState::EBeamId::Wave && x310_currentBeam != CPlayerState::EBeamId::Plasma)
            doFireSecondary = true;
        else
            doFireSecondary = (x2ec_lastFireButtonStates & 0x1) != 0;
        if (doFireSecondary)
            FireSecondary(dt, mgr);
        if ((x2f8_stateFlags & 0x10) != 0x10)
            x2f8_stateFlags |= 0x10;
        CancelCharge(mgr, true);
        if (doFireSecondary)
            x72c_currentBeam->EnableSecondaryFx(CGunWeapon::ESecondaryFxType::ToCombo);
        break;
    default:
        break;
    }
}

void CPlayerGun::DoUserAnimEvents(float dt, CStateManager& mgr)
{
    zeus::CVector3f posToCam =
        mgr.GetCameraManager()->GetCurrentCamera(mgr)->GetTranslation() - x3e8_xf.origin;
    const CAnimData& animData = *x72c_currentBeam->GetSolidModelData().GetAnimationData();
    for (int i=0 ; i<animData.GetPassedSoundPOICount() ; ++i)
    {
        const CSoundPOINode& node = CAnimData::g_SoundPOINodes[i];
        if (node.GetPoiType() != EPOIType::Sound ||
            (node.GetCharacterIndex() != -1 && animData.x204_charIdx != node.GetCharacterIndex()))
            continue;
        NWeaponTypes::do_sound_event(x670_animSfx, x328_animSfxPitch, false, node.GetSfxId(), node.GetWeight(),
                                     node.GetFlags(), node.GetFalloff(), node.GetMaxDist(), 0.16f, 1.f, posToCam,
                                     x3e8_xf.origin, mgr.GetPlayer().GetAreaIdAlways(), mgr);
    }
    for (int i=0 ; i<animData.GetPassedIntPOICount() ; ++i)
    {
        const CInt32POINode& node = CAnimData::g_Int32POINodes[i];
        switch (node.GetPoiType())
        {
        case EPOIType::UserEvent:
            DoUserAnimEvent(dt, mgr, node, EUserEventType(node.GetValue()));
            break;
        case EPOIType::SoundInt32:
            if (node.GetCharacterIndex() != -1 && animData.x204_charIdx != node.GetCharacterIndex())
                break;
            NWeaponTypes::do_sound_event(x670_animSfx, x328_animSfxPitch, false, u32(node.GetValue()),
                                         node.GetWeight(), node.GetFlags(), 0.1f, 150.f, 0.16f, 1.f, posToCam,
                                         x3e8_xf.origin, mgr.GetPlayer().GetAreaIdAlways(), mgr);
            break;
        default:
            break;
        }
    }
}

TUniqueId CPlayerGun::GetTargetId(CStateManager& mgr) const
{
    TUniqueId ret = mgr.GetPlayer().GetOrbitTargetId();
    if (x832_26_comboFiring && ret == kInvalidUniqueId &&
        x310_currentBeam == CPlayerState::EBeamId::Wave)
        ret = mgr.GetPlayer().GetOrbitNextTargetId();
    if (ret == kInvalidUniqueId)
        return ret;
    if (TCastToConstPtr<CActor> act = mgr.GetObjectById(ret))
        if (!act->GetMaterialList().HasMaterial(EMaterialTypes::Target))
            ret = kInvalidUniqueId;
    return ret;
}

void CPlayerGun::CancelLockOn()
{
    if (x832_29_lockedOn)
    {
        x832_29_lockedOn = false;
        x6a0_motionState.SetState(CMotionState::EMotionState::CancelLockOn);
        if (x32c_chargePhase == EChargePhase::NotCharging && x318_comboAmmoIdx != 1)
            PlayAnim(NWeaponTypes::EGunAnimType::BasePosition, false);
    }
}

static const CPlayerState::EItemType skItemArr[] =
{
    CPlayerState::EItemType::Invalid,
    CPlayerState::EItemType::Missiles
};

static const u16 skItemEmptySound[] = { 0, 1763 };

void CPlayerGun::FireSecondary(float dt, CStateManager& mgr)
{
    if (mgr.GetCameraManager()->IsInCinematicCamera())
        return;

    if (x835_25_inPhazonBeam || x318_comboAmmoIdx == 0 ||
        !mgr.GetPlayerState()->HasPowerUp(skItemArr[x318_comboAmmoIdx]) || (x2f8_stateFlags & 0x4) != 0x4)
    {
        NWeaponTypes::play_sfx(1781, x834_27_underwater, false, 0.165f);
        return;
    }

    bool comboFired = false;
    if (x318_comboAmmoIdx == 1)
    {
        x300_remainingMissiles = mgr.GetPlayerState()->GetItemAmount(CPlayerState::EItemType::Missiles);
        if (mgr.GetWeaponIdCount(x538_playerId, EWeaponType::Missile) < 3 && x300_remainingMissiles != 0)
        {
            mgr.GetPlayerState()->DecrPickup(CPlayerState::EItemType::Missiles,
                                             x832_26_comboFiring ?
                                             mgr.GetPlayerState()->GetMissileCostForAltAttack() : 1);
            comboFired = true;
        }
        if (x300_remainingMissiles > 5)
            x300_remainingMissiles = 5;
        else
            x300_remainingMissiles -= 1;
    }

    if (comboFired)
    {
        TUniqueId targetId = GetTargetId(mgr);
        if (x832_26_comboFiring && targetId == kInvalidUniqueId && x310_currentBeam == CPlayerState::EBeamId::Wave)
            targetId = mgr.GetPlayer().GetAimTarget();
        zeus::CTransform fireXf = x833_29_pointBlankWorldSurface ?
                                  x448_elbowWorldXf : x4a8_gunWorldXf * x418_beamLocalXf;
        if (!x833_29_pointBlankWorldSurface && x364_gunStrikeCoolTimer <= 0.f)
        {
            zeus::CVector3f backupOrigin = fireXf.origin;
            fireXf = x478_assistAimXf;
            fireXf.origin = backupOrigin;
        }
        fireXf.origin += mgr.GetCameraManager()->GetGlobalCameraTranslation(mgr);
        x744_auxWeapon->Fire(dt, x834_27_underwater, x310_currentBeam, x330_chargeState, fireXf,
                             mgr, x72c_currentBeam->GetWeaponType(), targetId);
        mgr.InformListeners(x4a8_gunWorldXf.origin, EListenNoiseType::Zero);
        x3a0_missileExitTimer = 7.f;
        if (!x832_26_comboFiring)
        {
            PlayAnim(NWeaponTypes::EGunAnimType::MissileShoot, false);
            x338_nextState = x300_remainingMissiles > 0 ? ENextState::MissileReload : ENextState::MissileShotDone;
            x2f8_stateFlags &= ~0x4;
        }
    }
    else
    {
        NWeaponTypes::play_sfx(skItemEmptySound[x318_comboAmmoIdx], x834_27_underwater, false, 0.165f);
    }
}

void CPlayerGun::ResetCharged(float dt, CStateManager& mgr)
{
    if (x832_26_comboFiring)
        return;
    if (x32c_chargePhase >= EChargePhase::FxGrowing)
    {
        x833_30_canShowAuxMuzzleEffect = false;
        UpdateNormalShotCycle(dt, mgr);
        x832_24_cancellingCharge = true;
        CancelCharge(mgr, true);
    }
    else if (x32c_chargePhase != EChargePhase::NotCharging)
    {
        x320_currentAuxBeam = x310_currentBeam;
        x833_30_canShowAuxMuzzleEffect = true;
        x32c_chargePhase = EChargePhase::ChargeDone;
    }
    StopChargeSound(mgr);
}

void CPlayerGun::ActivateCombo(CStateManager& mgr)
{
    if (x832_26_comboFiring)
        return;

    if (mgr.GetPlayerState()->GetItemAmount(skItemArr[x318_comboAmmoIdx]) >=
        mgr.GetPlayerState()->GetMissileCostForAltAttack())
    {
        bool canFire = true;
        if (x310_currentBeam == CPlayerState::EBeamId::Plasma)
            canFire = !x834_27_underwater;
        if (canFire)
        {
            x832_26_comboFiring = true;
            const auto& xferEffect = x72c_currentBeam->GetComboXferDescr();
            if (xferEffect.IsLoaded())
            {
                x77c_comboXferGen =
                    std::make_unique<CElementGen>(xferEffect);
                x77c_comboXferGen->SetGlobalScale(sGunScale);
            }
            x72c_currentBeam->EnableCharge(true);
            StopChargeSound(mgr);
            NWeaponTypes::play_sfx(1762, x834_27_underwater, false, 0.165f);
            x32c_chargePhase = EChargePhase::ComboXfer;
        }
    }
    else
    {
        NWeaponTypes::play_sfx(1781, x834_27_underwater, false, 0.165f);
    }
}

void CPlayerGun::ProcessChargeState(u32 releasedStates, u32 pressedStates, CStateManager& mgr, float dt)
{
    if ((releasedStates & 0x1) != 0)
        ResetCharged(dt, mgr);
    if ((pressedStates & 0x1) != 0)
    {
        if (x32c_chargePhase == EChargePhase::NotCharging && (pressedStates & 0x1) != 0 &&
            x348_chargeCancelTimer == 0.f && x832_28_readyForShot)
        {
            UpdateNormalShotCycle(dt, mgr);
            x32c_chargePhase = EChargePhase::ChargeRequested;
        }
    }
    else if (mgr.GetPlayerState()->HasPowerUp(CPlayerState::EItemType::Missiles) && (pressedStates & 0x2) != 0)
    {
        if (x32c_chargePhase >= EChargePhase::FxGrown)
        {
            if (mgr.GetPlayerState()->HasPowerUp(skBeamComboArr[int(x310_currentBeam)]))
                ActivateCombo(mgr);
        }
        else if (x32c_chargePhase == EChargePhase::NotCharging)
        {
            FireSecondary(dt, mgr);
        }
    }
}

void CPlayerGun::ResetNormal(CStateManager& mgr)
{
    Reset(mgr, false);
    x832_28_readyForShot = false;
}

void CPlayerGun::UpdateNormalShotCycle(float dt, CStateManager& mgr)
{
    if (!ExitMissile())
        return;
    if (mgr.GetCameraManager()->IsInCinematicCamera())
        return;
    x832_25_chargeEffectVisible = x833_28_phazonBeamActive || x310_currentBeam != CPlayerState::EBeamId::Plasma ||
        x32c_chargePhase != EChargePhase::NotCharging;
    x30c_rapidFireShots += 1;
    zeus::CTransform xf = x833_29_pointBlankWorldSurface ? x448_elbowWorldXf : x4a8_gunWorldXf * x418_beamLocalXf;
    if (!x833_29_pointBlankWorldSurface && x364_gunStrikeCoolTimer <= 0.f)
    {
        zeus::CVector3f oldOrigin = xf.origin;
        xf = x478_assistAimXf;
        xf.origin = oldOrigin;
    }
    xf.origin += mgr.GetCameraManager()->GetGlobalCameraTranslation(mgr);
    x38c_muzzleEffectVisTimer = 0.0625f;
    TUniqueId homingTarget;
    if (x72c_currentBeam->GetVelocityInfo().GetTargetHoming(int(x330_chargeState)))
        homingTarget = GetTargetId(mgr);
    else
        homingTarget = kInvalidUniqueId;
    x72c_currentBeam->Fire(x834_27_underwater, dt, x330_chargeState, xf, mgr, homingTarget,
                           x340_chargeBeamFactor, x340_chargeBeamFactor);
    mgr.InformListeners(x4a8_gunWorldXf.origin, EListenNoiseType::Zero);
}

void CPlayerGun::ProcessNormalState(u32 releasedStates, u32 pressedStates, CStateManager& mgr, float dt)
{
    if ((releasedStates & 0x1) != 0)
        ResetNormal(mgr);
    if ((pressedStates & 0x1) != 0 && x348_chargeCancelTimer == 0.f && x832_28_readyForShot)
        UpdateNormalShotCycle(dt, mgr);
    else if ((pressedStates & 0x2) != 0)
        FireSecondary(dt, mgr);
}

void CPlayerGun::UpdateWeaponFire(float dt, const CPlayerState& playerState, CStateManager& mgr)
{
    u32 oldFiring = x2ec_lastFireButtonStates;
    x2ec_lastFireButtonStates = x2f4_fireButtonStates;
    u32 pressedStates = x2f4_fireButtonStates & (oldFiring ^ x2f4_fireButtonStates);
    x2f0_pressedFireButtonStates = pressedStates;
    u32 releasedStates = oldFiring & (oldFiring ^ x2f4_fireButtonStates);
    x832_28_readyForShot = false;

    CPlayer& player = mgr.GetPlayer();
    if (!x832_24_cancellingCharge && !x834_30_inBigStrike)
    {
        float coolDown = x72c_currentBeam->GetWeaponInfo().x0_coolDown;
        if ((pressedStates & 0x1) == 0)
        {
            if (x390_cooldown >= coolDown)
            {
                x390_cooldown = coolDown;
                if (player.GetMorphballTransitionState() == CPlayer::EPlayerMorphBallState::Unmorphed &&
                    mgr.GetPlayerState()->ItemEnabled(CPlayerState::EItemType::ChargeBeam) &&
                    player.GetGunHolsterState() == CPlayer::EGunHolsterState::Drawn &&
                    player.GetGrappleState() == CPlayer::EGrappleState::None &&
                    mgr.GetPlayerState()->GetTransitioningVisor() != CPlayerState::EPlayerVisor::Scan &&
                    mgr.GetPlayerState()->GetCurrentVisor() != CPlayerState::EPlayerVisor::Scan &&
                    (x2ec_lastFireButtonStates & 0x1) != 0 && x32c_chargePhase == EChargePhase::NotCharging)
                {
                    x832_28_readyForShot = true;
                    pressedStates |= 0x1;
                    x390_cooldown = 0.f;
                }
            }
        }
        else if (x390_cooldown >= coolDown)
        {
            x832_28_readyForShot = true;
            x390_cooldown = 0.f;
        }
        x390_cooldown += dt;
    }

    if (x834_28_requestImmediateRecharge)
        x834_28_requestImmediateRecharge = (x2ec_lastFireButtonStates & 0x1) != 0;

    if (player.GetMorphballTransitionState() == CPlayer::EPlayerMorphBallState::Morphed)
    {
        x835_28_bombReady = false;
        x835_29_powerBombReady = false;
        if (!x835_31_actorAttached)
        {
            x835_28_bombReady = false;
            if (x53a_powerBomb != kInvalidUniqueId &&
                !mgr.CanCreateProjectile(x538_playerId, EWeaponType::PowerBomb, 1))
            {
                auto* pb = static_cast<const CPowerBomb*>(mgr.GetObjectById(x53a_powerBomb));
                if (pb && pb->GetCurTime() <= 4.25f)
                    x835_28_bombReady = false;
                else
                    x53a_powerBomb = kInvalidUniqueId;
            }
            if (((pressedStates & 0x1) != 0 || x32c_chargePhase != EChargePhase::NotCharging) &&
                mgr.GetPlayerState()->HasPowerUp(CPlayerState::EItemType::MorphBallBombs))
            {
                if (x835_28_bombReady)
                    DropBomb(EBWeapon::Bomb, mgr);
            }
            else if (mgr.GetPlayerState()->HasPowerUp(CPlayerState::EItemType::PowerBombs) &&
                     mgr.GetPlayerState()->GetItemAmount(CPlayerState::EItemType::PowerBombs) > 0)
            {
                x835_29_powerBombReady = mgr.CanCreateProjectile(x538_playerId, EWeaponType::PowerBomb, 1) &&
                                         mgr.CanCreateProjectile(x538_playerId, EWeaponType::Bomb, 1);
                if ((pressedStates & 0x2) != 0 && x835_29_powerBombReady)
                    DropBomb(EBWeapon::PowerBomb, mgr);
            }
        }
    }
    else if ((x2f8_stateFlags & 0x8) != 0x8 &&
             player.GetMorphballTransitionState() == CPlayer::EPlayerMorphBallState::Unmorphed)
    {
        if ((pressedStates & 0x2) != 0 && x318_comboAmmoIdx == 0 &&
            (x2f8_stateFlags & 0x2) != 0x2 && x32c_chargePhase == EChargePhase::NotCharging)
        {
            u32 missileCount = mgr.GetPlayerState()->GetItemAmount(CPlayerState::EItemType::Missiles);
            if (x338_nextState != ENextState::EnterMissile && x338_nextState != ENextState::ExitMissile)
            {
                if (mgr.GetPlayerState()->HasPowerUp(CPlayerState::EItemType::Missiles) && missileCount > 0)
                {
                    x300_remainingMissiles = missileCount;
                    if (x300_remainingMissiles > 5)
                        x300_remainingMissiles = 5;
                    if (!x835_25_inPhazonBeam)
                    {
                        x2f8_stateFlags &= ~0x1;
                        x2f8_stateFlags |= 0x6;
                        x318_comboAmmoIdx = 1;
                        x31c_missileMode = EMissleMode::Active;
                    }
                    FireSecondary(dt, mgr);
                }
                else
                {
                    if (!CSfxManager::IsPlaying(x2e4_invalidSfx))
                        x2e4_invalidSfx = NWeaponTypes::play_sfx(1781, x834_27_underwater, false, 0.165f);
                    else
                        x2e4_invalidSfx.reset();
                }
            }
        }
        else
        {
            if (x3a4_fidget.GetState() == CFidget::EState::NoFidget)
            {
                if ((x2f8_stateFlags & 0x10) == 0x10 && x744_auxWeapon->IsComboFxActive(mgr))
                {
                    if (x2ec_lastFireButtonStates == 0 ||
                        (x310_currentBeam == CPlayerState::EBeamId::Wave && x833_29_pointBlankWorldSurface))
                    {
                        StopContinuousBeam(mgr, (x2f8_stateFlags & 0x8) == 0x8);
                    }
                }
                else
                {
                    if (mgr.GetPlayerState()->ItemEnabled(CPlayerState::EItemType::ChargeBeam) &&
                        x33c_phazonBeamState == EPhazonBeamState::Inactive)
                        ProcessChargeState(releasedStates, pressedStates, mgr, dt);
                    else
                        ProcessNormalState(releasedStates, pressedStates, mgr, dt);
                }
            }
        }
    }
}

void CPlayerGun::EnterFreeLook(CStateManager& mgr)
{
    if (!x832_30_requestReturnToDefault)
        x73c_gunMotion->PlayPasAnim(SamusGun::EAnimationState::FreeLook, mgr, 0.f, false);
    x740_grappleArm->EnterFreeLook(x835_25_inPhazonBeam ? 1 : s32(x310_currentBeam),
                                   x73c_gunMotion->GetFreeLookSetId(), mgr);
}

void CPlayerGun::SetFidgetAnimBits(int animSet, bool beamOnly)
{
    x2fc_fidgetAnimBits = 0;
    if (beamOnly)
    {
        x2fc_fidgetAnimBits = 2;
        return;
    }

    switch (x3a4_fidget.GetType())
    {
    case SamusGun::EFidgetType::Minor:
        x2fc_fidgetAnimBits = 1;
        if (animSet != 1)
            return;
        x2fc_fidgetAnimBits |= 4;
        break;
    case SamusGun::EFidgetType::Major:
        if (animSet >= 6 || animSet < 4)
            x2fc_fidgetAnimBits = 2;
        else
            x2fc_fidgetAnimBits = 1;
        x2fc_fidgetAnimBits |= 4;
        break;
    default:
        break;
    }
}

void CPlayerGun::AsyncLoadFidget(CStateManager& mgr)
{
    SetFidgetAnimBits(x3a4_fidget.GetAnimSet(), x3a4_fidget.GetState() == CFidget::EState::HolsterBeam);
    if ((x2fc_fidgetAnimBits & 0x1) == 0x1)
        x73c_gunMotion->GunController().LoadFidgetAnimAsync(mgr, s32(x3a4_fidget.GetType()),
                                                            s32(x310_currentBeam), x3a4_fidget.GetAnimSet());
    if ((x2fc_fidgetAnimBits & 0x2) == 0x2)
    {
        x72c_currentBeam->AsyncLoadFidget(mgr, (x3a4_fidget.GetState() == CFidget::EState::HolsterBeam ?
            SamusGun::EFidgetType::Minor : x3a4_fidget.GetType()), x3a4_fidget.GetAnimSet());
        x832_31_inRestPose = false;
    }
    if ((x2fc_fidgetAnimBits & 0x4) == 0x4)
        if (CGunController* gc = x740_grappleArm->GunController())
            gc->LoadFidgetAnimAsync(mgr, s32(x3a4_fidget.GetType()),
                                    x3a4_fidget.GetType() != SamusGun::EFidgetType::Minor ? s32(x310_currentBeam) : 0,
                                    x3a4_fidget.GetAnimSet());
}

bool CPlayerGun::IsFidgetLoaded() const
{
    int loadFlags = 0;
    if ((x2fc_fidgetAnimBits & 0x1) == 0x1 && x73c_gunMotion->GunController().IsFidgetLoaded())
        loadFlags |= 0x1;
    if ((x2fc_fidgetAnimBits & 0x2) == 0x2 && x72c_currentBeam->IsFidgetLoaded())
        loadFlags |= 0x2;
    if ((x2fc_fidgetAnimBits & 0x4) == 0x4)
        if (CGunController* gc = x740_grappleArm->GunController())
            if (gc->IsFidgetLoaded())
                loadFlags |= 0x4;
    return x2fc_fidgetAnimBits == loadFlags;
}

void CPlayerGun::EnterFidget(CStateManager& mgr)
{
    if ((x2fc_fidgetAnimBits & 0x1) == 0x1)
    {
        x73c_gunMotion->EnterFidget(mgr, x3a4_fidget.GetType(), x3a4_fidget.GetAnimSet());
        x834_25_gunMotionFidgeting = true;
    }
    else
    {
        x834_25_gunMotionFidgeting = false;
    }

    if ((x2fc_fidgetAnimBits & 0x2) == 0x2)
        x72c_currentBeam->EnterFidget(mgr, x3a4_fidget.GetType(), x3a4_fidget.GetAnimSet());

    if ((x2fc_fidgetAnimBits & 0x4) == 0x4)
        x740_grappleArm->EnterFidget(mgr, x3a4_fidget.GetType(),
                                     x3a4_fidget.GetType() != SamusGun::EFidgetType::Minor ? s32(x310_currentBeam) : 0,
                                     x3a4_fidget.GetAnimSet());

    UnLoadFidget();
    x3a4_fidget.DoneLoading();
}

void CPlayerGun::UpdateGunIdle(bool inStrikeCooldown, float camBobT, float dt, CStateManager& mgr)
{
    CPlayer& player = mgr.GetPlayer();
    if (player.IsInFreeLook() && !x832_29_lockedOn && !x740_grappleArm->IsGrappling() &&
        x3a4_fidget.GetState() != CFidget::EState::HolsterBeam &&
        player.GetGunHolsterState() == CPlayer::EGunHolsterState::Drawn && !x834_30_inBigStrike)
    {
        if ((x2f8_stateFlags & 0x8) != 0x8)
        {
            if (!x833_31_inFreeLook && !x834_26_animPlaying)
            {
                if (x388_enterFreeLookDelayTimer < 0.25f)
                    x388_enterFreeLookDelayTimer += dt;
                if (x388_enterFreeLookDelayTimer >= 0.25f && !x740_grappleArm->IsSuitLoading())
                {
                    EnterFreeLook(mgr);
                    x833_31_inFreeLook = true;
                }
            }
            else
            {
                x388_enterFreeLookDelayTimer = 0.f;
                if (x834_26_animPlaying)
                    ResetIdle(mgr);
            }
        }
    }
    else
    {
        if (x833_31_inFreeLook)
        {
            if ((x2f8_stateFlags & 0x10) != 0x10)
            {
                x73c_gunMotion->ReturnToDefault(mgr, x834_30_inBigStrike);
                x740_grappleArm->ReturnToDefault(mgr, 0.f, false);
            }
            x833_31_inFreeLook = false;
        }
        x388_enterFreeLookDelayTimer = 0.f;
        if (player.GetMorphballTransitionState() != CPlayer::EPlayerMorphBallState::Morphed)
        {
            x833_24_isFidgeting = (player.GetSurfaceRestraint() != CPlayer::ESurfaceRestraints::Water &&
                mgr.GetPlayerState()->GetCurrentVisor() != CPlayerState::EPlayerVisor::Scan &&
                (x2f4_fireButtonStates & 0x3) == 0 && x32c_chargePhase == EChargePhase::NotCharging &&
                !x832_29_lockedOn && (x2f8_stateFlags & 0x8) != 0x8 && x364_gunStrikeCoolTimer <= 0.f &&
                player.GetPlayerMovementState() == CPlayer::EPlayerMovementState::OnGround &&
                !player.IsInFreeLook() && !player.GetFreeLookStickState() && x304_ == 0 &&
                std::fabs(player.GetAngularVelocityOR().angle()) <= 0.1f && camBobT <= 0.01f &&
                !mgr.GetCameraManager()->IsInCinematicCamera() &&
                player.GetGunHolsterState() == CPlayer::EGunHolsterState::Drawn &&
                player.GetGrappleState() == CPlayer::EGrappleState::None && !x834_30_inBigStrike &&
                !x835_25_inPhazonBeam);
            if (x833_24_isFidgeting)
            {
                if (!x834_30_inBigStrike)
                {
                    bool doWander = camBobT > 0.01f && (x2f4_fireButtonStates & 0x3) == 0;
                    if (doWander)
                    {
                        x370_gunMotionSpeedMult = 1.f;
                        x374_ = 0.f;
                        if (x364_gunStrikeCoolTimer <= 0.f && x368_idleWanderDelayTimer <= 0.f)
                        {
                            x368_idleWanderDelayTimer = 8.f;
                            x73c_gunMotion->PlayPasAnim(SamusGun::EAnimationState::Wander, mgr, 0.f, false);
                            x324_idleState = EIdleState::Wander;
                            x550_camBob.SetState(CPlayerCameraBob::ECameraBobState::Walk, mgr);
                        }
                        x368_idleWanderDelayTimer -= dt;
                        x360_ -= dt;
                    }
                    if (!doWander || x834_26_animPlaying)
                        ResetIdle(mgr);
                }
                if (x394_damageTimer > 0.f)
                {
                    x394_damageTimer -= dt;
                }
                else if (!x834_31_gunMotionInFidgetBasePosition)
                {
                    x394_damageTimer = 0.f;
                    x834_31_gunMotionInFidgetBasePosition = true;
                    x73c_gunMotion->BasePosition(true);
                }
                else if (!x73c_gunMotion->GetModelData().GetAnimationData()->IsAnimTimeRemaining(0.001f, "Whole Body"))
                {
                    x834_30_inBigStrike = false;
                    x834_31_gunMotionInFidgetBasePosition = false;
                }
            }
            else
            {
                switch (x3a4_fidget.Update(x2ec_lastFireButtonStates, camBobT > 0.01f, inStrikeCooldown, dt, mgr))
                {
                case CFidget::EState::NoFidget:
                    if (x324_idleState != EIdleState::Idle)
                    {
                        x73c_gunMotion->PlayPasAnim(SamusGun::EAnimationState::Idle, mgr, 0.f, false);
                        x324_idleState = EIdleState::Idle;
                    }
                    x550_camBob.SetState(CPlayerCameraBob::ECameraBobState::WalkNoBob, mgr);
                    break;
                case CFidget::EState::MinorFidget:
                case CFidget::EState::MajorFidget:
                case CFidget::EState::HolsterBeam:
                    if (x324_idleState != EIdleState::NotIdle)
                    {
                        x73c_gunMotion->BasePosition(false);
                        x324_idleState = EIdleState::NotIdle;
                    }
                    AsyncLoadFidget(mgr);
                    break;
                case CFidget::EState::Loading:
                    if (IsFidgetLoaded())
                        EnterFidget(mgr);
                    break;
                case CFidget::EState::StillMinorFidget:
                case CFidget::EState::StillMajorFidget:
                    x550_camBob.SetState(CPlayerCameraBob::ECameraBobState::Walk, mgr);
                    x833_24_isFidgeting = false;
                    x834_26_animPlaying = x834_25_gunMotionFidgeting ? x73c_gunMotion->IsAnimPlaying() :
                    x72c_currentBeam->GetSolidModelData().GetAnimationData()->IsAnimTimeRemaining(0.001f, "Whole Body");
                    if (!x834_26_animPlaying)
                    {
                        x3a4_fidget.ResetMinor();
                        ReturnToRestPose();
                    }
                    break;
                default:
                    break;
                }
            }
            x550_camBob.Update(dt, mgr);
        }
    }
}

static const float chargeShakeTbl[] = { -0.001f, 0.f, 0.001f };
static const CMaterialFilter sAimFilter =
    CMaterialFilter::MakeIncludeExclude({EMaterialTypes::Solid}, {EMaterialTypes::ProjectilePassthrough});

void CPlayerGun::Update(float grappleSwingT, float cameraBobT, float dt, CStateManager& mgr)
{
    CPlayer& player = mgr.GetPlayer();
    CPlayerState& playerState = *mgr.GetPlayerState();
    bool isUnmorphed = player.GetMorphballTransitionState() == CPlayer::EPlayerMorphBallState::Unmorphed;

    bool becameFrozen;
    if (isUnmorphed)
        becameFrozen = !x834_29_frozen && player.GetFrozenState();
    else
        becameFrozen = false;

    bool becameThawed;
    if (isUnmorphed)
        becameThawed = x834_29_frozen && !player.GetFrozenState();
    else
        becameThawed = false;

    x834_29_frozen = isUnmorphed && player.GetFrozenState();
    float advDt;
    if (x834_29_frozen)
        advDt = 0.f;
    else
        advDt = dt;

    bool r23 = x678_morph.GetGunState() != CGunMorph::EGunState::OutWipeDone;
    if (mgr.GetPlayerState()->GetCurrentVisor() == CPlayerState::EPlayerVisor::XRay || r23)
        x6e0_rightHandModel.AdvanceAnimation(advDt, mgr, kInvalidAreaId, true);
    if (r23 && x734_loadingBeam != 0 && x734_loadingBeam != x72c_currentBeam)
    {
        x744_auxWeapon->LoadIdle();
        x734_loadingBeam->Update(advDt, mgr);
    }
    if (!x744_auxWeapon->IsLoaded())
        x744_auxWeapon->LoadIdle();

    if (becameFrozen)
    {
        x72c_currentBeam->EnableSecondaryFx(CGunWeapon::ESecondaryFxType::None);
        x72c_currentBeam->EnableFrozenEffect(CGunWeapon::EFrozenFxType::Frozen);
    }
    else if (becameThawed)
    {
        x72c_currentBeam->EnableFrozenEffect(CGunWeapon::EFrozenFxType::Thawed);
    }

    if (becameFrozen || becameThawed)
    {
        x2f4_fireButtonStates = 0;
        x2ec_lastFireButtonStates = 0;
        CancelFiring(mgr);
    }

    x72c_currentBeam->Update(advDt, mgr);
    x73c_gunMotion->Update(advDt * x370_gunMotionSpeedMult, mgr);
    x740_grappleArm->Update(grappleSwingT, advDt, mgr);

    if (x338_nextState != ENextState::StatusQuo)
    {
        if (x678_morph.GetGunState() == CGunMorph::EGunState::InWipeDone)
        {
            if (x338_nextState == ENextState::ChangeWeapon)
            {
                ChangeWeapon(playerState, mgr);
                x338_nextState = ENextState::StatusQuo;
            }
        }
        else if (!x72c_currentBeam->GetSolidModelData().GetAnimationData()->IsAnimTimeRemaining(0.001f, "Whole Body") ||
                 x832_30_requestReturnToDefault)
        {
            bool statusQuo = true;
            switch (x338_nextState)
            {
            case ENextState::EnterMissile:
                x2f8_stateFlags &= ~0x1;
                x2f8_stateFlags |= 0x6;
                x318_comboAmmoIdx = 1;
                x31c_missileMode = EMissleMode::Active;
                break;
            case ENextState::ExitMissile:
                if ((x2f8_stateFlags & 0x8) != 0x8)
                {
                    x2f8_stateFlags |= 0x1;
                    x2f8_stateFlags &= 0xFFE9;
                }
                x318_comboAmmoIdx = 0;
                x31c_missileMode = EMissleMode::Inactive;
                x390_cooldown = x72c_currentBeam->GetWeaponInfo().x0_coolDown;
                break;
            case ENextState::MissileReload:
                PlayAnim(NWeaponTypes::EGunAnimType::MissileReload, false);
                x338_nextState = ENextState::MissileShotDone;
                statusQuo = false;
                break;
            case ENextState::MissileShotDone:
                x2f8_stateFlags |= 0x4;
                break;
            case ENextState::ChangeWeapon:
                ChangeWeapon(playerState, mgr);
                break;
            case ENextState::SetupBeam:
                x390_cooldown = x72c_currentBeam->GetWeaponInfo().x0_coolDown;
                x2f8_stateFlags &= ~0x8;
                if ((x2f8_stateFlags & 0x8) != 0x8)
                {
                    x2f8_stateFlags |= 0x1;
                    x2f8_stateFlags &= 0xFFE9;
                }
                x318_comboAmmoIdx = 0;
                x31c_missileMode = EMissleMode::Inactive;
                break;
            case ENextState::EnterPhazonBeam:
                if (x75c_phazonBeam->IsLoaded())
                    break;
                x72c_currentBeam->SetDrawHologram(true);
                x75c_phazonBeam->Load(mgr, false);
                x33c_phazonBeamState = EPhazonBeamState::Entering;
                break;
            case ENextState::ExitPhazonBeam:
                if (x738_nextBeam->IsLoaded())
                    break;
                x72c_currentBeam->SetDrawHologram(true);
                x738_nextBeam->Load(mgr, false);
                x33c_phazonBeamState = EPhazonBeamState::Exiting;
                break;
            default:
                break;
            }

            if (statusQuo)
                x338_nextState = ENextState::StatusQuo;
        }
    }

    if (x37c_rapidFireShotsDecayTimer < 0.2f)
    {
        x37c_rapidFireShotsDecayTimer += advDt;
    }
    else
    {
        x37c_rapidFireShotsDecayTimer = 0.f;
        if (x30c_rapidFireShots > 0)
            x30c_rapidFireShots -= 1;
    }

    if (x32c_chargePhase != EChargePhase::NotCharging && !player.GetFrozenState())
    {
        x34c_shakeX = chargeShakeTbl[mgr.GetActiveRandom()->Next() % 3] * x340_chargeBeamFactor;
        x350_shakeZ = chargeShakeTbl[mgr.GetActiveRandom()->Next() % 3] * x340_chargeBeamFactor;
    }

    if (!x72c_currentBeam->IsLoaded())
        return;

    GetLctrWithShake(x4d8_gunLocalXf, x73c_gunMotion->GetModelData(), "GBSE_SDK", true, true);
    GetLctrWithShake(x418_beamLocalXf, x72c_currentBeam->GetSolidModelData(), "LBEAM", false, true);
    GetLctrWithShake(x508_elbowLocalXf, x72c_currentBeam->GetSolidModelData(), "elbow", false, false);
    x4a8_gunWorldXf = x3e8_xf * x4d8_gunLocalXf * x550_camBob.GetCameraBobTransformation();

    if (x740_grappleArm->GetActive() && !x740_grappleArm->IsGrappling())
        UpdateLeftArmTransform(x72c_currentBeam->GetSolidModelData(), mgr);

    x6a0_motionState.Update(x2f0_pressedFireButtonStates != 0 && x832_28_readyForShot &&
                                x32c_chargePhase < EChargePhase::AnimAndSfx &&
                                !player.IsInFreeLook(), advDt, x4a8_gunWorldXf, mgr);

    x72c_currentBeam->GetSolidModelData().AdvanceParticles(x4a8_gunWorldXf, advDt, mgr);
    x72c_currentBeam->UpdateGunFx(x380_shotSmokeTimer > 2.f && x378_shotSmokeStartTimer > 0.15f,
                                  dt, mgr, x508_elbowLocalXf);

    zeus::CTransform beamWorldXf = x4a8_gunWorldXf * x418_beamLocalXf;

    if (player.GetMorphballTransitionState() == CPlayer::EPlayerMorphBallState::Unmorphed &&
        !mgr.GetCameraManager()->IsInCinematicCamera())
    {
        rstl::reserved_vector<TUniqueId, 1024> nearList;
        zeus::CAABox aabb = x72c_currentBeam->GetBounds().getTransformedAABox(x4a8_gunWorldXf);
        mgr.BuildNearList(nearList, aabb, sAimFilter, &player);
        TUniqueId bestId = kInvalidUniqueId;
        zeus::CVector3f dir = x4a8_gunWorldXf.basis[1].normalized();
        zeus::CVector3f pos = dir * -0.5f + x4a8_gunWorldXf.origin;
        CRayCastResult result = mgr.RayWorldIntersection(bestId, pos, dir, 3.5f, sAimFilter, nearList);
        x833_29_pointBlankWorldSurface = result.IsValid();
        if (result.IsValid())
        {
            x448_elbowWorldXf = x4a8_gunWorldXf * x508_elbowLocalXf;
            x448_elbowWorldXf.origin += dir * -0.5f;
            beamWorldXf.origin = result.GetPoint();
        }
    }
    else
    {
        x833_29_pointBlankWorldSurface = false;
    }

    zeus::CTransform beamTargetXf = x833_29_pointBlankWorldSurface ? x448_elbowWorldXf : beamWorldXf;

    zeus::CVector3f camTrans = mgr.GetCameraManager()->GetGlobalCameraTranslation(mgr);
    beamWorldXf.origin += camTrans;
    beamTargetXf.origin += camTrans;

    if (x832_25_chargeEffectVisible)
    {
        bool emitting = x833_30_canShowAuxMuzzleEffect ? x344_comboXferTimer < 1.f : false;
        zeus::CVector3f scale((emitting && x832_26_comboFiring) ? (1.f - x344_comboXferTimer) * 2.f : 2.f);
        x72c_currentBeam->UpdateMuzzleFx(advDt, scale, x418_beamLocalXf.origin, emitting);
        CElementGen& gen = *x800_auxMuzzleGenerators[int(x320_currentAuxBeam)];
        gen.SetGlobalOrientAndTrans(x418_beamLocalXf);
        gen.SetGlobalScale(scale);
        gen.SetParticleEmission(emitting);
        gen.Update(advDt);
    }

    if (x748_rainSplashGenerator)
        x748_rainSplashGenerator->Update(advDt, mgr);

    UpdateGunLight(beamWorldXf, mgr);
    ProcessGunMorph(advDt, mgr);
    if (x835_26_phazonBeamMorphing)
        ProcessPhazonGunMorph(advDt, mgr);

    if (x832_26_comboFiring && x77c_comboXferGen)
    {
        x77c_comboXferGen->SetGlobalTranslation(x418_beamLocalXf.origin);
        x77c_comboXferGen->SetGlobalOrientation(x418_beamLocalXf.getRotation());
        x77c_comboXferGen->Update(advDt);
        x344_comboXferTimer += advDt * 4.f;
    }

    if (x35c_bombTime > 0.f)
    {
        x35c_bombTime -= advDt;
        if (x35c_bombTime <= 0.f)
            x308_bombCount = 3;
    }

    if (playerState.ItemEnabled(CPlayerState::EItemType::ChargeBeam) && x32c_chargePhase != EChargePhase::NotCharging)
    {
        UpdateChargeState(advDt, mgr);
    }
    else
    {
        x340_chargeBeamFactor -= advDt;
        if (x340_chargeBeamFactor < 0.f)
            x340_chargeBeamFactor = 0.f;
    }

    UpdateAuxWeapons(advDt, beamTargetXf, mgr);
    DoUserAnimEvents(advDt, mgr);

    if (x304_ == 1 && GetTargetId(mgr) != kInvalidUniqueId)
    {
        if (!x832_29_lockedOn && !x832_26_comboFiring && (x2f8_stateFlags & 0x10) != 0x10)
        {
            x832_29_lockedOn = true;
            x6a0_motionState.SetState(CMotionState::EMotionState::LockOn);
            ReturnArmAndGunToDefault(mgr, true);
        }
    }
    else
    {
        CancelLockOn();
    }

    UpdateWeaponFire(advDt, playerState, mgr);
    UpdateGunIdle(x364_gunStrikeCoolTimer > 0.f, cameraBobT, advDt, mgr);

    if ((x2ec_lastFireButtonStates & 0x1) == 0x1)
    {
        x378_shotSmokeStartTimer = 0.f;
    }
    else if (x378_shotSmokeStartTimer < 2.f)
    {
        x378_shotSmokeStartTimer += advDt;
        if (x378_shotSmokeStartTimer > 1.f)
        {
            x30c_rapidFireShots = 0;
            x380_shotSmokeTimer = 0.f;
        }
    }

    if (x38c_muzzleEffectVisTimer > 0.f)
        x38c_muzzleEffectVisTimer -= advDt;

    if (x30c_rapidFireShots > 5 && x380_shotSmokeTimer < 2.f)
        x380_shotSmokeTimer += advDt;

    if (x384_gunStrikeDelayTimer > 0.f)
        x384_gunStrikeDelayTimer -= advDt;

    if (x364_gunStrikeCoolTimer > 0.f)
    {
        x2f4_fireButtonStates = 0;
        x364_gunStrikeCoolTimer -= advDt;
    }

    if (isUnmorphed && (x2f8_stateFlags & 0x4) == 0x4)
    {
        x3a0_missileExitTimer -= advDt;
        if (x3a0_missileExitTimer < 0.f)
        {
            x3a0_missileExitTimer = 0.f;
            ExitMissile();
        }
    }
}

void CPlayerGun::PreRender(const CStateManager& mgr, const zeus::CFrustum& frustum, const zeus::CVector3f& camPos)
{
    const CPlayerState& playerState = *mgr.GetPlayerState();
    if (playerState.GetCurrentVisor() == CPlayerState::EPlayerVisor::Scan)
        return;

    CPlayerState::EPlayerVisor activeVisor = playerState.GetActiveVisor(mgr);
    switch (activeVisor)
    {
    case CPlayerState::EPlayerVisor::Thermal:
        x0_lights.BuildConstantAmbientLighting(
            zeus::CColor(zeus::clamp(0.6f, 0.5f * x380_shotSmokeTimer + 0.6f - x378_shotSmokeStartTimer, 1.f), 1.f));
        break;
    case CPlayerState::EPlayerVisor::Combat:
    {
        zeus::CAABox aabb = x72c_currentBeam->GetBounds(zeus::CTransform::Translate(camPos) * x4a8_gunWorldXf);
        if (mgr.GetNextAreaId() != kInvalidAreaId)
        {
            x0_lights.SetFindShadowLight(true);
            x0_lights.SetShadowDynamicRangeThreshold(0.25f);
            x0_lights.BuildAreaLightList(mgr, *mgr.GetWorld()->GetAreaAlways(mgr.GetNextAreaId()), aabb);
        }
        x0_lights.BuildDynamicLightList(mgr, aabb);
        if (x0_lights.HasShadowLight())
        {
            if (x72c_currentBeam->IsLoaded())
            {
                x82c_shadow->BuildLightShadowTexture(mgr, mgr.GetNextAreaId(),
                                                     x0_lights.GetShadowLightIndex(), aabb, true, false);
            }
        }
        else
        {
            x82c_shadow->ResetBlur();
        }
        break;
    }
    default:
        break;
    }

    if (x740_grappleArm->GetActive())
        x740_grappleArm->PreRender(mgr, frustum, camPos);

    if (x678_morph.GetGunState() != CGunMorph::EGunState::OutWipeDone ||
        activeVisor == CPlayerState::EPlayerVisor::XRay)
        x6e0_rightHandModel.AnimationData()->PreRender();

    if (x833_28_phazonBeamActive)
        g_Renderer->AllocatePhazonSuitMaskTexture();
}

static const CModelFlags kThermalFlags[] =
{
    {0, 0, 3, zeus::CColor::skWhite},
    {5, 0, 3, zeus::CColor(0.f, 0.5f)},
    {0, 0, 3, zeus::CColor::skWhite},
    {0, 0, 3, zeus::CColor::skWhite}
};

void CPlayerGun::RenderEnergyDrainEffects(const CStateManager& mgr) const
{
    if (TCastToConstPtr<CPlayer> player = mgr.GetObjectById(x538_playerId))
    {
        for (const auto& source : player->GetEnergyDrain().GetEnergyDrainSources())
        {
            if (auto* metroid =
                CPatterned::CastTo<MP1::CMetroidBeta>(mgr.GetObjectById(source.GetEnergyDrainSourceId())))
            {
                metroid->RenderHitGunEffect();
                return;
            }
        }
    }
}

void CPlayerGun::DrawArm(const CStateManager& mgr, const zeus::CVector3f& pos, const CModelFlags& flags) const
{
    const CPlayer& player = mgr.GetPlayer();
    if (!x740_grappleArm->GetActive() || x740_grappleArm->GetAnimState() == CGrappleArm::EArmState::Done)
        return;

    if (player.GetGrappleState() != CPlayer::EGrappleState::None ||
        x740_grappleArm->GetTransform().basis[1].dot(player.GetTransform().basis[1]) > 0.1f)
    {
        CModelFlags useFlags;
        if (x740_grappleArm->IsArmMoving())
            useFlags = flags;
        else
            useFlags = CModelFlags(0, 0, 3, zeus::CColor::skWhite);

        x740_grappleArm->Render(mgr, pos, useFlags, &x0_lights);
    }
}

zeus::CVector3f CPlayerGun::ConvertToScreenSpace(const zeus::CVector3f& pos, const CGameCamera& cam) const
{
    zeus::CVector3f camToPosLocal = cam.GetTransform().transposeRotate(pos - cam.GetTranslation());
    if (!camToPosLocal.isZero())
        return CGraphics::GetPerspectiveProjectionMatrix(false).multiplyOneOverW(camToPosLocal);
    else
        return {-1.f, -1.f, 1.f};
}

void CPlayerGun::CopyScreenTex()
{
    // Copy lower right quadrant to gpCopyTexBuf as RGBA8
    CGraphics::ResolveSpareTexture(g_Viewport);
}

void CPlayerGun::DrawScreenTex(float z) const
{
    // Use CopyScreenTex rendering to draw over framebuffer pixels in front of `z`
    // This is accomplished using orthographic projection quad with sweeping `y` coordinates
    // Depth is set to GEQUAL to obscure pixels in front rather than behind
    m_screenQuad.draw(zeus::CColor::skWhite, 1.f, CTexturedQuadFilter::DefaultRect, z);
}

void CPlayerGun::DrawClipCube(const zeus::CAABox& aabb) const
{
    // Render AABB as completely transparent object, only modifying Z-buffer
    // AABB has already been set in constructor (since it's constant)
    m_aaboxShader.draw(zeus::CColor::skClear);
}

static const CModelFlags kHandThermalFlag = {7, 0, 3, zeus::CColor::skWhite};
static const CModelFlags kHandHoloFlag = {1, 0, 3, zeus::CColor(0.75f, 0.5f, 0.f, 1.f)};

void CPlayerGun::Render(const CStateManager& mgr, const zeus::CVector3f& pos, const CModelFlags& flags) const
{
    CGraphics::CProjectionState projState = CGraphics::GetProjectionState();
    CModelFlags useFlags = flags;
    if (x0_lights.HasShadowLight())
        useFlags.m_extendedShader = EExtendedShader::WorldShadow;
    CModelFlags beamFlags = useFlags;
    if (mgr.GetPlayerState()->GetCurrentVisor() == CPlayerState::EPlayerVisor::Thermal)
        beamFlags = kThermalFlags[int(x310_currentBeam)];
    else if (x835_26_phazonBeamMorphing)
        beamFlags.x4_color = zeus::CColor::lerp(zeus::CColor::skWhite, zeus::CColor::skBlack, x39c_phazonMorphT);

    const CGameCamera* cam = mgr.GetCameraManager()->GetCurrentCamera(mgr);
    CGraphics::SetDepthRange(0.03125f, 0.125f);
    zeus::CTransform offsetWorldXf = zeus::CTransform::Translate(pos) * x4a8_gunWorldXf;
    zeus::CTransform elbowOffsetXf = offsetWorldXf * x508_elbowLocalXf;
    if (x32c_chargePhase != EChargePhase::NotCharging && (x2f8_stateFlags & 0x10) != 0x10)
        offsetWorldXf.origin += zeus::CVector3f(x34c_shakeX, 0.f, x350_shakeZ);

    zeus::CTransform oldViewMtx = CGraphics::g_ViewMatrix;
    CGraphics::SetViewPointMatrix(offsetWorldXf.inverse() * oldViewMtx);
    CGraphics::SetModelMatrix(zeus::CTransform::Identity());
    if (x32c_chargePhase >= EChargePhase::FxGrown && x32c_chargePhase < EChargePhase::ComboXfer)
        x800_auxMuzzleGenerators[int(x320_currentAuxBeam)]->Render();

    if (x832_25_chargeEffectVisible &&
        (x38c_muzzleEffectVisTimer > 0.f || x32c_chargePhase > EChargePhase::AnimAndSfx))
        x72c_currentBeam->DrawMuzzleFx(mgr);

    if (x678_morph.GetGunState() == CGunMorph::EGunState::InWipe ||
        x678_morph.GetGunState() == CGunMorph::EGunState::OutWipe)
        x774_holoTransitionGen->Render();

    CGraphics::SetViewPointMatrix(oldViewMtx);
    if ((x2f8_stateFlags & 0x10) == 0x10)
        x744_auxWeapon->RenderMuzzleFx();

    x72c_currentBeam->PreRenderGunFx(mgr, offsetWorldXf);
    bool drawSuitArm = !x740_grappleArm->IsGrappling() &&
        mgr.GetPlayer().GetGunHolsterState() == CPlayer::EGunHolsterState::Drawn;
    x73c_gunMotion->Draw(mgr, offsetWorldXf);

    switch (x678_morph.GetGunState())
    {
    case CGunMorph::EGunState::OutWipeDone:
        if (x0_lights.HasShadowLight())
            x82c_shadow->EnableModelProjectedShadow(offsetWorldXf, x0_lights.GetShadowLightArrIndex(), 2.15f);
        if (mgr.GetPlayerState()->GetCurrentVisor() == CPlayerState::EPlayerVisor::XRay)
        {
            x6e0_rightHandModel.Render(mgr, elbowOffsetXf * zeus::CTransform::Translate(0.f, -0.2f, 0.02f), &x0_lights,
                                       mgr.GetPlayerState()->GetCurrentVisor() == CPlayerState::EPlayerVisor::Thermal ?
                                       kHandThermalFlag : kHandHoloFlag);
        }
        DrawArm(mgr, pos, useFlags);
        x72c_currentBeam->Draw(drawSuitArm, mgr, offsetWorldXf, beamFlags, &x0_lights);
        x82c_shadow->DisableModelProjectedShadow();
        break;
    case CGunMorph::EGunState::InWipeDone:
    case CGunMorph::EGunState::InWipe:
    case CGunMorph::EGunState::OutWipe:
        if (x678_morph.GetGunState() != CGunMorph::EGunState::InWipeDone)
        {
            zeus::CTransform morphXf = elbowOffsetXf * zeus::CTransform::Translate(0.f, x678_morph.GetYLerp(), 0.f);
            CopyScreenTex();
            x6e0_rightHandModel.Render(mgr, elbowOffsetXf * zeus::CTransform::Translate(0.f, -0.2f, 0.02f), &x0_lights,
                                       mgr.GetPlayerState()->GetCurrentVisor() == CPlayerState::EPlayerVisor::Thermal ?
                                       kHandThermalFlag : kHandHoloFlag);
            x72c_currentBeam->DrawHologram(mgr, offsetWorldXf, CModelFlags(0, 0, 3, zeus::CColor::skWhite));
            DrawScreenTex(ConvertToScreenSpace(morphXf.origin, *cam).z);
            if (x0_lights.HasShadowLight())
                x82c_shadow->EnableModelProjectedShadow(offsetWorldXf, x0_lights.GetShadowLightArrIndex(), 2.15f);
            CGraphics::SetModelMatrix(morphXf);
            DrawClipCube(x6c8_hologramClipCube);
            x72c_currentBeam->Draw(drawSuitArm, mgr, offsetWorldXf, beamFlags, &x0_lights);
            x82c_shadow->DisableModelProjectedShadow();
        }
        else
        {
            x6e0_rightHandModel.Render(mgr, elbowOffsetXf * zeus::CTransform::Translate(0.f, -0.2f, 0.02f), &x0_lights,
                                       mgr.GetPlayerState()->GetCurrentVisor() == CPlayerState::EPlayerVisor::Thermal ?
                                       kHandThermalFlag : kHandHoloFlag);
            x72c_currentBeam->DrawHologram(mgr, offsetWorldXf, CModelFlags(0, 0, 3, zeus::CColor::skWhite));
            if (x0_lights.HasShadowLight())
                x82c_shadow->EnableModelProjectedShadow(offsetWorldXf, x0_lights.GetShadowLightArrIndex(), 2.15f);
            DrawArm(mgr, pos, useFlags);
            x82c_shadow->DisableModelProjectedShadow();
        }
        break;
    }

    oldViewMtx = CGraphics::g_ViewMatrix;
    CGraphics::SetModelMatrix(offsetWorldXf.inverse() * oldViewMtx);
    CGraphics::SetModelMatrix(zeus::CTransform::Identity());
    x72c_currentBeam->PostRenderGunFx(mgr, offsetWorldXf);
    if (x832_26_comboFiring && x77c_comboXferGen)
        x77c_comboXferGen->Render();
    CGraphics::SetViewPointMatrix(oldViewMtx);

    RenderEnergyDrainEffects(mgr);

    CGraphics::SetDepthRange(0.125f, 1.f);
    CGraphics::SetProjectionState(projState);
}

void CPlayerGun::AddToRenderer(const zeus::CFrustum& frustum, const CStateManager& mgr) const
{
    if (x72c_currentBeam->HasSolidModelData())
        x72c_currentBeam->GetSolidModelData().RenderParticles(frustum);
}

void CPlayerGun::DropBomb(EBWeapon weapon, CStateManager& mgr)
{
    if (weapon == EBWeapon::Bomb)
    {
        if (x32c_chargePhase != EChargePhase::NotCharging)
        {
            x32c_chargePhase = EChargePhase::ChargeDone;
            return;
        }

        if (x308_bombCount <= 0)
            return;

        CBomb* bomb =
            new CBomb(x784_bombEffects[u32(weapon)][0], x784_bombEffects[u32(weapon)][1], mgr.AllocateUniqueId(),
                      mgr.GetPlayer().GetAreaId(), x538_playerId, x354_bombFuseTime,
                      zeus::CTransform::Translate(zeus::CVector3f{0.f, g_tweakPlayer->GetPlayerBallHalfExtent(), 0.f}),
                      g_tweakPlayerGun->GetBombInfo());
        mgr.AddObject(bomb);

        if (x308_bombCount == 3)
            x35c_bombTime = x358_bombDropDelayTime;

        --x308_bombCount;
        if (TCastToPtr<CScriptPlatform> plat = mgr.ObjectById(mgr.GetPlayer().GetRidingPlatformId()))
            plat->AddSlave(bomb->GetUniqueId(), mgr);
    }
    else if (weapon == EBWeapon::PowerBomb)
    {
        mgr.GetPlayerState()->DecrPickup(CPlayerState::EItemType::PowerBombs, 1);
        x53a_powerBomb = DropPowerBomb(mgr);
    }
}

TUniqueId CPlayerGun::DropPowerBomb(CStateManager& mgr)
{
    CDamageInfo dInfo = (mgr.GetPlayer().GetDeathTime() <= 0.f ? g_tweakPlayerGun->GetPowerBombInfo()
                                                               : CDamageInfo(CWeaponMode::PowerBomb(), 0.f, 0.f, 0.f));

    TUniqueId uid = mgr.AllocateUniqueId();
    CPowerBomb* pBomb =
        new CPowerBomb(x784_bombEffects[1][0], uid, kInvalidAreaId, x538_playerId,
                       zeus::CTransform::Translate(mgr.GetPlayer().GetTranslation() +
                                                   zeus::CVector3f{0.f, g_tweakPlayer->GetPlayerBallHalfExtent(), 0.f}),
                       dInfo);
    mgr.AddObject(*pBomb);
    return uid;
}
}