#include "CStateManager.hpp"
#include "Camera/CCameraShakeData.hpp"
#include "Camera/CGameCamera.hpp"
#include "Graphics/CBooRenderer.hpp"
#include "World/CGameLight.hpp"
#include "CSortedLists.hpp"
#include "Weapon/CWeaponMgr.hpp"
#include "CFluidPlaneManager.hpp"
#include "World/CEnvFxManager.hpp"
#include "World/CActorModelParticles.hpp"
#include "World/CTeamAiTypes.hpp"
#include "World/CScriptPlayerActor.hpp"
#include "Input/CRumbleManager.hpp"
#include "World/CWorld.hpp"
#include "Graphics/CLight.hpp"
#include "GameGlobalObjects.hpp"
#include "CSimplePool.hpp"
#include "CPlayerState.hpp"
#include "CGameState.hpp"
#include "World/CPlayer.hpp"
#include "Weapon/CPlayerGun.hpp"
#include "World/CMorphBall.hpp"
#include "World/CScriptSpawnPoint.hpp"
#include "AutoMapper/CMapWorldInfo.hpp"
#include "Particle/CGenDescription.hpp"
#include "CMemoryCardSys.hpp"
#include "TCastTo.hpp"
#include "World/CScriptSpecialFunction.hpp"
#include "CTimeProvider.hpp"
#include "Camera/CBallCamera.hpp"
#include "Collision/CMaterialFilter.hpp"
#include "World/CScriptDock.hpp"
#include "Particle/CDecalManager.hpp"
#include "Particle/CParticleElectric.hpp"
#include "World/CProjectedShadow.hpp"
#include "Weapon/CProjectileWeapon.hpp"
#include "World/CScriptEffect.hpp"
#include "MP1/CSamusHud.hpp"
#include "Collision/CGameCollision.hpp"
#include "World/CScriptPlatform.hpp"
#include "World/CScriptRoomAcoustics.hpp"

#include <cmath>

namespace urde
{
logvisor::Module LogModule("urde::CStateManager");
CStateManager::CStateManager(const std::weak_ptr<CRelayTracker>& relayTracker,
                             const std::weak_ptr<CMapWorldInfo>& mwInfo, const std::weak_ptr<CPlayerState>& playerState,
                             const std::weak_ptr<CWorldTransManager>& wtMgr,
                             const std::weak_ptr<CWorldLayerState>& layerState)
: x8b8_playerState(playerState)
, x8bc_relayTracker(relayTracker)
, x8c0_mapWorldInfo(mwInfo)
, x8c4_worldTransManager(wtMgr)
, x8c8_worldLayerState(layerState)
{
    x86c_stateManagerContainer.reset(new CStateManagerContainer);
    x870_cameraManager = &x86c_stateManagerContainer->x0_cameraManager;
    x874_sortedListManager = &x86c_stateManagerContainer->x3c0_sortedListManager;
    x878_weaponManager = &x86c_stateManagerContainer->xe3d8_weaponManager;
    x87c_fluidPlaneManager = &x86c_stateManagerContainer->xe3ec_fluidPlaneManager;
    x880_envFxManager = &x86c_stateManagerContainer->xe510_envFxManager;
    x884_actorModelParticles = &x86c_stateManagerContainer->xf168_actorModelParticles;
    x88c_rumbleManager = &x86c_stateManagerContainer->xf250_rumbleManager;

    g_Renderer->SetDrawableCallback(&CStateManager::RendererDrawCallback, this);

    x90c_loaderFuncs[int(EScriptObjectType::Actor)] = ScriptLoader::LoadActor;
    x90c_loaderFuncs[int(EScriptObjectType::Waypoint)] = ScriptLoader::LoadWaypoint;
    x90c_loaderFuncs[int(EScriptObjectType::Door)] = ScriptLoader::LoadDoor;
    x90c_loaderFuncs[int(EScriptObjectType::Trigger)] = ScriptLoader::LoadTrigger;
    x90c_loaderFuncs[int(EScriptObjectType::Timer)] = ScriptLoader::LoadTimer;
    x90c_loaderFuncs[int(EScriptObjectType::Counter)] = ScriptLoader::LoadCounter;
    x90c_loaderFuncs[int(EScriptObjectType::Effect)] = ScriptLoader::LoadEffect;
    x90c_loaderFuncs[int(EScriptObjectType::Platform)] = ScriptLoader::LoadPlatform;
    x90c_loaderFuncs[int(EScriptObjectType::Sound)] = ScriptLoader::LoadSound;
    x90c_loaderFuncs[int(EScriptObjectType::Generator)] = ScriptLoader::LoadGenerator;
    x90c_loaderFuncs[int(EScriptObjectType::Dock)] = ScriptLoader::LoadDock;
    x90c_loaderFuncs[int(EScriptObjectType::Camera)] = ScriptLoader::LoadCamera;
    x90c_loaderFuncs[int(EScriptObjectType::CameraWaypoint)] = ScriptLoader::LoadCameraWaypoint;
    x90c_loaderFuncs[int(EScriptObjectType::NewIntroBoss)] = ScriptLoader::LoadNewIntroBoss;
    x90c_loaderFuncs[int(EScriptObjectType::SpawnPoint)] = ScriptLoader::LoadSpawnPoint;
    x90c_loaderFuncs[int(EScriptObjectType::CameraHint)] = ScriptLoader::LoadCameraHint;
    x90c_loaderFuncs[int(EScriptObjectType::Pickup)] = ScriptLoader::LoadPickup;
    x90c_loaderFuncs[int(EScriptObjectType::MemoryRelay)] = ScriptLoader::LoadMemoryRelay;
    x90c_loaderFuncs[int(EScriptObjectType::RandomRelay)] = ScriptLoader::LoadRandomRelay;
    x90c_loaderFuncs[int(EScriptObjectType::Relay)] = ScriptLoader::LoadRelay;
    x90c_loaderFuncs[int(EScriptObjectType::Beetle)] = ScriptLoader::LoadBeetle;
    x90c_loaderFuncs[int(EScriptObjectType::HUDMemo)] = ScriptLoader::LoadHUDMemo;
    x90c_loaderFuncs[int(EScriptObjectType::CameraFilterKeyframe)] = ScriptLoader::LoadCameraFilterKeyframe;
    x90c_loaderFuncs[int(EScriptObjectType::CameraBlurKeyframe)] = ScriptLoader::LoadCameraBlurKeyframe;
    x90c_loaderFuncs[int(EScriptObjectType::DamageableTrigger)] = ScriptLoader::LoadDamageableTrigger;
    x90c_loaderFuncs[int(EScriptObjectType::Debris)] = ScriptLoader::LoadDebris;
    x90c_loaderFuncs[int(EScriptObjectType::CameraShaker)] = ScriptLoader::LoadCameraShaker;
    x90c_loaderFuncs[int(EScriptObjectType::ActorKeyframe)] = ScriptLoader::LoadActorKeyframe;
    x90c_loaderFuncs[int(EScriptObjectType::Water)] = ScriptLoader::LoadWater;
    x90c_loaderFuncs[int(EScriptObjectType::Warwasp)] = ScriptLoader::LoadWarWasp;
    x90c_loaderFuncs[int(EScriptObjectType::SpacePirate)] = ScriptLoader::LoadSpacePirate;
    x90c_loaderFuncs[int(EScriptObjectType::FlyingPirate)] = ScriptLoader::LoadFlyingPirate;
    x90c_loaderFuncs[int(EScriptObjectType::ElitePirate)] = ScriptLoader::LoadElitePirate;
    x90c_loaderFuncs[int(EScriptObjectType::MetroidBeta)] = ScriptLoader::LoadMetroidBeta;
    x90c_loaderFuncs[int(EScriptObjectType::ChozoGhost)] = ScriptLoader::LoadChozoGhost;
    x90c_loaderFuncs[int(EScriptObjectType::CoverPoint)] = ScriptLoader::LoadCoverPoint;
    x90c_loaderFuncs[int(EScriptObjectType::SpiderBallWaypoint)] = ScriptLoader::LoadSpiderBallWaypoint;
    x90c_loaderFuncs[int(EScriptObjectType::BloodFlower)] = ScriptLoader::LoadBloodFlower;
    x90c_loaderFuncs[int(EScriptObjectType::FlickerBat)] = ScriptLoader::LoadFlickerBat;
    x90c_loaderFuncs[int(EScriptObjectType::PathCamera)] = ScriptLoader::LoadPathCamera;
    x90c_loaderFuncs[int(EScriptObjectType::GrapplePoint)] = ScriptLoader::LoadGrapplePoint;
    x90c_loaderFuncs[int(EScriptObjectType::PuddleSpore)] = ScriptLoader::LoadPuddleSpore;
    x90c_loaderFuncs[int(EScriptObjectType::DebugCameraWaypoint)] = ScriptLoader::LoadDebugCameraWaypoint;
    x90c_loaderFuncs[int(EScriptObjectType::SpiderBallAttractionSurface)] =
        ScriptLoader::LoadSpiderBallAttractionSurface;
    x90c_loaderFuncs[int(EScriptObjectType::PuddleToadGamma)] = ScriptLoader::LoadPuddleToadGamma;
    x90c_loaderFuncs[int(EScriptObjectType::DistanceFog)] = ScriptLoader::LoadDistanceFog;
    x90c_loaderFuncs[int(EScriptObjectType::FireFlea)] = ScriptLoader::LoadFireFlea;
    x90c_loaderFuncs[int(EScriptObjectType::MetareeAlpha)] = ScriptLoader::LoadMetareeAlpha;
    x90c_loaderFuncs[int(EScriptObjectType::DockAreaChange)] = ScriptLoader::LoadDockAreaChange;
    x90c_loaderFuncs[int(EScriptObjectType::ActorRotate)] = ScriptLoader::LoadActorRotate;
    x90c_loaderFuncs[int(EScriptObjectType::SpecialFunction)] = ScriptLoader::LoadSpecialFunction;
    x90c_loaderFuncs[int(EScriptObjectType::SpankWeed)] = ScriptLoader::LoadSpankWeed;
    x90c_loaderFuncs[int(EScriptObjectType::Parasite)] = ScriptLoader::LoadParasite;
    x90c_loaderFuncs[int(EScriptObjectType::PlayerHint)] = ScriptLoader::LoadPlayerHint;
    x90c_loaderFuncs[int(EScriptObjectType::Ripper)] = ScriptLoader::LoadRipper;
    x90c_loaderFuncs[int(EScriptObjectType::PickupGenerator)] = ScriptLoader::LoadPickupGenerator;
    x90c_loaderFuncs[int(EScriptObjectType::AIKeyframe)] = ScriptLoader::LoadAIKeyframe;
    x90c_loaderFuncs[int(EScriptObjectType::PointOfInterest)] = ScriptLoader::LoadPointOfInterest;
    x90c_loaderFuncs[int(EScriptObjectType::Drone)] = ScriptLoader::LoadDrone;
    x90c_loaderFuncs[int(EScriptObjectType::MetroidAlpha)] = ScriptLoader::LoadMetroidAlpha;
    x90c_loaderFuncs[int(EScriptObjectType::DebrisExtended)] = ScriptLoader::LoadDebrisExtended;
    x90c_loaderFuncs[int(EScriptObjectType::Steam)] = ScriptLoader::LoadSteam;
    x90c_loaderFuncs[int(EScriptObjectType::Ripple)] = ScriptLoader::LoadRipple;
    x90c_loaderFuncs[int(EScriptObjectType::BallTrigger)] = ScriptLoader::LoadBallTrigger;
    x90c_loaderFuncs[int(EScriptObjectType::TargetingPoint)] = ScriptLoader::LoadTargetingPoint;
    x90c_loaderFuncs[int(EScriptObjectType::EMPulse)] = ScriptLoader::LoadEMPulse;
    x90c_loaderFuncs[int(EScriptObjectType::IceSheegoth)] = ScriptLoader::LoadIceSheegoth;
    x90c_loaderFuncs[int(EScriptObjectType::PlayerActor)] = ScriptLoader::LoadPlayerActor;
    x90c_loaderFuncs[int(EScriptObjectType::Flaahgra)] = ScriptLoader::LoadFlaahgra;
    x90c_loaderFuncs[int(EScriptObjectType::AreaAttributes)] = ScriptLoader::LoadAreaAttributes;
    x90c_loaderFuncs[int(EScriptObjectType::FishCloud)] = ScriptLoader::LoadFishCloud;
    x90c_loaderFuncs[int(EScriptObjectType::FishCloudModifier)] = ScriptLoader::LoadFishCloudModifier;
    x90c_loaderFuncs[int(EScriptObjectType::VisorFlare)] = ScriptLoader::LoadVisorFlare;
    x90c_loaderFuncs[int(EScriptObjectType::WorldTeleporter)] = ScriptLoader::LoadWorldTeleporter;
    x90c_loaderFuncs[int(EScriptObjectType::VisorGoo)] = ScriptLoader::LoadVisorGoo;
    x90c_loaderFuncs[int(EScriptObjectType::JellyZap)] = ScriptLoader::LoadJellyZap;
    x90c_loaderFuncs[int(EScriptObjectType::ControllerAction)] = ScriptLoader::LoadControllerAction;
    x90c_loaderFuncs[int(EScriptObjectType::Switch)] = ScriptLoader::LoadSwitch;
    x90c_loaderFuncs[int(EScriptObjectType::PlayerStateChange)] = ScriptLoader::LoadPlayerStateChange;
    x90c_loaderFuncs[int(EScriptObjectType::Thardus)] = ScriptLoader::LoadThardus;
    x90c_loaderFuncs[int(EScriptObjectType::WallCrawlerSwarm)] = ScriptLoader::LoadWallCrawlerSwarm;
    x90c_loaderFuncs[int(EScriptObjectType::AIJumpPoint)] = ScriptLoader::LoadAiJumpPoint;
    x90c_loaderFuncs[int(EScriptObjectType::FlaahgraTentacle)] = ScriptLoader::LoadFlaahgraTentacle;
    x90c_loaderFuncs[int(EScriptObjectType::RoomAcoustics)] = ScriptLoader::LoadRoomAcoustics;
    x90c_loaderFuncs[int(EScriptObjectType::ColorModulate)] = ScriptLoader::LoadColorModulate;
    x90c_loaderFuncs[int(EScriptObjectType::ThardusRockProjectile)] = ScriptLoader::LoadThardusRockProjectile;
    x90c_loaderFuncs[int(EScriptObjectType::Midi)] = ScriptLoader::LoadMidi;
    x90c_loaderFuncs[int(EScriptObjectType::StreamedAudio)] = ScriptLoader::LoadStreamedAudio;
    x90c_loaderFuncs[int(EScriptObjectType::WorldTeleporterToo)] = ScriptLoader::LoadWorldTeleporter;
    x90c_loaderFuncs[int(EScriptObjectType::Repulsor)] = ScriptLoader::LoadRepulsor;
    x90c_loaderFuncs[int(EScriptObjectType::GunTurret)] = ScriptLoader::LoadGunTurret;
    x90c_loaderFuncs[int(EScriptObjectType::FogVolume)] = ScriptLoader::LoadFogVolume;
    x90c_loaderFuncs[int(EScriptObjectType::Babygoth)] = ScriptLoader::LoadBabygoth;
    x90c_loaderFuncs[int(EScriptObjectType::Eyeball)] = ScriptLoader::LoadEyeball;
    x90c_loaderFuncs[int(EScriptObjectType::RadialDamage)] = ScriptLoader::LoadRadialDamage;
    x90c_loaderFuncs[int(EScriptObjectType::CameraPitchVolume)] = ScriptLoader::LoadCameraPitchVolume;
    x90c_loaderFuncs[int(EScriptObjectType::EnvFxDensityController)] = ScriptLoader::LoadEnvFxDensityController;
    x90c_loaderFuncs[int(EScriptObjectType::Magdolite)] = ScriptLoader::LoadMagdolite;
    x90c_loaderFuncs[int(EScriptObjectType::TeamAIMgr)] = ScriptLoader::LoadTeamAIMgr;
    x90c_loaderFuncs[int(EScriptObjectType::SnakeWeedSwarm)] = ScriptLoader::LoadSnakeWeedSwarm;
    x90c_loaderFuncs[int(EScriptObjectType::ActorContraption)] = ScriptLoader::LoadActorContraption;
    x90c_loaderFuncs[int(EScriptObjectType::Oculus)] = ScriptLoader::LoadOculus;
    x90c_loaderFuncs[int(EScriptObjectType::Geemer)] = ScriptLoader::LoadGeemer;
    x90c_loaderFuncs[int(EScriptObjectType::SpindleCamera)] = ScriptLoader::LoadSpindleCamera;
    x90c_loaderFuncs[int(EScriptObjectType::AtomicAlpha)] = ScriptLoader::LoadAtomicAlpha;
    x90c_loaderFuncs[int(EScriptObjectType::CameraHintTrigger)] = ScriptLoader::LoadCameraHintTrigger;
    x90c_loaderFuncs[int(EScriptObjectType::RumbleEffect)] = ScriptLoader::LoadRumbleEffect;
    x90c_loaderFuncs[int(EScriptObjectType::AmbientAI)] = ScriptLoader::LoadAmbientAI;
    x90c_loaderFuncs[int(EScriptObjectType::AtomicBeta)] = ScriptLoader::LoadAtomicBeta;
    x90c_loaderFuncs[int(EScriptObjectType::IceZoomer)] = ScriptLoader::LoadIceZoomer;
    x90c_loaderFuncs[int(EScriptObjectType::Puffer)] = ScriptLoader::LoadPuffer;
    x90c_loaderFuncs[int(EScriptObjectType::Tryclops)] = ScriptLoader::LoadTryclops;
    x90c_loaderFuncs[int(EScriptObjectType::Ridley)] = ScriptLoader::LoadRidley;
    x90c_loaderFuncs[int(EScriptObjectType::Seedling)] = ScriptLoader::LoadSeedling;
    x90c_loaderFuncs[int(EScriptObjectType::ThermalHeatFader)] = ScriptLoader::LoadThermalHeatFader;
    x90c_loaderFuncs[int(EScriptObjectType::Burrower)] = ScriptLoader::LoadBurrower;
    x90c_loaderFuncs[int(EScriptObjectType::ScriptBeam)] = ScriptLoader::LoadBeam;
    x90c_loaderFuncs[int(EScriptObjectType::WorldLightFader)] = ScriptLoader::LoadWorldLightFader;
    x90c_loaderFuncs[int(EScriptObjectType::MetroidPrimeStage2)] = ScriptLoader::LoadMetroidPrimeStage2;
    x90c_loaderFuncs[int(EScriptObjectType::MetroidPrimeStage1)] = ScriptLoader::LoadMetroidPrimeStage1;
    x90c_loaderFuncs[int(EScriptObjectType::MazeNode)] = ScriptLoader::LoadMazeNode;
    x90c_loaderFuncs[int(EScriptObjectType::OmegaPirate)] = ScriptLoader::LoadOmegaPirate;
    x90c_loaderFuncs[int(EScriptObjectType::PhazonPool)] = ScriptLoader::LoadPhazonPool;
    x90c_loaderFuncs[int(EScriptObjectType::PhazonHealingNodule)] = ScriptLoader::LoadPhazonHealingNodule;
    x90c_loaderFuncs[int(EScriptObjectType::NewCameraShaker)] = ScriptLoader::LoadNewCameraShaker;
    x90c_loaderFuncs[int(EScriptObjectType::ShadowProjector)] = ScriptLoader::LoadShadowProjector;
    x90c_loaderFuncs[int(EScriptObjectType::EnergyBall)] = ScriptLoader::LoadEnergyBall;

    x8f0_shadowTex = g_SimplePool->GetObj("DefaultShadow");
}

void CStateManager::UpdateThermalVisor()
{
    xf28_thermColdScale2 = 0.f;
    xf24_thermColdScale1 = 0.f;
    CPlayerState::EPlayerVisor visor = x8b8_playerState->GetActiveVisor(*this);
    if (visor == CPlayerState::EPlayerVisor::Thermal && x8cc_nextAreaId != kInvalidAreaId)
    {
        std::unique_ptr<CGameArea>& area = x850_world->GetGameAreas()[x8cc_nextAreaId];
        const zeus::CTransform& playerXf = x84c_player->GetTransform();
        zeus::CVector3f playerXYPos(playerXf.origin.x, playerXf.origin.y, 0.f);
        CGameArea* lastArea = nullptr;
        float closestDist = FLT_MAX;
        for (const CGameArea::Dock& dock : area->GetDocks())
        {
            zeus::CVector3f dockCenter = (dock.GetPlaneVertices()[0] + dock.GetPlaneVertices()[1] +
                                          dock.GetPlaneVertices()[2] + dock.GetPlaneVertices()[3]) *
                                         0.25f;
            dockCenter.z = 0.f;
            float dist = (playerXYPos - dockCenter).magSquared();
            if (dist < closestDist)
            {
                TAreaId connAreaId = dock.GetConnectedAreaId(0);
                if (connAreaId != kInvalidAreaId)
                {
                    std::unique_ptr<CGameArea>& connArea = x850_world->GetGameAreas()[x8cc_nextAreaId];
                    if (connArea->IsPostConstructed())
                    {
                        CGameArea::EOcclusionState occState = connArea->GetPostConstructed()->x10dc_occlusionState;
                        if (occState == CGameArea::EOcclusionState::Occluded)
                        {
                            closestDist = dist;
                            lastArea = connArea.get();
                        }
                    }
                }
            }
        }

        if (lastArea != nullptr)
        {
            if (closestDist != 0.f)
                closestDist /= std::sqrt(closestDist);
            closestDist -= 2.f;
            if (closestDist < 8.f)
            {
                if (closestDist > 0.f)
                    closestDist = (closestDist / 8.f) * 0.5f + 0.5f;
                else
                    closestDist = 0.5f;

                xf24_thermColdScale1 = (1.f - closestDist) * lastArea->GetPostConstructed()->x111c_thermalCurrent +
                                       closestDist * area->GetPostConstructed()->x111c_thermalCurrent;
                return;
            }
        }

        xf24_thermColdScale1 = area->GetPostConstructed()->x111c_thermalCurrent;
    }
}

void CStateManager::RendererDrawCallback(const void* drawable, const void* ctx, int type)
{
    CStateManager& mgr = reinterpret_cast<CStateManager&>(ctx);
    switch (type)
    {
    case 0:
    {
        CActor& actor = reinterpret_cast<CActor&>(drawable);
        if (actor.xc8_drawnToken == mgr.x8dc_objectDrawToken)
            break;
        if (actor.xc6_nextDrawNode != kInvalidUniqueId)
            mgr.RecursiveDrawTree(actor.xc6_nextDrawNode);
        actor.Render(mgr);
        actor.xc8_drawnToken = mgr.x8dc_objectDrawToken;
        break;
    }
    case 1:
        reinterpret_cast<CSimpleShadow&>(drawable).Render(mgr.x8f0_shadowTex.GetObj());
        break;
    case 2:
        reinterpret_cast<CDecal&>(drawable).Render();
        break;
    default: break;
    }
}

bool CStateManager::RenderLast(TUniqueId uid)
{
    if (x86c_stateManagerContainer->xf39c_renderLast.size() == 20)
        return false;
    x86c_stateManagerContainer->xf39c_renderLast.push_back(uid);
    return true;
}

void CStateManager::AddDrawableActorPlane(const CActor& actor, const zeus::CPlane& plane,
                                          const zeus::CAABox& aabb) const
{
    const_cast<CActor&>(actor).SetAddedToken(x8dc_objectDrawToken + 1);
    g_Renderer->AddPlaneObject(static_cast<const void*>(&actor), aabb, plane, 0);
}

void CStateManager::AddDrawableActor(const CActor& actor, const zeus::CVector3f& vec, const zeus::CAABox& aabb) const
{
    const_cast<CActor&>(actor).SetAddedToken(x8dc_objectDrawToken + 1);
    g_Renderer->AddDrawable(static_cast<const void*>(&actor), vec, aabb, 0,
                            IRenderer::EDrawableSorting::SortedCallback);
}

bool CStateManager::SpecialSkipCinematic()
{
    if (xf38_skipCineSpecialFunc == kInvalidUniqueId)
        return false;

    CScriptSpecialFunction* ent = static_cast<CScriptSpecialFunction*>(ObjectById(xf38_skipCineSpecialFunc));
    if (!ent || !ent->ShouldSkipCinematic(*this))
        return false;

    bool hadRandom = x900_activeRandom != nullptr;
    SetActiveRandomToDefault();
    x870_cameraManager->SkipCinematic(*this);
    ent->SkipCinematic(*this);
    x900_activeRandom = hadRandom ? &x8fc_random : nullptr;

    return true;
}

TAreaId CStateManager::GetVisAreaId() const
{
    const CGameCamera* cam = static_cast<const CGameCamera*>(x870_cameraManager->GetCurrentCamera(*this));
    const CBallCamera* ballCam = x870_cameraManager->GetBallCamera();
    TAreaId curArea = x850_world->x68_curAreaId;
    if (cam != ballCam)
        return curArea;

    const zeus::CVector3f& camTranslation = ballCam->GetTranslation();
    zeus::CAABox camAABB(camTranslation, camTranslation);
    camAABB.accumulateBounds(x84c_player->GetTranslation());
    rstl::reserved_vector<TUniqueId, 1024> nearList;
    BuildNearList(nearList, camAABB, CMaterialFilter(EMaterialTypes::AIBlock, CMaterialList(),
                                                     CMaterialFilter::EFilterType::One), nullptr);
    for (TUniqueId id : nearList)
        if (TCastToConstPtr<CScriptDock> dock = GetObjectById(id))
            if (dock->GetDestinationAreaId() == curArea && dock->HasPointCrossedDock(*this, camTranslation))
                return dock->GetCurrentConnectedAreaId(*this);

    return curArea;
}

s32 CStateManager::GetWeaponIdCount(TUniqueId uid, EWeaponType type)
{
    return x878_weaponManager->GetNumActive(uid, type);
}

void CStateManager::RemoveWeaponId(TUniqueId uid, EWeaponType type)
{
    x878_weaponManager->DecrCount(uid, type);
}

void CStateManager::AddWeaponId(TUniqueId uid, EWeaponType type)
{
    x878_weaponManager->IncrCount(uid, type);
}

void CStateManager::UpdateEscapeSequenceTimer(float dt)
{
    if (xf0c_escapeTimer <= 0.f)
        return;
    xf0c_escapeTimer = std::max(FLT_EPSILON, xf0c_escapeTimer - dt);
    if (xf0c_escapeTimer <= FLT_EPSILON)
        x8b8_playerState->SetPlayerAlive(false);

    if (!g_EscapeShakeCountdownInit)
    {
        g_EscapeShakeCountdown = 0.f;
        g_EscapeShakeCountdownInit = true;
    }

    g_EscapeShakeCountdown -= dt;
    if (g_EscapeShakeCountdown < 0.f)
    {
        float factor = 1.f - xf0c_escapeTimer / xf10_escapeTotalTime;
        float factor2 = factor * factor;
        CCameraShakeData shakeData(1.f, factor2 * 0.2f * x900_activeRandom->Range(0.5f, 1.f));
        x870_cameraManager->AddCameraShaker(shakeData, true);
        x88c_rumbleManager->Rumble(*this, ERumbleFxId::Seven, 0.75f, ERumblePriority::One);
        g_EscapeShakeCountdown = -12.f * factor2 + 15.f;
    }
}

float CStateManager::GetEscapeSequenceTimer() const { return xf0c_escapeTimer; }

void CStateManager::ResetEscapeSequenceTimer(float time)
{
    xf0c_escapeTimer = time;
    xf10_escapeTotalTime = time;
}

void CStateManager::SetupParticleHook(const CActor& actor) const
{
    x884_actorModelParticles->SetupHook(actor.GetUniqueId());
}

void CStateManager::MurderScriptInstanceNames()
{
    xb40_uniqueInstanceNames.clear();
}

std::string CStateManager::HashInstanceName(CInputStream& in)
{
#ifdef NDEBUG
    static std::string name;
    while (in.readByte() != 0) {};
    return name;
#else
    return in.readString();
#endif
}

void CStateManager::SetActorAreaId(CActor& actor, TAreaId aid)
{
    TAreaId actorAid = actor.GetAreaIdAlways();
    if (actorAid == aid)
        return;

    if (actorAid != kInvalidAreaId)
    {
        CGameArea* area = x850_world->GetArea(actorAid);
        if (area->IsPostConstructed())
            area->GetAreaObjects().RemoveObject(actor.GetUniqueId());
    }

    if (aid == kInvalidAreaId)
        return;
    CGameArea* area = x850_world->GetArea(aid);
    if (!area->IsPostConstructed() || area->GetAreaObjects().GetValidObjectById(actor.GetUniqueId()))
        return;

    area->GetAreaObjects().AddObject(actor);
}

void CStateManager::TouchSky() const
{
    x850_world->TouchSky();
}

void CStateManager::TouchPlayerActor()
{
    if (xf6c_playerActor == kInvalidUniqueId)
        return;
    if (CEntity* ent = ObjectById(xf6c_playerActor))
        static_cast<CScriptPlayerActor*>(ent)->TouchModels();
}

void CStateManager::DrawSpaceWarp(const zeus::CVector3f& v, float strength) const
{
    CPlayerState::EPlayerVisor visor = x8b8_playerState->GetActiveVisor(*this);
    if (visor == CPlayerState::EPlayerVisor::Scan || visor == CPlayerState::EPlayerVisor::Combat)
    {
        zeus::CVector3f screenV = TCastToConstPtr<CGameCamera>(x870_cameraManager->GetCurrentCamera(*this))->ConvertToScreenSpace(v);
        g_Renderer->DrawSpaceWarp(screenV, strength);
    }
}

void CStateManager::DrawReflection(const zeus::CVector3f& reflectPoint)
{
    zeus::CAABox aabb = x84c_player->GetBoundingBox();
    zeus::CVector3f playerPos = aabb.center();
    zeus::CVector3f surfToPlayer = playerPos - reflectPoint;
    surfToPlayer.z = 0.f;
    zeus::CVector3f viewPos = playerPos - surfToPlayer.normalized() * 3.5f;
    zeus::CTransform look = zeus::lookAt(viewPos, playerPos, {0.f, 0.f, -1.f});

    zeus::CTransform backupView = CGraphics::g_ViewMatrix;
    CGraphics::SetViewPointMatrix(look);
    CGraphics::CProjectionState backupProj = CGraphics::GetProjectionState();
    CGameCamera* cam = x870_cameraManager->GetCurrentCamera(*this);
    g_Renderer->SetPerspective(cam->GetFov(), g_Viewport.x8_width, g_Viewport.xc_height,
                               cam->GetNearClipDistance(), cam->GetFarClipDistance());

    x84c_player->RenderReflectedPlayer(*this);

    CGraphics::SetViewPointMatrix(backupView);
    CGraphics::SetProjectionState(backupProj);
}

void CStateManager::ReflectionDrawer(void* ctx, const zeus::CVector3f& vec)
{
    reinterpret_cast<CStateManager*>(ctx)->DrawReflection(vec);
}

void CStateManager::CacheReflection()
{
    g_Renderer->CacheReflection(ReflectionDrawer, this, true);
}

bool CStateManager::CanCreateProjectile(TUniqueId, EWeaponType, int) const { return false; }

const CGameLightList* CStateManager::GetDynamicLightList() const { return nullptr; }

void CStateManager::BuildDynamicLightListForWorld()
{
    if (x8b8_playerState->GetActiveVisor(*this) == CPlayerState::EPlayerVisor::Thermal)
    {
        x8e0_dynamicLights.clear();
        return;
    }

    if (GetLightObjectList().size() == 0)
        return;

    x8e0_dynamicLights.clear();
    for (CEntity* ent : GetLightObjectList())
    {
        CGameLight& light = static_cast<CGameLight&>(*ent);
        if (light.GetActive())
        {
            CLight l = light.GetLight();
            if (l.GetIntensity() > FLT_EPSILON && l.GetRadius() > FLT_EPSILON)
                x8e0_dynamicLights.push_back(l);
        }
    }
}

void CStateManager::DrawDebugStuff() const {}

void CStateManager::RenderCamerasAndAreaLights() const {}

void CStateManager::DrawE3DeathEffect() const {}

void CStateManager::DrawAdditionalFilters() const {}

zeus::CFrustum CStateManager::SetupViewForDraw(const SViewport& vp) const
{
    const CGameCamera* cam = static_cast<const CGameCamera*>(x870_cameraManager->GetCurrentCamera(*this));
    zeus::CTransform camXf = x870_cameraManager->GetCurrentCameraTransform(*this);
    g_Renderer->SetWorldViewpoint(camXf);
    CBooModel::SetNewPlayerPositionAndTime(x84c_player->GetTranslation());
    int vpWidth = xf2c_viewportScale.x * vp.x8_width;
    int vpHeight = xf2c_viewportScale.y * vp.xc_height;
    int vpLeft = (vp.x8_width - vpWidth) / 2 + vp.x0_left;
    int vpTop = (vp.xc_height - vpHeight) / 2 + vp.x4_top;
    g_Renderer->SetViewport(vpLeft, vpTop, vpWidth, vpHeight);
    CGraphics::SetDepthRange(0.125f, 1.f);
    float fov = std::atan(std::tan(zeus::degToRad(cam->GetFov()) * 0.5f) * xf2c_viewportScale.y * 2.f);
    float width = xf2c_viewportScale.x * vp.x8_width;
    float height = xf2c_viewportScale.y * vp.xc_height;
    g_Renderer->SetPerspective(zeus::radToDeg(fov), width, height,
                               cam->GetNearClipDistance(), cam->GetFarClipDistance());
    zeus::CFrustum frustum;
    zeus::CProjection proj;
    proj.setPersp(zeus::SProjPersp{fov, width / height, cam->GetNearClipDistance(), cam->GetFarClipDistance()});
    frustum.updatePlanes(camXf, proj);
    g_Renderer->SetClippingPlanes(frustum);
    //g_Renderer->PrimColor(zeus::CColor::skWhite);
    CGraphics::SetModelMatrix(zeus::CTransform::Identity());
    x87c_fluidPlaneManager->StartFrame(false);
    g_Renderer->SetDebugOption(IRenderer::EDebugOption::One, 1);
    return frustum;
}

void CStateManager::ResetViewAfterDraw(const SViewport& backupViewport,
                                       const zeus::CTransform& backupViewMatrix) const
{
    g_Renderer->SetViewport(backupViewport.x0_left, backupViewport.x4_top,
                            backupViewport.x8_width, backupViewport.xc_height);
    const CGameCamera* cam = x870_cameraManager->GetCurrentCamera(*this);

    zeus::CFrustum frustum;
    frustum.updatePlanes(backupViewMatrix, zeus::SProjPersp(zeus::degToRad(cam->GetFov()),
                                                            cam->GetAspectRatio(),
                                                            cam->GetNearClipDistance(),
                                                            cam->GetFarClipDistance()));
    g_Renderer->SetClippingPlanes(frustum);

    g_Renderer->SetPerspective(cam->GetFov(), g_Viewport.x8_width, g_Viewport.xc_height,
                               cam->GetNearClipDistance(), cam->GetFarClipDistance());
}

void CStateManager::DrawWorld() const
{
    CTimeProvider timeProvider(xf14_curTimeMod900);
    SViewport backupViewport = g_Viewport;
    zeus::CFrustum frustum = SetupViewForDraw(g_Viewport);
    zeus::CTransform backupViewMatrix = CGraphics::g_ViewMatrix;

    /* Area camera is in (not necessarily player) */
    TAreaId visAreaId = GetVisAreaId();

    x850_world->TouchSky();

    int areaCount = 0;
    CGameArea* areaArr[10];
    for (CGameArea* area = x850_world->GetChainHead(EChain::Alive);
         area != CWorld::AliveAreasEnd() && areaCount != 10;
         area = area->x130_next)
    {
        CGameArea::EOcclusionState occState = CGameArea::EOcclusionState::NotOccluded;
        if (area->IsPostConstructed())
            occState = area->GetOcclusionState();
        if (occState == CGameArea::EOcclusionState::Occluded)
            areaArr[areaCount++] = area;
    }

    std::sort(std::begin(areaArr), std::begin(areaArr) + areaCount,
    [visAreaId](CGameArea* a, CGameArea* b) -> bool
    {
        if (a->x4_selfIdx == b->x4_selfIdx)
            return false;
        if (visAreaId == a->x4_selfIdx)
            return false;
        if (visAreaId == b->x4_selfIdx)
            return true;
        return CGraphics::g_ViewPoint.dot(a->GetAABB().center()) >
               CGraphics::g_ViewPoint.dot(b->GetAABB().center());
    });

    int pvsCount = 0;
    CPVSVisSet pvsArr[10];
    for (CGameArea** area = areaArr;
         area != areaArr + areaCount;
         ++area)
    {
        CGameArea* areaPtr = *area;
        CPVSVisSet& pvsSet = pvsArr[pvsCount++];
        pvsSet.Reset(EPVSVisSetState::OutOfBounds);
        GetVisSetForArea(areaPtr->x4_selfIdx, visAreaId, pvsSet);
    }

    int mask;
    int targetMask;
    CPlayerState::EPlayerVisor visor = x8b8_playerState->GetActiveVisor(*this);
    bool thermal = visor == CPlayerState::EPlayerVisor::Thermal;
    if (thermal)
    {
        const_cast<CStateManager&>(*this).xf34_particleFlags = 1;
        mask = 52;
        targetMask = 0;
    }
    else
    {
        const_cast<CStateManager&>(*this).xf34_particleFlags = 2;
        mask = 1 << (visor == CPlayerState::EPlayerVisor::XRay ? 3 : 1);
        targetMask = 0;
    }

    g_Renderer->SetThermal(thermal, g_tweakGui->GetThermalVisorLevel(), g_tweakGui->GetThermalVisorColor());
    g_Renderer->SetThermalColdScale(xf28_thermColdScale2 + xf24_thermColdScale1);

    for (int i=areaCount-1 ; i>=0 ; --i)
    {
        CGameArea& area = *areaArr[i];
        SetupFogForArea(area);
        g_Renderer->EnablePVS(&pvsArr[i], area.x4_selfIdx);
        g_Renderer->SetWorldLightFadeLevel(area.GetPostConstructed()->x1128_worldLightingLevel);
        g_Renderer->DrawUnsortedGeometry(area.x4_selfIdx, mask, targetMask);
    }

    if (!SetupFogForDraw())
        g_Renderer->SetWorldFog(ERglFogMode::None, 0.f, 1.f, zeus::CColor::skBlack);

    x850_world->DrawSky(zeus::CTransform::Translate(CGraphics::g_ViewPoint));

    if (areaCount)
        SetupFogForArea(*areaArr[areaCount-1]);

    for (TUniqueId id : x86c_stateManagerContainer->xf370_)
        if (const CActor* ent = static_cast<const CActor*>(GetObjectById(id)))
            if (!thermal || ent->xe6_27_ & 0x2)
                ent->Render(*this);

    bool morphingPlayerVisible = false;
    int thermalActorCount = 0;
    CActor* thermalActorArr[1024];
    for (int i=0 ; i<areaCount ; ++i)
    {
        CGameArea& area = *areaArr[i];
        CPVSVisSet& pvs = pvsArr[i];
        bool isVisArea = area.x4_selfIdx == visAreaId;
        SetupFogForArea(area);
        g_Renderer->SetWorldLightFadeLevel(area.GetPostConstructed()->x1128_worldLightingLevel);
        for (CEntity* ent : *area.GetPostConstructed()->x10c0_areaObjs)
        {
            if (TCastToPtr<CActor> actor = ent)
            {
                if (!actor->xe7_29_)
                    continue;
                TUniqueId actorId = actor->GetUniqueId();
                if (!thermal && area.LookupPVSUniqueID(actorId) == actorId)
                    if (pvs.GetVisible(area.LookupPVSID(actorId)) == EPVSVisSetState::EndOfTree)
                        continue;
                if (x84c_player.get() == actor.GetPtr())
                {
                    if (thermal)
                        continue;
                    switch (x84c_player->GetMorphballTransitionState())
                    {
                    case CPlayer::EPlayerMorphBallState::Unmorphed:
                    case CPlayer::EPlayerMorphBallState::Morphed:
                        x84c_player->AddToRenderer(frustum, *this);
                        continue;
                    default:
                        morphingPlayerVisible = true;
                        continue;
                    }
                }
                if (!thermal || actor->xe6_27_ & 0x2)
                    actor->AddToRenderer(frustum, *this);
                if (thermal && actor->xe6_27_ & 0x4)
                    thermalActorArr[thermalActorCount++] = actor.GetPtr();
            }
        }

        if (isVisArea && !thermal)
        {
            CDecalManager::AddToRenderer(frustum, *this);
            x884_actorModelParticles->AddStragglersToRenderer(*this);
        }

        ++const_cast<CStateManager&>(*this).x8dc_objectDrawToken;

        x84c_player->GetMorphBall()->DrawBallShadow(*this);

        if (xf7c_projectedShadow)
            xf7c_projectedShadow->Render(*this);

        g_Renderer->EnablePVS(&pvs, area.x4_selfIdx);
        g_Renderer->DrawSortedGeometry(area.x4_selfIdx, mask, targetMask);
    }

    x880_envFxManager->Render(*this);

    if (morphingPlayerVisible)
        x84c_player->Render(*this);

    g_Renderer->PostRenderFogs();

    if (thermal)
    {
        if (x86c_stateManagerContainer->xf39c_renderLast.size())
        {
            CGraphics::SetDepthRange(0.015625f, 0.03125f);
            for (TUniqueId id : x86c_stateManagerContainer->xf39c_renderLast)
                if (const CActor* actor = static_cast<const CActor*>(GetObjectById(id)))
                    if (actor->xe6_27_ & 0x2)
                        actor->Render(*this);
            CGraphics::SetDepthRange(0.125f, 1.f);
        }
        g_Renderer->DoThermalBlendCold();

        for (TUniqueId id : x86c_stateManagerContainer->xf370_)
            if (const CActor* actor = static_cast<const CActor*>(GetObjectById(id)))
                if (actor->xe6_27_ & 0x4)
                    actor->Render(*this);

        for (int i=areaCount-1 ; i>=0 ; --i)
        {
            CGameArea& area = *areaArr[i];
            CPVSVisSet& pvs = pvsArr[i];

            g_Renderer->EnablePVS(&pvs, area.x4_selfIdx);
            g_Renderer->DrawUnsortedGeometry(area.x4_selfIdx, mask, 0x20);
            g_Renderer->DrawAreaGeometry(area.x4_selfIdx, mask, 0x10);
        }

        ++const_cast<CStateManager&>(*this).x8dc_objectDrawToken;

        for (int i=0 ; i<areaCount ; ++i)
        {
            CGameArea& area = *areaArr[i];
            CPVSVisSet& pvs = pvsArr[i];

            for (int j=0 ; j<thermalActorCount ; ++j)
            {
                CActor* actor = thermalActorArr[j];
                if (actor->GetAreaIdAlways() != area.x4_selfIdx)
                    if (actor->GetAreaIdAlways() != kInvalidAreaId || area.x4_selfIdx != visAreaId)
                        continue;
                actor->AddToRenderer(frustum, *this);
            }

            if (areaCount - 1 == i)
            {
                x884_actorModelParticles->AddStragglersToRenderer(*this);
                CDecalManager::AddToRenderer(frustum, *this);
                if (x84c_player)
                    x84c_player->AddToRenderer(frustum, *this);
            }

            ++const_cast<CStateManager&>(*this).x8dc_objectDrawToken;

            g_Renderer->EnablePVS(&pvs, area.x4_selfIdx);
            g_Renderer->DrawSortedGeometry(area.x4_selfIdx, mask, 0x10);
        }

        g_Renderer->PostRenderFogs();
    }

    x87c_fluidPlaneManager->EndFrame();

    g_Renderer->SetWorldFog(ERglFogMode::None, 0.f, 1.f, zeus::CColor::skBlack);

#if 0
    if (false)
        CacheReflection();
#endif

    if (x84c_player)
        x84c_player->RenderGun(*this, x870_cameraManager->GetGlobalCameraTranslation(*this));

    if (x86c_stateManagerContainer->xf39c_renderLast.size())
    {
        CGraphics::SetDepthRange(0.015625f, 0.03125f);
        for (TUniqueId id : x86c_stateManagerContainer->xf39c_renderLast)
            if (const CActor* actor = static_cast<const CActor*>(GetObjectById(id)))
                if (actor->xe6_27_ & 0x4)
                    actor->Render(*this);
        CGraphics::SetDepthRange(0.125f, 1.f);
    }

    if (thermal)
    {
        g_Renderer->DoThermalBlendHot();
        g_Renderer->SetThermal(false, 0.f, zeus::CColor::skBlack);
        const_cast<CStateManager&>(*this).xf34_particleFlags = 2;
    }

    DrawDebugStuff();
    RenderCamerasAndAreaLights();
    ResetViewAfterDraw(backupViewport, backupViewMatrix);
    DrawE3DeathEffect();
    DrawAdditionalFilters();
}

void CStateManager::SetupFogForArea(const CGameArea& area) const
{
    if (SetupFogForDraw())
        return;

    if (x8b8_playerState->GetActiveVisor(*this) == CPlayerState::EPlayerVisor::XRay)
    {
        float fogDist = area.GetXRayFogDistance();
        float farz = g_tweakGui->GetXRayFogNearZ() * (1.f - fogDist) +
                     g_tweakGui->GetXRayFogFarZ() * fogDist;
        g_Renderer->SetWorldFog(ERglFogMode(g_tweakGui->GetXRayFogMode()),
                                g_tweakGui->GetXRayFogNearZ(),
                                farz, g_tweakGui->GetXRayFogColor());
    }
    else
    {
        area.GetAreaFog()->SetCurrent();
    }
}

bool CStateManager::SetupFogForDraw() const
{
    switch (x8b8_playerState->GetActiveVisor(*this))
    {
    case CPlayerState::EPlayerVisor::Thermal:
        g_Renderer->SetWorldFog(ERglFogMode::None, 0.f, 1.f, zeus::CColor::skBlack);
        return true;
    case CPlayerState::EPlayerVisor::XRay:
    default:
        return false;
    case CPlayerState::EPlayerVisor::Combat:
    case CPlayerState::EPlayerVisor::Scan:
        auto& fog = x870_cameraManager->Fog();
        if (fog.IsFogDisabled())
            return false;
        fog.SetCurrent();
        return true;
    }
}

void CStateManager::PreRender()
{
    if (xf94_24_)
    {
        x86c_stateManagerContainer->xf370_.clear();
        x86c_stateManagerContainer->xf39c_renderLast.clear();
        xf7c_projectedShadow = nullptr;
        x850_world->PreRender();
        BuildDynamicLightListForWorld();
        CGameCamera* cam = static_cast<CGameCamera*>(x870_cameraManager->GetCurrentCamera(*this));
        zeus::CFrustum frustum;
        zeus::CProjection proj;
        proj.setPersp(zeus::SProjPersp{zeus::degToRad(cam->GetFov()),
                                       cam->GetAspectRatio(), cam->GetNearClipDistance(), cam->GetFarClipDistance()});
        frustum.updatePlanes(x870_cameraManager->GetCurrentCameraTransform(*this), proj);
        for (CGameArea* area = x850_world->GetChainHead(EChain::Alive);
             area != CWorld::AliveAreasEnd();
             area = area->x130_next)
        {
            CGameArea::EOcclusionState occState = CGameArea::EOcclusionState::NotOccluded;
            if (area->IsPostConstructed())
                occState = area->GetOcclusionState();
            if (occState == CGameArea::EOcclusionState::Occluded)
            {
                for (CEntity* ent : *area->GetPostConstructed()->x10c0_areaObjs)
                {
                    if (TCastToPtr<CActor> act = ent)
                    {
                        if (act->GetE7_29())
                        {
                            act->CalculateRenderBounds();
                            act->PreRender(*this, frustum);
                        }
                    }
                }
            }
        }

        CacheReflection();
        g_Renderer->PrepareDynamicLights(x8e0_dynamicLights);
    }
}

bool CStateManager::GetVisSetForArea(TAreaId a, TAreaId b, CPVSVisSet& setOut) const
{
    if (b == kInvalidAreaId)
        return false;

    zeus::CVector3f viewPoint = CGraphics::g_ViewMatrix.origin;
    zeus::CVector3f closestDockPoint = viewPoint;
    bool hasClosestDock = false;
    if (a != b)
    {
        CGameArea& area = *x850_world->GetGameAreas()[b];
        if (area.IsPostConstructed())
        {
            for (const CGameArea::Dock& dock : area.GetDocks())
            {
                for (int i=0 ; i<dock.GetDockRefs().size() ; ++i)
                {
                    TAreaId connArea = dock.GetConnectedAreaId(i);
                    if (connArea == a)
                    {
                        const auto& verts = dock.GetPlaneVertices();
                        zeus::CVector3f dockCenter = (verts[0] + verts[1] + verts[2] + verts[4]) * 0.25f;
                        if (hasClosestDock)
                            if ((dockCenter - viewPoint).magSquared() >=
                                (closestDockPoint - viewPoint).magSquared())
                                continue;
                        closestDockPoint = dockCenter;
                        hasClosestDock = true;
                    }
                }
            }
        }
    }
    else
    {
        hasClosestDock = true;
    }

    if (hasClosestDock)
    {
        if (CPVSAreaSet* pvs = x850_world->GetGameAreas()[a]->GetPostConstructed()->xa0_pvs.get())
        {
            const CPVSVisOctree& octree = pvs->GetVisOctree();
            zeus::CVector3f closestDockLocal =
                x850_world->GetGameAreas()[a]->GetInverseTransform() * closestDockPoint;
            CPVSVisSet set;
            set.SetTestPoint(octree, closestDockLocal);

            if (set.GetState() == EPVSVisSetState::NodeFound)
            {
                setOut = set;
                return true;
            }
        }
    }

    return false;
}

void CStateManager::RecursiveDrawTree(TUniqueId node) const
{
    if (TCastToConstPtr<CActor> actor = GetObjectById(node))
    {
        if (x8dc_objectDrawToken != actor->xc8_drawnToken)
        {
            if (actor->xc6_nextDrawNode != kInvalidUniqueId)
                RecursiveDrawTree(actor->xc6_nextDrawNode);
            if (x8dc_objectDrawToken == actor->xcc_addedToken)
                actor->Render(*this);
            const_cast<CActor*>(actor.GetPtr())->xc8_drawnToken = x8dc_objectDrawToken;
        }
    }
}

void CStateManager::SendScriptMsg(CEntity* dest, TUniqueId src, EScriptObjectMessage msg)
{
    if (dest && !dest->x30_26_scriptingBlocked)
    {
        dest->AcceptScriptMsg(msg, src, *this);
    }
}

void CStateManager::SendScriptMsg(TUniqueId dest, TUniqueId src, EScriptObjectMessage msg)
{
    CEntity* ent = ObjectById(dest);
    SendScriptMsg(ent, src, msg);
}

void CStateManager::SendScriptMsgAlways(TUniqueId dest, TUniqueId src, EScriptObjectMessage msg)
{
    CEntity* dst = ObjectById(dest);
    if (dst)
        dst->AcceptScriptMsg(msg, src, *this);
}

void CStateManager::SendScriptMsg(TUniqueId src, TEditorId dest, EScriptObjectMessage msg, EScriptObjectState state)
{
    CEntity* ent = ObjectById(src);
    auto search = GetIdListForScript(dest);
    if (ent && search.first != x890_scriptIdMap.cend() && search.second != x890_scriptIdMap.cend())
    {
        for (auto it = search.first; it != search.second; ++it)
        {
            TUniqueId id = it->second;
            CEntity* dobj = GetAllObjectList().GetObjectById(id);
            SendScriptMsg(dobj, src, msg);
        }
    }
}

void CStateManager::FreeScriptObjects(TAreaId aid)
{
    for (const auto& p : x890_scriptIdMap)
        if (p.first.AreaNum() == aid)
            FreeScriptObject(p.second);

    for (auto it = x8a4_loadedScriptObjects.begin() ; it != x8a4_loadedScriptObjects.end() ;)
    {
        if (it->first.AreaNum() == aid)
        {
            it = x8a4_loadedScriptObjects.erase(it);
            continue;
        }
        ++it;
    }

    CGameArea* area = x850_world->GetGameAreas()[aid].get();
    if (area->IsPostConstructed())
    {
        const CGameArea::CPostConstructed* pc = area->GetPostConstructed();
        for (CEntity* ent : *pc->x10c0_areaObjs)
            if (ent && !ent->IsInUse())
                FreeScriptObject(ent->GetUniqueId());
    }
}

void CStateManager::FreeScriptObject(TUniqueId id)
{
    CEntity* ent = ObjectById(id);
    if (!ent || ent->IsInGraveyard())
        return;

    ent->SetIsInGraveyard(true);
    x854_objectGraveyard.push_back(id);
    ent->AcceptScriptMsg(EScriptObjectMessage::Deleted, kInvalidUniqueId, *this);
    ent->SetIsScriptingBlocked(true);

    if (TCastToPtr<CActor> act = ent)
    {
        x874_sortedListManager->Remove(act.GetPtr());
        act->SetUseInSortedLists(false);
    }
}

std::pair<const SScriptObjectStream*, TEditorId> CStateManager::GetBuildForScript(TEditorId id) const
{
    auto search = x8a4_loadedScriptObjects.find(id);
    if (search == x8a4_loadedScriptObjects.cend())
        return {nullptr, kInvalidEditorId};
    return {&search->second, search->first};
}

TEditorId CStateManager::GetEditorIdForUniqueId(TUniqueId id) const
{
    const CEntity* ent = GetObjectById(id);
    if (ent)
        return ent->GetEditorId();
    return kInvalidEditorId;
}

TUniqueId CStateManager::GetIdForScript(TEditorId id) const
{
    auto search = x890_scriptIdMap.find(id);
    if (search == x890_scriptIdMap.cend())
        return kInvalidUniqueId;
    return search->second;
}

std::pair<std::multimap<TEditorId, TUniqueId>::const_iterator, std::multimap<TEditorId, TUniqueId>::const_iterator>
CStateManager::GetIdListForScript(TEditorId id) const
{
    return x890_scriptIdMap.equal_range(id);
}

void CStateManager::LoadScriptObjects(TAreaId aid, CInputStream& in, std::vector<TEditorId>& idsOut)
{
    in.readUByte();
    int objCount = in.readUint32Big();
    idsOut.reserve(idsOut.size() + objCount);
    for (int i=0 ; i<objCount ; ++i)
    {
        EScriptObjectType objType = EScriptObjectType(in.readUByte());
        u32 objSize = in.readUint32Big();
        u32 pos = in.position();
        auto id = LoadScriptObject(aid, objType, objSize, in);
        if (id.first == kInvalidEditorId)
            continue;
        auto build = GetBuildForScript(id.first);
        if (build.first)
            continue;
        x8a4_loadedScriptObjects[id.first] = SScriptObjectStream{objType, pos, objSize};
        idsOut.push_back(id.first);
    }
}

std::pair<TEditorId, TUniqueId> CStateManager::LoadScriptObject(TAreaId aid, EScriptObjectType type,
                                                                u32 length, CInputStream& in)
{
    TEditorId id = in.readUint32Big();
    u32 connCount = in.readUint32Big();
    length -= 8;
    std::vector<SConnection> conns;
    conns.reserve(connCount);
    for (int i=0 ; i<connCount ; ++i)
    {
        EScriptObjectState state = EScriptObjectState(in.readUint32Big());
        EScriptObjectMessage msg = EScriptObjectMessage(in.readUint32Big());
        TEditorId target = in.readUint32Big();
        length -= 12;
        conns.push_back(SConnection{state, msg, target});
    }
    u32 propCount = in.readUint32Big();
    length -= 4;
    auto startPos = in.position();

    bool error = false;
    FScriptLoader loader = {};
    if (type < EScriptObjectType::ScriptObjectTypeMAX && type >= EScriptObjectType::Actor)
        loader = x90c_loaderFuncs[int(type)];

    CEntity* ent = nullptr;
    if (loader)
    {
        CEntityInfo info(aid, conns, id);
        ent = loader(*this, in, propCount, info);
    }
    else
    {
        error = true;
    }

    if (ent)
        AddObject(ent);
    else
        error = true;

    u32 readAmt = in.position() - startPos;
    if (readAmt > length)
        LogModule.report(logvisor::Fatal, "Script object overread");
    u32 leftover = length - readAmt;
    for (u32 i=0 ; i<leftover ; ++i)
        in.readByte();

    if (error || ent == nullptr)
    {
        LogModule.report(logvisor::Fatal, "Script load error");
        return {kInvalidEditorId, kInvalidUniqueId};
    }
    else
        return {id, ent->GetUniqueId()};
}

std::pair<TEditorId, TUniqueId> CStateManager::GenerateObject(TEditorId)
{
    return {kInvalidEditorId, kInvalidUniqueId};
}

void CStateManager::InitScriptObjects(const std::vector<TEditorId>& ids)
{
    for (TEditorId id : ids)
    {
        if (id == kInvalidEditorId)
            continue;
        TUniqueId uid = GetIdForScript(id);
        SendScriptMsg(uid, kInvalidUniqueId, EScriptObjectMessage::InitializedInArea);
    }
    MurderScriptInstanceNames();
}

void CStateManager::InformListeners(const zeus::CVector3f&, EListenNoiseType) {}

bool CStateManager::ApplyKnockBack(CActor& actor, const CDamageInfo& info, const CDamageVulnerability&,
                                   const zeus::CVector3f&, float)
{
    return false;
}

bool CStateManager::ApplyDamageToWorld(TUniqueId, const CActor&, const zeus::CVector3f&, const CDamageInfo& info,
                                       const CMaterialFilter&)
{
    return false;
}

void CStateManager::ProcessRadiusDamage(const CActor&, CActor&, const zeus::CVector3f&, const CDamageInfo& info,
                                        const CMaterialFilter&)
{
}

bool CStateManager::ApplyRadiusDamage(const CActor&, const zeus::CVector3f&, CActor&, const CDamageInfo& info)
{
    return false;
}

bool CStateManager::ApplyLocalDamage(const zeus::CVector3f& vec1, const zeus::CVector3f& vec2, CActor& actor, float dt,
                                     const CWeaponMode& weapMode)
{
    CHealthInfo* hInfo = actor.HealthInfo();
    if (!hInfo || dt < 0.f)
        return false;

    if (hInfo->GetHP() <= 0.f)
        return true;

    float f30 = dt;

    CPlayer* player = TCastToPtr<CPlayer>(actor);
    CAi* ai = TCastToPtr<CAi>(actor);
#if 0
    CDestroyableRock* dRock = nullptr;
    if (!ai)
        TCastToPtr<CDestroyableRock>(actor);
#endif

    if (player)
    {
        if (x870_cameraManager->IsInCinematicCamera())
        {
        }
    }
    return false;
}

bool CStateManager::ApplyDamage(TUniqueId, TUniqueId, TUniqueId, const CDamageInfo& info, const CMaterialFilter&)
{
    return false;
}

void CStateManager::UpdateAreaSounds() {}

void CStateManager::FrameEnd()
{
    g_SimplePool->Flush();
}

void CStateManager::ProcessPlayerInput()
{
    if (x84c_player)
        x84c_player->ProcessInput(xb54_finalInput, *this);
}

static const CFinalInput s_DisabledFinalInput = {};

void CStateManager::ProcessInput(const CFinalInput& input)
{
    if (input.ControllerIdx() == 0)
    {
        CGameCamera* cam = x870_cameraManager->GetCurrentCamera(*this);
        bool disableInput = cam->x170_25_disablesInput;
        if (x84c_player->x9c6_29_disableInput)
            disableInput = true;
        if (disableInput)
        {
            xb54_finalInput = s_DisabledFinalInput;
            xb54_finalInput.x0_dt = input.DeltaTime();
        }
        else
        {
            xb54_finalInput = input;
        }
    }
    x870_cameraManager->ProcessInput(input, *this);
}

void CStateManager::Update(float dt)
{
    CElementGen::SetGlobalSeed(x8d8_updateFrameIdx);
    CParticleElectric::SetGlobalSeed(x8d8_updateFrameIdx);
    CDecal::SetGlobalSeed(x8d8_updateFrameIdx);
    CProjectileWeapon::SetGlobalSeed(x8d8_updateFrameIdx);

    xf14_curTimeMod900 += dt;
    if (xf14_curTimeMod900 > 900.f)
        xf14_curTimeMod900 -= 900.f;

    xf08_pauseHudMessage = -1;

    CScriptEffect::ResetParticleCounts();
    UpdateThermalVisor();
    UpdateGameState();

    bool _9f4_gt0 = x84c_player->x9f4_ > 0.f;

    if (x904_ == 0)
    {
        if (!TCastToPtr<CCinematicCamera>(x870_cameraManager->GetCurrentCamera(*this)))
        {
            g_GameState->SetTotalPlayTime(g_GameState->xa0_playTime + dt);
            UpdateHintState(dt);
        }

        for (int i=0 ; i<9 ; ++i)
        {
            xb84_camFilterPasses[i].Update(dt);
            xd14_camBlurPasses[i].Update(dt);
        }
    }

    if (x904_ != 2)
    {
        PreThinkEffects(dt);
        x87c_fluidPlaneManager->Update(dt);
    }

    if (x904_ == 0)
    {
        if (!_9f4_gt0)
            CDecalManager::Update(dt, *this);
        UpdateSortedLists();
        if (!_9f4_gt0)
        {
            MovePlatforms(dt);
            MoveDoors(dt);
        }
        ProcessPlayerInput();
        if (x904_ != 1)
            CGameCollision::Move(*this, *x84c_player, dt, nullptr);
        UpdateSortedLists();
        if (!_9f4_gt0)
            CrossTouchActors();
    }
    else
    {
        ProcessPlayerInput();
    }

    if (!_9f4_gt0 && x904_ == 0)
        x884_actorModelParticles->Update(dt, *this);

    if (x904_ == 0 || x904_ == 1)
        ThinkEffectsAndActors(dt);

    if (x904_ != 1)
        x870_cameraManager->Update(dt, *this);

    while (xf76_lastRelay != kInvalidUniqueId)
    {
        if (CEntity* ent = ObjectById(xf76_lastRelay))
        {
            ent->Think(dt, *this);
        }
        else
        {
            xf76_lastRelay = kInvalidUniqueId;
            break;
        }
    }

    if (x904_ != 2)
        UpdatePlayer(dt);

    if (xf84_ == xf80_hudMessageFrameCount)
    {
        ShowPausedHUDMemo(xf88_, xf8c_);
        --xf84_;
        xf88_ = -1;
    }

    if (!_9f4_gt0 && x904_ == 0 && !x870_cameraManager->IsInCinematicCamera())
        UpdateEscapeSequenceTimer(dt);

    x850_world->Update(dt);
    x88c_rumbleManager->Update(dt);

    if (!_9f4_gt0)
        x880_envFxManager->Update(dt, *this);

    UpdateAreaSounds();

    xf94_24_ = true;

    if (xf94_27_inMapScreen)
    {
        if (const CHintOptions::SHintState* hint = g_GameState->HintOptions().GetCurrentDisplayedHint())
        {
            if (hint->CanContinue())
                g_GameState->HintOptions().DismissDisplayedHint();
        }
        xf94_27_inMapScreen = false;
    }

    g_GameState->CurrentWorldState().SetAreaId(x8cc_nextAreaId);
    x850_world->TravelToArea(x8cc_nextAreaId, *this, false);

    ClearGraveyard();
    ++x8d8_updateFrameIdx;
}

void CStateManager::UpdateGameState()
{
    // Intentionally empty
}

void CStateManager::UpdateHintState(float dt)
{
    CHintOptions& ho = g_GameState->HintOptions();
    ho.Update(dt, *this);
    u32 nextHintIdx = -1;
    u32 hintPeriods = -1;
    if (const CHintOptions::SHintState* state = ho.GetCurrentDisplayedHint())
    {
        const CGameHintInfo::CGameHint& next = g_MemoryCardSys->GetHints()[ho.GetNextHintIdx()];
        for (const CGameHintInfo::SHintLocation& loc : next.GetLocations())
        {
            const auto& mwInfo = g_GameState->StateForWorld(loc.x0_mlvlId).MapWorldInfo();
            mwInfo->SetIsMapped(loc.x8_areaId, true);
        }
        if (state->x4_time < next.GetTextTime())
        {
            nextHintIdx = ho.GetNextHintIdx();
            hintPeriods = state->x4_time / 3.f;
        }
    }

    if (xeec_hintIdx != nextHintIdx || xef0_hintPeriods != hintPeriods)
    {
        if (nextHintIdx == -1)
        {
            SHudMemoInfo memoInfo = {0.f, true, true, true};
            MP1::CSamusHud::DisplayHudMemo(u"", memoInfo);
        }
        else
        {
            const CGameHintInfo::CGameHint& data = g_MemoryCardSys->GetHints()[nextHintIdx];
            SHudMemoInfo memoInfo = {0.f, true, false, true};
            MP1::CSamusHud::DeferHintMemo(data.GetStringID(), hintPeriods, memoInfo);
        }
        xeec_hintIdx = nextHintIdx;
        xef0_hintPeriods = hintPeriods;
    }
}

void CStateManager::PreThinkEffects(float dt)
{
    if (x84c_player->x9f4_ > 0.f)
    {
        x84c_player->DoPreThink(dt, *this);
        return;
    }

    if (x904_ == 1)
        for (CEntity* ent : GetAllObjectList())
            if (TCastToPtr<CScriptEffect> effect = ent)
                effect->PreThink(dt, *this);

    for (CEntity* ent : GetCameraObjectList())
        if (ent && !GetCameraObjectList().GetObjectById(ent->GetUniqueId()))
            ent->PreThink(dt, *this);
}

void CStateManager::MovePlatforms(float dt)
{
    for (CEntity* ent : GetPlatformAndDoorObjectList())
    {
        if (!ent || !GetPlatformAndDoorObjectList().IsPlatform(*ent))
            continue;
        CScriptPlatform& plat = static_cast<CScriptPlatform&>(*ent);
        if (!plat.GetActive() || plat.GetMass() == 0.f)
            continue;
        CGameCollision::Move(*this, plat, dt, nullptr);
    }
}

void CStateManager::MoveDoors(float dt)
{
    for (CEntity* ent : GetPhysicsActorObjectList())
    {
        if (!ent || !ent->GetActive())
            continue;
        CPhysicsActor& physActor = static_cast<CPhysicsActor&>(*ent);
        if (physActor.GetMass() == 0.f)
            continue;
        if (TCastToPtr<CAi> ai = physActor)
        {
            bool doThink = !xf94_29_;
            if (doThink && ai->GetAreaIdAlways() != kInvalidAreaId)
            {
                const CGameArea* area = x850_world->GetAreaAlways(ai->GetAreaIdAlways());
                float f1;
                if (area->IsPostConstructed())
                    f1 = area->GetPostConstructed()->x10e4_;
                else
                    f1 = 0.f;
                if (f1 > 5.f)
                    doThink = false;
            }
            if (!doThink)
                SendScriptMsgAlways(ai->GetUniqueId(), kInvalidUniqueId,
                                    EScriptObjectMessage::InternalMessage26);
            else if (x84c_player.get() != ent)
                if (!GetPlatformAndDoorObjectList().IsPlatform(*ent))
                    CGameCollision::Move(*this, physActor, dt, nullptr);
        }
    }
}

void CStateManager::CrossTouchActors()
{
    bool visits[1024] = {};
    for (CEntity* ent : GetActorObjectList())
    {
        if (!ent)
            continue;
        CActor& actor = static_cast<CActor&>(*ent);
        if (!actor.GetActive() || !actor.GetCallTouch())
            continue;
        rstl::optional_object<zeus::CAABox> touchAABB = actor.GetTouchBounds();
        if (!touchAABB)
            continue;

        CMaterialFilter filter = CMaterialFilter::skPassEverything;
        if (actor.GetMaterialList().HasMaterial(EMaterialTypes::Trigger))
            filter = CMaterialFilter::MakeExclude(EMaterialTypes::Trigger);

        rstl::reserved_vector<TUniqueId, 1024> nearList;
        BuildNearList(nearList, *touchAABB, filter, &actor);

        for (TUniqueId id : nearList)
        {
            CActor* ent2 = static_cast<CActor*>(ObjectById(id));
            if (!ent2)
                continue;

            rstl::optional_object<zeus::CAABox> touchAABB2 = ent2->GetTouchBounds();
            if (!ent2->GetActive() || touchAABB2)
                continue;

            if (visits[ent2->GetUniqueId() & 0x3ff])
                continue;

            if (touchAABB->intersects(*touchAABB2))
            {
                actor.Touch(*ent2, *this);
                ent2->Touch(actor, *this);
            }

            visits[ent2->GetUniqueId() & 0x3ff] = true;
        }
    }
}

void CStateManager::ThinkEffectsAndActors(float dt)
{
    if (x84c_player->x9f4_ > 0.f)
    {
        x84c_player->DoThink(dt, *this);
        return;
    }

    if (x904_ == 1)
    {
        for (CEntity* ent : GetAllObjectList())
            if (TCastToPtr<CScriptEffect> effect = ent)
                effect->Think(dt, *this);
    }
    else
    {
        for (CEntity* ent : GetAllObjectList())
            if (TCastToPtr<CAi> ai = ent)
            {
                bool doThink = !xf94_29_;
                if (doThink && ai->GetAreaIdAlways() != kInvalidAreaId)
                {
                    const CGameArea* area = x850_world->GetAreaAlways(ai->GetAreaIdAlways());
                    float f1;
                    if (area->IsPostConstructed())
                        f1 = area->GetPostConstructed()->x10e4_;
                    else
                        f1 = 0.f;
                    if (f1 > 5.f)
                        doThink = false;
                }
                if (doThink)
                {
                    CEntity* ent2 = GetAllObjectList().GetObjectById(ai->GetUniqueId());
                    ent2->Think(dt, *this);
                }
            }
    }
}

void CStateManager::UpdatePlayer(float dt)
{
    x84c_player->Update(dt, *this);
}

void CStateManager::ShowPausedHUDMemo(ResId strg, float time)
{
    xf78_hudMessageTime = time;
    xf08_pauseHudMessage = strg;
    DeferStateTransition(EStateManagerTransition::MessageScreen);
}

void CStateManager::ClearGraveyard()
{
    for (TUniqueId id : x854_objectGraveyard)
    {
        CEntity* ent = GetAllObjectList().GetValidObjectById(id);
        RemoveObject(id);
        if (ent)
            std::default_delete<CEntity>()(ent);
    }
    x854_objectGraveyard.clear();
}

void CStateManager::FrameBegin(s32 frameCount)
{
    x8d4_inputFrameIdx = frameCount;
}

void CStateManager::InitializeState(ResId mlvlId, TAreaId aid, ResId mreaId)
{
    bool hadRandom = x900_activeRandom != nullptr;
    SetActiveRandomToDefault();

    if (xb3c_initPhase == EInitPhase::LoadWorld)
    {
        CreateStandardGameObjects();
        x850_world.reset(new CWorld(*g_SimplePool, *g_ResFactory, mlvlId));
        xb3c_initPhase = EInitPhase::LoadFirstArea;
    }

    if (xb3c_initPhase == EInitPhase::LoadFirstArea)
    {
        if (!x8f0_shadowTex.IsLoaded())
            return;
        x8f0_shadowTex.GetObj();

        if (!x850_world->CheckWorldComplete(this, aid, mreaId))
            return;
        x8cc_nextAreaId = x850_world->x68_curAreaId;
        CGameArea* area = x850_world->x18_areas[x8cc_nextAreaId].get();
        if (x850_world->ScheduleAreaToLoad(area, *this))
        {
            area->StartStreamIn(*this);
            return;
        }
        xb3c_initPhase = EInitPhase::Done;
    }

    SetCurrentAreaId(x8cc_nextAreaId);
    g_GameState->CurrentWorldState().SetAreaId(x8cc_nextAreaId);
    x850_world->TravelToArea(x8cc_nextAreaId, *this, true);
    UpdateRoomAcoustics(x8cc_nextAreaId);

    for (CEntity* ent : GetAllObjectList())
        SendScriptMsg(ent, kInvalidUniqueId, EScriptObjectMessage::InternalMessage14);

    for (CEntity* ent : GetAllObjectList())
    {
        CScriptSpawnPoint* sp = TCastToPtr<CScriptSpawnPoint>(ent);
        if (sp && sp->x30_24_active && sp->FirstSpawn())
        {
            const zeus::CTransform& xf = sp->GetTransform();
            zeus::CVector3f lookVec{xf.basis[0][1], xf.basis[1][1], xf.basis[2][1]};
            if (lookVec.canBeNormalized())
            {
                auto lookXf = zeus::lookAt(xf.origin, lookVec);
                x84c_player->Teleport(lookXf, *this, true);
            }

            if (!g_GameState->x228_25_deferPowerupInit)
                break;

            g_GameState->x228_25_deferPowerupInit = false;
            for (int i = 0; i < int(CPlayerState::EItemType::Max); ++i)
            {
                CPlayerState::EItemType iType = CPlayerState::EItemType(i);

                u32 spawnPu = sp->GetPowerup(iType);
                u32 statePu = x8b8_playerState->GetItemAmount(iType);
                if (statePu < spawnPu)
                    x8b8_playerState->InitializePowerUp(iType, spawnPu - statePu);

                spawnPu = sp->GetPowerup(iType);
                statePu = x8b8_playerState->GetItemAmount(iType);
                if (statePu < spawnPu)
                    x8b8_playerState->IncrPickup(iType, spawnPu - statePu);
            }
        }
    }

    x84c_player->AsyncLoadSuit(*this);
    x870_cameraManager->ResetCameras(*this);

    if (!hadRandom)
        ClearActiveRandom();
    else
        SetActiveRandomToDefault();

    x880_envFxManager->AsyncLoadResources(*this);
}

void CStateManager::CreateStandardGameObjects()
{
    float height = g_tweakPlayer->GetPlayerHeight();
    float xyHe = g_tweakPlayer->GetPlayerXYHalfExtent();
    float unk1 = g_tweakPlayer->GetX274();
    float unk2 = g_tweakPlayer->GetX278();
    float unk3 = g_tweakPlayer->GetX27C();
    zeus::CAABox pBounds = {{-xyHe, -xyHe, 0.f}, {xyHe, xyHe, height}};
    auto q = zeus::CQuaternion::fromAxisAngle(zeus::CVector3f{0.f, 0.f, 1.f}, zeus::degToRad(129.6f));
    x84c_player.reset(new CPlayer(
        AllocateUniqueId(), zeus::CTransform(q), pBounds,
        g_tweakPlayerRes->xc4_ballTransitionsANCS,
        zeus::CVector3f{1.65f, 1.65f, 1.65f}, 200.f, unk1, unk2,
        unk3, CMaterialList(EMaterialTypes::Player,
        EMaterialTypes::Solid, EMaterialTypes::GroundCollider)));
    AddObject(*x84c_player);
    x870_cameraManager->CreateStandardCameras(*this);
}

CObjectList* CStateManager::ObjectListById(EGameObjectList type)
{
    if (type == EGameObjectList::Invalid)
        return nullptr;
    return x808_objLists[int(type)].get();
}

const CObjectList* CStateManager::GetObjectListById(EGameObjectList type) const
{
    if (type == EGameObjectList::Invalid)
        return nullptr;
    return x808_objLists[int(type)].get();
}

void CStateManager::RemoveObject(TUniqueId uid)
{
    if (CEntity* ent = GetAllObjectList().GetValidObjectById(uid))
    {
        if (ent->GetEditorId() != kInvalidEditorId)
        {
            x890_scriptIdMap.erase(ent->GetEditorId());
        }
        if (ent->GetAreaIdAlways() != kInvalidAreaId)
        {
            CGameArea* area = x850_world->GetArea(ent->GetAreaIdAlways());
            if (area->IsPostConstructed())
                area->GetAreaObjects().RemoveObject(uid);
        }
        if (TCastToPtr<CActor> act = ent)
            x874_sortedListManager->Remove(act.GetPtr());
    }
    for (auto& list : x808_objLists)
        list->RemoveObject(uid);
}

void CStateManager::UpdateRoomAcoustics(TAreaId aid)
{
    u32 updateCount = 0;
    CScriptRoomAcoustics* updates[10];
    for (CEntity* ent : GetAllObjectList())
    {
        if (TCastToPtr<CScriptRoomAcoustics> acoustics = ent)
        {
            if (acoustics->GetAreaIdAlways() != aid || !acoustics->GetActive())
                continue;
            updates[updateCount++] = acoustics.GetPtr();
        }
        if (updateCount >= 10)
            break;
    }

    if (!updateCount)
    {
        CScriptRoomAcoustics::DisableAuxCallbacks();
        return;
    }

    int idx = updateCount * x900_activeRandom->Float() * 0.99f;
    updates[idx]->EnableAuxCallbacks();
}

void CStateManager::SetCurrentAreaId(TAreaId aid)
{
    if (aid != x8cc_nextAreaId)
    {
        x8d0_prevAreaId = x8cc_nextAreaId;
        UpdateRoomAcoustics(aid);
        x8cc_nextAreaId = aid;
    }

    if (aid == kInvalidAreaId)
        return;
    if (x8c0_mapWorldInfo->IsAreaVisted(aid))
        return;
    x8c0_mapWorldInfo->SetAreaVisited(aid, true);
    x850_world->GetMapWorld()->RecalculateWorldSphere(*x8c0_mapWorldInfo, *x850_world);
}

void CStateManager::DeleteObjectRequest(TUniqueId id)
{
    CEntity* entity = ObjectById(id);
    if (!entity)
        return;

    if (entity->IsInGraveyard())
        return;

    entity->SetIsInGraveyard(true);

    x854_objectGraveyard.push_back(entity->GetUniqueId());
    entity->AcceptScriptMsg(EScriptObjectMessage::Deleted, kInvalidUniqueId, *this);
    entity->SetIsScriptingBlocked(true);

    if (TCastToPtr<CActor> actor = entity)
    {
        x874_sortedListManager->Remove(actor);
        actor->SetUseInSortedLists(false);
    }
}

CEntity* CStateManager::ObjectById(TUniqueId uid) { return GetAllObjectList().GetObjectById(uid); }
const CEntity* CStateManager::GetObjectById(TUniqueId uid) const { return GetAllObjectList().GetObjectById(uid); }

void CStateManager::AreaUnloaded(TAreaId) {}

void CStateManager::PrepareAreaUnload(TAreaId) {}

void CStateManager::AreaLoaded(TAreaId) {}

void CStateManager::BuildNearList(rstl::reserved_vector<TUniqueId, 1024>& listOut, const zeus::CVector3f& v1,
                                  const zeus::CVector3f& v2, float f1, const CMaterialFilter& filter,
                                  const CActor* actor) const
{
    x874_sortedListManager->BuildNearList(listOut, v1, v2, f1, filter, actor);
}

void CStateManager::BuildColliderList(rstl::reserved_vector<TUniqueId, 1024>& listOut, const CActor& actor,
                                      const zeus::CAABox& aabb) const
{
    x874_sortedListManager->BuildNearList(listOut, actor, aabb);
}

void CStateManager::BuildNearList(rstl::reserved_vector<TUniqueId, 1024>& listOut, const zeus::CAABox& aabb,
                                  const CMaterialFilter& filter, const CActor* actor) const
{
    x874_sortedListManager->BuildNearList(listOut, aabb, filter, actor);
}

void CStateManager::UpdateActorInSortedLists(CActor& act)
{
    if (!act.GetUseInSortedLists() || !act.xe4_27_)
        return;

    std::experimental::optional<zeus::CAABox> aabb = CalculateObjectBounds(act);
    bool actorInLists = x874_sortedListManager->ActorInLists(&act);
    if (actorInLists || aabb)
    {
        act.xe4_27_ = false;
        if (actorInLists)
        {
            if (!act.GetActive() || !aabb)
            {
                x874_sortedListManager->Remove(&act);
            }
            else
            {
                x874_sortedListManager->Move(&act, *aabb);
            }
        }
        else if (act.GetActive() && aabb)
        {
            x874_sortedListManager->Insert(&act, *aabb);
        }
    }
}

void CStateManager::UpdateSortedLists()
{
    if (!x850_world)
        return;
    for (CEntity* actor : GetActorObjectList())
        UpdateActorInSortedLists(static_cast<CActor&>(*actor));
}

std::experimental::optional<zeus::CAABox> CStateManager::CalculateObjectBounds(const CActor& actor)
{
    rstl::optional_object<zeus::CAABox> bounds = actor.GetTouchBounds();
    if (bounds)
    {
        zeus::CAABox aabb;
        aabb.accumulateBounds(bounds->min);
        aabb.accumulateBounds(bounds->max);
        if (TCastToConstPtr<CPhysicsActor> physAct = actor)
        {
            zeus::CAABox physAabb = physAct->GetBoundingBox();
            aabb.accumulateBounds(physAabb.min);
            aabb.accumulateBounds(physAabb.max);
        }
        return {aabb};
    }
    else
    {
        if (TCastToConstPtr<CPhysicsActor> physAct = actor)
            return {physAct->GetBoundingBox()};
    }
    return {};
}

void CStateManager::AddObject(CEntity& ent)
{
    if (ent.GetEditorId() != kInvalidEditorId)
        x890_scriptIdMap.insert(std::make_pair(ent.GetEditorId(), ent.GetUniqueId()));
    for (auto& list : x808_objLists)
        list->AddObject(ent);

    if (ent.GetAreaIdAlways() == kInvalidAreaId && x84c_player &&
        ent.GetUniqueId() != x84c_player->GetUniqueId())
        ent.x4_areaId = x84c_player->GetAreaIdAlways();
    if (ent.GetAreaIdAlways() != kInvalidAreaId)
    {
        CGameArea* area = x850_world->GetArea(ent.GetAreaIdAlways());
        if (area->IsPostConstructed())
            area->GetAreaObjects().AddObject(ent);
    }

    if (TCastToPtr<CActor> act = ent)
        UpdateActorInSortedLists(*act.GetPtr());

    ent.AcceptScriptMsg(EScriptObjectMessage::Registered, kInvalidUniqueId, *this);

    if (ent.GetAreaIdAlways() != kInvalidAreaId && x850_world)
    {
        CGameArea* area = x850_world->GetArea(ent.GetAreaIdAlways());
        if (area->IsValidated())
            SendScriptMsg(&ent, kInvalidUniqueId, EScriptObjectMessage::InitializedInArea);
    }
}

void CStateManager::AddObject(CEntity* ent)
{
    if (ent)
        AddObject(*ent);
}

bool CStateManager::RayStaticIntersection(const zeus::CVector3f&, const zeus::CVector3f&, float,
                                          const CMaterialFilter&) const
{
    return false;
}

bool CStateManager::RayWorldIntersection(TUniqueId, const zeus::CVector3f&, const zeus::CVector3f&, float,
                                         const CMaterialFilter&,
                                         const rstl::reserved_vector<TUniqueId, 1024>& list) const
{
    return false;
}

void CStateManager::UpdateObjectInLists(CEntity&) {}

TUniqueId CStateManager::AllocateUniqueId()
{
    const s16 lastIndex = x0_nextFreeIndex;
    s16 ourIndex;
    do
    {
        ourIndex = x0_nextFreeIndex;
        x0_nextFreeIndex = (x0_nextFreeIndex + 1) & 0x3ff;
        if (x0_nextFreeIndex == lastIndex)
            LogModule.report(logvisor::Fatal, "Object List Full!");
    }
    while (GetAllObjectList().GetObjectByIndex(ourIndex) != nullptr);

    x8_idArr[ourIndex] = (x8_idArr[ourIndex] + 1) & 0x3f;
    if (((ourIndex | ((x8_idArr[ourIndex]) << 10)) & 0xFFFF) == kInvalidUniqueId)
        x8_idArr[0] = 0;

    return ((ourIndex | ((x8_idArr[ourIndex]) << 10)) & 0xFFFF);
}

void CStateManager::DeferStateTransition(EStateManagerTransition t)
{
    if (t == EStateManagerTransition::InGame)
    {
        if (xf90_deferredTransition != EStateManagerTransition::InGame)
        {
            x850_world->SetPauseState(false);
            xf90_deferredTransition = EStateManagerTransition::InGame;
        }
    }
    else
    {
        if (xf90_deferredTransition == EStateManagerTransition::InGame)
        {
            x850_world->SetPauseState(true);
            xf90_deferredTransition = t;
        }
    }
}

bool CStateManager::CanShowMapScreen() const
{
    const CHintOptions::SHintState* curDispHint = g_GameState->HintOptions().GetCurrentDisplayedHint();
    if (!curDispHint || curDispHint->CanContinue())
        return true;
    return false;
}

std::pair<u32, u32> CStateManager::CalculateScanCompletionRate() const
{
    u32 num = 0;
    u32 denom = 0;
    int idx = 0;
    for (const std::pair<u32, float>& scan : x8b8_playerState->GetScanTimes())
    {
        CSaveWorld::EScanCategory category = g_MemoryCardSys->GetScanStates()[idx++].second;
        if (category != CSaveWorld::EScanCategory::None && category != CSaveWorld::EScanCategory::Research)
        {
            ++denom;
            if (scan.second == 1.f)
                ++num;
        }
    }
    return {num, denom};
}

bool CStateManager::ApplyDamage(TUniqueId, TUniqueId, TUniqueId, const CDamageInfo& info, const CMaterialFilter&,
                                const zeus::CVector3f&)
{
    return false;
}

float CStateManager::g_EscapeShakeCountdown;
bool CStateManager::g_EscapeShakeCountdownInit = false;
}