metaforce/Runtime/World/ScriptLoader.cpp

#include "ScriptLoader.hpp"
#include "CStateManager.hpp"
#include "CGrappleParameters.hpp"
#include "CActorParameters.hpp"
#include "CVisorParameters.hpp"
#include "CScannableParameters.hpp"
#include "CLightParameters.hpp"
#include "CAnimationParameters.hpp"
#include "CFluidUVMotion.hpp"
#include "GameGlobalObjects.hpp"
#include "CWorld.hpp"
#include "Character/CModelData.hpp"
#include "Collision/CMaterialList.hpp"
#include "Particle/CWeaponDescription.hpp"
#include "CDamageInfo.hpp"
#include "CScriptActor.hpp"
#include "CScriptWaypoint.hpp"
#include "CScriptDoor.hpp"
#include "CScriptTrigger.hpp"
#include "CScriptTimer.hpp"
#include "CScriptCounter.hpp"
#include "CScriptDock.hpp"
#include "CScriptActorKeyframe.hpp"
#include "CScriptWater.hpp"
#include "CScriptEffect.hpp"
#include "CScriptPlatform.hpp"
#include "CScriptSound.hpp"
#include "CScriptGenerator.hpp"
#include "CScriptGrapplePoint.hpp"
#include "CScriptPickupGenerator.hpp"
#include "CScriptPointOfInterest.hpp"
#include "CScriptPlayerActor.hpp"
#include "CScriptAreaAttributes.hpp"
#include "CScriptCameraWaypoint.hpp"
#include "CScriptCoverPoint.hpp"
#include "CScriptSpawnPoint.hpp"
#include "CScriptCameraHint.hpp"
#include "CScriptPickup.hpp"
#include "CScriptMemoryRelay.hpp"
#include "CScriptRandomRelay.hpp"
#include "CScriptRelay.hpp"
#include "CScriptHUDMemo.hpp"
#include "CScriptCameraFilterKeyframe.hpp"
#include "CScriptCameraBlurKeyframe.hpp"
#include "CScriptDamageableTrigger.hpp"
#include "CScriptDebris.hpp"
#include "CScriptSteam.hpp"
#include "CScriptDistanceFog.hpp"
#include "CScriptDockAreaChange.hpp"
#include "CScriptActorRotate.hpp"
#include "CScriptSpecialFunction.hpp"
#include "CScriptSwitch.hpp"
#include "CWallCrawlerSwarm.hpp"
#include "CScriptAiJumpPoint.hpp"
#include "CScriptColorModulate.hpp"
#include "CScriptCameraShaker.hpp"
#include "CRepulsor.hpp"
#include "CScriptCameraPitchVolume.hpp"
#include "CScriptCameraHintTrigger.hpp"
#include "CScriptVisorFlare.hpp"
#include "CScriptBeam.hpp"
#include "Camera/CCinematicCamera.hpp"
#include "MP1/World/CNewIntroBoss.hpp"
#include "MP1/World/CBeetle.hpp"
#include "MP1/World/CWarWasp.hpp"
#include "MP1/World/CSpacePirate.hpp"
#include "MP1/World/CActorContraption.hpp"
#include "CScriptShadowProjector.hpp"
#include "CScriptStreamedMusic.hpp"
#include "CScriptMidi.hpp"
#include "CScriptRoomAcoustics.hpp"
#include "CScriptControllerAction.hpp"
#include "CPatternedInfo.hpp"
#include "CSimplePool.hpp"
#include "Collision/CCollidableOBBTreeGroup.hpp"
#include "Editor/ProjectResourceFactoryMP1.hpp"
#include "logvisor/logvisor.hpp"

namespace urde
{
static logvisor::Module Log("urde::ScriptLoader");

static SObjectTag MorphballDoorANCS = {};
static const SObjectTag& GetMorphballDoorACS()
{
    if (!MorphballDoorANCS)
    {
        MorphballDoorANCS.type = FOURCC('ANCS');
        MorphballDoorANCS.id = g_ResFactory->TranslateOriginalToNew(0x1F9DA858);
    }
    return MorphballDoorANCS;
}

static bool EnsurePropertyCount(int count, int expected, const char* structName)
{
    if (count < expected)
    {
        Log.report(logvisor::Warning, "Insufficient number of props (%d/%d) for %s entity", count, expected,
                   structName);
        return false;
    }
    return true;
}

struct SActorHead
{
    std::string x0_name;
    zeus::CTransform x10_transform;
};

struct SScaledActorHead : SActorHead
{
    zeus::CVector3f x40_scale;
    SScaledActorHead(SActorHead&& head) : SActorHead(std::move(head)) {}
};

static zeus::CTransform LoadEditorTransform(CInputStream& in)
{
    zeus::CVector3f position;
    position.readBig(in);
    zeus::CVector3f orientation;
    orientation.readBig(in);
    return ScriptLoader::ConvertEditorEulerToTransform4f(orientation, position);
}

static zeus::CTransform LoadEditorTransformPivotOnly(CInputStream& in)
{
    zeus::CVector3f position;
    position.readBig(in);
    zeus::CVector3f orientation;
    orientation.readBig(in);
    orientation.x = 0.f;
    orientation.y = 0.f;
    return ScriptLoader::ConvertEditorEulerToTransform4f(orientation, position);
}

static SActorHead LoadActorHead(CInputStream& in, CStateManager& stateMgr)
{
    SActorHead ret;
    ret.x0_name = stateMgr.HashInstanceName(in);
    ret.x10_transform = LoadEditorTransform(in);
    return ret;
}

static SScaledActorHead LoadScaledActorHead(CInputStream& in, CStateManager& stateMgr)
{
    SScaledActorHead ret = LoadActorHead(in, stateMgr);
    ret.x40_scale.readBig(in);
    return ret;
}

static zeus::CAABox GetCollisionBox(CStateManager& stateMgr, TAreaId id, const zeus::CVector3f& extent,
                                    const zeus::CVector3f& offset)
{
    zeus::CAABox box(-extent * 0.5f + offset, extent * 0.5f + offset);
    const zeus::CTransform& rot = stateMgr.WorldNC()->GetGameAreas()[id]->GetTransform().getRotation();
    return box.getTransformedAABox(rot);
}

u32 ScriptLoader::LoadParameterFlags(CInputStream& in)
{
    u32 count = in.readUint32Big();
    u32 ret = 0;
    for (u32 i = 0; i < count; ++i)
        if (in.readBool())
            ret |= 1 << i;
    return ret;
}

CGrappleParameters ScriptLoader::LoadGrappleParameters(CInputStream& in)
{
    float a = in.readFloatBig();
    float b = in.readFloatBig();
    float c = in.readFloatBig();
    float d = in.readFloatBig();
    float e = in.readFloatBig();
    float f = in.readFloatBig();
    float g = in.readFloatBig();
    float h = in.readFloatBig();
    float i = in.readFloatBig();
    float j = in.readFloatBig();
    float k = in.readFloatBig();
    bool l = in.readBool();
    return CGrappleParameters(a, b, c, d, e, f, g, h, i, j, k, l);
}

CActorParameters ScriptLoader::LoadActorParameters(CInputStream& in)
{
    u32 propCount = in.readUint32Big();
    if (propCount >= 5 && propCount <= 0xe)
    {
        CLightParameters lParms = ScriptLoader::LoadLightParameters(in);

        CScannableParameters sParams;
        if (propCount > 5)
            sParams = LoadScannableParameters(in);

        ResId xrayModel = in.readUint32Big();
        ResId xraySkin = in.readUint32Big();
        ResId infraModel = in.readUint32Big();
        ResId infraSkin = in.readUint32Big();

        bool b1 = true;
        if (propCount > 7)
            b1 = in.readBool();

        float f1 = 1.f;
        if (propCount > 8)
            f1 = in.readFloatBig();

        float f2 = 1.f;
        if (propCount > 9)
            f2 = in.readFloatBig();

        CVisorParameters vParms;
        if (propCount > 6)
            vParms = LoadVisorParameters(in);

        bool b2 = false;
        if (propCount > 10)
            b2 = in.readBool();

        bool b3 = false;
        if (propCount > 11)
            b3 = in.readBool();

        bool b4 = false;
        if (propCount > 12)
            b4 = in.readBool();

        float f3 = 1.f;
        if (propCount > 13)
            f3 = in.readFloatBig();

        std::pair<ResId, ResId> xray = {};
        if (g_ResFactory->GetResourceTypeById(xrayModel))
            xray = {xrayModel, xraySkin};

        std::pair<ResId, ResId> infra = {};
        if (g_ResFactory->GetResourceTypeById(infraModel))
            infra = {infraModel, infraSkin};

        return CActorParameters(lParms, sParams, xray, infra, vParms, b1, b2, b3, b4);
    }
    return CActorParameters::None();
}

CVisorParameters ScriptLoader::LoadVisorParameters(CInputStream& in)
{
    u32 propCount = in.readUint32Big();
    if (propCount >= 1 && propCount <= 3)
    {
        bool b1 = in.readBool();
        bool b2 = false;
        u8 mask = 0xf;
        if (propCount > 1)
            b2 = in.readBool();
        if (propCount > 2)
            mask = in.readUint32Big();
        return CVisorParameters(mask, b1, b2);
    }
    return CVisorParameters();
}

CScannableParameters ScriptLoader::LoadScannableParameters(CInputStream& in)
{
    u32 propCount = in.readUint32Big();
    if (propCount == 1)
        return CScannableParameters(in.readUint32Big());
    return CScannableParameters();
}

CLightParameters ScriptLoader::LoadLightParameters(CInputStream& in)
{
    u32 propCount = in.readUint32Big();
    if (propCount == 14)
    {
        bool a = in.readBool();
        float b = in.readFloatBig();
        CLightParameters::EShadowTesselation shadowTess = CLightParameters::EShadowTesselation(in.readUint32Big());
        float d = in.readFloatBig();
        float e = in.readFloatBig();

        zeus::CColor noLightsAmbient;
        noLightsAmbient.readRGBABig(in);

        bool makeLights = in.readBool();
        CLightParameters::EWorldLightingOptions lightOpts = CLightParameters::EWorldLightingOptions(in.readUint32Big());
        CLightParameters::ELightRecalculationOptions recalcOpts =
            CLightParameters::ELightRecalculationOptions(in.readUint32Big());

        zeus::CVector3f actorPosBias;
        actorPosBias.readBig(in);

        s32 maxDynamicLights = -1;
        s32 maxAreaLights = -1;
        if (propCount >= 12)
        {
            maxDynamicLights = in.readUint32Big();
            maxAreaLights = in.readUint32Big();
        }

        bool ambientChannelOverflow = false;
        if (propCount >= 13)
            ambientChannelOverflow = in.readBool();

        s32 layerIdx = 0;
        if (propCount >= 14)
            layerIdx = in.readUint32Big();

        return CLightParameters(a, b, shadowTess, d, e, noLightsAmbient, makeLights, lightOpts, recalcOpts, actorPosBias,
                                maxDynamicLights, maxAreaLights, ambientChannelOverflow, layerIdx);
    }
    return CLightParameters::None();
}

CAnimationParameters ScriptLoader::LoadAnimationParameters(CInputStream& in)
{
    ResId ancs = in.readUint32Big();
    s32 charIdx = in.readUint32Big();
    u32 defaultAnim = in.readUint32Big();
    return CAnimationParameters(ancs, charIdx, defaultAnim);
}

CFluidUVMotion ScriptLoader::LoadFluidUVMotion(CInputStream& in)
{
    /* NOTE: DO NOT RE-ORDER THIS FUNCTION
     * For some inexplicable reason Retro stores the layers in this order.
     * Changing it will change the behavior of CFluidUVMotion,
     * which is something we don't want.
     * - Phil
     * P.S: If you do change it, I'll hunt you down and put pink lipstick on your dog.
     */
    CFluidUVMotion::EFluidUVMotion motion = CFluidUVMotion::EFluidUVMotion(in.readUint32Big());
    float a = in.readFloatBig();
    float b = in.readFloatBig();
    b = zeus::degToRad(b) - M_PIF;
    float c = in.readFloatBig();
    float d = in.readFloatBig();
    CFluidUVMotion::SFluidLayerMotion layerMotion2(motion, a, b, c, d);

    motion = CFluidUVMotion::EFluidUVMotion(in.readUint32Big());
    a = in.readFloatBig();
    b = in.readFloatBig();
    b = zeus::degToRad(b) - M_PIF;
    c = in.readFloatBig();
    d = in.readFloatBig();
    CFluidUVMotion::SFluidLayerMotion layerMotion3(motion, a, b, c, d);

    motion = CFluidUVMotion::EFluidUVMotion(in.readUint32Big());
    a = in.readFloatBig();
    b = in.readFloatBig();
    b = zeus::degToRad(b) - M_PIF;
    c = in.readFloatBig();
    d = in.readFloatBig();
    CFluidUVMotion::SFluidLayerMotion layerMotion1(motion, a, b, c, d);

    a = in.readFloatBig();
    b = in.readFloatBig();

    b = zeus::degToRad(b) - M_PIF;

    return CFluidUVMotion(a, b, layerMotion1, layerMotion2, layerMotion3);
}

zeus::CTransform ScriptLoader::ConvertEditorEulerToTransform4f(const zeus::CVector3f& orientation,
                                                               const zeus::CVector3f& position)
{
    return zeus::CTransform::RotateZ(zeus::degToRad(orientation.z)) *
               zeus::CTransform::RotateY(zeus::degToRad(orientation.y)) *
               zeus::CTransform::RotateX(zeus::degToRad(orientation.x)) +
           position;
}

CEntity* ScriptLoader::LoadActor(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    if (!EnsurePropertyCount(propCount, 24, "Actor"))
        return nullptr;

    SScaledActorHead head = LoadScaledActorHead(in, mgr);

    zeus::CVector3f collisionExtent;
    collisionExtent.readBig(in);

    zeus::CVector3f centroid;
    centroid.readBig(in);

    float f1 = in.readFloatBig();
    float f2 = in.readFloatBig();

    CHealthInfo hInfo(in);

    CDamageVulnerability dInfo(in);

    ResId staticId = in.readUint32Big();
    CAnimationParameters aParms = LoadAnimationParameters(in);

    CActorParameters actParms = LoadActorParameters(in);

    bool b1 = in.readBool();
    bool snow = in.readBool();
    bool solid = in.readBool();
    bool cameraPassthrough = in.readBool();
    bool b5 = in.readBool();
    u32 w2 = in.readUint32Big();
    float f3 = in.readFloatBig();
    bool b6 = in.readBool();
    bool b7 = in.readBool();
    bool b8 = in.readBool();
    bool b9 = in.readBool();

    FourCC animType = g_ResFactory->GetResourceTypeById(aParms.GetACSFile());
    if (!g_ResFactory->GetResourceTypeById(staticId) && !animType)
        return nullptr;

    zeus::CAABox aabb = GetCollisionBox(mgr, info.GetAreaId(), collisionExtent, centroid);

    CMaterialList list;
    if (snow) // Bool 2
        list.Add(EMaterialTypes::Snow);

    if (solid) // Bool 3
        list.Add(EMaterialTypes::Solid);

    if (cameraPassthrough) // Bool 4
        list.Add(EMaterialTypes::CameraPassthrough);

    CModelData data;
    if (animType == SBIG('ANCS'))
        data = CAnimRes(aParms.GetACSFile(), aParms.GetCharacter(), head.x40_scale, aParms.GetInitialAnimation(), true);
    else
        data = CStaticRes(staticId, head.x40_scale);

    if ((collisionExtent.x < 0.f || collisionExtent.y < 0.f || collisionExtent.z < 0.f)|| collisionExtent.isZero())
        aabb = data.GetBounds(head.x10_transform.getRotation());

    return new CScriptActor(mgr.AllocateUniqueId(), head.x0_name, info, head.x10_transform, std::move(data), aabb, f1,
                            f2, list, hInfo, dInfo, actParms, b1, b5, w2, f3, b6, b7, b8, b9);
}

CEntity* ScriptLoader::LoadWaypoint(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    if (!EnsurePropertyCount(propCount, 13, "Waypoint"))
        return nullptr;

    SActorHead head = LoadActorHead(in, mgr);

    bool active = in.readBool();
    float f1 = in.readFloatBig();
    float delay = in.readFloatBig();
    u32 w1 = in.readUint32Big();
    u32 w2 = in.readUint32Big();
    u32 w3 = in.readUint32Big();
    u32 w4 = in.readUint32Big();
    u32 w5 = in.readUint32Big();
    u32 w6 = in.readUint32Big();
    u32 w7 = in.readUint32Big();

    return new CScriptWaypoint(mgr.AllocateUniqueId(), head.x0_name, info, head.x10_transform, active, f1, delay, w1,
                               w2, w3, w4, w5, w6, w7);
}

CEntity* ScriptLoader::LoadDoor(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    if (!EnsurePropertyCount(propCount, 13, "Door") || propCount > 14)
        return nullptr;

    SScaledActorHead head = LoadScaledActorHead(in, mgr);
    CAnimationParameters aParms = LoadAnimationParameters(in);
    CActorParameters actParms = LoadActorParameters(in);

    zeus::CVector3f v1;
    v1.readBig(in);
    zeus::CVector3f collisionExtent;
    collisionExtent.readBig(in);
    zeus::CVector3f offset;
    offset.readBig(in);

    bool active = in.readBool();
    bool open = in.readBool();
    bool b3 = in.readBool();
    float animationLength = in.readFloatBig();

    zeus::CAABox aabb = GetCollisionBox(mgr, info.GetAreaId(), collisionExtent, offset);

    if (!g_ResFactory->GetResourceTypeById(aParms.GetACSFile()))
        return nullptr;

    CModelData mData =
        CAnimRes(aParms.GetACSFile(), aParms.GetCharacter(), head.x40_scale, true, aParms.GetInitialAnimation());
    if (collisionExtent.isZero())
        aabb = mData.GetBounds(head.x10_transform.getRotation());

    bool isMorphballDoor = false;
    if (propCount == 13)
    {
        if (aParms.GetACSFile() == GetMorphballDoorACS().id)
            isMorphballDoor = true;
    }
    else if (propCount == 14)
        isMorphballDoor = in.readBool();

    return new CScriptDoor(mgr.AllocateUniqueId(), head.x0_name, info, head.x10_transform, std::move(mData), actParms,
                           v1, aabb, active, open, b3, animationLength, isMorphballDoor);
}

CEntity* ScriptLoader::LoadTrigger(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    if (!EnsurePropertyCount(propCount, 9, "Trigger"))
        return nullptr;

    std::string name = mgr.HashInstanceName(in);

    zeus::CVector3f position = zeus::CVector3f::ReadBig(in);

    zeus::CVector3f extent = zeus::CVector3f::ReadBig(in);

    CDamageInfo dInfo(in);

    zeus::CVector3f forceVec = zeus::CVector3f::ReadBig(in);

    ETriggerFlags flags = ETriggerFlags(in.readUint32Big());
    bool active = in.readBool();
    bool b2 = in.readBool();
    bool b3 = in.readBool();

    zeus::CAABox box(-extent * 0.5f, extent * 0.5f);

    const zeus::CTransform& areaXf = mgr.WorldNC()->GetGameAreas()[info.GetAreaId()]->GetTransform();
    zeus::CVector3f orientedForce = areaXf.basis * forceVec;

    return new CScriptTrigger(mgr.AllocateUniqueId(), name, info, position, box, dInfo, orientedForce, flags, active,
                              b2, b3);
}

CEntity* ScriptLoader::LoadTimer(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    if (!EnsurePropertyCount(propCount, 6, "Timer"))
        return nullptr;

    std::string name = mgr.HashInstanceName(in);

    float f1 = in.readFloatBig();
    float f2 = in.readFloatBig();
    bool b1 = in.readBool();
    bool b2 = in.readBool();
    bool b3 = in.readBool();

    return new CScriptTimer(mgr.AllocateUniqueId(), name, info, f1, f2, b1, b2, b3);
}

CEntity* ScriptLoader::LoadCounter(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    if (!EnsurePropertyCount(propCount, 5, "Counter"))
        return nullptr;

    std::string name = mgr.HashInstanceName(in);

    u32 w1 = in.readUint32Big();
    u32 w2 = in.readUint32Big();
    bool b1 = in.readBool();
    bool b2 = in.readBool();

    return new CScriptCounter(mgr.AllocateUniqueId(), name, info, w1, w2, b1, b2);
}

CEntity* ScriptLoader::LoadEffect(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    if (!EnsurePropertyCount(propCount, 24, "Effect"))
        return nullptr;

    SScaledActorHead head = LoadScaledActorHead(in, mgr);

    ResId partId = in.readUint32Big();
    ResId elscId = in.readUint32Big();
    bool b1 = in.readBool();
    bool b2 = in.readBool();
    bool b3 = in.readBool();
    bool b4 = in.readBool();

    if (partId == 0xffffffff && elscId == 0xffffffff)
        return nullptr;

    if (!g_ResFactory->GetResourceTypeById(partId) && !g_ResFactory->GetResourceTypeById(elscId))
        return nullptr;

    bool b5 = in.readBool();
    float f1 = in.readFloatBig();
    float f2 = in.readFloatBig();
    float f3 = in.readFloatBig();
    float f4 = in.readFloatBig();
    bool b6 = in.readBool();
    float f5 = in.readFloatBig();
    float f6 = in.readFloatBig();
    float f7 = in.readFloatBig();
    bool b7 = in.readBool();
    bool b8 = in.readBool();
    bool b9 = in.readBool();
    bool b10 = in.readBool();

    CLightParameters lParms = LoadLightParameters(in);

    return new CScriptEffect(mgr.AllocateUniqueId(), head.x0_name, info, head.x10_transform, head.x40_scale, partId,
                             elscId, b1, b2, b3, b4, b5, f1, f2, f3, f4, b6, f5, f6, f7, b7, b8, b9, lParms, b10);
}

CEntity* ScriptLoader::LoadPlatform(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    if (!EnsurePropertyCount(propCount, 19, "Platform"))
        return nullptr;

    SScaledActorHead head = LoadScaledActorHead(in, mgr);

    zeus::CVector3f extent;
    extent.readBig(in);

    zeus::CVector3f centroid;
    centroid.readBig(in);

    ResId staticId = in.readUint32Big();
    CAnimationParameters aParms = LoadAnimationParameters(in);

    CActorParameters actParms = LoadActorParameters(in);

    float f1 = in.readFloatBig();
    bool b1 = in.readBool();
    ResId dclnId = in.readUint32Big();

    CHealthInfo hInfo(in);

    CDamageVulnerability dInfo(in);

    bool b2 = in.readBool();
    float f2 = in.readFloatBig();
    bool b3 = in.readBool();
    u32 w2 = in.readUint32Big();
    u32 w3 = in.readUint32Big();

    FourCC animType = g_ResFactory->GetResourceTypeById(aParms.GetACSFile());
    if (!g_ResFactory->GetResourceTypeById(staticId) && !animType)
        return nullptr;

    zeus::CAABox aabb = GetCollisionBox(mgr, info.GetAreaId(), extent, centroid);

    FourCC dclnType = g_ResFactory->GetResourceTypeById(dclnId);
    rstl::optional_object<TLockedToken<CCollidableOBBTreeGroup>> dclnToken;
    if (dclnType)
    {
        dclnToken.emplace(g_SimplePool->GetObj({SBIG('DCLN'), dclnId}));
        dclnToken->GetObj();
    }

    CModelData data;
    if (animType == SBIG('ANCS'))
        data = CAnimRes(aParms.GetACSFile(), aParms.GetCharacter(), head.x40_scale, true, aParms.GetInitialAnimation());
    else
        data = CStaticRes(staticId, head.x40_scale);

    if (extent.isZero())
        aabb = data.GetBounds(head.x10_transform.getRotation());

    return new CScriptPlatform(mgr.AllocateUniqueId(), head.x0_name, info, head.x10_transform, std::move(data),
                               actParms, aabb, f1, b2, f2, b1, hInfo, dInfo, dclnToken, b3, w2, w3);
}

CEntity* ScriptLoader::LoadSound(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    if (!EnsurePropertyCount(propCount, 20, "Sound"))
        return nullptr;

    SActorHead head = LoadActorHead(in, mgr);
    s32 soundId = in.readInt32Big();
    bool active = in.readBool();
    float maxDistance = in.readFloatBig();
    float minDistance = in.readFloatBig();
    float f3 = in.readFloatBig();
    u32 priority = in.readUint32Big();
    u32 maxVolume = in.readUint32Big();
    u32 minVolume = in.readUint32Big();
    u32 panning = in.readUint32Big();
    bool loop = in.readBool();
    bool persistent = in.readBool();
    bool triggered = in.readBool();
    bool b4 = in.readBool();
    bool roomAcoustic = in.readBool();
    bool b6 = in.readBool();
    bool b7 = in.readBool();
    u32 w5 = in.readUint32Big();

    if (soundId < 0)
        return nullptr;

    return new CScriptSound(mgr.AllocateUniqueId(), head.x0_name, info, head.x10_transform, soundId, active,
                            maxDistance, minDistance, f3, priority, maxVolume, 0, minVolume, panning, 0, loop,
                            persistent, triggered, b4, roomAcoustic, b6, b7, w5);
}

CEntity* ScriptLoader::LoadGenerator(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    if (!EnsurePropertyCount(propCount, 8, "Generator"))
        return nullptr;

    std::string name = mgr.HashInstanceName(in);

    u32 spawnCount = in.readUint32Big();
    bool reuseFollowers = in.readBool();
    bool inheritXf = in.readBool();

    zeus::CVector3f offset = zeus::CVector3f::ReadBig(in);

    bool active = in.readBool();
    float minScale = in.readFloatBig();
    float maxScale = in.readFloatBig();

    return new CScriptGenerator(mgr.AllocateUniqueId(), name, info, spawnCount, reuseFollowers, offset, inheritXf,
                                active, minScale, maxScale);
}

CEntity* ScriptLoader::LoadDock(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    if (!EnsurePropertyCount(propCount, 7, "Dock"))
        return nullptr;

    std::string name = mgr.HashInstanceName(in);
    bool active = in.readBool();
    zeus::CVector3f position;
    position.readBig(in);
    zeus::CVector3f scale;
    scale.readBig(in);
    u32 dock = in.readUint32Big();
    TAreaId area = in.readUint32Big();
    bool b1 = in.readBool();
    return new CScriptDock(mgr.AllocateUniqueId(), name, info, position, scale, dock, area, active, 0, b1);
}

CEntity* ScriptLoader::LoadCamera(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    if (!EnsurePropertyCount(propCount, 14, "Camera"))
        return nullptr;

    SActorHead head = LoadActorHead(in, mgr);

    bool b1 = in.readBool();
    float f1 = in.readFloatBig();
    bool b2 = in.readBool();
    bool b3 = in.readBool();
    bool b4 = in.readBool();
    bool b5 = in.readBool();
    bool b6 = in.readBool();
    bool b7 = in.readBool();
    bool b8 = in.readBool();
    float f2 = in.readFloatBig();
    bool b9 = in.readBool();

    bool b10 = false;
    if (propCount > 14)
        b10 = in.readBool();

    u32 flags = u32(b2) | u32(b3) << 1 | u32(b4) << 2 | u32(b5) << 3 | u32(b6) << 4 | u32(b7) << 5 | u32(b8) << 6 |
                u32(b9) << 8;

    return new CCinematicCamera(mgr.AllocateUniqueId(), head.x0_name, info, head.x10_transform, b1, f1,
                                f2 / CCameraManager::Aspect(), CCameraManager::NearPlane(), CCameraManager::FarPlane(),
                                CCameraManager::Aspect(), flags);
}

CEntity* ScriptLoader::LoadCameraWaypoint(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    if (!EnsurePropertyCount(propCount, 6, "CameraWaypoint"))
        return nullptr;

    SActorHead head = LoadActorHead(in, mgr);

    bool b1 = in.readBool();
    float f1 = in.readFloatBig();
    u32 w1 = in.readUint32Big();

    return new CScriptCameraWaypoint(mgr.AllocateUniqueId(), head.x0_name, info, head.x10_transform, b1, f1, w1);
}

CEntity* ScriptLoader::LoadNewIntroBoss(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    if (!EnsurePropertyCount(propCount, 13, "NewIntroBoss"))
        return nullptr;

    SScaledActorHead head = LoadScaledActorHead(in, mgr);

    std::pair<bool, u32> pcount = CPatternedInfo::HasCorrectParameterCount(in);
    if (!pcount.first)
        return nullptr;

    CPatternedInfo pInfo(in, pcount.second);

    CActorParameters actParms = LoadActorParameters(in);

    float f1 = in.readFloatBig();
    u32 w1 = in.readUint32Big();

    CDamageInfo dInfo(in);

    u32 w2 = in.readUint32Big();
    u32 w3 = in.readUint32Big();
    u32 w4 = in.readUint32Big();
    u32 w5 = in.readUint32Big();

    const CAnimationParameters& aParms = pInfo.GetAnimationParameters();
    FourCC animType = g_ResFactory->GetResourceTypeById(aParms.GetACSFile());
    if (animType != SBIG('ANCS'))
        return nullptr;

    CAnimRes res(aParms.GetACSFile(), aParms.GetCharacter(), head.x40_scale, true, aParms.GetInitialAnimation());

    return new MP1::CNewIntroBoss(mgr.AllocateUniqueId(), head.x0_name, info, head.x10_transform, res, pInfo, actParms,
                                  f1, w1, dInfo, w2, w3, w4, w5);
}

CEntity* ScriptLoader::LoadSpawnPoint(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    if (!EnsurePropertyCount(propCount, 35, "SpawnPoint"))
        return nullptr;

    std::string name = mgr.HashInstanceName(in);

    zeus::CVector3f position;
    position.readBig(in);

    zeus::CVector3f rotation;
    rotation.readBig(in);

    std::vector<u32> itemCounts;
    itemCounts.reserve(propCount - 6);
    for (int i = 0; i < propCount - 6; ++i)
        itemCounts.push_back(in.readUint32Big());

    bool defaultSpawn = in.readBool();
    bool active = in.readBool();
    bool morphed = false;
    if (propCount > 34)
        morphed = in.readBool();

    return new CScriptSpawnPoint(mgr.AllocateUniqueId(), name, info,
                                 ConvertEditorEulerToTransform4f(rotation, position), itemCounts, defaultSpawn, active,
                                 morphed);
}

CEntity* ScriptLoader::LoadCameraHint(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    if (!EnsurePropertyCount(propCount, 25, "CamerHint"))
        return nullptr;

    SActorHead head = LoadActorHead(in, mgr);

    bool active = in.readBool();
    u32 w1 = in.readUint32Big();
    u32 w2 = in.readUint32Big();
    u32 pf = LoadParameterFlags(in);
    pf |= in.readBool() << 6;
    float f1 = in.readFloatBig();
    pf |= in.readBool() << 7;
    float f2 = in.readFloatBig();
    pf |= in.readBool() << 8;
    float f3 = in.readFloatBig();
    zeus::CVector3f vec1;
    vec1.readBig(in);
    pf |= in.readBool() << 9;
    zeus::CVector3f vec2;
    vec2.readBig(in);
    zeus::CVector3f vec3;
    vec3.readBig(in);
    pf |= in.readBool() << 10;
    float f4 = in.readFloatBig();
    pf |= in.readBool() << 11;
    float f5 = in.readFloatBig();
    pf |= in.readBool() << 12;
    float f6 = in.readFloatBig();
    pf |= in.readBool() << 13;
    float f7 = in.readFloatBig();
    float f8 = in.readFloatBig();
    float f9 = in.readFloatBig();
    pf |= in.readBool() << 14;
    float f10 = in.readFloatBig();
    float f11 = in.readFloatBig();
    float f12 = in.readFloatBig();
    float f13 = in.readFloatBig();

    return new CScriptCameraHint(mgr.AllocateUniqueId(), head.x0_name, info, head.x10_transform, active, w1, w2, pf, f1,
                                 f2, f3, vec1, vec2, vec3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13);
}

CEntity* ScriptLoader::LoadPickup(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    if (!EnsurePropertyCount(propCount, 18, "Pickup"))
        return nullptr;

    SScaledActorHead head = LoadScaledActorHead(in, mgr);
    zeus::CVector3f extent = zeus::CVector3f::ReadBig(in);
    zeus::CVector3f offset = zeus::CVector3f::ReadBig(in);
    u32 w1 = in.readUint32Big();
    u32 w2 = in.readUint32Big();
    u32 w3 = in.readUint32Big();
    float f1 = in.readFloatBig();
    float f2 = in.readFloatBig();
    float f3 = in.readFloatBig();
    ResId staticModel = in.readUint32Big();
    CAnimationParameters animParms = LoadAnimationParameters(in);
    CActorParameters actorParms = LoadActorParameters(in);
    bool active = in.readBool();
    float f4 = in.readFloatBig();
    u32 w5 = in.readUint32Big();

    FourCC acsType = g_ResFactory->GetResourceTypeById(animParms.GetACSFile());
    if (g_ResFactory->GetResourceTypeById(staticModel) == 0 && acsType == 0)
        return nullptr;

    zeus::CAABox aabb = GetCollisionBox(mgr, info.GetAreaId(), extent, offset);

    CModelData data;

    if (acsType == SBIG('ANCS'))
        data = CAnimRes(animParms.GetACSFile(), animParms.GetCharacter(), head.x40_scale,
                        animParms.GetInitialAnimation(), true);
    else
        data = CStaticRes(staticModel, head.x40_scale);

    if (extent.isZero())
        aabb = data.GetBounds(head.x10_transform.getRotation());

    return new CScriptPickup(mgr.AllocateUniqueId(), head.x0_name, info, head.x10_transform, std::move(data),
                             actorParms, aabb, w1, w3, w2, w5, f1, f2, f3, f4, active);
}

CEntity* ScriptLoader::LoadMemoryRelay(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    if (!EnsurePropertyCount(propCount, 3, "MemoryRelay") || propCount > 4)
        return nullptr;

    std::string name = mgr.HashInstanceName(in);
    bool b1 = in.readBool();
    bool b2 = in.readBool();
    bool b3 = false;
    if (propCount > 3)
        b3 = in.readBool();

    return new CScriptMemoryRelay(mgr.AllocateUniqueId(), name, info, b1, b2, b3);
}

CEntity* ScriptLoader::LoadRandomRelay(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    if (!EnsurePropertyCount(propCount, 5, "RandomRelay"))
        return nullptr;
    std::string name = mgr.HashInstanceName(in);
    u32 w1 = in.readUint32Big();
    u32 w2 = in.readUint32Big();
    bool b1 = in.readBool();
    bool b2 = in.readBool();

    return new CScriptRandomRelay(mgr.AllocateUniqueId(), name, info, w1, w2, b1, b2);
}

CEntity* ScriptLoader::LoadRelay(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    if (!EnsurePropertyCount(propCount, 2, "Relay") || propCount > 3)
        return nullptr;

    std::string name = mgr.HashInstanceName(in);
    if (propCount >= 3)
        in.readUint32Big();
    bool b1 = in.readBool();

    return new CScriptRelay(mgr.AllocateUniqueId(), name, info, b1);
}

CEntity* ScriptLoader::LoadBeetle(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    if (!EnsurePropertyCount(propCount, 16, "Beetle"))
        return nullptr;
    std::string name = mgr.HashInstanceName(in);
    CPatterned::EFlavorType flavor = CPatterned::EFlavorType(in.readUint32Big());
    zeus::CTransform xfrm = LoadEditorTransform(in);
    zeus::CVector3f scale = zeus::CVector3f::ReadBig(in);
    std::pair<bool, u32> pcount = CPatternedInfo::HasCorrectParameterCount(in);
    if (!pcount.first)
        return nullptr;

    CPatternedInfo pInfo(in, pcount.second);
    CActorParameters aParams = LoadActorParameters(in);
    CDamageInfo dInfo(in);
    zeus::CVector3f v1 = zeus::CVector3f::ReadBig(in);
    float f1 = in.readFloatBig();
    CDamageVulnerability dVuln1(in);
    CDamageVulnerability dVuln2(in);
    ResId abdomen = in.readUint32Big();
    MP1::CBeetle::EEntranceType entrance = MP1::CBeetle::EEntranceType(in.readUint32Big());
    float f2 = in.readFloatBig();
    float f3 = in.readFloatBig();

    FourCC animType = g_ResFactory->GetResourceTypeById(pInfo.GetAnimationParameters().GetACSFile());
    if (animType != SBIG('ANCS'))
        return nullptr;

    rstl::optional_object<CStaticRes> abdomenRes;
    if (flavor == CPatterned::EFlavorType::One)
        abdomenRes.emplace(CStaticRes(abdomen, scale));

    const CAnimationParameters& animParams = pInfo.GetAnimationParameters();
    CAnimRes animRes(animParams.GetACSFile(), animParams.GetCharacter(), scale, animParams.GetInitialAnimation(), true);

    return new MP1::CBeetle(mgr.AllocateUniqueId(), name, info, xfrm, animRes, pInfo, flavor, entrance, dInfo, dVuln2,
                            v1, f2, f3, f1, dVuln1, aParams, abdomenRes);
}

CEntity* ScriptLoader::LoadHUDMemo(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    if (propCount != 5 && !EnsurePropertyCount(propCount, 6, "HUDMemo"))
        return 0;
    std::string name = mgr.HashInstanceName(in);
    CHUDMemoParms hParms(in);
    CScriptHUDMemo::EDisplayType displayType = CScriptHUDMemo::EDisplayType::MessageBox;
    if (propCount == 6)
        displayType = CScriptHUDMemo::EDisplayType(in.readUint32Big());
    ResId message = in.readUint32Big();
    bool active = in.readBool();

    return new CScriptHUDMemo(mgr.AllocateUniqueId(), name, info, hParms, displayType, message, active);
}

CEntity* ScriptLoader::LoadCameraFilterKeyframe(CStateManager& mgr, CInputStream& in, int propCount,
                                                const CEntityInfo& info)
{
    if (!EnsurePropertyCount(propCount, 10, "CameraFilterKeyframe"))
        return nullptr;
    std::string name = mgr.HashInstanceName(in);
    bool active = in.readBool();
    u32 w1 = in.readUint32Big();
    u32 w2 = in.readUint32Big();
    u32 w3 = in.readUint32Big();
    u32 w4 = in.readUint32Big();
    zeus::CColor color;
    color.readRGBABig(in);
    float f1 = in.readFloatBig();
    float f2 = in.readFloatBig();
    u32 w5 = in.readUint32Big();

    return new CScriptCameraFilterKeyframe(mgr.AllocateUniqueId(), name, info, w1, w2, w3, w4, color, f1, f2, w5,
                                           active);
}

CEntity* ScriptLoader::LoadCameraBlurKeyframe(CStateManager& mgr, CInputStream& in, int propCount,
                                              const CEntityInfo& info)
{
    if (!EnsurePropertyCount(propCount, 7, "CameraBlurKeyframe"))
        return nullptr;

    std::string name = mgr.HashInstanceName(in);
    bool active = in.readBool();
    u32 w1 = in.readUint32Big();
    float f1 = in.readFloatBig();
    u32 w2 = in.readUint32Big();
    float f2 = in.readFloatBig();
    float f3 = in.readFloatBig();

    return new CScriptCameraBlurKeyframe(mgr.AllocateUniqueId(), name, info, w1, f1, w2, f2, f3, active);
}

u32 ClassifyVector(const zeus::CVector3f& dir)
{
    zeus::CVector3f absDir(std::fabs(dir.x), std::fabs(dir.y), std::fabs(dir.z));
    u32 max = (absDir.x > absDir.y ? 0 : 1);
    max = (absDir[max] > absDir.z ? max : 2);

    bool positive = (absDir[max] == dir[max]);
    if (max == 0)
        return (positive ? 0x08 : 0x04);
    else if (max == 1)
        return (positive ? 0x01 : 0x02);
    else if (max == 2)
        return (positive ? 0x10 : 0x20);

    return 0;
}

u32 TransformDamagableTriggerFlags(CStateManager& mgr, TAreaId aId, u32 flags)
{
    CGameArea* area = mgr.WorldNC()->GetGameAreas().at(u32(aId)).get();
    zeus::CTransform rotation = area->GetTransform().getRotation();

    u32 ret = 0;
    if (flags & 0x01)
        ret |= ClassifyVector(rotation * zeus::CVector3f::skForward);
    if (flags & 0x02)
        ret |= ClassifyVector(rotation * zeus::CVector3f::skBack);
    if (flags & 0x04)
        ret |= ClassifyVector(rotation * zeus::CVector3f::skLeft);
    if (flags & 0x08)
        ret |= ClassifyVector(rotation * zeus::CVector3f::skRight);
    if (flags & 0x10)
        ret |= ClassifyVector(rotation * zeus::CVector3f::skUp);
    if (flags & 0x20)
        ret |= ClassifyVector(rotation * zeus::CVector3f::skDown);
    return ret;
}

CEntity* ScriptLoader::LoadDamageableTrigger(CStateManager& mgr, CInputStream& in, int propCount,
                                             const CEntityInfo& info)
{
    if (!EnsurePropertyCount(propCount, 12, "DamageableTrigger"))
        return nullptr;

    std::string name = mgr.HashInstanceName(in);
    zeus::CVector3f position(zeus::CVector3f::ReadBig(in));
    zeus::CVector3f volume(zeus::CVector3f::ReadBig(in));

    CHealthInfo hInfo(in);
    CDamageVulnerability dVuln(in);
    u32 triggerFlags = in.readUint32Big();
    triggerFlags = TransformDamagableTriggerFlags(mgr, info.GetAreaId(), triggerFlags);
    ResId w1 = in.readUint32Big();
    ResId w2 = in.readUint32Big();
    ResId w3 = in.readUint32Big();
    CScriptDamageableTrigger::ECanOrbit canOrbit = CScriptDamageableTrigger::ECanOrbit(in.readBool());
    bool active = in.readBool();
    CVisorParameters vParms = LoadVisorParameters(in);
    return new CScriptDamageableTrigger(mgr.AllocateUniqueId(), name, info, position, volume, hInfo, dVuln,
                                        triggerFlags, w1, w2, w3, canOrbit, active, vParms);
}

CEntity* ScriptLoader::LoadDebris(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    if (!EnsurePropertyCount(propCount, 18, "Debris"))
        return nullptr;

    SScaledActorHead head = LoadScaledActorHead(in, mgr);
    float f1 = in.readFloatBig();
    zeus::CVector3f v1 = zeus::CVector3f::ReadBig(in);
    zeus::CColor color;
    color.readRGBABig(in);
    float f2 = in.readFloatBig();
    float f3 = in.readFloatBig();
    float f4 = in.readFloatBig();
    CScriptDebris::EScaleType scaleType = CScriptDebris::EScaleType(in.readUint32Big());
    bool b1 = in.readBool();
    ResId model = in.readUint32Big();
    CActorParameters aParams = LoadActorParameters(in);
    ResId w3 = in.readUint32Big();
    zeus::CVector3f v2 = zeus::CVector3f::ReadBig(in);
    bool b2 = in.readBool();
    bool b3 = in.readBool();

    if (!g_ResFactory->GetResourceTypeById(model))
        return nullptr;
    return new CScriptDebris(mgr.AllocateUniqueId(), head.x0_name, info, head.x10_transform,
                             CStaticRes(model, head.x40_scale), aParams, w3, v2, f1, v1, color, f2, f3, f4, scaleType,
                             b2, b1, b3);
}

CEntity* ScriptLoader::LoadCameraShaker(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    if (!EnsurePropertyCount(propCount, 9, "CameraShaker"))
        return nullptr;

    std::string name = mgr.HashInstanceName(in);
    CCameraShakeData shakeData = CCameraShakeData::LoadCameraShakeData(in);
    bool active = in.readBool();

    return new CScriptCameraShaker(mgr.AllocateUniqueId(), name, info, active, shakeData);
}

CEntity* ScriptLoader::LoadActorKeyframe(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    if (!EnsurePropertyCount(propCount, 7, "ActorKeyframe"))
        return nullptr;

    std::string name = mgr.HashInstanceName(in);
    s32 w1 = in.readInt32Big();
    bool b1 = in.readBool();
    float f1 = in.readFloatBig();
    bool active = in.readBool();
    u32 w2 = in.readUint32Big();
    float f2 = in.readFloatBig();

    if (w1 == -1)
        return nullptr;

    return new CScriptActorKeyframe(mgr.AllocateUniqueId(), name, info, w1, b1, f1, false, w2, active, f2);
}

CEntity* ScriptLoader::LoadWater(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    if (!EnsurePropertyCount(propCount, 63, "Water"))
        return nullptr;

    std::string name = mgr.HashInstanceName(in);
    zeus::CVector3f position;
    position.readBig(in);
    zeus::CVector3f extent;
    extent.readBig(in);
    CDamageInfo dInfo(in);
    zeus::CVector3f orientedForce;
    orientedForce.readBig(in);
    ETriggerFlags triggerFlags = ETriggerFlags(in.readUint32Big()) | ETriggerFlags::DetectProjectiles1 |
                                 ETriggerFlags::DetectProjectiles2 | ETriggerFlags::DetectProjectiles3 |
                                 ETriggerFlags::DetectProjectiles4 | ETriggerFlags::DetectBombs |
                                 ETriggerFlags::DetectPowerBombs | ETriggerFlags::DetectProjectiles5 |
                                 ETriggerFlags::DetectProjectiles6 | ETriggerFlags::DetectProjectiles7;
    bool b1 = in.readBool();
    bool displaySurface = in.readBool();
    ResId textureId1 = in.readUint32Big();
    ResId textureId2 = in.readUint32Big();
    ResId textureId3 = in.readUint32Big();
    ResId textureId4 = in.readUint32Big();
    ResId textureId5 = in.readUint32Big();
    ResId textureId6 = in.readUint32Big();
    zeus::CVector3f v2;
    v2.readBig(in);

    zeus::CVector3f otherV2 = v2;
    if (otherV2.canBeNormalized())
        otherV2.assign(0.f, 0.f, -1.f);

    float f1 = 1.f / in.readFloatBig();
    float f2 = in.readFloatBig();
    float f3 = in.readFloatBig();
    bool active = in.readBool();
    CFluidPlane::EFluidType fluidType = CFluidPlane::EFluidType(in.readUint32Big());
    bool b4 = in.readBool();
    float f4 = in.readFloatBig();
    CFluidUVMotion fluidMotion = LoadFluidUVMotion(in);

    float f5 = in.readFloatBig();
    float f6 = in.readFloatBig();
    float f7 = in.readFloatBig();
    float f8 = in.readFloatBig();
    float f9 = zeus::degToRad(in.readFloatBig());
    float f10 = zeus::degToRad(in.readFloatBig());
    float f11 = in.readFloatBig();
    float f12 = in.readFloatBig();
    zeus::CColor c1;
    c1.readRGBABig(in);
    zeus::CColor c2;
    c2.readRGBABig(in);
    ResId enterParticle = in.readUint32Big();
    ResId partId2 = in.readUint32Big();
    ResId partId3 = in.readUint32Big();
    ResId partId4 = in.readUint32Big();
    ResId partId5 = in.readUint32Big();
    u32 soundId1 = in.readUint32Big();
    u32 soundId2 = in.readUint32Big();
    u32 soundId3 = in.readUint32Big();
    u32 soundId4 = in.readUint32Big();
    u32 soundId5 = in.readUint32Big();
    float f13 = in.readFloatBig();
    u32 w19 = in.readUint32Big();
    float f14 = in.readFloatBig();
    float f15 = in.readFloatBig();
    float f16 = in.readFloatBig();
    float f17 = in.readFloatBig();
    float f18 = in.readFloatBig();
    float f19 = in.readFloatBig();
    float heatWaveHeight = in.readFloatBig();
    float heatWaveSpeed = in.readFloatBig();
    zeus::CColor heatWaveColor;
    heatWaveColor.readRGBABig(in);
    ResId lightmap = in.readUint32Big();
    float f22 = in.readFloatBig();
    float f23 = in.readFloatBig();
    float f24 = in.readFloatBig();
    u32 w21 = in.readUint32Big();
    u32 w22 = in.readUint32Big();
    bool b5 = in.readBool();

    u32* bitset = nullptr;
    u32 bitVal0 = 0;
    u32 bitVal1 = 0;

    if (b5)
    {
        bitVal0 = in.readUint16Big();
        bitVal1 = in.readUint16Big();
        u32 len = ((bitVal0 * bitVal1) + 31) / 31;
        bitset = new u32[len];
        in.readBytesToBuf(&bitset, len * 4);
    }

    zeus::CAABox box(-extent * 0.5f, extent * 0.5f);

    ResId realTextureId6 = -1;
    if (textureId4 == -1)
        realTextureId6 = textureId6;

    ResId realTextureId5 = -1;
    if (textureId4 == -1)
        realTextureId5 = textureId5;

    return new CScriptWater(
        mgr, mgr.AllocateUniqueId(), name, info, position, box, dInfo, orientedForce, triggerFlags, b1, displaySurface,
        textureId1, textureId2, textureId3, textureId4, realTextureId5, realTextureId6, -1, otherV2, f1, f2, f3, active,
        fluidType, b4, f4, fluidMotion, f5, f6, f7, f8, f9, f10, f11, f12, c1, c2, enterParticle, partId2, partId3,
        partId4, partId5, soundId1, soundId2, soundId3, soundId4, soundId5, f13, w19, f14, f15, f16, f17, f18, f19,
        heatWaveHeight, heatWaveSpeed, heatWaveColor, lightmap, f22, f23, f24, w21, w22, b5, bitVal0, bitVal1, bitset);
}

CEntity* ScriptLoader::LoadWarWasp(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    if (!EnsurePropertyCount(propCount, 13, "WarWasp"))
        return nullptr;

    std::string name = mgr.HashInstanceName(in);
    CPatterned::EFlavorType flavor = CPatterned::EFlavorType(in.readUint32Big());
    zeus::CTransform xf = LoadEditorTransformPivotOnly(in);
    zeus::CVector3f scale;
    scale.readBig(in);

    std::pair<bool, u32> verifyPair = CPatternedInfo::HasCorrectParameterCount(in);
    if (!verifyPair.first)
        return nullptr;

    CPatternedInfo pInfo(in, verifyPair.second);
    CActorParameters actorParms = LoadActorParameters(in);
    CPatterned::EColliderType collider = CPatterned::EColliderType(in.readBool());
    CDamageInfo damageInfo1(in);
    ResId weaponDesc = in.readUint32Big();
    CDamageInfo damageInfo2(in);
    ResId particle = in.readUint32Big();
    u32 w1 = in.readUint32Big();

    const CAnimationParameters& aParms = pInfo.GetAnimationParameters();
    FourCC animType = g_ResFactory->GetResourceTypeById(aParms.GetACSFile());
    if (animType != SBIG('ANCS'))
        return nullptr;

    CAnimRes res(aParms.GetACSFile(), aParms.GetCharacter(), scale, true, aParms.GetInitialAnimation());
    CModelData mData(res);
    return new MP1::CWarWasp(mgr.AllocateUniqueId(), name, info, xf, std::move(mData), pInfo, flavor, collider,
                             damageInfo1, actorParms, weaponDesc, damageInfo2, particle, w1);
}

CEntity* ScriptLoader::LoadSpacePirate(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    if (!EnsurePropertyCount(propCount, 34, "SpacePirate"))
        return nullptr;
    SScaledActorHead head = LoadScaledActorHead(in, mgr);
    std::pair<bool, u32> verifyPair = CPatternedInfo::HasCorrectParameterCount(in);
    if (!verifyPair.first)
        return nullptr;

    CPatternedInfo pInfo(in, verifyPair.second);
    CActorParameters aParams = LoadActorParameters(in);
    CAnimationParameters& animParms = pInfo.GetAnimationParameters();

    if (g_ResFactory->GetResourceTypeById(animParms.GetACSFile()) != SBIG('ANCS'))
        return nullptr;

    if (animParms.GetCharacter() == 0)
    {
        Log.report(logvisor::Warning,
                   "SpacePirate <%s> has AnimationInformation property with invalid character selected",
                   head.x0_name.c_str());
        animParms.SetCharacter(2);
    }

    CModelData mData(CAnimRes(animParms.GetACSFile(), animParms.GetCharacter(), head.x40_scale,
                              animParms.GetInitialAnimation(), true));

    return new MP1::CSpacePirate(mgr.AllocateUniqueId(), head.x0_name, info, head.x10_transform, std::move(mData),
                                 aParams, pInfo, in, propCount);
}

CEntity* ScriptLoader::LoadFlyingPirate(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    return nullptr;
}

CEntity* ScriptLoader::LoadElitePirate(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    return nullptr;
}

CEntity* ScriptLoader::LoadMetroidBeta(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    return nullptr;
}

CEntity* ScriptLoader::LoadChozoGhost(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    return nullptr;
}

CEntity* ScriptLoader::LoadCoverPoint(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    if (!EnsurePropertyCount(propCount, 9, "CoverPoint"))
        return nullptr;

    SActorHead head = LoadActorHead(in, mgr);
    bool active = in.readBool();
    u32 flags = in.readUint32Big();
    bool crouch = in.readBool();
    float horizontalAngle = in.readFloatBig();
    float verticalAngle = in.readFloatBig();
    float coverTime = in.readFloatBig();

    return new CScriptCoverPoint(mgr.AllocateUniqueId(), head.x0_name, info, head.x10_transform, active, flags, crouch,
                                 horizontalAngle, verticalAngle, coverTime);
}

CEntity* ScriptLoader::LoadSpiderBallWaypoint(CStateManager& mgr, CInputStream& in, int propCount,
                                              const CEntityInfo& info)
{
    return nullptr;
}

CEntity* ScriptLoader::LoadBloodFlower(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    return nullptr;
}

CEntity* ScriptLoader::LoadFlickerBat(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    return nullptr;
}

CEntity* ScriptLoader::LoadPathCamera(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    return nullptr;
}

CEntity* ScriptLoader::LoadGrapplePoint(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    if (!EnsurePropertyCount(propCount, 5, "GrapplePoint"))
        return nullptr;

    std::string name = mgr.HashInstanceName(in);
    zeus::CTransform grappleXf = LoadEditorTransform(in);
    bool active = in.readBool();
    CGrappleParameters parameters = LoadGrappleParameters(in);
    return new CScriptGrapplePoint(mgr.AllocateUniqueId(), name, info, grappleXf, active, parameters);
}

CEntity* ScriptLoader::LoadPuddleSpore(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    return nullptr;
}

CEntity* ScriptLoader::LoadDebugCameraWaypoint(CStateManager& mgr, CInputStream& in, int propCount,
                                               const CEntityInfo& info)
{
    return nullptr;
}

CEntity* ScriptLoader::LoadSpiderBallAttractionSurface(CStateManager& mgr, CInputStream& in, int propCount,
                                                       const CEntityInfo& info)
{
    return nullptr;
}

CEntity* ScriptLoader::LoadPuddleToadGamma(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    return nullptr;
}

CEntity* ScriptLoader::LoadDistanceFog(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    if (!EnsurePropertyCount(propCount, 8, "DistanceFog"))
        return nullptr;

    std::string name = mgr.HashInstanceName(in);
    u32 mode = in.readUint32Big();
    zeus::CColor color;
    color.readRGBABig(in);
    zeus::CVector2f range;
    range.readBig(in);
    float colorDelta = in.readFloatBig();
    zeus::CVector2f rangeDelta;
    rangeDelta.readBig(in);
    bool expl = in.readBool();
    bool active = in.readBool();
    ERglFogMode realMode;

    if (mode == 0)
        realMode = ERglFogMode::None;
    else if (mode == 1)
        realMode = ERglFogMode::PerspLin;
    else if (mode == 2)
        realMode = ERglFogMode::PerspExp;
    else if (mode == 3)
        realMode = ERglFogMode::PerspExp2;
    else if (mode == 4)
        realMode = ERglFogMode::PerspRevExp;
    else if (mode == 5)
        realMode = ERglFogMode::PerspRevExp2;

    return new CScriptDistanceFog(mgr.AllocateUniqueId(), name, info, realMode, color, range, colorDelta, rangeDelta,
                                  expl, active, 0.f, 0.f, 0.f, 0.f);
}

CEntity* ScriptLoader::LoadFireFlea(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    return nullptr;
}

CEntity* ScriptLoader::LoadMetareeAlpha(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    return nullptr;
}

CEntity* ScriptLoader::LoadDockAreaChange(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    if (!EnsurePropertyCount(propCount, 3, "DockAreaChange"))
        return nullptr;

    std::string name = mgr.HashInstanceName(in);
    s32 w1 = in.readInt32Big();
    bool active = in.readBool();

    return new CScriptDockAreaChange(mgr.AllocateUniqueId(), name, info, w1, active);
}

CEntity* ScriptLoader::LoadActorRotate(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    if (!EnsurePropertyCount(propCount, 6, "ActorRotate"))
        return nullptr;

    std::string name = mgr.HashInstanceName(in);
    zeus::CVector3f rotation = zeus::CVector3f::ReadBig(in);
    float scale = in.readFloatBig();
    bool b1 = in.readBool();
    bool b2 = in.readBool();
    bool active = in.readBool();

    return new CScriptActorRotate(mgr.AllocateUniqueId(), name, info, rotation, scale, b1, b2, active);
}

CEntity* ScriptLoader::LoadSpecialFunction(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    if (!EnsurePropertyCount(propCount, 15, "SpecialFunction"))
        return nullptr;

    SActorHead head = LoadActorHead(in, mgr);
    CScriptSpecialFunction::ESpecialFunction specialFunction =
        CScriptSpecialFunction::ESpecialFunction(in.readUint32Big());
    std::string str = in.readString();
    float f1 = in.readFloatBig();
    float f2 = in.readFloatBig();
    float f3 = in.readFloatBig();
    u32 w2 = in.readUint32Big();
    u32 w3 = in.readUint32Big();
    u32 w4 = in.readUint32Big();
    bool active1 = in.readBool();
    float f4 = in.readFloatBig();
    s16 w5 = in.readUint32Big() & 0xFFFF;
    s16 w6 = in.readUint32Big() & 0xFFFF;
    s16 w7 = in.readUint32Big() & 0xFFFF;
    if (specialFunction == CScriptSpecialFunction::ESpecialFunction::FogVolume ||
        specialFunction == CScriptSpecialFunction::ESpecialFunction::RadialDamage)
        return nullptr;

    return new CScriptSpecialFunction(mgr.AllocateUniqueId(), head.x0_name, info, head.x10_transform, specialFunction,
                                      str, f1, f2, f3, f4, zeus::CVector3f::skZero, zeus::CColor::skBlack, active1,
                                      CDamageInfo(), w2, w3, w4, w5, w6, w7);
}

CEntity* ScriptLoader::LoadSpankWeed(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    return nullptr;
}

CEntity* ScriptLoader::LoadParasite(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    return nullptr;
}

CEntity* ScriptLoader::LoadPlayerHint(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    return nullptr;
}

CEntity* ScriptLoader::LoadRipper(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    return nullptr;
}

CEntity* ScriptLoader::LoadPickupGenerator(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    if (!EnsurePropertyCount(propCount, 4, "PickupGenerator"))
        return nullptr;

    std::string name = mgr.HashInstanceName(in);
    zeus::CVector3f pos = zeus::CVector3f::ReadBig(in);
    bool active = in.readBool();
    float f1 = in.readFloatBig();
    return new CScriptPickupGenerator(mgr.AllocateUniqueId(), name, info, pos, f1, active);
}

CEntity* ScriptLoader::LoadAIKeyframe(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    return nullptr;
}

CEntity* ScriptLoader::LoadPointOfInterest(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    if (!EnsurePropertyCount(propCount, 6, "PointOfInterest"))
        return nullptr;

    SActorHead aHead = LoadActorHead(in, mgr);
    bool active = in.readBool();
    CScannableParameters sParms = LoadScannableParameters(in);
    float f1 = in.readFloatBig();

    return new CScriptPointOfInterest(mgr.AllocateUniqueId(), aHead.x0_name, info, aHead.x10_transform, active, sParms,
                                      f1);
}

CEntity* ScriptLoader::LoadDrone(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    return nullptr;
}

CEntity* ScriptLoader::LoadMetroidAlpha(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    return nullptr;
}

CEntity* ScriptLoader::LoadDebrisExtended(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    if (!EnsurePropertyCount(propCount, 39, "DebrisExtended"))
        return nullptr;

    SScaledActorHead aHead = LoadScaledActorHead(in, mgr);

    float f1 = in.readFloatBig();
    float f2 = in.readFloatBig();
    float f3 = in.readFloatBig();
    float f4 = in.readFloatBig();
    float f5 = in.readFloatBig();
    float f6 = in.readFloatBig();
    float f7 = in.readFloatBig();
    float f8 = in.readFloatBig();
    float f9 = in.readFloatBig();

    zeus::CColor c1 = zeus::CColor::ReadRGBABig(in);
    zeus::CColor c2 = zeus::CColor::ReadRGBABig(in);

    float f10 = in.readFloatBig();

    zeus::CVector3f v1 = zeus::CVector3f::ReadBig(in);

    float f11 = in.readFloatBig();
    float f12 = in.readFloatBig();

    zeus::CVector3f v2 = zeus::CVector3f::ReadBig(in);

    ResId model = in.readUint32Big();

    CActorParameters aParam = LoadActorParameters(in);

    ResId particle1 = in.readUint32Big();
    zeus::CVector3f particle1Scale = zeus::CVector3f::ReadBig(in);
    bool particle1B1 = in.readBool();
    bool particle1B2 = in.readBool();
    CScriptDebris::EOrientationType particle1W = CScriptDebris::EOrientationType(in.readUint32Big());

    ResId particle2 = in.readUint32Big();
    zeus::CVector3f particle2Scale = zeus::CVector3f::ReadBig(in);
    bool particle2B1 = in.readBool();
    bool particle2B2 = in.readBool();
    CScriptDebris::EOrientationType particle2W = CScriptDebris::EOrientationType(in.readUint32Big());

    ResId particle3 = in.readUint32Big();
    zeus::CVector3f particle3Scale = zeus::CVector3f::ReadBig(in);
    CScriptDebris::EOrientationType particle3W = CScriptDebris::EOrientationType(in.readUint32Big());

    bool b1 = in.readBool();
    bool b2 = in.readBool();
    bool b3 = in.readBool();
    bool b4 = in.readBool();

    CModelData modelData;
    if (g_ResFactory->GetResourceTypeById(model))
        modelData = CModelData(CStaticRes(model, aHead.x40_scale));

    return new CScriptDebris(mgr.AllocateUniqueId(), aHead.x0_name, info, aHead.x10_transform,
                             std::move(modelData), aParam, f1, f2, f3, f4, f5, f6, f7, f8, f9,
                             c1, c2, f10, aHead.x40_scale, v1, f11, f12, v2,
                             particle1, particle1Scale, particle1B1, particle1B2, particle1W,
                             particle2, particle2Scale, particle2B1, particle2B2, particle2W,
                             particle3, particle3Scale, particle3W, b1, b2, b3, b4);
}

CEntity* ScriptLoader::LoadSteam(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    if (!EnsurePropertyCount(propCount, 11, "Steam"))
        return nullptr;

    std::string name = mgr.HashInstanceName(in);

    zeus::CVector3f v1 = zeus::CVector3f::ReadBig(in);
    zeus::CVector3f v2 = zeus::CVector3f::ReadBig(in);

    CDamageInfo dInfo(in);

    zeus::CVector3f v3 = zeus::CVector3f::ReadBig(in);

    ETriggerFlags w1 = ETriggerFlags(in.readUint32Big());
    bool b1 = in.readBool();
    u32 w2 = in.readUint32Big();
    float f1 = in.readFloatBig();
    float f2 = in.readFloatBig();
    float f3 = in.readFloatBig();
    float f4 = in.readFloatBig();
    bool b2 = in.readBool();

    zeus::CAABox aabb(-v2 * 0.5f, v2 * 0.5f);

    return new CScriptSteam(mgr.AllocateUniqueId(), name, info, v1, aabb, dInfo,
                            v3, w1, b1, w2, f1, f2, f3, f4, b2);
}

CEntity* ScriptLoader::LoadRipple(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    return nullptr;
}

CEntity* ScriptLoader::LoadBallTrigger(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    return nullptr;
}

CEntity* ScriptLoader::LoadTargetingPoint(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    return nullptr;
}

CEntity* ScriptLoader::LoadEMPulse(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    return nullptr;
}

CEntity* ScriptLoader::LoadIceSheegoth(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    return nullptr;
}

CEntity* ScriptLoader::LoadPlayerActor(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    if (!EnsurePropertyCount(propCount, 19, "PlayerActor"))
        return nullptr;

    SScaledActorHead aHead = LoadScaledActorHead(in, mgr);
    zeus::CVector3f extents = zeus::CVector3f::ReadBig(in);
    zeus::CVector3f offset = zeus::CVector3f::ReadBig(in);
    float mass = in.readFloatBig();
    float zMomentum = in.readFloatBig();
    CHealthInfo hInfo(in);
    CDamageVulnerability dVuln(in);
    in.readUint32Big();
    CAnimationParameters animParms = LoadAnimationParameters(in);
    CActorParameters actParms = LoadActorParameters(in);
    bool loop = in.readBool();
    bool snow = in.readBool();
    bool solid = in.readBool();
    bool active = in.readBool();
    u32 flags = LoadParameterFlags(in);
    bool w1 = in.readUint32Big() - 1;

    FourCC fcc = g_ResFactory->GetResourceTypeById(animParms.GetACSFile());
    if (!fcc || fcc != SBIG('ANCS'))
        return nullptr;

    zeus::CAABox aabox = GetCollisionBox(mgr, info.GetAreaId(), extents, offset);
    CMaterialList list;
    if (snow)
        list.Add(EMaterialTypes::Snow);

    if (solid)
        list.Add(EMaterialTypes::Solid);

    if ((extents.x < 0.f || extents.y < 0.f || extents.z < 0.f) || extents.isZero())
        aabox = zeus::CAABox({-.5f}, {0.5f});

    return new CScriptPlayerActor(mgr.AllocateUniqueId(), aHead.x0_name, info, aHead.x10_transform,
                                  CAnimRes(animParms.GetACSFile(), animParms.GetCharacter(), aHead.x40_scale,
                                           animParms.GetInitialAnimation(), loop), CModelData::CModelDataNull(),
                                  aabox, true, list, mass, zMomentum, hInfo, dVuln, actParms, loop, active, flags, w1);
}

CEntity* ScriptLoader::LoadFlaahgra(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    return nullptr;
}

CEntity* ScriptLoader::LoadAreaAttributes(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    if (!EnsurePropertyCount(propCount, 9, "AreaAttributes"))
        return nullptr;

    bool load = in.readUint32Big() != 0;
    if (!load)
        return nullptr;

    bool showSkybox = in.readBool();
    EEnvFxType fxType = EEnvFxType(in.readUint32Big());
    float envFxDensity = in.readFloatBig();
    float thermalHeat = in.readFloatBig();
    float xrayFogDistance = in.readFloatBig();
    float worldLightingLevel = in.readFloatBig();
    ResId skybox = in.readUint32Big();
    EPhazonType phazonType = EPhazonType(in.readUint32Big());

    return new CScriptAreaAttributes(mgr.AllocateUniqueId(), info, showSkybox, fxType, envFxDensity, thermalHeat,
                                     xrayFogDistance, worldLightingLevel, skybox, phazonType);
}

CEntity* ScriptLoader::LoadFishCloud(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    return nullptr;
}

CEntity* ScriptLoader::LoadFishCloudModifier(CStateManager& mgr, CInputStream& in, int propCount,
                                             const CEntityInfo& info)
{
    return nullptr;
}

CEntity* ScriptLoader::LoadVisorFlare(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    if (!EnsurePropertyCount(propCount, 14, "VisorFlare"))
        return nullptr;

    std::string name = mgr.HashInstanceName(in);
    zeus::CVector3f pos = zeus::CVector3f::ReadBig(in);
    bool b1 = in.readBool();
    CVisorFlare::EBlendMode w1 = CVisorFlare::EBlendMode(in.readUint32Big());
    bool b2 = in.readBool();
    float f1 = in.readFloatBig();
    float f2 = in.readFloatBig();
    float f3 = in.readFloatBig();
    u32 w2 = in.readUint32Big();
    std::vector<CVisorFlare::CFlareDef> flares;
    flares.reserve(5);
    for (int i=0 ; i<5 ; ++i)
        if (auto flare = CVisorFlare::LoadFlareDef(in))
            flares.push_back(*flare);

    return new CScriptVisorFlare(mgr.AllocateUniqueId(), name, info, b1, pos, w1, b2, f1, f2, f3, 2, w2, flares);
}

CEntity* ScriptLoader::LoadWorldTeleporter(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    return nullptr;
}

CEntity* ScriptLoader::LoadVisorGoo(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    return nullptr;
}

CEntity* ScriptLoader::LoadJellyZap(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    return nullptr;
}

CEntity* ScriptLoader::LoadControllerAction(CStateManager& mgr, CInputStream& in, int propCount,
                                            const CEntityInfo& info)
{
    if (!EnsurePropertyCount(propCount, 4, "ControllerAction") || propCount > 6)
        return nullptr;

    std::string name = mgr.HashInstanceName(in);
    bool active = in.readBool();
    ControlMapper::ECommands w1 = ControlMapper::ECommands(in.readUint32Big());
    bool b1 = false;
    u32 w2 = 0;
    if (propCount == 6)
    {
        b1 = in.readBool();
        w2 = in.readUint32Big();
    }
    bool b2 = in.readBool();

    return new CScriptControllerAction(mgr.AllocateUniqueId(), name, info, active, w1, b1, w2, b2);
}

CEntity* ScriptLoader::LoadSwitch(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    if (!EnsurePropertyCount(propCount, 4, "Switch"))
        return nullptr;

    std::string name = mgr.HashInstanceName(in);
    bool active = in.readBool();
    bool b2 = in.readBool();
    bool b3 = in.readBool();

    return new CScriptSwitch(mgr.AllocateUniqueId(), name, info, active, b2, b3);
}

CEntity* ScriptLoader::LoadPlayerStateChange(CStateManager& mgr, CInputStream& in, int propCount,
                                             const CEntityInfo& info)
{
    return nullptr;
}

CEntity* ScriptLoader::LoadThardus(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    return nullptr;
}

CEntity* ScriptLoader::LoadWallCrawlerSwarm(CStateManager& mgr, CInputStream& in, int propCount,
                                            const CEntityInfo& info)
{
    if (!EnsurePropertyCount(propCount, 39, "WallCrawlerSwarm"))
        return nullptr;

    SScaledActorHead aHead = LoadScaledActorHead(in, mgr);
    bool active = in.readBool();
    CActorParameters aParams = LoadActorParameters(in);
    u32 w1 = in.readUint32Big();
    u32 w2 = in.readUint32Big();
    u32 w3 = in.readUint32Big();
    u32 w4 = in.readUint32Big();
    u32 w5 = in.readUint32Big();
    u32 w6 = in.readUint32Big();
    u32 w7 = in.readUint32Big();
    u32 w8 = in.readUint32Big();
    u32 w9 = in.readUint32Big();
    u32 w10 = in.readUint32Big();
    CDamageInfo dInfo1(in);
    float f1 = in.readFloatBig();
    CDamageInfo dInfo2(in);
    float f2 = in.readFloatBig();
    float f3 = in.readFloatBig();
    float f4 = in.readFloatBig();
    float f5 = in.readFloatBig();
    u32 w11 = in.readUint32Big();
    u32 w12 = in.readUint32Big();
    float f6 = in.readFloatBig();
    float f7 = in.readFloatBig();
    float f8 = in.readFloatBig();
    float f9 = in.readFloatBig();
    float f10 = in.readFloatBig();
    float f11 = in.readFloatBig();
    float f12 = in.readFloatBig();
    float f13 = in.readFloatBig();
    u32 w13 = in.readUint32Big();
    float f14 = in.readFloatBig();
    float f15 = in.readFloatBig();
    float f16 = in.readFloatBig();
    CHealthInfo hInfo(in);
    CDamageVulnerability dVulns(in);
    u32 w14 = in.readUint32Big();
    u32 w15 = in.readUint32Big();

    return new CWallCrawlerSwarm(mgr.AllocateUniqueId(), active, aHead.x0_name, info, aHead.x40_scale,
                                 aHead.x10_transform, w1, CAnimRes(w2, w3, {1.5f}, w4, true), w5, w6, w7, w8, w9, w10,
                                 dInfo1, dInfo2, f1, f2, f3, f4, w11, w12, f5, f6, f7, f8, f9, f10, f11, f12, f13, w13,
                                 f14, f15, f16, hInfo, dVulns, w14, w15, aParams);
}

CEntity* ScriptLoader::LoadAiJumpPoint(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    if (!EnsurePropertyCount(propCount, 5, "AiJumpPoint"))
        return nullptr;

    SActorHead aHead = LoadActorHead(in, mgr);
    bool active = in.readBool();
    float f1 = in.readFloat();

    return new CScriptAiJumpPoint(mgr.AllocateUniqueId(), aHead.x0_name, info, aHead.x10_transform, active, f1);
}

CEntity* ScriptLoader::LoadFlaahgraTentacle(CStateManager& mgr, CInputStream& in, int propCount,
                                            const CEntityInfo& info)
{
    return nullptr;
}

CEntity* ScriptLoader::LoadRoomAcoustics(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    if (!EnsurePropertyCount(propCount, 32, "RoomAcoustics"))
        return nullptr;

    std::string name = mgr.HashInstanceName(in);
    bool a = in.readBool();
    u32 b = in.readUint32Big();
    bool c = in.readBool();
    bool d = in.readBool();
    float e = in.readFloatBig();
    float f = in.readFloatBig();
    float g = in.readFloatBig();
    float h = in.readFloatBig();
    float i = in.readFloatBig();
    float j = in.readFloatBig();
    bool k = in.readBool();
    float l = in.readFloatBig();
    float m = in.readFloatBig();
    float n = in.readFloatBig();
    bool o = in.readBool();
    bool p = in.readBool();
    float q = in.readFloatBig();
    float r = in.readFloatBig();
    float s = in.readFloatBig();
    float t = in.readFloatBig();
    float u = in.readFloatBig();
    bool v = in.readBool();
    u32 w = in.readUint32Big();
    u32 x = in.readUint32Big();
    u32 y = in.readUint32Big();
    u32 z = in.readUint32Big();
    u32 _a = in.readUint32Big();
    u32 _b = in.readUint32Big();
    u32 _c = in.readUint32Big();
    u32 _d = in.readUint32Big();
    u32 _e = in.readUint32Big();

    return new CScriptRoomAcoustics(mgr.AllocateUniqueId(), name, info, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p,
                                    q, r, s, t, u, v, w, x, y, z, _a, _b, _c, _d, _e);
}

CEntity* ScriptLoader::LoadColorModulate(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    if (!EnsurePropertyCount(propCount, 12, "ColorModulate"))
        return nullptr;

    std::string name = mgr.HashInstanceName(in);
    zeus::CColor c1;
    c1.readRGBABig(in);
    zeus::CColor c2;
    c2.readRGBABig(in);
    CScriptColorModulate::EBlendMode bm = CScriptColorModulate::EBlendMode(in.readUint32Big());
    float f1 = in.readFloatBig();
    float f2 = in.readFloatBig();
    bool b1 = in.readBool();
    bool b2 = in.readBool();
    bool b3 = in.readBool();
    bool b4 = in.readBool();
    bool b5 = in.readBool();
    bool active = in.readBool();
    return new CScriptColorModulate(mgr.AllocateUniqueId(), name, info, c1, c2, bm, f1, f2, b1, b2, b3, b4, b5, active);
}

CEntity* ScriptLoader::LoadThardusRockProjectile(CStateManager& mgr, CInputStream& in, int propCount,
                                                 const CEntityInfo& info)
{
    return nullptr;
}

CEntity* ScriptLoader::LoadMidi(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    if (!EnsurePropertyCount(propCount, 6, "Midi"))
        return nullptr;

    std::string name = mgr.HashInstanceName(in);
    bool active = in.readBool();
    u32 csng = in.readUint32Big();
    float fadeIn = in.readFloatBig();
    float fadeOut = in.readFloatBig();
    u32 vol = in.readUint32Big();
    return new CScriptMidi(mgr.AllocateUniqueId(), info, name, active, csng, fadeIn, fadeOut, vol);
}

CEntity* ScriptLoader::LoadStreamedAudio(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    if (!EnsurePropertyCount(propCount, 9, "StreamedAudio"))
        return nullptr;

    const std::string name = mgr.HashInstanceName(in);
    bool active = in.readBool();
    std::string fileName = in.readString();
    bool noStopOnDeactivate = in.readBool();
    float fadeIn = in.readFloatBig();
    float fadeOut = in.readFloatBig();
    u32 volume = in.readUint32Big();
    u32 oneShot = in.readUint32Big();
    bool music = in.readBool();

    return new CScriptStreamedMusic(mgr.AllocateUniqueId(), info, name, active, fileName, noStopOnDeactivate, fadeIn,
                                    fadeOut, volume, !oneShot, music);
}

CEntity* ScriptLoader::LoadRepulsor(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    if (!EnsurePropertyCount(propCount, 4, "Repulsor"))
        return nullptr;

    std::string name = mgr.HashInstanceName(in);
    zeus::CVector3f center = in.readVec3fBig();
    bool active = in.readBool();
    float radius = in.readFloatBig();

    return new CRepulsor(mgr.AllocateUniqueId(), active, name, info, center, radius);
}

CEntity* ScriptLoader::LoadGunTurret(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    return nullptr;
}

CEntity* ScriptLoader::LoadFogVolume(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    return nullptr;
}

CEntity* ScriptLoader::LoadBabygoth(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    return nullptr;
}

CEntity* ScriptLoader::LoadEyeball(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    return nullptr;
}

CEntity* ScriptLoader::LoadRadialDamage(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    if (!EnsurePropertyCount(propCount, 5, "RadialDamage"))
        return nullptr;

    std::string name = mgr.HashInstanceName(in);
    zeus::CVector3f center = zeus::CVector3f::ReadBig(in);
    bool active = in.readBool();
    CDamageInfo dInfo(in);
    float radius = in.readFloatBig();
    zeus::CTransform xf = ConvertEditorEulerToTransform4f(zeus::CVector3f::skZero, center);

    return new CScriptSpecialFunction(
        mgr.AllocateUniqueId(), name, info, xf, CScriptSpecialFunction::ESpecialFunction::RadialDamage, "", radius, 0.f,
        0.f, 0.f, zeus::CVector3f::skZero, zeus::CColor::skBlack, active, dInfo, -1, -1, -1, -1, -1, -1);
}

CEntity* ScriptLoader::LoadCameraPitchVolume(CStateManager& mgr, CInputStream& in, int propCount,
                                             const CEntityInfo& info)
{
    if (!EnsurePropertyCount(propCount, 8, "CameraPitchVolume"))
        return nullptr;

    SScaledActorHead aHead = LoadScaledActorHead(in, mgr);
    bool active = in.readBool();
    zeus::CRelAngle f1 = zeus::CRelAngle::FromDegrees(in.readFloatBig());
    zeus::CRelAngle f2 = zeus::CRelAngle::FromDegrees(in.readFloatBig());
    float f3 = in.readFloatBig();

    return new CScriptCameraPitchVolume(mgr.AllocateUniqueId(), active, aHead.x0_name, info, aHead.x40_scale,
                                        aHead.x10_transform, f1, f2, f3);
}

CEntity* ScriptLoader::LoadEnvFxDensityController(CStateManager& mgr, CInputStream& in, int propCount,
                                                  const CEntityInfo& info)
{
    return nullptr;
}

CEntity* ScriptLoader::LoadMagdolite(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    return nullptr;
}

CEntity* ScriptLoader::LoadTeamAIMgr(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    return nullptr;
}

CEntity* ScriptLoader::LoadSnakeWeedSwarm(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    return nullptr;
}

CEntity* ScriptLoader::Load(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    return nullptr;
}

CEntity* ScriptLoader::LoadActorContraption(CStateManager& mgr, CInputStream& in, int propCount,
                                            const CEntityInfo& info)
{

    return nullptr;
}

CEntity* ScriptLoader::LoadOculus(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    return nullptr;
}

CEntity* ScriptLoader::LoadGeemer(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    return nullptr;
}

CEntity* ScriptLoader::LoadSpindleCamera(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    return nullptr;
}

CEntity* ScriptLoader::LoadAtomicAlpha(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    return nullptr;
}

CEntity* ScriptLoader::LoadCameraHintTrigger(CStateManager& mgr, CInputStream& in, int propCount,
                                             const CEntityInfo& info)
{
    if (!EnsurePropertyCount(propCount, 7, "CameraHintTrigger"))
        return nullptr;

    SActorHead aHead = LoadActorHead(in, mgr);
    zeus::CVector3f scale = 0.5f * zeus::CVector3f::ReadBig(in);
    bool active = in.readBool();
    bool b2 = in.readBool();
    bool b3 = in.readBool();

    zeus::CTransform xfRot = aHead.x10_transform.getRotation();
    if (xfRot == zeus::CTransform::Identity())
        return new CScriptTrigger(mgr.AllocateUniqueId(), aHead.x0_name, info, aHead.x10_transform.origin,
                                  zeus::CAABox(-scale, scale), CDamageInfo(), zeus::CVector3f::skZero,
                                  ETriggerFlags::DetectPlayer, active, b2, b3);

    return new CScriptCameraHintTrigger(mgr.AllocateUniqueId(), active, aHead.x0_name, info, scale, aHead.x10_transform,
                                        b2, b3);
}

CEntity* ScriptLoader::LoadRumbleEffect(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    return nullptr;
}

CEntity* ScriptLoader::LoadAmbientAI(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    return nullptr;
}

CEntity* ScriptLoader::LoadAtomicBeta(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    return nullptr;
}

CEntity* ScriptLoader::LoadIceZoomer(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    return nullptr;
}

CEntity* ScriptLoader::LoadPuffer(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    return nullptr;
}

CEntity* ScriptLoader::LoadTryclops(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    return nullptr;
}

CEntity* ScriptLoader::LoadRidley(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    return nullptr;
}

CEntity* ScriptLoader::LoadSeedling(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    return nullptr;
}

CEntity* ScriptLoader::LoadThermalHeatFader(CStateManager& mgr, CInputStream& in, int propCount,
                                            const CEntityInfo& info)
{
    if (!EnsurePropertyCount(propCount, 4, "ThermalHeatFader"))
        return nullptr;

    return LoadWorldLightFader(mgr, in, propCount, info);
}

CEntity* ScriptLoader::LoadBurrower(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    return nullptr;
}

CEntity* ScriptLoader::LoadBeam(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    if (!EnsurePropertyCount(propCount, 7, "Beam"))
        return nullptr;

    SActorHead aHead = LoadActorHead(in, mgr);
    bool active = in.readBool();
    u32 weaponDescId = in.readUint32Big();
    if (!g_ResFactory->GetResourceTypeById(weaponDescId))
        return nullptr;

    CBeamInfo beamInfo(in);
    CDamageInfo dInfo(in);
    TToken<CWeaponDescription> weaponDesc = g_SimplePool->GetObj({SBIG('WPSC'), weaponDescId});

    return new CScriptBeam(mgr.AllocateUniqueId(), aHead.x0_name, info, aHead.x10_transform, active, weaponDesc,
                           beamInfo, dInfo);
}

CEntity* ScriptLoader::LoadWorldLightFader(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    if (!EnsurePropertyCount(propCount, 4, "WorldLightFader"))
        return nullptr;

    return nullptr;
}

CEntity* ScriptLoader::LoadMetroidPrimeStage2(CStateManager& mgr, CInputStream& in, int propCount,
                                              const CEntityInfo& info)
{
    return nullptr;
}

CEntity* ScriptLoader::LoadMetroidPrimeStage1(CStateManager& mgr, CInputStream& in, int propCount,
                                              const CEntityInfo& info)
{
    return nullptr;
}

CEntity* ScriptLoader::LoadMazeNode(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    return nullptr;
}

CEntity* ScriptLoader::LoadOmegaPirate(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    return nullptr;
}

CEntity* ScriptLoader::LoadPhazonPool(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    return nullptr;
}

CEntity* ScriptLoader::LoadPhazonHealingNodule(CStateManager& mgr, CInputStream& in, int propCount,
                                               const CEntityInfo& info)
{
    return nullptr;
}

CEntity* ScriptLoader::LoadNewCameraShaker(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    if (!EnsurePropertyCount(propCount, 8, "NewCameraShaker"))
        return nullptr;

    std::string name = mgr.HashInstanceName(in);
    zeus::CVector3f v1 = zeus::CVector3f::ReadBig(in);
    bool active = in.readBool();
    u32 flags = LoadParameterFlags(in);
    float f1 = in.readFloatBig();
    float f2 = in.readFloatBig();
    CCameraShakerComponent shaker1 = CCameraShakerComponent::LoadNewCameraShakerComponent(in);
    CCameraShakerComponent shaker2 = CCameraShakerComponent::LoadNewCameraShakerComponent(in);
    CCameraShakerComponent shaker3 = CCameraShakerComponent::LoadNewCameraShakerComponent(in);

    CCameraShakeData shakeData(f1, f2, flags, v1, shaker1, shaker2, shaker3);

    return new CScriptCameraShaker(mgr.AllocateUniqueId(), name, info, active, shakeData);
}

CEntity* ScriptLoader::LoadShadowProjector(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    if (!EnsurePropertyCount(propCount, 10, "ShadowProjector"))
        return nullptr;

    std::string name = mgr.HashInstanceName(in);
    zeus::CVector3f position(zeus::CVector3f::ReadBig(in));
    bool b1 = in.readBool();
    float f1 = in.readFloatBig();
    zeus::CVector3f vec2(zeus::CVector3f::ReadBig(in));
    float f2 = in.readFloatBig();
    float f3 = in.readFloatBig();
    float f4 = in.readFloatBig();
    bool b2 = in.readBool();
    u32 w1 = in.readUint32Big();
    return new CScriptShadowProjector(mgr.AllocateUniqueId(), name, info, zeus::CTransform::Translate(position), b1,
                                      vec2, b2, f1, f2, f3, f4, w1);
}

CEntity* ScriptLoader::LoadEnergyBall(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
{
    return nullptr;
}
}