diff --git a/DataSpec/DNACommon/Tweaks/ITweakGui.hpp b/DataSpec/DNACommon/Tweaks/ITweakGui.hpp
index 6d70162dd..909573bea 100644
--- a/DataSpec/DNACommon/Tweaks/ITweakGui.hpp
+++ b/DataSpec/DNACommon/Tweaks/ITweakGui.hpp
@@ -79,8 +79,11 @@ struct ITweakGui : ITweak
     virtual float GetFreeLookFadeTime() const=0;
     virtual float GetFreeLookSfxPitchScale() const=0;
     virtual bool GetNoAbsoluteFreeLookSfxPitch() const=0;
+    virtual float GetFaceReflectionOrthoWidth() const=0;
+    virtual float GetFaceReflectionOrthoHeight() const=0;
     virtual float GetFaceReflectionDistance() const=0;
     virtual float GetFaceReflectionHeight() const=0;
+    virtual float GetFaceReflectionAspect() const=0;
     virtual float GetMissileWarningPulseTime() const=0;
     virtual float GetExplosionLightFalloffMultConstant() const=0;
     virtual float GetExplosionLightFalloffMultLinear() const=0;
@@ -107,6 +110,7 @@ struct ITweakGui : ITweak
     virtual float GetScanWindowActiveWidth() const=0;
     virtual float GetScanWindowActiveHeight() const=0;
     virtual float GetScanWindowMagnification() const=0;
+    virtual float GetScanWindowScanningAspect() const=0;
     virtual float GetScanSpeed(int idx) const=0;
     virtual float GetXrayBlurScaleLinear() const=0;
     virtual float GetXrayBlurScaleQuadratic() const=0;
@@ -141,6 +145,9 @@ struct ITweakGui : ITweak
 
     static float FaceReflectionDistanceDebugValueToActualValue(float v) { return 0.015f * v + 0.2f; }
     static float FaceReflectionHeightDebugValueToActualValue(float v) { return 0.005f * v - 0.05f; }
+    static float FaceReflectionAspectDebugValueToActualValue(float v) { return 0.05f * v + 1.f; }
+    static float FaceReflectionOrthoWidthDebugValueToActualValue(float v) { return 0.007f * v + 0.02f; }
+    static float FaceReflectionOrthoHeightDebugValueToActualValue(float v) { return 0.007f * v + 0.02f; }
 };
 
 }
diff --git a/DataSpec/DNAMP1/Tweaks/CTweakGui.hpp b/DataSpec/DNAMP1/Tweaks/CTweakGui.hpp
index 3394f2d1e..03ebc89a0 100644
--- a/DataSpec/DNAMP1/Tweaks/CTweakGui.hpp
+++ b/DataSpec/DNAMP1/Tweaks/CTweakGui.hpp
@@ -84,11 +84,11 @@ struct CTweakGui : ITweakGui
     Value<bool> x130_noAbsoluteFreeLookSfxPitch;
     Value<float> x134_;
     Value<float> x138_;
-    Value<atUint32> x13c_;
-    Value<atUint32> x140_;
+    Value<atUint32> x13c_faceReflectionOrthoWidth;
+    Value<atUint32> x140_faceReflectionOrthoHeight;
     Value<atUint32> x144_faceReflectionDistance;
     Value<atUint32> x148_faceReflectionHeight;
-    Value<atUint32> x14c_;
+    Value<atUint32> x14c_faceReflectionAspect;
     String<-1> x150_;
     String<-1> x160_;
     String<-1> x170_;
@@ -146,7 +146,7 @@ struct CTweakGui : ITweakGui
     Value<float> x260_scanWindowActiveW;
     Value<float> x264_scanWindowActiveH;
     Value<float> x268_scanWindowMagnification;
-    Value<float> x26c_;
+    Value<float> x26c_scanWindowScanningAspect;
     Value<float> x270_scanSidesPositionStart;
     Value<bool> x274_showAutomapperInMorphball;
     bool x275_latchArticleText = true;
@@ -241,8 +241,11 @@ struct CTweakGui : ITweakGui
     float GetFreeLookFadeTime() const { return x118_freeLookFadeTime; }
     float GetFreeLookSfxPitchScale() const { return x12c_freeLookSfxPitchScale; }
     bool GetNoAbsoluteFreeLookSfxPitch() const { return x130_noAbsoluteFreeLookSfxPitch; }
+    float GetFaceReflectionOrthoWidth() const { return x13c_faceReflectionOrthoWidth; }
+    float GetFaceReflectionOrthoHeight() const { return x140_faceReflectionOrthoHeight; }
     float GetFaceReflectionDistance() const { return x144_faceReflectionDistance; }
     float GetFaceReflectionHeight() const { return x148_faceReflectionHeight; }
+    float GetFaceReflectionAspect() const { return x14c_faceReflectionAspect; }
     float GetMissileWarningPulseTime() const { return x1a0_missileWarningPulseTime; }
     float GetExplosionLightFalloffMultConstant() const { return x1a4_explosionLightFalloffMultConstant; }
     float GetExplosionLightFalloffMultLinear() const { return x1a8_explosionLightFalloffMultLinear; }
@@ -283,6 +286,7 @@ struct CTweakGui : ITweakGui
     float GetScanWindowActiveWidth() const { return x260_scanWindowActiveW; }
     float GetScanWindowActiveHeight() const { return x264_scanWindowActiveH; }
     float GetScanWindowMagnification() const { return x268_scanWindowMagnification; }
+    float GetScanWindowScanningAspect() const { return x26c_scanWindowScanningAspect; }
     float GetScanSidesPositionStart() const { return x270_scanSidesPositionStart; }
     bool GetShowAutomapperInMorphball() const { return x274_showAutomapperInMorphball; }
     bool GetLatchArticleText() const { return x275_latchArticleText; }
diff --git a/DataSpec/DNAMP1/Tweaks/CTweakPlayer.cpp b/DataSpec/DNAMP1/Tweaks/CTweakPlayer.cpp
index 8e83ede98..77a02e6f4 100644
--- a/DataSpec/DNAMP1/Tweaks/CTweakPlayer.cpp
+++ b/DataSpec/DNAMP1/Tweaks/CTweakPlayer.cpp
@@ -1216,64 +1216,64 @@ void CTweakPlayer::read(athena::io::YAMLDocReader& __dna_docin)
     x1a0_ = __dna_docin.readFloat("x1a0_");
     /* x1a4_ */
     x1a4_ = __dna_docin.readFloat("x1a4_");
-    /* x1a8_ */
+    /* x1a8_orbitScreenBoxHalfExtentX */
     size_t __x1a8_Count;
-    if (auto v = __dna_docin.enterSubVector("x1a8_", __x1a8_Count))
+    if (auto v = __dna_docin.enterSubVector("x1a8_orbitScreenBoxHalfExtentX", __x1a8_Count))
     {
-    /* x1a8_[0] */
-    x1a8_orbitScreenBoxHalfExtentX[0] = __dna_docin.readUint32("x1a8_");
-    /* x1a8_[1] */
-    x1a8_orbitScreenBoxHalfExtentX[1] = __dna_docin.readUint32("x1a8_");
+    /* x1a8_orbitScreenBoxHalfExtentX[0] */
+    x1a8_orbitScreenBoxHalfExtentX[0] = __dna_docin.readUint32("x1a8_orbitScreenBoxHalfExtentX");
+    /* x1a8_orbitScreenBoxHalfExtentX[1] */
+    x1a8_orbitScreenBoxHalfExtentX[1] = __dna_docin.readUint32("x1a8_orbitScreenBoxHalfExtentX");
     }
-    /* x1b0_ */
+    /* x1b0_orbitScreenBoxHalfExtentY */
     size_t __x1b0_Count;
-    if (auto v = __dna_docin.enterSubVector("x1b0_", __x1b0_Count))
+    if (auto v = __dna_docin.enterSubVector("x1b0_orbitScreenBoxHalfExtentY", __x1b0_Count))
     {
-    /* x1b0_[0] */
-    x1b0_orbitScreenBoxHalfExtentY[0] = __dna_docin.readUint32("x1b0_");
-    /* x1b0_[1] */
-    x1b0_orbitScreenBoxHalfExtentY[1] = __dna_docin.readUint32("x1b0_");
+    /* x1b0_orbitScreenBoxHalfExtentY[0] */
+    x1b0_orbitScreenBoxHalfExtentY[0] = __dna_docin.readUint32("x1b0_orbitScreenBoxHalfExtentY");
+    /* x1b0_orbitScreenBoxHalfExtentY[1] */
+    x1b0_orbitScreenBoxHalfExtentY[1] = __dna_docin.readUint32("x1b0_orbitScreenBoxHalfExtentY");
     }
-    /* x1b8_ */
+    /* x1b8_orbitScreenBoxCenterX */
     size_t __x1b8_Count;
-    if (auto v = __dna_docin.enterSubVector("x1b8_", __x1b8_Count))
+    if (auto v = __dna_docin.enterSubVector("x1b8_orbitScreenBoxCenterX", __x1b8_Count))
     {
-    /* x1b8_[0] */
-    x1b8_orbitScreenBoxCenterX[0] = __dna_docin.readUint32("x1b8_");
-    /* x1b8_[1] */
-    x1b8_orbitScreenBoxCenterX[1] = __dna_docin.readUint32("x1b8_");
+    /* x1b8_orbitScreenBoxCenterX[0] */
+    x1b8_orbitScreenBoxCenterX[0] = __dna_docin.readUint32("x1b8_orbitScreenBoxCenterX");
+    /* x1b8_orbitScreenBoxCenterX[1] */
+    x1b8_orbitScreenBoxCenterX[1] = __dna_docin.readUint32("x1b8_orbitScreenBoxCenterX");
     }
-    /* x1c0_ */
+    /* x1c0_orbitScreenBoxCenterY */
     size_t __x1c0_Count;
-    if (auto v = __dna_docin.enterSubVector("x1c0_", __x1c0_Count))
+    if (auto v = __dna_docin.enterSubVector("x1c0_orbitScreenBoxCenterY", __x1c0_Count))
     {
-    /* x1c0_[0] */
-    x1c0_orbitScreenBoxCenterY[0] = __dna_docin.readUint32("x1c0_");
-    /* x1c0_[1] */
-    x1c0_orbitScreenBoxCenterY[1] = __dna_docin.readUint32("x1c0_");
+    /* x1c0_orbitScreenBoxCenterY[0] */
+    x1c0_orbitScreenBoxCenterY[0] = __dna_docin.readUint32("x1c0_orbitScreenBoxCenterY");
+    /* x1c0_orbitScreenBoxCenterY[1] */
+    x1c0_orbitScreenBoxCenterY[1] = __dna_docin.readUint32("x1c0_orbitScreenBoxCenterY");
     }
-    /* x1c8_ */
+    /* x1c8_enemyScreenBoxCenterX */
     size_t __x1c8_Count;
-    if (auto v = __dna_docin.enterSubVector("x1c8_", __x1c8_Count))
+    if (auto v = __dna_docin.enterSubVector("x1c8_enemyScreenBoxCenterX", __x1c8_Count))
     {
-    /* x1c8_[0] */
-    x1c8_enemyScreenBoxCenterX[0] = __dna_docin.readUint32("x1c8_");
-    /* x1c8_[1] */
-    x1c8_enemyScreenBoxCenterX[1] = __dna_docin.readUint32("x1c8_");
+    /* x1c8_enemyScreenBoxCenterX[0] */
+    x1c8_enemyScreenBoxCenterX[0] = __dna_docin.readUint32("x1c8_enemyScreenBoxCenterX");
+    /* x1c8_enemyScreenBoxCenterX[1] */
+    x1c8_enemyScreenBoxCenterX[1] = __dna_docin.readUint32("x1c8_enemyScreenBoxCenterX");
     }
-    /* x1d0_ */
+    /* x1d0_enemyScreenBoxCenterY */
     size_t __x1d0_Count;
-    if (auto v = __dna_docin.enterSubVector("x1d0_", __x1d0_Count))
+    if (auto v = __dna_docin.enterSubVector("x1d0_enemyScreenBoxCenterY", __x1d0_Count))
     {
-    /* x1d0_[0] */
-    x1d0_enemyScreenBoxCenterY[0] = __dna_docin.readUint32("x1d0_");
-    /* x1d0_[1] */
-    x1d0_enemyScreenBoxCenterY[1] = __dna_docin.readUint32("x1d0_");
+    /* x1d0_enemyScreenBoxCenterY[0] */
+    x1d0_enemyScreenBoxCenterY[0] = __dna_docin.readUint32("x1d0_enemyScreenBoxCenterY");
+    /* x1d0_enemyScreenBoxCenterY[1] */
+    x1d0_enemyScreenBoxCenterY[1] = __dna_docin.readUint32("x1d0_enemyScreenBoxCenterY");
     }
-    /* x1d8_ */
-    x1d8_orbitNearX = __dna_docin.readFloat("x1d8_");
-    /* x1dc_ */
-    x1dc_orbitNearZ = __dna_docin.readFloat("x1dc_");
+    /* x1d8_orbitNearX */
+    x1d8_orbitNearX = __dna_docin.readFloat("x1d8_orbitNearX");
+    /* x1dc_orbitNearZ */
+    x1dc_orbitNearZ = __dna_docin.readFloat("x1dc_orbitNearZ");
     /* x1e0_ */
     x1e0_ = __dna_docin.readFloat("x1e0_");
     /* x1e4_ */
@@ -1308,14 +1308,14 @@ void CTweakPlayer::read(athena::io::YAMLDocReader& __dna_docin)
     x218_scanningRange = __dna_docin.readFloat("x218_scanningRange");
     /* x21c_24_ */
     x21c_24_ = __dna_docin.readBool("x21c_24_");
-    /* x21c_25_ */
-    x21c_25_scanFreezesGame = __dna_docin.readBool("x21c_25_");
+    /* x21c_25_scanFreezesGame */
+    x21c_25_scanFreezesGame = __dna_docin.readBool("x21c_25_scanFreezesGame");
     /* x21c_26_ */
     x21c_26_ = __dna_docin.readBool("x21c_26_");
     /* x220_ */
     x220_ = __dna_docin.readFloat("x220_");
-    /* x224_ */
-    x224_scanningFrameSenseRange = __dna_docin.readFloat("x224_");
+    /* x224_scanningFrameSenseRange */
+    x224_scanningFrameSenseRange = __dna_docin.readFloat("x224_scanningFrameSenseRange");
     /* x2a0_ */
     x2a0_ = __dna_docin.readFloat("x2a0_");
     /* x2a4_ */
@@ -1722,58 +1722,58 @@ void CTweakPlayer::CTweakPlayer::write(athena::io::YAMLDocWriter& __dna_docout)
     __dna_docout.writeFloat("x1a0_", x1a0_);
     /* x1a4_ */
     __dna_docout.writeFloat("x1a4_", x1a4_);
-    /* x1a8_ */
-    if (auto v = __dna_docout.enterSubVector("x1a8_"))
+    /* x1a8_orbitScreenBoxHalfExtentX */
+    if (auto v = __dna_docout.enterSubVector("x1a8_orbitScreenBoxHalfExtentX"))
     {
-    /* x1a8_[0] */
-    __dna_docout.writeUint32("x1a8_", x1a8_orbitScreenBoxHalfExtentX[0]);
-    /* x1a8_[1] */
-    __dna_docout.writeUint32("x1a8_", x1a8_orbitScreenBoxHalfExtentX[1]);
+    /* x1a8_orbitScreenBoxHalfExtentX[0] */
+    __dna_docout.writeUint32("x1a8_orbitScreenBoxHalfExtentX", x1a8_orbitScreenBoxHalfExtentX[0]);
+    /* x1a8_orbitScreenBoxHalfExtentX[1] */
+    __dna_docout.writeUint32("x1a8_orbitScreenBoxHalfExtentX", x1a8_orbitScreenBoxHalfExtentX[1]);
     }
-    /* x1b0_ */
-    if (auto v = __dna_docout.enterSubVector("x1b0_"))
+    /* x1b0_orbitScreenBoxHalfExtentY */
+    if (auto v = __dna_docout.enterSubVector("x1b0_orbitScreenBoxHalfExtentY"))
     {
-    /* x1b0_[0] */
-    __dna_docout.writeUint32("x1b0_", x1b0_orbitScreenBoxHalfExtentY[0]);
-    /* x1b0_[1] */
-    __dna_docout.writeUint32("x1b0_", x1b0_orbitScreenBoxHalfExtentY[1]);
+    /* x1b0_orbitScreenBoxHalfExtentY[0] */
+    __dna_docout.writeUint32("x1b0_orbitScreenBoxHalfExtentY", x1b0_orbitScreenBoxHalfExtentY[0]);
+    /* x1b0_orbitScreenBoxHalfExtentY[1] */
+    __dna_docout.writeUint32("x1b0_orbitScreenBoxHalfExtentY", x1b0_orbitScreenBoxHalfExtentY[1]);
     }
-    /* x1b8_ */
-    if (auto v = __dna_docout.enterSubVector("x1b8_"))
+    /* x1b8_orbitScreenBoxCenterX */
+    if (auto v = __dna_docout.enterSubVector("x1b8_orbitScreenBoxCenterX"))
     {
-    /* x1b8_[0] */
-    __dna_docout.writeUint32("x1b8_", x1b8_orbitScreenBoxCenterX[0]);
-    /* x1b8_[1] */
-    __dna_docout.writeUint32("x1b8_", x1b8_orbitScreenBoxCenterX[1]);
+    /* x1b8_orbitScreenBoxCenterX[0] */
+    __dna_docout.writeUint32("x1b8_orbitScreenBoxCenterX", x1b8_orbitScreenBoxCenterX[0]);
+    /* x1b8_orbitScreenBoxCenterX[1] */
+    __dna_docout.writeUint32("x1b8_orbitScreenBoxCenterX", x1b8_orbitScreenBoxCenterX[1]);
     }
-    /* x1c0_ */
-    if (auto v = __dna_docout.enterSubVector("x1c0_"))
+    /* x1c0_orbitScreenBoxCenterY */
+    if (auto v = __dna_docout.enterSubVector("x1c0_orbitScreenBoxCenterY"))
     {
-    /* x1c0_[0] */
-    __dna_docout.writeUint32("x1c0_", x1c0_orbitScreenBoxCenterY[0]);
-    /* x1c0_[1] */
-    __dna_docout.writeUint32("x1c0_", x1c0_orbitScreenBoxCenterY[1]);
+    /* x1c0_orbitScreenBoxCenterY[0] */
+    __dna_docout.writeUint32("x1c0_orbitScreenBoxCenterY", x1c0_orbitScreenBoxCenterY[0]);
+    /* x1c0_orbitScreenBoxCenterY[1] */
+    __dna_docout.writeUint32("x1c0_orbitScreenBoxCenterY", x1c0_orbitScreenBoxCenterY[1]);
     }
-    /* x1c8_ */
-    if (auto v = __dna_docout.enterSubVector("x1c8_"))
+    /* x1c8_enemyScreenBoxCenterX */
+    if (auto v = __dna_docout.enterSubVector("x1c8_enemyScreenBoxCenterX"))
     {
-    /* x1c8_[0] */
-    __dna_docout.writeUint32("x1c8_", x1c8_enemyScreenBoxCenterX[0]);
-    /* x1c8_[1] */
-    __dna_docout.writeUint32("x1c8_", x1c8_enemyScreenBoxCenterX[1]);
+    /* x1c8_enemyScreenBoxCenterX[0] */
+    __dna_docout.writeUint32("x1c8_enemyScreenBoxCenterX", x1c8_enemyScreenBoxCenterX[0]);
+    /* x1c8_enemyScreenBoxCenterX[1] */
+    __dna_docout.writeUint32("x1c8_enemyScreenBoxCenterX", x1c8_enemyScreenBoxCenterX[1]);
     }
-    /* x1d0_ */
-    if (auto v = __dna_docout.enterSubVector("x1d0_"))
+    /* x1d0_enemyScreenBoxCenterY */
+    if (auto v = __dna_docout.enterSubVector("x1d0_enemyScreenBoxCenterY"))
     {
-    /* x1d0_[0] */
-    __dna_docout.writeUint32("x1d0_", x1d0_enemyScreenBoxCenterY[0]);
-    /* x1d0_[1] */
-    __dna_docout.writeUint32("x1d0_", x1d0_enemyScreenBoxCenterY[1]);
+    /* x1d0_enemyScreenBoxCenterY[0] */
+    __dna_docout.writeUint32("x1d0_enemyScreenBoxCenterY", x1d0_enemyScreenBoxCenterY[0]);
+    /* x1d0_enemyScreenBoxCenterY[1] */
+    __dna_docout.writeUint32("x1d0_enemyScreenBoxCenterY", x1d0_enemyScreenBoxCenterY[1]);
     }
     /* x1d8_ */
-    __dna_docout.writeFloat("x1d8_", x1d8_orbitNearX);
+    __dna_docout.writeFloat("x1d8_orbitNearX", x1d8_orbitNearX);
     /* x1dc_ */
-    __dna_docout.writeFloat("x1dc_", x1dc_orbitNearZ);
+    __dna_docout.writeFloat("x1dc_orbitNearZ", x1dc_orbitNearZ);
     /* x1e0_ */
     __dna_docout.writeFloat("x1e0_", x1e0_);
     /* x1e4_ */
@@ -1808,14 +1808,14 @@ void CTweakPlayer::CTweakPlayer::write(athena::io::YAMLDocWriter& __dna_docout)
     __dna_docout.writeFloat("x218_scanningRange", x218_scanningRange);
     /* x21c_24_ */
     __dna_docout.writeBool("x21c_24_", x21c_24_);
-    /* x21c_25_ */
-    __dna_docout.writeBool("x21c_25_", x21c_25_scanFreezesGame);
+    /* x21c_25_scanFreezesGame */
+    __dna_docout.writeBool("x21c_25_scanFreezesGame", x21c_25_scanFreezesGame);
     /* x21c_26_ */
     __dna_docout.writeBool("x21c_26_", x21c_26_);
     /* x220_ */
     __dna_docout.writeFloat("x220_", x220_);
-    /* x224_ */
-    __dna_docout.writeFloat("x224_", x224_scanningFrameSenseRange);
+    /* x224_scanningFrameSenseRange */
+    __dna_docout.writeFloat("x224_scanningFrameSenseRange", x224_scanningFrameSenseRange);
     /* x2a0_ */
     __dna_docout.writeFloat("x2a0_", x2a0_);
     /* x2a4_ */
diff --git a/Runtime/CStateManager.cpp b/Runtime/CStateManager.cpp
index def551422..029a122a7 100644
--- a/Runtime/CStateManager.cpp
+++ b/Runtime/CStateManager.cpp
@@ -214,7 +214,7 @@ void CStateManager::UpdateThermalVisor()
     CPlayerState::EPlayerVisor visor = x8b8_playerState->GetActiveVisor(*this);
     if (visor == CPlayerState::EPlayerVisor::Thermal && x8cc_nextAreaId != kInvalidAreaId)
     {
-        std::unique_ptr<CGameArea>& area = x850_world->GetGameAreas()[x8cc_nextAreaId];
+        CGameArea* area = x850_world->GetArea(x8cc_nextAreaId);
         const zeus::CTransform& playerXf = x84c_player->GetTransform();
         zeus::CVector3f playerXYPos(playerXf.origin.x, playerXf.origin.y, 0.f);
         CGameArea* lastArea = nullptr;
@@ -231,14 +231,14 @@ void CStateManager::UpdateThermalVisor()
                 TAreaId connAreaId = dock.GetConnectedAreaId(0);
                 if (connAreaId != kInvalidAreaId)
                 {
-                    std::unique_ptr<CGameArea>& connArea = x850_world->GetGameAreas()[x8cc_nextAreaId];
+                    CGameArea* connArea = x850_world->GetArea(x8cc_nextAreaId);
                     if (connArea->IsPostConstructed())
                     {
                         CGameArea::EOcclusionState occState = connArea->GetPostConstructed()->x10dc_occlusionState;
                         if (occState == CGameArea::EOcclusionState::Visible)
                         {
                             closestDist = dist;
-                            lastArea = connArea.get();
+                            lastArea = connArea;
                         }
                     }
                 }
diff --git a/Runtime/Character/CActorLights.hpp b/Runtime/Character/CActorLights.hpp
index 70a2d74ec..b831fd474 100644
--- a/Runtime/Character/CActorLights.hpp
+++ b/Runtime/Character/CActorLights.hpp
@@ -73,6 +73,7 @@ public:
     void BuildDynamicLightList(const CStateManager& mgr, const zeus::CAABox& aabb);
     void ActivateLights(CBooModel& model) const;
     void SetCastShadows(bool v) { x298_25_castShadows = v; }
+    void SetFindShadowLight(bool v) { x298_27_findShadowLight = v; }
 
     void SetAmbientColor(const zeus::CColor& color) { x288_ambientColor = color; }
     const zeus::CColor& GetAmbientColor() const { return x288_ambientColor; }
diff --git a/Runtime/Graphics/CModel.hpp b/Runtime/Graphics/CModel.hpp
index 9b906c781..969371866 100644
--- a/Runtime/Graphics/CModel.hpp
+++ b/Runtime/Graphics/CModel.hpp
@@ -138,6 +138,8 @@ private:
     };
     std::vector<ModelInstance> m_instances;
 
+    boo::ITexture* m_txtrOverrides[8] = {};
+
     ModelInstance* PushNewModelInstance();
     void DrawAlphaSurfaces(const CModelFlags& flags) const;
     void DrawNormalSurfaces(const CModelFlags& flags) const;
@@ -155,7 +157,7 @@ public:
     CBooModel(TToken<CModel>& token, std::vector<CBooSurface>* surfaces, SShader& shader,
               boo::IVertexFormat* vtxFmt, boo::IGraphicsBufferS* vbo, boo::IGraphicsBufferS* ibo,
               size_t weightVecCount, size_t skinBankCount, const zeus::CAABox& aabb, u8 renderMask,
-              int numInsts);
+              int numInsts, boo::ITexture* txtrOverrides[8]);
 
     static void MakeTexturesFromMats(const MaterialSet& matSet,
                                      std::vector<TCachedToken<CTexture>>& toksOut,
@@ -242,7 +244,7 @@ public:
     const zeus::CAABox& GetAABB() const {return m_aabb;}
     CBooModel& GetInstance() {return *x28_modelInst;}
     const CBooModel& GetInstance() const {return *x28_modelInst;}
-    std::unique_ptr<CBooModel> MakeNewInstance(int shaderIdx, int subInsts);
+    std::unique_ptr<CBooModel> MakeNewInstance(int shaderIdx, int subInsts, boo::ITexture* txtrOverrides[8] = nullptr);
     void UpdateLastFrame() const { const_cast<CModel&>(*this).x38_lastFrame = CGraphics::GetFrameCounter(); }
 };
 
diff --git a/Runtime/Graphics/CModelBoo.cpp b/Runtime/Graphics/CModelBoo.cpp
index 490572c5f..e96a3d8ac 100644
--- a/Runtime/Graphics/CModelBoo.cpp
+++ b/Runtime/Graphics/CModelBoo.cpp
@@ -136,12 +136,16 @@ CBooModel::~CBooModel()
 CBooModel::CBooModel(TToken<CModel>& token, std::vector<CBooSurface>* surfaces, SShader& shader,
                      boo::IVertexFormat* vtxFmt, boo::IGraphicsBufferS* vbo, boo::IGraphicsBufferS* ibo,
                      size_t weightVecCount, size_t skinBankCount, const zeus::CAABox& aabb, u8 renderMask,
-                     int instCount)
+                     int instCount, boo::ITexture* txtrOverrides[8])
 : m_model(token), x0_surfaces(surfaces), x4_matSet(&shader.m_matSet), m_matSetIdx(shader.m_matSetIdx),
   m_pipelines(&shader.m_shaders), m_vtxFmt(vtxFmt), x8_vbo(vbo), xc_ibo(ibo), m_weightVecCount(weightVecCount),
   m_skinBankCount(skinBankCount), x1c_textures(shader.x0_textures), x20_aabb(aabb),
   x40_24_texturesLoaded(false), x40_25_modelVisible(0), x41_mask(renderMask)
 {
+    if (txtrOverrides)
+        for (int i=0 ; i<8 ; ++i)
+            m_txtrOverrides[i] = txtrOverrides[i];
+
     if (!g_FirstModel)
         g_FirstModel = this;
     else
@@ -283,8 +287,15 @@ CBooModel::ModelInstance* CBooModel::PushNewModelInstance()
             u32 texCount = 0;
             for (atUint32 idx : mat.textureIdxs)
             {
-                TCachedToken<CTexture>& tex = x1c_textures[idx];
-                texs[texCount++] = tex.GetObj()->GetBooTexture();
+                if (boo::ITexture* overtex = m_txtrOverrides[texCount])
+                {
+                    texs[texCount++] = overtex;
+                }
+                else
+                {
+                    TCachedToken<CTexture>& tex = x1c_textures[idx];
+                    texs[texCount++] = tex.GetObj()->GetBooTexture();
+                }
             }
             texs[7] = g_Renderer->x220_sphereRamp;
 
@@ -924,13 +935,13 @@ static const u8* MemoryFromPartData(const u8*& dataCur, const s32*& secSizeCur)
     return ret;
 }
 
-std::unique_ptr<CBooModel> CModel::MakeNewInstance(int shaderIdx, int subInsts)
+std::unique_ptr<CBooModel> CModel::MakeNewInstance(int shaderIdx, int subInsts, boo::ITexture* txtrOverrides[8])
 {
     if (shaderIdx >= x18_matSets.size())
         shaderIdx = 0;
     return std::make_unique<CBooModel>(m_selfToken, &x8_surfaces, x18_matSets[shaderIdx],
                                        m_vtxFmt, m_vbo, m_ibo, m_weightVecCount, m_skinBankCount,
-                                       m_aabb, (m_flags & 0x2) != 0, subInsts);
+                                       m_aabb, (m_flags & 0x2) != 0, subInsts, txtrOverrides);
 }
 
 CModel::CModel(std::unique_ptr<u8[]>&& in, u32 /* dataLen */, IObjectStore* store, CObjectReference* selfRef)
diff --git a/Runtime/MP1/CPlayerVisor.cpp b/Runtime/MP1/CPlayerVisor.cpp
index 4abe4190b..f9b864dc7 100644
--- a/Runtime/MP1/CPlayerVisor.cpp
+++ b/Runtime/MP1/CPlayerVisor.cpp
@@ -8,6 +8,7 @@
 #include "Camera/CGameCamera.hpp"
 #include "Graphics/CBooRenderer.hpp"
 #include "GuiSys/CCompoundTargetReticle.hpp"
+#include "GuiSys/CTargetingManager.hpp"
 
 namespace urde
 {
@@ -357,8 +358,137 @@ void CPlayerVisor::LockUnlockAssets()
 
 void CPlayerVisor::DrawScanEffect(const CStateManager& mgr, const CTargetingManager* tgtMgr) const
 {
-    DrawScanObjectIndicators(mgr);
-    /* TODO: Finish */
+    bool indicatorsDrawn = DrawScanObjectIndicators(mgr);
+    if (tgtMgr && indicatorsDrawn)
+    {
+        CGraphics::SetDepthRange(0.12500012f, 0.12500012f);
+        tgtMgr->Draw(mgr, false);
+        CGraphics::SetDepthRange(0.015625f, 0.03125f);
+    }
+
+    float transFactor = mgr.GetPlayerState()->GetVisorTransitionFactor();
+    float scanSidesDuration = g_tweakGui->GetScanSidesDuration();
+    float scanSidesStart = g_tweakGui->GetScanSidesStartTime();
+
+    float t;
+    if (x34_nextState == EScanWindowState::Scan)
+        t = 1.f - ((x3c_windowInterpTimer < scanSidesDuration) ? 0.f : (x3c_windowInterpTimer - scanSidesDuration) / scanSidesStart);
+    else
+        t = (x3c_windowInterpTimer > scanSidesStart) ? 1.f : x3c_windowInterpTimer / scanSidesStart;
+
+    float divisor = (transFactor * ((1.f - t) * x58_scanMagInterp + t * g_tweakGui->GetScanWindowScanningAspect()) + (1.f - transFactor));
+    float vpW = 169.218f * x48_interpWindowDims.x / divisor;
+    vpW = zeus::clamp(0.f, vpW, 640.f) * g_Viewport.x8_width / 640.f;
+    float vpH = 152.218f * x48_interpWindowDims.y / divisor;
+    vpH = zeus::clamp(0.f, vpH, 448.f) * g_Viewport.xc_height / 448.f;
+
+    SClipScreenRect rect;
+    rect.x4_left = (g_Viewport.x8_width - vpW) / 2.f;
+    rect.x8_top = (g_Viewport.xc_height - vpH) / 2.f;
+    rect.xc_width = vpW;
+    rect.x10_height = vpH;
+    CGraphics::ResolveSpareTexture(rect);
+
+    x64_scanDim.Draw();
+
+    g_Renderer->SetViewportOrtho(true, -1.f, 1.f);
+
+    zeus::CTransform windowScale = zeus::CTransform::Scale(x48_interpWindowDims.x, 1.f, x48_interpWindowDims.y);
+    zeus::CTransform seventeenScale = zeus::CTransform::Scale(17.f, 1.f, 17.f);
+    CGraphics::SetModelMatrix(seventeenScale * windowScale);
+
+    if (x108_newScanPane.IsLoaded())
+    {
+        if (!m_newScanPaneInst)
+        {
+            CPlayerVisor* ncThis = const_cast<CPlayerVisor*>(this);
+            boo::ITexture* texs[8] = {CGraphics::g_SpareTexture};
+            ncThis->m_newScanPaneInst = ncThis->x108_newScanPane->MakeNewInstance(0, 1, texs);
+            ncThis->m_newScanPaneInst->VerifyCurrentShader(0);
+        }
+        m_newScanPaneInst->Draw(CModelFlags(5, 0, 3 | 4, zeus::CColor(1.f, transFactor)), nullptr, nullptr);
+    }
+
+    // No cull faces
+
+    zeus::CColor frameColor = zeus::CColor::lerp(
+        g_tweakGuiColors->GetScanFrameInactiveColor(),
+        g_tweakGuiColors->GetScanFrameActiveColor(),
+        x54c_frameColorInterp);
+    frameColor.a = transFactor;
+
+    CModelFlags flags(5, 0, 0,
+        frameColor + g_tweakGuiColors->GetScanFrameImpulseColor() *
+            zeus::CColor(x550_frameColorImpulseInterp, x550_frameColorImpulseInterp));
+
+    zeus::CTransform verticalFlip = zeus::CTransform::Scale(1.f, 1.f, -1.f);
+    zeus::CTransform horizontalFlip = zeus::CTransform::Scale(-1.f, 1.f, 1.f);
+
+    if (xe4_scanFrameCenterTop.IsLoaded())
+    {
+        zeus::CTransform modelXf =
+            seventeenScale * zeus::CTransform::Translate(windowScale * zeus::CVector3f(0.f, 0.f, 4.553f));
+        CGraphics::SetModelMatrix(modelXf);
+        xe4_scanFrameCenterTop->Draw(flags);
+        CGraphics::SetModelMatrix(verticalFlip * modelXf);
+        xe4_scanFrameCenterTop->Draw(flags);
+    }
+
+    if (xd8_scanFrameCenterSide.IsLoaded())
+    {
+        zeus::CTransform modelXf =
+            seventeenScale * zeus::CTransform::Translate(windowScale * zeus::CVector3f(-5.f, 0.f, 0.f));
+        CGraphics::SetModelMatrix(modelXf);
+        xd8_scanFrameCenterSide->Draw(flags);
+        CGraphics::SetModelMatrix(horizontalFlip * modelXf);
+        xd8_scanFrameCenterSide->Draw(flags);
+    }
+
+    if (xcc_scanFrameCorner.IsLoaded())
+    {
+        zeus::CTransform modelXf =
+            seventeenScale * zeus::CTransform::Translate(windowScale * zeus::CVector3f(-5.f, 0.f, 4.553f));
+        CGraphics::SetModelMatrix(modelXf);
+        xcc_scanFrameCorner->Draw(flags);
+        CGraphics::SetModelMatrix(horizontalFlip * modelXf);
+        xcc_scanFrameCorner->Draw(flags);
+        CGraphics::SetModelMatrix(verticalFlip * modelXf);
+        xcc_scanFrameCorner->Draw(flags);
+        CGraphics::SetModelMatrix(verticalFlip * horizontalFlip * modelXf);
+        xcc_scanFrameCorner->Draw(flags);
+    }
+
+    if (xfc_scanFrameStretchTop.IsLoaded())
+    {
+        zeus::CTransform modelXf =
+            seventeenScale * zeus::CTransform::Translate(-1.f, 0.f, 4.553f * windowScale.basis[2][2]) *
+            zeus::CTransform::Scale(5.f * windowScale.basis[0][0] - 1.f - 1.884f, 1.f, 1.f);
+        CGraphics::SetModelMatrix(modelXf);
+        xfc_scanFrameStretchTop->Draw(flags);
+        CGraphics::SetModelMatrix(horizontalFlip * modelXf);
+        xfc_scanFrameStretchTop->Draw(flags);
+        CGraphics::SetModelMatrix(verticalFlip * modelXf);
+        xfc_scanFrameStretchTop->Draw(flags);
+        CGraphics::SetModelMatrix(verticalFlip * horizontalFlip * modelXf);
+        xfc_scanFrameStretchTop->Draw(flags);
+    }
+
+    if (xf0_scanFrameStretchSide.IsLoaded())
+    {
+        zeus::CTransform modelXf =
+            seventeenScale * zeus::CTransform::Translate(-5.f * windowScale.basis[0][0], 0.f, 1.f) *
+            zeus::CTransform::Scale(1.f, 1.f, 4.553f * windowScale.basis[2][2] - 1.f - 1.886f);
+        CGraphics::SetModelMatrix(modelXf);
+        xf0_scanFrameStretchSide->Draw(flags);
+        CGraphics::SetModelMatrix(horizontalFlip * modelXf);
+        xf0_scanFrameStretchSide->Draw(flags);
+        CGraphics::SetModelMatrix(verticalFlip * modelXf);
+        xf0_scanFrameStretchSide->Draw(flags);
+        CGraphics::SetModelMatrix(verticalFlip * horizontalFlip * modelXf);
+        xf0_scanFrameStretchSide->Draw(flags);
+    }
+
+    // cull faces
 }
 
 void CPlayerVisor::DrawXRayEffect(const CStateManager&) const
@@ -576,7 +706,21 @@ void CPlayerVisor::Update(float dt, const CStateManager& mgr)
 
 void CPlayerVisor::Draw(const CStateManager& mgr, const CTargetingManager* tgtManager) const
 {
-
+    CGraphics::SetAmbientColor(zeus::CColor::skWhite);
+    CGraphics::DisableAllLights();
+    switch (mgr.GetPlayerState()->GetActiveVisor(mgr))
+    {
+    case CPlayerState::EPlayerVisor::XRay:
+        DrawXRayEffect(mgr);
+        break;
+    case CPlayerState::EPlayerVisor::Thermal:
+        DrawThermalEffect(mgr);
+        break;
+    case CPlayerState::EPlayerVisor::Scan:
+        DrawScanEffect(mgr, tgtManager);
+        break;
+    default: break;
+    }
 }
 
 void CPlayerVisor::Touch()
diff --git a/Runtime/MP1/CPlayerVisor.hpp b/Runtime/MP1/CPlayerVisor.hpp
index 30a2d7146..e09d9d2c9 100644
--- a/Runtime/MP1/CPlayerVisor.hpp
+++ b/Runtime/MP1/CPlayerVisor.hpp
@@ -6,12 +6,12 @@
 #include "zeus/CVector2f.hpp"
 #include "Audio/CSfxManager.hpp"
 #include "CPlayerState.hpp"
+#include "Graphics/CModel.hpp"
 
 namespace urde
 {
 class CStateManager;
 class CTargetingManager;
-class CModel;
 
 namespace MP1
 {
@@ -70,6 +70,8 @@ class CPlayerVisor
     float x54c_frameColorInterp = 0.f;
     float x550_frameColorImpulseInterp = 0.f;
 
+    std::unique_ptr<CBooModel> m_newScanPaneInst;
+
     int FindEmptyInactiveScanTarget() const;
     int FindCachedInactiveScanTarget(TUniqueId uid) const;
     bool DrawScanObjectIndicators(const CStateManager& mgr) const;
diff --git a/Runtime/MP1/CSamusFaceReflection.cpp b/Runtime/MP1/CSamusFaceReflection.cpp
index 935a1b824..ad0ed4efb 100644
--- a/Runtime/MP1/CSamusFaceReflection.cpp
+++ b/Runtime/MP1/CSamusFaceReflection.cpp
@@ -1,34 +1,118 @@
 #include "CSamusFaceReflection.hpp"
 #include "GameGlobalObjects.hpp"
+#include "CStateManager.hpp"
+#include "TCastTo.hpp"
+#include "Camera/CFirstPersonCamera.hpp"
+#include "World/CPlayer.hpp"
+#include "World/CWorld.hpp"
 
 namespace urde
 {
 namespace MP1
 {
 
+static const zeus::CTransform PreXf = zeus::CTransform::Scale(0.3f) * zeus::CTransform::Translate(0.f, 0.5f, 0.f);
+
 CSamusFaceReflection::CSamusFaceReflection(CStateManager& stateMgr)
 : x0_modelData(CAnimRes(g_ResFactory->GetResourceIdByName("ACS_SamusFace")->id,
                         0, zeus::CVector3f::skOne, 0, true)),
   x4c_lights(std::make_unique<CActorLights>(8, zeus::CVector3f::skZero, 4, 4, false, 0, 0, 0.1f))
 {
-    x60_ = zeus::CVector3f::skForward;
+    x60_lookDir = zeus::CVector3f::skForward;
     CAnimPlaybackParms parms(0, -1, 1.f, true);
     x0_modelData.AnimationData()->SetAnimation(parms, false);
 }
 
-void CSamusFaceReflection::PreDraw(const CStateManager& stateMgr)
+void CSamusFaceReflection::PreDraw(const CStateManager& mgr)
 {
-
+    if (x6c_ != 2 && (x4c_lights->GetActiveLightCount() >= 1 || (x6c_ != 0 && x6c_ != 3)))
+    {
+        if (!TCastToConstPtr<CFirstPersonCamera>(mgr.GetCameraManager()->GetCurrentCamera(mgr)))
+        {
+            x70_hidden = true;
+        }
+        else
+        {
+            x70_hidden = false;
+            x0_modelData.AnimationData()->PreRender();
+        }
+    }
 }
 
-void CSamusFaceReflection::Draw(const CStateManager& stateMgr) const
+void CSamusFaceReflection::Draw(const CStateManager& mgr) const
 {
+    if (x70_hidden)
+        return;
 
+    if (TCastToConstPtr<CFirstPersonCamera> fpCam = (mgr.GetCameraManager()->GetCurrentCamera(mgr)))
+    {
+        zeus::CQuaternion camRot(fpCam->GetTransform().basis);
+        float dist = ITweakGui::FaceReflectionDistanceDebugValueToActualValue(g_tweakGui->GetFaceReflectionDistance());
+        float height = ITweakGui::FaceReflectionHeightDebugValueToActualValue(g_tweakGui->GetFaceReflectionHeight());
+        float aspect = ITweakGui::FaceReflectionAspectDebugValueToActualValue(g_tweakGui->GetFaceReflectionAspect());
+        float orthoWidth = ITweakGui::FaceReflectionOrthoWidthDebugValueToActualValue(g_tweakGui->GetFaceReflectionOrthoWidth());
+        float orthoHeight = ITweakGui::FaceReflectionOrthoHeightDebugValueToActualValue(g_tweakGui->GetFaceReflectionOrthoHeight());
+
+        zeus::CTransform modelXf =
+            zeus::CTransform(camRot * x50_lookRot,
+                fpCam->GetTransform().basis[1] * dist +
+                fpCam->GetTransform().origin +
+                fpCam->GetTransform().basis[2] * height) * PreXf;
+
+        CGraphics::SetViewPointMatrix(fpCam->GetTransform());
+        CGraphics::SetOrtho(aspect * -orthoWidth, aspect * orthoWidth,
+                            orthoHeight, -orthoHeight, -10.f, 10.f);
+
+        CActorLights* lights = x6c_ == 1 ? nullptr : x4c_lights.get();
+        if (x6c_ == 3)
+        {
+            const_cast<CModelData&>(x0_modelData).Render(mgr, modelXf, lights, CModelFlags(0, 0, 3, zeus::CColor::skWhite));
+        }
+        else
+        {
+            float transFactor;
+            if (mgr.GetPlayerState()->GetActiveVisor(mgr) == CPlayerState::EPlayerVisor::Combat)
+                transFactor = mgr.GetPlayerState()->GetVisorTransitionFactor();
+            else
+                transFactor = 0.f;
+            if (transFactor > 0.f)
+            {
+                const_cast<CModelData&>(x0_modelData).Render(mgr, modelXf, nullptr, CModelFlags(7, 0, 3, zeus::CColor::skBlack));
+                const_cast<CModelData&>(x0_modelData).Render(mgr, modelXf, lights, CModelFlags(7, 0, 1, zeus::CColor(1.f, transFactor)));
+            }
+        }
+    }
 }
 
-void CSamusFaceReflection::Update(float dt, const CStateManager& stateMgr, CRandom16& rand)
+void CSamusFaceReflection::Update(float dt, const CStateManager& mgr, CRandom16& rand)
 {
+    if (TCastToConstPtr<CFirstPersonCamera> fpCam = (mgr.GetCameraManager()->GetCurrentCamera(mgr)))
+    {
+        x0_modelData.AdvanceAnimationIgnoreParticles(dt, rand, true);
+        x4c_lights->SetFindShadowLight(false);
+        TAreaId areaId = mgr.GetPlayer().GetAreaIdAlways();
+        if (areaId == kInvalidAreaId)
+            return;
 
+        zeus::CAABox aabb(fpCam->GetTranslation() - 0.125f, fpCam->GetTranslation() + 0.125f);
+        const CGameArea* area = mgr.GetWorld()->GetAreaAlways(areaId);
+        x4c_lights->BuildFaceLightList(mgr, *area, aabb);
+
+        zeus::CUnitVector3f lookDir(fpCam->GetTransform().basis[1]);
+        zeus::CUnitVector3f xfLook =
+            zeus::CQuaternion::lookAt(lookDir, zeus::CVector3f::skForward, 2.f * M_PIF).transform(x60_lookDir);
+        zeus::CQuaternion xfLook2 = zeus::CQuaternion::lookAt(zeus::CVector3f::skForward, xfLook, 2.f * M_PIF);
+        xfLook2 *= xfLook2;
+        zeus::CMatrix3f newXf(xfLook2);
+        zeus::CMatrix3f prevXf(x50_lookRot);
+        float lookDot = prevXf[1].dot(newXf[1]);
+        if (std::fabs(lookDot) > 1.f)
+            lookDot = lookDot > 0.f ? 1.f : -1.f;
+        float lookAng = std::acos(lookDot);
+        x50_lookRot = zeus::CQuaternion::slerp(x50_lookRot, xfLook2,
+            zeus::clamp(0.f, 18.f * dt * ((lookAng > 0.f) ? 0.5f * dt * g_tweakPlayer->GetHudLagAmount() / lookAng : 0.f), 1.f));
+        x60_lookDir = lookDir;
+    }
 }
 
 }
diff --git a/Runtime/MP1/CSamusFaceReflection.hpp b/Runtime/MP1/CSamusFaceReflection.hpp
index 53f55a457..50737543e 100644
--- a/Runtime/MP1/CSamusFaceReflection.hpp
+++ b/Runtime/MP1/CSamusFaceReflection.hpp
@@ -13,10 +13,10 @@ class CSamusFaceReflection
 {
     CModelData x0_modelData;
     std::unique_ptr<CActorLights> x4c_lights;
-    zeus::CQuaternion x50_;
-    zeus::CVector3f x60_;
+    zeus::CQuaternion x50_lookRot;
+    zeus::CVector3f x60_lookDir;
     u32 x6c_ = 0;
-    bool x70_ = true;
+    bool x70_hidden = true;
 public:
     CSamusFaceReflection(CStateManager& stateMgr);
     void PreDraw(const CStateManager& stateMgr);
diff --git a/Runtime/World/CGameArea.cpp b/Runtime/World/CGameArea.cpp
index 9da745d26..01599d3c3 100644
--- a/Runtime/World/CGameArea.cpp
+++ b/Runtime/World/CGameArea.cpp
@@ -1007,7 +1007,7 @@ void CGameArea::FillInStaticGeometry()
             TToken<CModel> nullModel;
             inst.m_instance = std::make_unique<CBooModel>
                 (nullModel, &inst.m_surfaces, x12c_postConstructed->m_materialSet, vtxFmt, vbo, ibo,
-                 hmdlMeta.weightCount, hmdlMeta.bankCount, inst.x34_aabb, inst.x0_visorFlags, 1);
+                 hmdlMeta.weightCount, hmdlMeta.bankCount, inst.x34_aabb, inst.x0_visorFlags, 1, nullptr);
         }
 
         return true;
diff --git a/Runtime/World/CWorld.hpp b/Runtime/World/CWorld.hpp
index aadff6be3..7bb080c08 100644
--- a/Runtime/World/CWorld.hpp
+++ b/Runtime/World/CWorld.hpp
@@ -167,7 +167,7 @@ public:
 
     CWorld(IObjectStore& objStore, IFactory& resFactory, ResId mlvlId);
     bool DoesAreaExist(TAreaId area) const;
-    std::vector<std::unique_ptr<CGameArea>>& GetGameAreas() {return x18_areas;}
+    const std::vector<std::unique_ptr<CGameArea>>& GetGameAreas() const { return x18_areas; }
 
     const CMapWorld* GetMapWorld() const { return x28_mapWorld.GetObj(); }
     u32 GetRelayCount() const { return x2c_relays.size(); }