Various loader implementations

2025-12-16 23:37:04 +00:00 · 2018-10-11 15:57:05 -07:00
parent 8b25548482
commit bbfe61efbf
59 changed files with 1136 additions and 133 deletions
--- a/Runtime/World/CDamageVulnerability.cpp
+++ b/Runtime/World/CDamageVulnerability.cpp
@@ -188,9 +188,7 @@ bool CDamageVulnerability::WeaponHurts(const CWeaponMode& mode, bool ignoreDirec
        return true;
    if (chargedHurts && mode.IsCharged())
        return true;
-    if (comboedHurts && mode.IsComboed())
-        return true;
-    return false;
+    return comboedHurts && mode.IsComboed();
 }

 bool CDamageVulnerability::WeaponHits(const CWeaponMode& mode, bool checkDirect) const
--- a/Runtime/World/CMakeLists.txt
+++ b/Runtime/World/CMakeLists.txt
@@ -73,6 +73,7 @@ set(WORLD_SOURCES
    CScriptPlayerHint.hpp CScriptPlayerHint.cpp
    CScriptPlayerStateChange.hpp CScriptPlayerStateChange.cpp
    CScriptTargetingPoint.hpp CScriptTargetingPoint.cpp
+    CScriptEMPulse.hpp CScriptEMPulse.cpp
    CScriptPlayerActor.hpp CScriptPlayerActor.cpp
    CFishCloud.hpp CFishCloud.cpp
    CFishCloudModifier.hpp CFishCloudModifier.cpp
--- a/Runtime/World/CPatternedInfo.cpp
+++ b/Runtime/World/CPatternedInfo.cpp
@@ -52,8 +52,6 @@ CPatternedInfo::CPatternedInfo(CInputStream& in, u32 pcount)
 std::pair<bool, u32> CPatternedInfo::HasCorrectParameterCount(CInputStream& in)
 {
    u32 pcount = in.readUint32Big();
-    if (pcount < 35 || pcount > 38)
-        return {false, pcount};
-    return {true, pcount};
+    return {(pcount >= 35 && pcount <= 38), pcount};
 }
 }
--- a/Runtime/World/CPlayer.cpp
+++ b/Runtime/World/CPlayer.cpp
@@ -5817,7 +5817,7 @@ float CPlayer::JumpInput(const CFinalInput& input, CStateManager& mgr)
            float backwards = ControlMapper::GetAnalogInput(ControlMapper::ECommands::Backward, input);
            if (forwards < backwards)
                forwards = ControlMapper::GetAnalogInput(ControlMapper::ECommands::Backward, input);
-            return (vDoubleJumpAccel - (vDoubleJumpAccel - hDoubleJumpAccel) * forwards) * xe8_mass * jumpFactor;
+            return ((vDoubleJumpAccel - (vDoubleJumpAccel - hDoubleJumpAccel) * forwards) * xe8_mass) * jumpFactor;
        }

        return GetGravity() * xe8_mass;
@@ -5831,7 +5831,7 @@ float CPlayer::JumpInput(const CFinalInput& input, CStateManager& mgr)
            if (ControlMapper::GetPressInput(ControlMapper::ECommands::JumpOrBoost, input))
            {
                SetMoveState(EPlayerMovementState::Jump, mgr);
-                return vJumpAccel * xe8_mass * jumpFactor;
+                return (vJumpAccel * xe8_mass) * jumpFactor;
            }
            return 0.f;
        }
@@ -5839,7 +5839,7 @@ float CPlayer::JumpInput(const CFinalInput& input, CStateManager& mgr)
        float backwards = ControlMapper::GetAnalogInput(ControlMapper::ECommands::Backward, input);
        if (forwards < backwards)
            forwards = ControlMapper::GetAnalogInput(ControlMapper::ECommands::Backward, input);
-        return (vJumpAccel - (vJumpAccel - hJumpAccel) * forwards) * xe8_mass * jumpFactor;
+        return ((vJumpAccel - (vJumpAccel - hJumpAccel) * forwards) * xe8_mass) * jumpFactor;
    }

    if (x258_movementState == EPlayerMovementState::Jump)
--- a/Runtime/World/CPlayer.hpp
+++ b/Runtime/World/CPlayer.hpp
@@ -660,6 +660,7 @@ public:
    CPlayerGun* GetPlayerGun() const { return x490_gun.get(); }
    CMorphBall* GetMorphBall() const { return x768_morphball.get(); }
    CPlayerCameraBob* GetCameraBob() const { return x76c_cameraBob.get(); }
+    float GetStaticTimer() const { return x740_staticTimer; }
    float GetDeathTime() const { return x9f4_deathTime; }
    const CPlayerEnergyDrain& GetEnergyDrain() const { return x274_energyDrain; }
    EPlayerZoneInfo GetOrbitZone() const { return x330_orbitZoneMode; }
--- a/Runtime/World/CScriptDistanceFog.cpp
+++ b/Runtime/World/CScriptDistanceFog.cpp
@@ -6,7 +6,7 @@
 namespace urde
 {
 CScriptDistanceFog::CScriptDistanceFog(TUniqueId uid, std::string_view name, const CEntityInfo& info,
-                                       const ERglFogMode& mode, const zeus::CColor& color,
+                                       ERglFogMode mode, const zeus::CColor& color,
                                       const zeus::CVector2f& range, float colorDelta,
                                       const zeus::CVector2f& rangeDelta, bool expl, bool active,
                                       float thermalTarget, float thermalSpeed, float xrayTarget, float xraySpeed)
--- a/Runtime/World/CScriptDistanceFog.hpp
+++ b/Runtime/World/CScriptDistanceFog.hpp
@@ -20,7 +20,7 @@ class CScriptDistanceFog : public CEntity
    bool x60_explicit;
    bool x61_nonZero;
 public:
-    CScriptDistanceFog(TUniqueId, std::string_view, const CEntityInfo&, const ERglFogMode&,
+    CScriptDistanceFog(TUniqueId, std::string_view, const CEntityInfo&, ERglFogMode,
                       const zeus::CColor&, const zeus::CVector2f&, float, const zeus::CVector2f&,
                       bool, bool, float, float, float, float);

--- a/Runtime/World/CScriptEMPulse.cpp
+++ b/Runtime/World/CScriptEMPulse.cpp
@@ -0,0 +1,105 @@
+#include "CScriptEMPulse.hpp"
+#include "CActorParameters.hpp"
+#include "Particle/CGenDescription.hpp"
+#include "Particle/CElementGen.hpp"
+#include "GameGlobalObjects.hpp"
+#include "CSimplePool.hpp"
+#include "CStateManager.hpp"
+#include "CPlayer.hpp"
+#include "Graphics/CBooRenderer.hpp"
+#include "TCastTo.hpp"
+
+namespace urde
+{
+
+CScriptEMPulse::CScriptEMPulse(TUniqueId uid, std::string_view name, const CEntityInfo& info,
+                               const zeus::CTransform& xf, bool active, float initialRadius, float finalRadius,
+                               float duration,
+                               float interferenceDur, float f5, float interferenceMag, float f7, CAssetId partId)
+    : CActor(uid, active, name, info, xf, CModelData::CModelDataNull(), CMaterialList(EMaterialTypes::Projectile),
+             CActorParameters::None().HotInThermal(true), kInvalidUniqueId), xe8_duration(duration),
+      xec_finalRadius(finalRadius), xf0_currentRadius(initialRadius), xf4_initialRadius(initialRadius),
+      xf8_interferenceDur(interferenceDur), xfc_(f5), x100_interferenceMag(interferenceMag), x104_(f7),
+      x108_particleDesc(g_SimplePool->GetObj({SBIG('PART'), partId}))
+{
+}
+
+void CScriptEMPulse::Accept(IVisitor& visitor)
+{
+    visitor.Visit(this);
+}
+
+void CScriptEMPulse::Think(float dt, CStateManager& mgr)
+{
+    if (!GetActive())
+        return;
+
+    xf0_currentRadius += ((xec_finalRadius - xf4_initialRadius) / xe8_duration) * dt;
+    if (xf0_currentRadius < xec_finalRadius)
+        mgr.FreeScriptObject(GetUniqueId());
+
+    x114_particleGen->Update(dt);
+}
+
+void CScriptEMPulse::AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId uid, CStateManager& mgr)
+{
+    CActor::AcceptScriptMsg(msg, uid, mgr);
+    if (msg == EScriptObjectMessage::Activate)
+    {
+        x114_particleGen.reset(new CElementGen(x108_particleDesc, CElementGen::EModelOrientationType::Normal,
+                                               CElementGen::EOptionalSystemFlags::One));
+
+        x114_particleGen->SetOrientation(GetTransform().getRotation());
+        x114_particleGen->SetGlobalTranslation(GetTranslation());
+        x114_particleGen->SetParticleEmission(true);
+        mgr.GetPlayerState()->GetStaticInterference().AddSource(GetUniqueId(), x100_interferenceMag,
+                                                                xf8_interferenceDur);
+    }
+}
+
+void CScriptEMPulse::AddToRenderer(const zeus::CFrustum& frustum, CStateManager& mgr) const
+{
+    CActor::AddToRenderer(frustum, mgr);
+    if (GetActive())
+        g_Renderer->AddParticleGen(*x114_particleGen);
+}
+
+void CScriptEMPulse::CalculateRenderBounds()
+{
+    x9c_renderBounds = CalculateBoundingBox();
+}
+
+std::experimental::optional<zeus::CAABox> CScriptEMPulse::GetTouchBounds() const
+{
+    return {CalculateBoundingBox()};
+}
+
+void CScriptEMPulse::Touch(CActor& act, CStateManager& mgr)
+{
+    if (!GetActive())
+        return;
+
+    if (TCastToPtr<CPlayer> pl = act)
+    {
+        zeus::CVector3f posDiff = GetTranslation() - pl->GetTranslation();
+        if (posDiff.magnitude() < xec_finalRadius)
+        {
+            float dur =
+                ((1.f - (posDiff.magnitude() / xec_finalRadius)) * (xfc_ - xf8_interferenceDur)) + xf8_interferenceDur;
+            float mag = ((1.f - (posDiff.magnitude() / xec_finalRadius)) * (x104_ - xf8_interferenceDur)) +
+                        x100_interferenceMag;
+
+            if (dur > pl->GetStaticTimer())
+                pl->SetHudDisable(dur, 0.5f, 2.5f);
+            else
+                mgr.GetPlayerState()->GetStaticInterference().AddSource(GetUniqueId(), mag, dur);
+        }
+    }
+}
+
+zeus::CAABox CScriptEMPulse::CalculateBoundingBox() const
+{
+    return zeus::CAABox(GetTranslation() - xf0_currentRadius, GetTranslation() + xf0_currentRadius);
+}
+
+}
--- a/Runtime/World/CScriptEMPulse.hpp
+++ b/Runtime/World/CScriptEMPulse.hpp
@@ -0,0 +1,36 @@
+#ifndef __URDE_CSCRIPTEMPULSE_HPP__
+#define __URDE_CSCRIPTEMPULSE_HPP__
+
+#include "CActor.hpp"
+
+namespace urde
+{
+class CGenDescription;
+class CElementGen;
+class CScriptEMPulse : public CActor
+{
+    float xe8_duration;
+    float xec_finalRadius;
+    float xf0_currentRadius;
+    float xf4_initialRadius;
+    float xf8_interferenceDur;
+    float xfc_;
+    float x100_interferenceMag;
+    float x104_;
+    TCachedToken<CGenDescription> x108_particleDesc;
+    std::unique_ptr<CElementGen> x114_particleGen;
+    zeus::CAABox CalculateBoundingBox() const;
+public:
+    CScriptEMPulse(TUniqueId, std::string_view, const CEntityInfo&, const zeus::CTransform&, bool, float, float, float,
+        float, float, float, float, CAssetId);
+
+    void Accept(IVisitor&);
+    void Think(float, CStateManager&);
+    void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&);
+    void AddToRenderer(const zeus::CFrustum&, CStateManager&) const;
+    void CalculateRenderBounds();
+    std::experimental::optional<zeus::CAABox> GetTouchBounds() const;
+    void Touch(CActor&, CStateManager&);
+};
+}
+#endif // __URDE_CSCRIPTEMPULSE_HPP__
--- a/Runtime/World/CScriptEffect.cpp
+++ b/Runtime/World/CScriptEffect.cpp
@@ -407,6 +407,13 @@ zeus::CAABox CScriptEffect::GetSortingBounds(const CStateManager& mgr) const

 bool CScriptEffect::AreBothSystemsDeleteable()
 {
-    return x104_particleSystem->IsSystemDeletable() && xf4_electric->IsSystemDeletable();
+    bool ret = true;
+    if (x104_particleSystem && !x104_particleSystem->IsSystemDeletable())
+        ret = false;
+
+    if (xf4_electric && !xf4_electric->IsSystemDeletable())
+        ret = false;
+
+    return ret;
 }
 }
--- a/Runtime/World/CScriptPickup.hpp
+++ b/Runtime/World/CScriptPickup.hpp
@@ -31,6 +31,10 @@ public:
    void Accept(IVisitor& visitor);
    void Think(float, CStateManager&);
    void Touch(CActor &, CStateManager &);
+    std::experimental::optional<zeus::CAABox> GetTouchBounds() const
+    {
+        return CPhysicsActor::GetBoundingBox();
+    }
    float GetPossibility() const { return x264_possibility; }
    CPlayerState::EItemType GetItem() { return x258_itemType; }
 };
--- a/Runtime/World/CScriptSpawnPoint.cpp
+++ b/Runtime/World/CScriptSpawnPoint.cpp
@@ -14,12 +14,13 @@ CScriptSpawnPoint::CScriptSpawnPoint(TUniqueId uid, std::string_view name, const
 : CEntity(uid, info, active, name), x34_xf(xf), x64_itemCounts(itemCounts)
 {
 #ifndef NDEBUG
+    x64_itemCounts[int(CPlayerState::EItemType::GravitySuit)] = 1;
    x64_itemCounts[int(CPlayerState::EItemType::ThermalVisor)] = 1;
    x64_itemCounts[int(CPlayerState::EItemType::XRayVisor)] = 1;
    x64_itemCounts[int(CPlayerState::EItemType::GrappleBeam)] = 1;
    x64_itemCounts[int(CPlayerState::EItemType::BoostBall)] = 1;
    x64_itemCounts[int(CPlayerState::EItemType::ChargeBeam)] = 1;
-    x64_itemCounts[int(CPlayerState::EItemType::PowerBombs)] = 1;
+    x64_itemCounts[int(CPlayerState::EItemType::PowerBombs)] = 8;
 #endif
    x10c_24_firstSpawn = defaultSpawn;
    x10c_25_morphed = morphed;
--- a/Runtime/World/CScriptSpindleCamera.cpp
+++ b/Runtime/World/CScriptSpindleCamera.cpp
@@ -1,6 +1,8 @@
 #include "CScriptSpindleCamera.hpp"
 #include "Camera/CCameraManager.hpp"
+#include "CStateManager.hpp"
 #include "ScriptLoader.hpp"
+#include "Camera/CBallCamera.hpp"
 #include "TCastTo.hpp"

 namespace urde
@@ -43,7 +45,16 @@ void CScriptSpindleCamera::ProcessInput(const CFinalInput& input, CStateManager&

 void CScriptSpindleCamera::Reset(const zeus::CTransform& xf, CStateManager& mgr)
 {
+    const CScriptCameraHint* hint = mgr.GetCameraManager()->GetCameraHint(mgr);
+    if (!GetActive() || hint == nullptr)
+        return;

+    x33c_24_ = true;
+    mgr.GetCameraManager()->GetBallCamera()->UpdateLookAtPosition(0.01f, mgr);
+}
+
+void CScriptSpindleCamera::Think(float, CStateManager&)
+{
 }

 }
--- a/Runtime/World/CScriptSpindleCamera.hpp
+++ b/Runtime/World/CScriptSpindleCamera.hpp
@@ -49,6 +49,7 @@ class CScriptSpindleCamera : public CGameCamera
    float x328_ = 0.f;
    bool x32c_24 = false;
    zeus::CVector3f x330_lookDir;
+    bool x33c_24_;
 public:
    CScriptSpindleCamera(TUniqueId uid, std::string_view name, const CEntityInfo& info,
                         const zeus::CTransform& xf, bool active, u32 r9,
@@ -62,8 +63,9 @@ public:
                         const SSpindleProperty& seg14, const SSpindleProperty& seg15);

    void Accept(IVisitor& visitor);
-    void ProcessInput(const CFinalInput& input, CStateManager& mgr);
+    void Think(float, CStateManager&);
    void Reset(const zeus::CTransform& xf, CStateManager& mgr);
+    void ProcessInput(const CFinalInput& input, CStateManager& mgr);
 };

 }
--- a/Runtime/World/CScriptWorldTeleporter.cpp
+++ b/Runtime/World/CScriptWorldTeleporter.cpp
@@ -95,8 +95,9 @@ void CScriptWorldTeleporter::AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId
            const auto& world = mgr.WorldNC();
            world->SetLoadPauseState(true);
            CAssetId currentWorld = g_GameState->CurrentWorldAssetId();
+            g_GameState->SetCurrentWorldId(x34_worldId);

-            if (g_ResFactory->GetResourceTypeById(currentWorld) == SBIG('MLVL'))
+            if (g_ResFactory->GetResourceTypeById(x34_worldId) == SBIG('MLVL'))
            {
                StartTransition(mgr);
                g_GameState->SetCurrentWorldId(x34_worldId);
--- a/Runtime/World/CWorldTransManager.cpp
+++ b/Runtime/World/CWorldTransManager.cpp
@@ -155,7 +155,7 @@ void CWorldTransManager::UpdateText(float dt)
        if (printed >= nextSfxInterval)
        {
            x3c_sfxInterval = nextSfxInterval;
-            //CSfxManager::SfxStart(SFXsfx059E, 1.f, 0.f, false, 0x7f, false, kInvalidAreaId);
+            CSfxManager::SfxStart(SFXsfx059E, 1.f, 0.f, false, 0x7f, false, kInvalidAreaId);
        }
    }

@@ -424,6 +424,7 @@ void CWorldTransManager::EnableTransition(const CAnimRes& samusRes,
    else
        x1c_bgHeight = 0.f;

+    StartTransition();
    TouchModels();
 }

@@ -446,6 +447,7 @@ void CWorldTransManager::EnableTransition(CAssetId fontId, CAssetId stringId, u3
    x8_textData->SetTypeWriteEffectOptions(true, chFadeTime, chFadeRate);
    xc_strTable = g_SimplePool->GetObj(SObjectTag{FOURCC('STRG'), stringId});
    x8_textData->SetText(u"");
+    StartTransition();
 }

 void CWorldTransManager::StartTextFadeOut()
--- a/Runtime/World/ScriptLoader.cpp
+++ b/Runtime/World/ScriptLoader.cpp
@@ -12,14 +12,18 @@
 #include "CScriptAiJumpPoint.hpp"
 #include "CScriptAreaAttributes.hpp"
 #include "MP1/World/CSeedling.hpp"
+#include "MP1/World/CBurrower.hpp"
 #include "CScriptBeam.hpp"
 #include "CScriptCameraBlurKeyframe.hpp"
 #include "CScriptCameraFilterKeyframe.hpp"
 #include "CScriptCameraHint.hpp"
 #include "CScriptCameraHintTrigger.hpp"
 #include "CAmbientAI.hpp"
+#include "MP1/World/CPuffer.hpp"
+#include "MP1/World/CTryclops.hpp"
 #include "MP1/World/CRidley.hpp"
 #include "CScriptCameraPitchVolume.hpp"
+#include "MP1/World/CMagdolite.hpp"
 #include "CTeamAiMgr.hpp"
 #include "CSnakeWeedSwarm.hpp"
 #include "CScriptCameraShaker.hpp"
@@ -27,11 +31,15 @@
 #include "CScriptColorModulate.hpp"
 #include "CScriptControllerAction.hpp"
 #include "CScriptCounter.hpp"
+#include "MP1/World/CElitePirate.hpp"
 #include "CScriptCoverPoint.hpp"
+#include "CScriptSpiderBallWaypoint.hpp"
 #include "CScriptDamageableTrigger.hpp"
 #include "CScriptDebris.hpp"
 #include "CScriptDistanceFog.hpp"
 #include "CScriptDock.hpp"
+#include "MP1/World/CFireFlea.hpp"
+#include "MP1/World/CMetaree.hpp"
 #include "CScriptDockAreaChange.hpp"
 #include "CScriptDoor.hpp"
 #include "CScriptEffect.hpp"
@@ -44,6 +52,7 @@
 #include "CScriptPickup.hpp"
 #include "CScriptPickupGenerator.hpp"
 #include "CScriptPlatform.hpp"
+#include "CScriptEMPulse.hpp"
 #include "CScriptPlayerActor.hpp"
 #include "CFishCloud.hpp"
 #include "CFishCloudModifier.hpp"
@@ -57,6 +66,8 @@
 #include "CScriptSound.hpp"
 #include "CScriptSpawnPoint.hpp"
 #include "CScriptSpecialFunction.hpp"
+#include "MP1/World/CBabygoth.hpp"
+#include "MP1/World/CEyeball.hpp"
 #include "CScriptSteam.hpp"
 #include "CScriptRipple.hpp"
 #include "CScriptBallTrigger.hpp"
@@ -72,6 +83,7 @@
 #include "CScriptWorldTeleporter.hpp"
 #include "CScriptSpiderBallAttractionSurface.hpp"
 #include "CScriptSpindleCamera.hpp"
+#include "MP1/World/CAtomicAlpha.hpp"
 #include "CSimplePool.hpp"
 #include "CStateManager.hpp"
 #include "CWallCrawlerSwarm.hpp"
@@ -88,12 +100,15 @@
 #include "MP1/World/CWarWasp.hpp"
 #include "MP1/World/CParasite.hpp"
 #include "Particle/CWeaponDescription.hpp"
+#include "MP1/World/CBloodFlower.hpp"
+#include "MP1/World/CFlickerBat.hpp"
 #include "Camera/CPathCamera.hpp"
 namespace urde
 {
 static logvisor::Module Log("urde::ScriptLoader");

 static SObjectTag MorphballDoorANCS = {};
+
 static const SObjectTag& GetMorphballDoorACS()
 {
    if (!MorphballDoorANCS)
@@ -124,6 +139,7 @@ struct SActorHead
 struct SScaledActorHead : SActorHead
 {
    zeus::CVector3f x40_scale;
+
    SScaledActorHead(SActorHead&& head) : SActorHead(std::move(head)) {}
 };

@@ -245,11 +261,11 @@ CActorParameters ScriptLoader::LoadActorParameters(CInputStream& in)
        if (propCount > 13)
            thermalMag = in.readFloatBig();

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

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

@@ -374,8 +390,8 @@ zeus::CTransform ScriptLoader::ConvertEditorEulerToTransform4f(const zeus::CVect
                                                               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)) +
+           zeus::CTransform::RotateY(zeus::degToRad(orientation.y)) *
+           zeus::CTransform::RotateX(zeus::degToRad(orientation.x)) +
           position;
 }

@@ -505,8 +521,7 @@ CEntity* ScriptLoader::LoadDoor(CStateManager& mgr, CInputStream& in, int propCo
    {
        if (aParms.GetACSFile() == GetMorphballDoorACS().id)
            isMorphballDoor = true;
-    }
-    else if (propCount == 14)
+    } else if (propCount == 14)
        isMorphballDoor = in.readBool();

    return new CScriptDoor(mgr.AllocateUniqueId(), head.x0_name, info, head.x10_transform, std::move(mData), actParms,
@@ -528,7 +543,8 @@ CEntity* ScriptLoader::LoadTrigger(CStateManager& mgr, CInputStream& in, int pro

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

-    ETriggerFlags flags = ETriggerFlags(in.readUint32Big());
+    ETriggerFlags
+    flags = ETriggerFlags(in.readUint32Big());
    bool active = in.readBool();
    bool b2 = in.readBool();
    bool b3 = in.readBool();
@@ -656,7 +672,7 @@ CEntity* ScriptLoader::LoadPlatform(CStateManager& mgr, CInputStream& in, int pr
    zeus::CAABox aabb = GetCollisionBox(mgr, info.GetAreaId(), extent, centroid);

    FourCC dclnType = g_ResFactory->GetResourceTypeById(dclnId);
-    std::experimental::optional<TLockedToken<CCollidableOBBTreeGroupContainer>> dclnToken;
+    std::experimental::optional <TLockedToken<CCollidableOBBTreeGroupContainer>> dclnToken;
    if (dclnType)
    {
        dclnToken.emplace(g_SimplePool->GetObj({SBIG('DCLN'), dclnId}));
@@ -756,22 +772,23 @@ CEntity* ScriptLoader::LoadCamera(CStateManager& mgr, CInputStream& in, int prop

    bool active = in.readBool();
    float shotDuration = in.readFloatBig();
-    bool b2 = in.readBool();
-    bool b3 = in.readBool();
-    bool b4 = in.readBool();
-    bool b5 = in.readBool();
-    bool b6 = in.readBool();
+    bool lookAtPlayer = in.readBool();
+    bool outOfPlayerEye = in.readBool();
+    bool intoPlayerEye = in.readBool();
+    bool drawPlayer = in.readBool();
    bool disableInput = in.readBool();
-    bool b8 = in.readBool();
+    bool b7 = in.readBool();
+    bool finishCineSkip = in.readBool();
    float fov = in.readFloatBig();
-    bool b9 = in.readBool();
+    bool checkFailsafe = in.readBool();

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

-    u32 flags = u32(b2) | u32(b3) << 1 | u32(b4) << 2 | u32(b5) << 3 | u32(b6) << 4 | u32(disableInput) << 5 |
-                u32(b8) << 6 | u32(b9) << 8;
+    s32 flags = s32(lookAtPlayer) | s32(outOfPlayerEye) << 1 | s32(intoPlayerEye) << 2 | s32(b7) << 3 |
+                s32(finishCineSkip) << 4 | s32(disableInput) << 5 | s32(drawPlayer) << 6 |
+                s32(checkFailsafe) << 7 | s32(disableOutOfInto) << 9;

    return new CCinematicCamera(mgr.AllocateUniqueId(), head.x0_name, info, head.x10_transform, active, shotDuration,
                                fov / CCameraManager::Aspect(), CCameraManager::NearPlane(), CCameraManager::FarPlane(),
@@ -1019,7 +1036,7 @@ CEntity* ScriptLoader::LoadBeetle(CStateManager& mgr, CInputStream& in, int prop
    if (animType != SBIG('ANCS'))
        return nullptr;

-    std::experimental::optional<CStaticRes> abdomenRes;
+    std::experimental::optional <CStaticRes> abdomenRes;
    if (flavor == CPatterned::EFlavorType::One)
        abdomenRes.emplace(CStaticRes(abdomen, scale));

@@ -1220,11 +1237,12 @@ CEntity* ScriptLoader::LoadWater(CStateManager& mgr, CInputStream& in, int propC
    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;
+    ETriggerFlags
+    triggerFlags = ETriggerFlags(in.readUint32Big()) | ETriggerFlags::DetectProjectiles1 |
+                   ETriggerFlags::DetectProjectiles2 | ETriggerFlags::DetectProjectiles3 |
+                   ETriggerFlags::DetectProjectiles4 | ETriggerFlags::DetectBombs |
+                   ETriggerFlags::DetectPowerBombs | ETriggerFlags::DetectProjectiles5 |
+                   ETriggerFlags::DetectProjectiles6 | ETriggerFlags::DetectProjectiles7;
    bool thermalCold = in.readBool();
    bool displaySurface = in.readBool();
    CAssetId patternMap1 = in.readUint32Big();
@@ -1291,7 +1309,7 @@ CEntity* ScriptLoader::LoadWater(CStateManager& mgr, CInputStream& in, int propC
    u32 w22 = in.readUint32Big();
    bool b5 = in.readBool();

-    std::unique_ptr<u32[]> bitset;
+    std::unique_ptr < u32[] > bitset;
    u32 bitVal0 = 0;
    u32 bitVal1 = 0;

@@ -1318,7 +1336,8 @@ CEntity* ScriptLoader::LoadWater(CStateManager& mgr, CInputStream& in, int propC
                            thermalCold, displaySurface, patternMap1, patternMap2, colorMap, bumpMap, envMap,
                            envBumpMap, {}, bumpLightDir, bumpScale, morphInTime, morphOutTime, active, fluidType, b4,
                            alpha, uvMotion, turbSpeed, turbDistance, turbFreqMax, turbFreqMin, turbPhaseMax,
-                            turbPhaseMin, turbAmplitudeMax, turbAmplitudeMin, splashColor, insideFogColor, splashParticle1,
+                            turbPhaseMin, turbAmplitudeMax, turbAmplitudeMin, splashColor, insideFogColor,
+                            splashParticle1,
                            splashParticle2, splashParticle3, visorRunoffParticle, unmorphVisorRunoffParticle,
                            visorRunoffSfx, unmorphVisorRunoffSfx, splashSfx1, splashSfx2, splashSfx3, tileSize,
                            tileSubdivisions, specularMin, specularMax, reflectionSize, rippleIntensity,
@@ -1399,7 +1418,28 @@ CEntity* ScriptLoader::LoadFlyingPirate(CStateManager& mgr, CInputStream& in, in

 CEntity* ScriptLoader::LoadElitePirate(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
 {
-    return nullptr;
+    if (!EnsurePropertyCount(propCount, 41, "ElitePirate"))
+        return nullptr;
+
+    SScaledActorHead actHead = LoadScaledActorHead(in, mgr);
+    auto pair = CPatternedInfo::HasCorrectParameterCount(in);
+    if (!pair.first)
+        return nullptr;
+
+    CPatternedInfo pInfo(in, pair.second);
+    CActorParameters actParms = LoadActorParameters(in);
+    MP1::CElitePirateData elitePirateData(in, propCount);
+
+    if (!pInfo.GetAnimationParameters().GetACSFile().IsValid())
+        return nullptr;
+
+    CModelData mData(
+        CAnimRes(pInfo.GetAnimationParameters().GetACSFile(), pInfo.GetAnimationParameters().GetCharacter(),
+                 actHead.x40_scale, pInfo.GetAnimationParameters().GetInitialAnimation(), true));
+
+
+    return new MP1::CElitePirate(mgr.AllocateUniqueId(), actHead.x0_name, info, actHead.x10_transform, std::move(mData),
+                                 pInfo, actParms, elitePirateData);
 }

 CEntity* ScriptLoader::LoadMetroidBeta(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
@@ -1432,17 +1472,82 @@ CEntity* ScriptLoader::LoadCoverPoint(CStateManager& mgr, CInputStream& in, int
 CEntity* ScriptLoader::LoadSpiderBallWaypoint(CStateManager& mgr, CInputStream& in, int propCount,
                                              const CEntityInfo& info)
 {
-    return nullptr;
+    if (!EnsurePropertyCount(propCount, 5, "SpiderBallWaypoint"))
+        return nullptr;
+
+    SActorHead actHead = LoadActorHead(in, mgr);
+    bool active = in.readBool();
+    u32 w1 = in.readUint32Big();
+
+    return new CScriptSpiderBallWaypoint(mgr.AllocateUniqueId(), actHead.x0_name, info, actHead.x10_transform, active,
+                                         w1);
 }

 CEntity* ScriptLoader::LoadBloodFlower(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
 {
-    return nullptr;
+    if (!EnsurePropertyCount(propCount, 18, "BloodFlower"))
+        return nullptr;
+
+    SScaledActorHead actHead = LoadScaledActorHead(in, mgr);
+    auto pair = CPatternedInfo::HasCorrectParameterCount(in);
+    if (!pair.first)
+        return nullptr;
+
+    CPatternedInfo pInfo(in, pair.second);
+    CActorParameters actParms = LoadActorParameters(in);
+    CAssetId partId1(in);
+    CAssetId wpsc1(in);
+    CAssetId wpsc2(in);
+    CDamageInfo dInfo1(in);
+    CDamageInfo dInfo2(in);
+    CDamageInfo dInfo3(in);
+    CAssetId partId2(in);
+    CAssetId partId3(in);
+    CAssetId partId4(in);
+    float f1 = in.readFloatBig();
+    CAssetId partId5(in);
+    u32 soundId = in.readUint32Big();
+
+    if (g_ResFactory->GetResourceTypeById(pInfo.GetAnimationParameters().GetACSFile()) != SBIG('ANCS'))
+        return nullptr;
+
+
+    CModelData mData(
+        CAnimRes(pInfo.GetAnimationParameters().GetACSFile(), pInfo.GetAnimationParameters().GetCharacter(),
+                 actHead.x40_scale, pInfo.GetAnimationParameters().GetInitialAnimation(), true));
+
+    return new MP1::CBloodFlower(mgr.AllocateUniqueId(), actHead.x0_name, info, actHead.x10_transform, std::move(mData),
+                                 pInfo, partId1, wpsc1, actParms, wpsc2, dInfo1, dInfo2, dInfo3, partId2, partId3,
+                                 partId4, f1, partId5, soundId);
 }

 CEntity* ScriptLoader::LoadFlickerBat(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
 {
-    return nullptr;
+    if (!EnsurePropertyCount(propCount, 10, "FlickerBat"))
+        return nullptr;
+
+    std::string name = mgr.HashInstanceName(in);
+    CPatterned::EFlavorType flavor = CPatterned::EFlavorType(in.readUint32Big());
+    zeus::CTransform xf = LoadEditorTransform(in);
+    zeus::CVector3f scale = zeus::CVector3f::ReadBig(in);
+    auto pair = CPatternedInfo::HasCorrectParameterCount(in);
+    if (!pair.first)
+        return nullptr;
+
+    CPatternedInfo pInfo(in, pair.second);
+    CActorParameters actParms = LoadActorParameters(in);
+    bool b1 = in.readBool();
+    bool b2 = in.readBool();
+    bool b3 = in.readBool();
+
+    if (g_ResFactory->GetResourceTypeById(pInfo.GetAnimationParameters().GetACSFile()) != SBIG('ANCS'))
+        return nullptr;
+
+    CModelData mData(
+        CAnimRes(pInfo.GetAnimationParameters().GetACSFile(), pInfo.GetAnimationParameters().GetCharacter(),
+                 scale, pInfo.GetAnimationParameters().GetInitialAnimation(), true));
+    return new MP1::CFlickerBat(mgr.AllocateUniqueId(), name, flavor, info, xf, std::move(mData), pInfo,
+                                CPatterned::EColliderType(b1), b2, actParms, b3);
 }

 CEntity* ScriptLoader::LoadPathCamera(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
@@ -1543,12 +1648,63 @@ CEntity* ScriptLoader::LoadDistanceFog(CStateManager& mgr, CInputStream& in, int

 CEntity* ScriptLoader::LoadFireFlea(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
 {
-    return nullptr;
+    if (!EnsurePropertyCount(propCount, 9, "FireFlea"))
+        return nullptr;
+
+    SScaledActorHead acthead = LoadScaledActorHead(in, mgr);
+    auto pair = CPatternedInfo::HasCorrectParameterCount(in);
+    if (!pair.first)
+        return nullptr;
+
+    CPatternedInfo pInfo(in, pair.second);
+    CActorParameters actParms = LoadActorParameters(in);
+    in.readBool();
+    in.readBool();
+    float f1 = in.readFloatBig();
+
+    if (!pInfo.GetAnimationParameters().GetACSFile().IsValid())
+        return nullptr;
+
+    CModelData mData(
+        CAnimRes(pInfo.GetAnimationParameters().GetACSFile(), pInfo.GetAnimationParameters().GetCharacter(),
+                 acthead.x40_scale, pInfo.GetAnimationParameters().GetInitialAnimation(), true));
+
+    return new MP1::CFireFlea(mgr.AllocateUniqueId(), acthead.x0_name, info, acthead.x10_transform, std::move(mData),
+                              actParms, pInfo, f1);
 }

-CEntity* ScriptLoader::LoadMetareeAlpha(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
+CEntity* ScriptLoader::LoadMetaree(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
 {
-    return nullptr;
+    if (!EnsurePropertyCount(propCount, 12, "Metaree"))
+        return nullptr;
+
+    std::string name = mgr.HashInstanceName(in);
+    zeus::CTransform xf = LoadEditorTransform(in);
+    zeus::CVector3f scale = zeus::CVector3f::ReadBig(in);
+
+    auto pair = CPatternedInfo::HasCorrectParameterCount(in);
+    if (!pair.first)
+        return nullptr;
+
+    CPatternedInfo pInfo(in, pair.second);
+    CActorParameters aParms = LoadActorParameters(in);
+    CDamageInfo dInfo(in);
+    float f1 = in.readFloatBig();
+    zeus::CVector3f vec = zeus::CVector3f::ReadBig(in);
+    float f2 = in.readFloatBig();
+    float f3 = in.readFloatBig();
+
+    if (g_ResFactory->GetResourceTypeById(pInfo.GetAnimationParameters().GetACSFile()) != SBIG('ANCS'))
+        return nullptr;
+
+    float f4 = in.readFloatBig();
+
+    CModelData mData(
+        CAnimRes(pInfo.GetAnimationParameters().GetACSFile(), pInfo.GetAnimationParameters().GetCharacter(),
+                 scale, pInfo.GetAnimationParameters().GetInitialAnimation(), true));
+    return new MP1::CMetaree(mgr.AllocateUniqueId(), name, CPatterned::EFlavorType::Zero, info, xf, std::move(mData),
+                             pInfo,
+                             dInfo, f1, vec, f2, EBodyType::Invalid, f3, f4, aParms);
 }

 CEntity* ScriptLoader::LoadDockAreaChange(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
@@ -1798,7 +1954,8 @@ CEntity* ScriptLoader::LoadSteam(CStateManager& mgr, CInputStream& in, int propC

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

-    ETriggerFlags w1 = ETriggerFlags(in.readUint32Big());
+    ETriggerFlags
+    w1 = ETriggerFlags(in.readUint32Big());
    bool b1 = in.readBool();
    u32 w2 = in.readUint32Big();
    float f1 = in.readFloatBig();
@@ -1854,7 +2011,22 @@ CEntity* ScriptLoader::LoadTargetingPoint(CStateManager& mgr, CInputStream& in,

 CEntity* ScriptLoader::LoadEMPulse(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
 {
-    return nullptr;
+    if (!EnsurePropertyCount(propCount, 12, "EMPulse"))
+        return nullptr;
+
+    SActorHead actorHead = LoadActorHead(in, mgr);
+    bool active = in.readBool();
+    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();
+    CAssetId particleId(in);
+
+    return new CScriptEMPulse(mgr.AllocateUniqueId(), actorHead.x0_name, info, actorHead.x10_transform, active, f1, f2,
+                              f3, f4, f5, f6, f7, particleId);
 }

 CEntity* ScriptLoader::LoadIceSheegoth(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
@@ -2013,7 +2185,7 @@ CEntity* ScriptLoader::LoadVisorFlare(CStateManager& mgr, CInputStream& in, int
    float f2 = in.readFloatBig();
    float f3 = in.readFloatBig();
    u32 w2 = in.readUint32Big();
-    std::vector<CVisorFlare::CFlareDef> flares;
+    std::vector <CVisorFlare::CFlareDef> flares;
    flares.reserve(5);
    for (int i = 0; i < 5; ++i)
        if (auto flare = CVisorFlare::LoadFlareDef(in))
@@ -2088,11 +2260,10 @@ CEntity* ScriptLoader::LoadVisorGoo(CStateManager& mgr, CInputStream& in, int pr
    s32 sfx = in.readInt32Big();
    bool forceShow = in.readBool();

-    if (particle.IsValid() || electric.IsValid())
-        return new CScriptVisorGoo(mgr.AllocateUniqueId(), name, info, xf, particle, electric, minDist, maxDist,
-                                   nearProb, farProb, color, sfx, forceShow, false);
-
-    return nullptr;
+    if (!particle.IsValid() && !electric.IsValid())
+        return nullptr;
+    return new CScriptVisorGoo(mgr.AllocateUniqueId(), name, info, xf, particle, electric, minDist, maxDist,
+                               nearProb, farProb, color, sfx, forceShow, false);
 }

 CEntity* ScriptLoader::LoadJellyZap(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
@@ -2399,12 +2570,69 @@ CEntity* ScriptLoader::LoadFogVolume(CStateManager& mgr, CInputStream& in, int p

 CEntity* ScriptLoader::LoadBabygoth(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
 {
-    return nullptr;
+    if (!EnsurePropertyCount(propCount, 33, "Babygoth"))
+        return nullptr;
+
+    SScaledActorHead actHead = LoadScaledActorHead(in, mgr);
+    auto pair = CPatternedInfo::HasCorrectParameterCount(in);
+    if (!pair.first)
+        return nullptr;
+
+    CPatternedInfo pInfo(in, pair.second);
+    CActorParameters actParms = LoadActorParameters(in);
+    MP1::CBabygothData babyData(in);
+
+    if (!pInfo.GetAnimationParameters().GetACSFile().IsValid())
+        return nullptr;
+
+    CModelData mData(CAnimRes(pInfo.GetAnimationParameters().GetACSFile(),
+                              pInfo.GetAnimationParameters().GetCharacter(), actHead.x40_scale,
+                              pInfo.GetAnimationParameters().GetInitialAnimation(), true));
+    return new MP1::CBabygoth(mgr.AllocateUniqueId(), actHead.x0_name, info, actHead.x10_transform, std::move(mData),
+                              pInfo, actParms, babyData);
 }

 CEntity* ScriptLoader::LoadEyeball(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
 {
-    return nullptr;
+    if (!EnsurePropertyCount(propCount, 21, "Eyeball"))
+        return nullptr;
+
+    std::string name = mgr.HashInstanceName(in);
+    CPatterned::EFlavorType flavor = CPatterned::EFlavorType(in.readUint32Big());
+    zeus::CTransform xf = LoadEditorTransform(in);
+    zeus::CVector3f scale = zeus::CVector3f::ReadBig(in);
+
+    auto pair = CPatternedInfo::HasCorrectParameterCount(in);
+    if (!pair.first)
+        return nullptr;
+
+    CPatternedInfo pInfo(in, pair.second);
+    CActorParameters actParms = LoadActorParameters(in);
+    float f1 = in.readFloatBig();
+    float f2 = in.readFloatBig();
+    CAssetId wpsc(in);
+    CDamageInfo dInfo(in);
+    CAssetId partId1(in);
+    CAssetId partId2(in);
+    CAssetId texture1(in);
+    CAssetId texture2(in);
+    u32 w1 = in.readUint32Big();
+    u32 w2 = in.readUint32Big();
+    u32 w3 = in.readUint32Big();
+    u32 w4 = in.readUint32Big();
+    u32 w5 = in.readUint32Big();
+
+    if (g_ResFactory->GetResourceTypeById(pInfo.GetAnimationParameters().GetACSFile()) != SBIG('ANCS'))
+        return nullptr;
+
+    bool b1 = in.readBool();
+
+    CModelData mData(CAnimRes(pInfo.GetAnimationParameters().GetACSFile(),
+                              pInfo.GetAnimationParameters().GetCharacter(), scale,
+                              pInfo.GetAnimationParameters().GetInitialAnimation(), true));
+
+    return new MP1::CEyeball(mgr.AllocateUniqueId(), name, flavor, info, xf, std::move(mData), pInfo, f1, f2, wpsc,
+                             dInfo, partId1, partId2, texture1, texture2, w1, w2, w3, w4, w5, actParms, b1);
 }

 CEntity* ScriptLoader::LoadRadialDamage(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
@@ -2419,9 +2647,10 @@ CEntity* ScriptLoader::LoadRadialDamage(CStateManager& mgr, CInputStream& in, 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);
+    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,
@@ -2459,7 +2688,46 @@ CEntity* ScriptLoader::LoadEnvFxDensityController(CStateManager& mgr, CInputStre

 CEntity* ScriptLoader::LoadMagdolite(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
 {
-    return nullptr;
+    if (!EnsurePropertyCount(propCount, 22, "Magdolite"))
+        return nullptr;
+
+    SScaledActorHead actorHead = LoadScaledActorHead(in, mgr);
+
+    auto pair = CPatternedInfo::HasCorrectParameterCount(in);
+    if (!pair.first)
+        return nullptr;
+
+    CPatternedInfo pInfo(in, pair.second);
+    CActorParameters actorParameters = LoadActorParameters(in);
+
+    if (!pInfo.GetAnimationParameters().GetACSFile().IsValid())
+        return nullptr;
+
+    float f1 = in.readFloatBig();
+    float f2 = in.readFloatBig();
+    CDamageInfo damageInfo1(in);
+    CDamageInfo damageInfo2(in);
+    CDamageVulnerability damageVulnerability1(in);
+    CDamageVulnerability damageVulnerability2(in);
+    CAssetId modelId(in);
+    CAssetId skinId(in);
+    float f3 = in.readFloatBig();
+    float f4 = in.readFloatBig();
+    float f5 = in.readFloatBig();
+    float f6 = in.readFloatBig();
+    MP1::CMagdolite::CMagdoliteData magData(in);
+    float f7 = in.readFloatBig();
+    float f8 = in.readFloatBig();
+    float f9 = in.readFloatBig();
+
+    CModelData modelData(CAnimRes(pInfo.GetAnimationParameters().GetACSFile(),
+                                  pInfo.GetAnimationParameters().GetCharacter(), actorHead.x40_scale,
+                                  pInfo.GetAnimationParameters().GetInitialAnimation(), true));
+
+    return new MP1::CMagdolite(mgr.AllocateUniqueId(), actorHead.x0_name, info, actorHead.x10_transform,
+                               std::move(modelData), pInfo, actorParameters, f1, f2, damageInfo1, damageInfo2,
+                               damageVulnerability1,
+                               damageVulnerability2, modelId, skinId, f3, f4, f5, f6, magData, f7, f8, f9);
 }

 CEntity* ScriptLoader::LoadTeamAIMgr(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
@@ -2507,9 +2775,9 @@ CEntity* ScriptLoader::LoadSnakeWeedSwarm(CStateManager& mgr, CInputStream& in,
    u32 w9 = (propCount < 29 ? -1 : in.readUint32Big());
    u32 f16 = (propCount < 29 ? 0.f : in.readFloatBig());

-    return new CSnakeWeedSwarm(mgr.AllocateUniqueId(), active, name, info, pos, scale, animParms,
-                               actParms, f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13,
-                               f14, dInfo, f15, w4, w5, w6, w7, w8, w9, f16);
+    return new CSnakeWeedSwarm(mgr.AllocateUniqueId(), active, name, info, pos, scale, animParms, actParms, f1, f2, f3,
+                               f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, dInfo, f15, w4, w5, w6, w7, w8, w9,
+                               f16);
 }

 CEntity* ScriptLoader::LoadActorContraption(CStateManager& mgr, CInputStream& in, int propCount,
@@ -2581,11 +2849,13 @@ CEntity* ScriptLoader::LoadGeemer(CStateManager& mgr, CInputStream& in, int prop
    u16 sId2 = in.readUint32Big() & 0xFFFF;
    u16 sId3 = in.readUint32Big() & 0xFFFF;

-    CModelData mData(CAnimRes(pInfo.GetAnimationParameters().GetACSFile(), pInfo.GetAnimationParameters().GetCharacter(),
-                              actHead.x40_scale, pInfo.GetAnimationParameters().GetInitialAnimation(), true));
+    CModelData mData(
+        CAnimRes(pInfo.GetAnimationParameters().GetACSFile(), pInfo.GetAnimationParameters().GetCharacter(),
+                 actHead.x40_scale, pInfo.GetAnimationParameters().GetInitialAnimation(), true));

    return new MP1::CParasite(mgr.AllocateUniqueId(), actHead.x0_name, CPatterned::EFlavorType::Zero, info,
-                              actHead.x10_transform, std::move(mData), pInfo, EBodyType::WallWalker, 0.f, f1, f2, f3, f4, 0.2f, 0.4f, 0.f,
+                              actHead.x10_transform, std::move(mData), pInfo, EBodyType::WallWalker, 0.f, f1, f2, f3,
+                              f4, 0.2f, 0.4f, 0.f,
                              0.f, 0.f, 0.f, 0.f, 1.f, f7, 0.f, 0.f, f5, f6, false, 2,
                              CDamageVulnerability::NormalVulnerabilty(), CDamageInfo(), sId1, sId2, sId3, -1,
                              -1, 0.f, actParms);
@@ -2636,7 +2906,32 @@ CEntity* ScriptLoader::LoadSpindleCamera(CStateManager& mgr, CInputStream& in, i

 CEntity* ScriptLoader::LoadAtomicAlpha(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
 {
-    return nullptr;
+    if (!EnsurePropertyCount(propCount, 14, "AtomicAlpha"))
+        return nullptr;
+
+    SScaledActorHead actHead = LoadScaledActorHead(in, mgr);
+    auto pair = CPatternedInfo::HasCorrectParameterCount(in);
+    if (!pair.first)
+        return nullptr;
+
+    CPatternedInfo pInfo(in, pair.second);
+    CActorParameters actParms = LoadActorParameters(in);
+
+    CAssetId wpsc(in);
+    CAssetId model(in);
+    CDamageInfo dInfo(in);
+    float f1 = in.readFloatBig();
+    float f2 = in.readFloatBig();
+    float f3 = in.readFloatBig();
+    bool b1 = in.readBool();
+    bool b2 = in.readBool();
+
+    CModelData mData(
+        CAnimRes(pInfo.GetAnimationParameters().GetACSFile(), pInfo.GetAnimationParameters().GetCharacter(),
+                 actHead.x40_scale, pInfo.GetAnimationParameters().GetInitialAnimation(), true));
+
+    return new MP1::CAtomicAlpha(mgr.AllocateUniqueId(), actHead.x0_name, info, actHead.x10_transform, std::move(mData),
+                                 actParms, pInfo, wpsc, dInfo, f1, f2, f3, model, b1, b2);
 }

 CEntity* ScriptLoader::LoadCameraHintTrigger(CStateManager& mgr, CInputStream& in, int propCount,
@@ -2712,7 +3007,8 @@ CEntity* ScriptLoader::LoadAmbientAI(CStateManager& mgr, CInputStream& in, int p
        aabox = mData.GetBounds(head.x10_transform.getRotation());

    return new CAmbientAI(mgr.AllocateUniqueId(), head.x0_name, info, head.x10_transform, std::move(mData), aabox,
-                          matList, mass, hInfo, dVuln, actParms, alertRange, impactRange, alertAnim, impactAnim, active);
+                          matList, mass, hInfo, dVuln, actParms, alertRange, impactRange, alertAnim, impactAnim,
+                          active);
 }

 CEntity* ScriptLoader::LoadAtomicBeta(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
@@ -2727,12 +3023,66 @@ CEntity* ScriptLoader::LoadIceZoomer(CStateManager& mgr, CInputStream& in, int p

 CEntity* ScriptLoader::LoadPuffer(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
 {
-    return nullptr;
+    if (!EnsurePropertyCount(propCount, 16, "Puffer"))
+        return nullptr;
+
+    SScaledActorHead aHead = LoadScaledActorHead(in, mgr);
+    auto pair = CPatternedInfo::HasCorrectParameterCount(in);
+    if (!pair.first)
+        return nullptr;
+
+    CPatternedInfo pInfo(in, pair.second);
+    if (!pInfo.GetAnimationParameters().GetACSFile().IsValid())
+        return nullptr;
+
+    CActorParameters actorParameters = LoadActorParameters(in);
+    float hoverSpeed = in.readFloatBig();
+    CAssetId cloudEffect(in);
+    CDamageInfo cloudDamage(in);
+    CAssetId cloudSteam(in);
+    float f2 = in.readFloatBig();
+    bool b1 = in.readBool();
+    bool b2 = in.readBool();
+    bool b3 = in.readBool();
+    CDamageInfo explosionDamage(in);
+    s16 sfxId = in.readUint16Big();
+
+    CModelData mData(
+        CAnimRes(pInfo.GetAnimationParameters().GetACSFile(), pInfo.GetAnimationParameters().GetCharacter(),
+                 aHead.x40_scale, pInfo.GetAnimationParameters().GetInitialAnimation(), true));
+    return new MP1::CPuffer(mgr.AllocateUniqueId(), aHead.x0_name, info, aHead.x10_transform, std::move(mData),
+                            actorParameters, pInfo, hoverSpeed, cloudEffect, cloudDamage, cloudSteam, f2, b1, b2, b3,
+                            explosionDamage, sfxId);
 }

 CEntity* ScriptLoader::LoadTryclops(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
 {
-    return nullptr;
+    if (!EnsurePropertyCount(propCount, 10, "Tryclops"))
+        return nullptr;
+
+    SScaledActorHead actorHead = LoadScaledActorHead(in, mgr);
+    auto pair = CPatternedInfo::HasCorrectParameterCount(in);
+
+    if (!pair.first)
+        return nullptr;
+
+    CPatternedInfo pInfo(in, pair.second);
+
+    if (!pInfo.GetAnimationParameters().GetACSFile().IsValid())
+        return nullptr;
+
+    CActorParameters actorParameters = LoadActorParameters(in);
+    float f1 = in.readFloatBig();
+    float f2 = in.readFloatBig();
+    float f3 = in.readFloatBig();
+    float f4 = in.readFloatBig();
+
+    CModelData mData(CAnimRes(pInfo.GetAnimationParameters().GetACSFile(),
+                              pInfo.GetAnimationParameters().GetCharacter(), actorHead.x40_scale,
+                              pInfo.GetAnimationParameters().GetInitialAnimation(), true));
+
+    return new MP1::CTryclops(mgr.AllocateUniqueId(), actorHead.x0_name, info, actorHead.x10_transform,
+                              std::move(mData), pInfo, actorParameters, f1, f2, f3, f4);
 }

 CEntity* ScriptLoader::LoadRidley(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
@@ -2750,8 +3100,11 @@ CEntity* ScriptLoader::LoadRidley(CStateManager& mgr, CInputStream& in, int prop
    if (!pInfo.GetAnimationParameters().GetACSFile().IsValid())
        return nullptr;

-    CModelData mData(CAnimRes(pInfo.GetAnimationParameters().GetACSFile(), pInfo.GetAnimationParameters().GetCharacter(), aHead.x40_scale, pInfo.GetAnimationParameters().GetInitialAnimation(), true));
-    return new MP1::CRidley(mgr.AllocateUniqueId(), aHead.x0_name, info, aHead.x10_transform, std::move(mData), pInfo, actParms, in, propCount);
+    CModelData mData(
+        CAnimRes(pInfo.GetAnimationParameters().GetACSFile(), pInfo.GetAnimationParameters().GetCharacter(),
+                 aHead.x40_scale, pInfo.GetAnimationParameters().GetInitialAnimation(), true));
+    return new MP1::CRidley(mgr.AllocateUniqueId(), aHead.x0_name, info, aHead.x10_transform, std::move(mData), pInfo,
+                            actParms, in, propCount);
 }

 CEntity* ScriptLoader::LoadSeedling(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
@@ -2779,8 +3132,11 @@ CEntity* ScriptLoader::LoadSeedling(CStateManager& mgr, CInputStream& in, int pr
    float f3 = in.readFloatBig();
    float f4 = in.readFloatBig();

-    CModelData mData(CAnimRes(pInfo.GetAnimationParameters().GetACSFile(), pInfo.GetAnimationParameters().GetCharacter(), aHead.x40_scale, pInfo.GetAnimationParameters().GetInitialAnimation(), true));
-    return new MP1::CSeedling(mgr.AllocateUniqueId(), aHead.x0_name, info, aHead.x10_transform, std::move(mData), pInfo, actParms, needleId, weaponId, dInfo1, dInfo2, f1, f2, f3, f4);
+    CModelData mData(
+        CAnimRes(pInfo.GetAnimationParameters().GetACSFile(), pInfo.GetAnimationParameters().GetCharacter(),
+                 aHead.x40_scale, pInfo.GetAnimationParameters().GetInitialAnimation(), true));
+    return new MP1::CSeedling(mgr.AllocateUniqueId(), aHead.x0_name, info, aHead.x10_transform, std::move(mData), pInfo,
+                              actParms, needleId, weaponId, dInfo1, dInfo2, f1, f2, f3, f4);
 }

 CEntity* ScriptLoader::LoadThermalHeatFader(CStateManager& mgr, CInputStream& in, int propCount,
@@ -2789,12 +3145,46 @@ CEntity* ScriptLoader::LoadThermalHeatFader(CStateManager& mgr, CInputStream& in
    if (!EnsurePropertyCount(propCount, 4, "ThermalHeatFader"))
        return nullptr;

-    return LoadWorldLightFader(mgr, in, propCount, info);
+    std::string name = mgr.HashInstanceName(in);
+    bool active = in.readBool();
+    float fadedLevel = in.readFloatBig();
+    float initialLevel = in.readFloatBig();
+    return new CScriptDistanceFog(mgr.AllocateUniqueId(), name, info, ERglFogMode::None, zeus::CColor::skBlack,
+                                  zeus::CVector2f(), 0.f, zeus::CVector2f(), false, active, fadedLevel, initialLevel,
+                                  0.f, 0.f);
 }

 CEntity* ScriptLoader::LoadBurrower(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
 {
-    return nullptr;
+    if (!EnsurePropertyCount(propCount, 13, "Burrower"))
+        return nullptr;
+
+    SScaledActorHead aHead = LoadScaledActorHead(in, mgr);
+    auto pair = CPatternedInfo::HasCorrectParameterCount(in);
+    if (!pair.first)
+        return nullptr;
+
+    CPatternedInfo pInfo(in, pair.second);
+
+    if (!pInfo.GetAnimationParameters().GetACSFile().IsValid())
+        return nullptr;
+
+    CActorParameters actParms = LoadActorParameters(in);
+    CAssetId w1(in);
+    CAssetId w2(in);
+    CAssetId w3(in);
+    CDamageInfo dInfo(in);
+
+    CAssetId w4(in);
+    u32 w5 = in.readUint32Big();
+    CAssetId w6(in);
+
+    CModelData mData(
+        CAnimRes(pInfo.GetAnimationParameters().GetACSFile(), pInfo.GetAnimationParameters().GetCharacter(),
+                 aHead.x40_scale, pInfo.GetAnimationParameters().GetInitialAnimation(), true));
+
+    return new MP1::CBurrower(mgr.AllocateUniqueId(), aHead.x0_name, info, aHead.x10_transform, std::move(mData), pInfo,
+                              actParms, w1, w2, w3, dInfo, w4, w5, w6);
 }

 CEntity* ScriptLoader::LoadBeam(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)
@@ -2810,7 +3200,7 @@ CEntity* ScriptLoader::LoadBeam(CStateManager& mgr, CInputStream& in, int propCo

    CBeamInfo beamInfo(in);
    CDamageInfo dInfo(in);
-    TToken<CWeaponDescription> weaponDesc = g_SimplePool->GetObj({SBIG('WPSC'), weaponDescId});
+    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);
@@ -2821,7 +3211,14 @@ CEntity* ScriptLoader::LoadWorldLightFader(CStateManager& mgr, CInputStream& in,
    if (!EnsurePropertyCount(propCount, 4, "WorldLightFader"))
        return nullptr;

-    return nullptr;
+    std::string name = mgr.HashInstanceName(in);
+    bool active = in.readBool();
+    float f1 = in.readFloatBig();
+    float f2 = in.readFloatBig();
+
+    return new CScriptDistanceFog(mgr.AllocateUniqueId(), name, info, ERglFogMode::None, zeus::CColor::skBlack,
+                                  zeus::CVector2f::skZero, 0.f, zeus::CVector2f::skZero, false, active, 0.f, 0.f, f1,
+                                  f2);
 }

 CEntity* ScriptLoader::LoadMetroidPrimeStage2(CStateManager& mgr, CInputStream& in, int propCount,
--- a/Runtime/World/ScriptLoader.hpp
+++ b/Runtime/World/ScriptLoader.hpp
@@ -82,7 +82,7 @@ public:
    static CEntity* LoadPuddleToadGamma(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info);
    static CEntity* LoadDistanceFog(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info);
    static CEntity* LoadFireFlea(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info);
-    static CEntity* LoadMetareeAlpha(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info);
+    static CEntity* LoadMetaree(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info);
    static CEntity* LoadDockAreaChange(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info);
    static CEntity* LoadActorRotate(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info);
    static CEntity* LoadSpecialFunction(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info);
--- a/Runtime/World/ScriptObjectSupport.cpp
+++ b/Runtime/World/ScriptObjectSupport.cpp
@@ -56,7 +56,7 @@ std::string_view ScriptObjectTypeToStr(EScriptObjectType type)
    case EScriptObjectType::PuddleToadGamma: return "PuddleToadGamma"sv;
    case EScriptObjectType::DistanceFog: return "DistanceFog"sv;
    case EScriptObjectType::FireFlea: return "FireFlea"sv;
-    case EScriptObjectType::MetareeAlpha: return "MetareeAlpha"sv;
+    case EScriptObjectType::Metaree: return "Metaree"sv;
    case EScriptObjectType::DockAreaChange: return "DockAreaChange"sv;
    case EScriptObjectType::ActorRotate: return "ActorRotate"sv;
    case EScriptObjectType::SpecialFunction: return "SpecialFunction"sv;
--- a/Runtime/World/ScriptObjectSupport.hpp
+++ b/Runtime/World/ScriptObjectSupport.hpp
@@ -55,7 +55,7 @@ enum class EScriptObjectType
    PuddleToadGamma = 0x34,
    DistanceFog = 0x35,
    FireFlea = 0x36,
-    MetareeAlpha = 0x37,
+    Metaree = 0x37,
    DockAreaChange = 0x38,
    ActorRotate = 0x39,
    SpecialFunction = 0x3A,