Merge branch 'master' into commandhandler-controlling

Author: FileEX

Client/core/Graphics/CVideoModeManager.cpp

@@ -12,14 +12,19 @@
 #include "StdInc.h"
 #include "CCamSA.h"
 #include "CGameSA.h"
+#include <cmath>
 
 extern CGameSA* pGame;
 
 CEntity* CCamSA::GetTargetEntity() const
 {
+
+    if (!m_pInterface)
+        return nullptr;
+        
     CEntitySAInterface* pInterface = m_pInterface->CamTargetEntity;
     if (pInterface)
-    {
+    {           
         CPools* pPools = pGame->GetPools();
         return pPools->GetEntity((DWORD*)pInterface);
     }
@@ -28,18 +33,64 @@ CEntity* CCamSA::GetTargetEntity() const
 
 void CCamSA::SetTargetEntity(CEntity* pEntity)
 {
-    m_pInterface->CamTargetEntity = pEntity->GetInterface();
+    if (!m_pInterface)
+        return;
+        
+    if (pEntity)
+    {
+        auto pEntityInterface = pEntity->GetInterface();
+        if (!pEntityInterface)
+            return;
+            
+        m_pInterface->CamTargetEntity = pEntityInterface;
+    }
+    else
+    {
+        m_pInterface->CamTargetEntity = nullptr;
+    }
 }
 
 void CCamSA::GetDirection(float& fHorizontal, float& fVertical)
 {
-    fHorizontal = m_pInterface->m_fHorizontalAngle;
-    fVertical = m_pInterface->m_fVerticalAngle;
+    if (!m_pInterface)
+    {
+        fHorizontal = 0.0f;
+        fVertical = 0.0f;
+        return;
+    }
+
+    float fHoriz = m_pInterface->m_fHorizontalAngle;
+    float fVert = m_pInterface->m_fVerticalAngle;
+    
+    if (!std::isfinite(fHoriz) || !std::isfinite(fVert))
+    {
+        fHorizontal = 0.0f;
+        fVertical = 0.0f;
+        return;
+    }
+    
+    fHorizontal = fHoriz;
+    fVertical = fVert;
 }
 
 void CCamSA::SetDirection(float fHorizontal, float fVertical)
 {
+    if (!m_pInterface)
+        return;
+        
+    // Validate input float values
+    if (!std::isfinite(fHorizontal) || !std::isfinite(fVertical))
+        return;
+        
+    // Clamp angle values to prevent overflow
+    constexpr float MIN_ANGLE = -360.0f;
+    constexpr float MAX_ANGLE = 360.0f;
+    
+    if (fHorizontal < MIN_ANGLE || fHorizontal > MAX_ANGLE ||
+        fVertical < MIN_ANGLE || fVertical > MAX_ANGLE)
+        return;
+
     // Calculation @ sub 0x50F970
     m_pInterface->m_fHorizontalAngle = fHorizontal;
     m_pInterface->m_fVerticalAngle = fVertical;
-}
+}

Client/game_sa/CCamSA.cpp

@@ -162,22 +162,75 @@ class CCamSA : public CCam
     CCamSAInterface* m_pInterface;
 
 public:
-    CCamSA(CCamSAInterface* pInterface) { m_pInterface = pInterface; }
+    CCamSA(CCamSAInterface* pInterface) : m_pInterface(pInterface) 
+    {
+        if (!pInterface)
+        {
+            m_pInterface = nullptr;
+        }
+    }
+    
     CCamSAInterface* GetInterface() { return m_pInterface; }
 
-    CVector*     GetFront() const { return &m_pInterface->Front; }
-    CVector*     GetUp() const { return &m_pInterface->Up; }
-    CVector*     GetSource() const { return &m_pInterface->Source; }
-    unsigned int GetMode() const { return m_pInterface->Mode; }
-    float        GetFOV() const { return m_pInterface->FOV; }
-    void         SetFOV(float fFOV) { m_pInterface->FOV = fFOV; }
-    void         GetDirection(float& fHorizontal, float& fVertical);
-    void         SetDirection(float fHorizontal, float fVertical);
-
-    CVector* GetFixedModeSource() const { return &m_pInterface->m_cvecCamFixedModeSource; }
-    CVector* GetFixedModeVector() const { return &m_pInterface->m_cvecCamFixedModeVector; }
-    CVector* GetTargetHistoryPos() const { return m_pInterface->m_aTargetHistoryPos; }
-
-    CEntity* GetTargetEntity() const;
+    CVector* GetFront() const override 
+    { 
+        return m_pInterface ? &m_pInterface->Front : nullptr; 
+    }
+    
+    CVector* GetUp() const override 
+    { 
+        return m_pInterface ? &m_pInterface->Up : nullptr; 
+    }
+    
+    CVector* GetSource() const override 
+    { 
+        return m_pInterface ? &m_pInterface->Source : nullptr; 
+    }
+    
+    unsigned int GetMode() const override 
+    { 
+        return m_pInterface ? static_cast<unsigned int>(m_pInterface->Mode) : 0; 
+    }
+    
+    float GetFOV() const override 
+    { 
+        if (!m_pInterface)
+            return 70.0f; // Default FOV
+            
+        float fov = m_pInterface->FOV;
+        return std::isfinite(fov) ? fov : 70.0f;
+    }
+    
+    void SetFOV(float fFOV) override 
+    { 
+        if (!m_pInterface)
+            return;
+            
+        // Validate FOV range
+        if (!std::isfinite(fFOV) || fFOV <= 0.0f || fFOV >= 180.0f)
+            return;
+            
+        m_pInterface->FOV = fFOV; 
+    }
+
+    void GetDirection(float& fHorizontal, float& fVertical) override;
+    void SetDirection(float fHorizontal, float fVertical) override;
+
+    CVector* GetFixedModeSource() const override 
+    { 
+        return m_pInterface ? &m_pInterface->m_cvecCamFixedModeSource : nullptr; 
+    }
+    
+    CVector* GetFixedModeVector() const override 
+    { 
+        return m_pInterface ? &m_pInterface->m_cvecCamFixedModeVector : nullptr; 
+    }
+    
+    CVector* GetTargetHistoryPos() const override 
+    { 
+        return m_pInterface ? m_pInterface->m_aTargetHistoryPos : nullptr; 
+    }
+
+    CEntity* GetTargetEntity() const override;
     void     SetTargetEntity(CEntity* pEntity) override;
-};
+};