diff --git a/Client/game_sa/CSettingsSA.cpp b/Client/game_sa/CSettingsSA.cpp
index 24f29aa31f..9fe6cdf56b 100644
--- a/Client/game_sa/CSettingsSA.cpp
+++ b/Client/game_sa/CSettingsSA.cpp
@@ -494,6 +494,18 @@ float ms_fFOVCarMax = 100;            // at high vehicle velocity
 bool  ms_bFOVPlayerFromScript = false;
 bool  ms_bFOVVehicleFromScript = false;
 
+float ms_fovAiming = 70.0f;
+float ms_fovSniperAiming_Min = 0.0f; // default 15
+float ms_fovSniperAiming_Max = 179.0f; // default 70
+float ms_fov1stPersonAiming = 70.0f;
+float ms_fovSniperAiming = 70.0f;
+bool  ms_fovAimingFromScript = false;
+bool  ms_fovSniperAimingFromScript = false;
+bool  ms_fov1stPersonAimingFromScript = false;
+
+float ms_fov1stPerson = 60.0f;
+bool  ms_fov1stPersonFromScript = false;
+
 // consider moving this to the camera class - qaisjp
 float CSettingsSA::GetFieldOfViewPlayer()
 {
@@ -510,6 +522,102 @@ float CSettingsSA::GetFieldOfViewVehicleMax()
     return ms_fFOVCarMax;
 }
 
+float CSettingsSA::GetFieldOfViewAiming()
+{
+    CCamera* camera = pGame->GetCamera();
+    assert(camera);
+
+    CCam*    cam = camera->GetCam(camera->GetActiveCam());
+    assert(cam);
+
+    eCamMode cameraViewMode = static_cast<eCamMode>(camera->GetCam(camera->GetActiveCam())->GetMode());
+    return (cameraViewMode == MODE_AIMWEAPON || cameraViewMode == MODE_AIMWEAPON_FROMCAR || cameraViewMode == MODE_AIMWEAPON_ATTACHED) ? cam->GetFOV() : ms_fovAiming;
+}
+
+float CSettingsSA::GetFieldOfViewSniperAiming()
+{
+    CCamera* camera = pGame->GetCamera();
+    assert(camera);
+
+    CCam*    cam = camera->GetCam(camera->GetActiveCam());
+    assert(cam);
+
+    eCamMode cameraViewMode = static_cast<eCamMode>(camera->GetCam(camera->GetActiveCam())->GetMode());
+    return (cameraViewMode == MODE_SNIPER) ? cam->GetFOV() : ms_fovSniperAiming;
+}
+
+float CSettingsSA::GetFieldOfView1stPersonAiming()
+{
+    return ms_fov1stPersonAiming;
+}
+
+float CSettingsSA::GetFieldOfViewVehicleBump()
+{
+    return ms_fov1stPerson;
+}
+
+void CSettingsSA::ResetFieldOfViewPlayer()
+{
+    float fieldOfView;
+    g_pCore->GetCVars()->Get("fov", fieldOfView);
+    fieldOfView = Clamp(70.f, fieldOfView, 100.f);
+
+    ms_bFOVPlayerFromScript = false;
+    SetFieldOfViewPlayer(fieldOfView, false);
+}
+
+void CSettingsSA::ResetFieldOfViewVehicle()
+{
+    float fieldOfView;
+    g_pCore->GetCVars()->Get("fov", fieldOfView);
+    fieldOfView = Clamp(70.f, fieldOfView, 100.f);
+
+    ms_bFOVVehicleFromScript = false;
+    SetFieldOfViewVehicle(fieldOfView, false);
+}
+
+void CSettingsSA::ResetFieldOfViewVehicleMax()
+{
+    ms_bFOVVehicleFromScript = false;
+    SetFieldOfViewVehicleMax(100, false);
+}
+
+void CSettingsSA::ResetFieldOfViewSniperAiming()
+{
+    // Restore original bytes
+    // Zoom in
+    MemCpy((void*)0x51089D, "\xD8\x1D\xE0\x8C\x85\x00", 6);
+    MemCpy((void*)0x5108B6, "\xD8\x1D\xE0\x8C\x85\x00", 6);
+    MemCpy((void*)0x5108AA, "\xC7\x07\x00\x00\x8C\x42", 6);
+    MemCpy((void*)0x5108C7, "\xC7\x05\xE8\xFF\xB6\x00\x00\x00\x8C\x42", 10);
+
+    // Zoom out
+    MemCpy((void*)0x5109A1, "\xD8\x1D\x48\x8B\x85\x00", 6);
+    MemCpy((void*)0x5109BA, "\xD8\x1D\x48\x8B\x85\x00", 6);
+    MemCpy((void*)0x5109AE, "\xC7\x07\x00\x00\x70\x41", 6);
+    MemCpy((void*)0x5109C7, "\xC7\x05\xE8\xFF\xB6\x00\x00\x00\x70\x41 ", 10);   
+
+    ms_fovSniperAimingFromScript = false;
+    ms_fovSniperAiming = 70.0f;
+}
+
+void CSettingsSA::ResetFieldOfView1stPersonAiming()
+{
+    MemCpy((void*)0x510711, "\xC7\x07\x00\x00\x8C\x42", 6);
+    MemCpy((void*)0x511B71, "\xC7\x86\xB4\x00\x00\x00\x00\x00\x8C\x42", 10);
+
+    ms_fov1stPersonAimingFromScript = false;
+    ms_fov1stPersonAiming = 70.0f;
+}
+
+void CSettingsSA::ResetFieldOfViewVehicleBump()
+{
+    ms_fov1stPerson = 60.0f;
+    
+    MemCpy((void*)0x517EBA, "\x00\x00\x8C\x42", 4);
+    MemCpy((void*)0x51814B, "\x00\x00\x70\x42", 4);
+}
+
 void CSettingsSA::UpdateFieldOfViewFromSettings()
 {
     float fFieldOfView;
@@ -518,12 +626,22 @@ void CSettingsSA::UpdateFieldOfViewFromSettings()
     SetFieldOfViewPlayer(fFieldOfView, false);
     SetFieldOfViewVehicle(fFieldOfView, false);
     SetFieldOfViewVehicleMax(100, false);
+
+    ms_fovAiming = 70.0f;
+    ResetFieldOfViewSniperAiming();
+    ResetFieldOfView1stPersonAiming();
+    ResetFieldOfViewVehicleBump();
 }
 
 void CSettingsSA::ResetFieldOfViewFromScript()
 {
     ms_bFOVPlayerFromScript = false;
     ms_bFOVVehicleFromScript = false;
+    ms_fovAimingFromScript = false;
+    ms_fovSniperAimingFromScript = false;
+    ms_fov1stPersonAimingFromScript = false;
+    ms_fov1stPersonFromScript = false;
+
     UpdateFieldOfViewFromSettings();
 }
 
@@ -598,6 +716,115 @@ void CSettingsSA::SetFieldOfViewVehicleMax(float fAngle, bool bFromScript, bool
     MemPut<float>(0x0524BC5, ms_fFOVCarMax);
 }
 
+//////////////////////////////////////////////
+// This needs to be called every frame, because CCam::Process_AimWeapon overrides the FOV every frame
+//////////////////////////////////////////////
+bool CSettingsSA::SetFieldOfViewAiming(float angle, bool fromScript)
+{
+    if (!fromScript && ms_fovAimingFromScript)
+        return false;
+
+    CCamera* camera = pGame->GetCamera();
+    assert(camera);
+
+    CCam*    cam = camera->GetCam(camera->GetActiveCam());
+    assert(cam);
+
+    eCamMode cameraViewMode = static_cast<eCamMode>(cam->GetMode());
+
+    if (cameraViewMode != MODE_AIMWEAPON && cameraViewMode != MODE_AIMWEAPON_FROMCAR && cameraViewMode != MODE_AIMWEAPON_ATTACHED)
+        return false;
+
+    cam->SetFOV(angle);
+    ms_fovAimingFromScript = fromScript;
+    ms_fovAiming = angle;
+
+    return true;
+}
+
+bool CSettingsSA::SetFieldOfViewSniperAiming(float angle, bool fromScript)
+{
+    if (!fromScript && ms_fovSniperAimingFromScript)
+        return false;
+
+    CCamera* camera = pGame->GetCamera();
+    assert(camera);
+
+    CCam*    cam = camera->GetCam(camera->GetActiveCam());
+    assert(cam);
+
+    eCamMode cameraViewMode = static_cast<eCamMode>(cam->GetMode());
+
+    if (!ms_fovSniperAimingFromScript && fromScript)
+    {
+        // Patch sniper zoom-in/zoom-out limit
+        // Zoom in
+        MemPut<void*>(0x51089F, &ms_fovSniperAiming_Max);
+        MemPut<void*>(0x5108B8, &ms_fovSniperAiming_Max);
+        MemCpy((void*)0x5108AA, "\xC7\x07\x00\x00\x33\x43", 6);
+        MemCpy((void*)0x5108C7, "\xC7\x05\xE8\xFF\xB6\x00\x00\x00\x33\x43", 10);
+
+        // Zoom out
+        MemPut<void*>(0x5109A3, &ms_fovSniperAiming_Min);
+        MemPut<void*>(0x5109BC, &ms_fovSniperAiming_Min);
+        MemCpy((void*)0x5109AE, "\xC7\x07\x00\x00\x00\x00", 6);
+        MemCpy((void*)0x5109C7, "\xC7\x05\xE8\xFF\xB6\x00\x00\x00\x00\x00", 10);
+    }
+
+    if (cameraViewMode == MODE_SNIPER)
+    {
+        cam->SetFOV(angle);
+
+        *(float*)0xB6FFE8 = angle; // something related to FOV - need it to be set here
+    }
+
+    ms_fovSniperAimingFromScript = fromScript;
+    ms_fovSniperAiming = angle;
+
+    return true;
+}
+
+bool CSettingsSA::SetFieldOfView1stPersonAiming(float angle, bool fromScript)
+{
+    if (!fromScript && ms_fov1stPersonAimingFromScript)
+        return false;
+
+    CCamera* camera = pGame->GetCamera();
+    assert(camera);
+
+    CCam*    cam = camera->GetCam(camera->GetActiveCam());
+    assert(cam);
+
+    eCamMode cameraViewMode = static_cast<eCamMode>(cam->GetMode());
+
+    if (!ms_fov1stPersonAimingFromScript && fromScript)
+    {
+        MemSet((void*)0x510711, 0x90, 6);
+        MemSet((void*)0x511B71, 0x90, 10);
+    }
+
+    if (cameraViewMode == MODE_SNIPER || cameraViewMode == MODE_M16_1STPERSON || cameraViewMode == MODE_HELICANNON_1STPERSON || cameraViewMode == MODE_CAMERA || cameraViewMode == MODE_ROCKETLAUNCHER)
+        cam->SetFOV(angle);
+
+    ms_fov1stPersonAimingFromScript = fromScript;
+    ms_fov1stPersonAiming = angle;
+    return true;
+}
+
+bool CSettingsSA::SetFieldOfViewVehicleBump(float angle, bool fromScript)
+{
+    if (!fromScript && ms_fov1stPersonFromScript)
+        return false;
+
+    ms_fov1stPerson = angle;
+
+    MemCpy((void*)0x517EBA, &ms_fov1stPerson, 4);
+    MemCpy((void*)0x51814B, &ms_fov1stPerson, 4);
+
+    ms_fov1stPersonFromScript = fromScript;
+    return true;
+}
+
 ////////////////////////////////////////////////
 //
 // Vehicles LOD draw distance
diff --git a/Client/game_sa/CSettingsSA.h b/Client/game_sa/CSettingsSA.h
index 8e1443d117..a867b0566d 100644
--- a/Client/game_sa/CSettingsSA.h
+++ b/Client/game_sa/CSettingsSA.h
@@ -165,9 +165,23 @@ class CSettingsSA : public CGameSettings
     void  SetFieldOfViewPlayer(float fAngle, bool bFromScript, bool instant = false);
     void  SetFieldOfViewVehicle(float fAngle, bool bFromScript, bool instant = false);
     void  SetFieldOfViewVehicleMax(float fAngle, bool bFromScript, bool instant = false);
+    bool  SetFieldOfViewAiming(float angle, bool fromScript);
+    bool  SetFieldOfViewSniperAiming(float angle, bool fromScript);
+    bool  SetFieldOfView1stPersonAiming(float angle, bool fromScript);
+    bool  SetFieldOfViewVehicleBump(float angle, bool fromScript);
     float GetFieldOfViewPlayer();
     float GetFieldOfViewVehicle();
     float GetFieldOfViewVehicleMax();
+    float GetFieldOfViewAiming();
+    float GetFieldOfViewSniperAiming();
+    float GetFieldOfView1stPersonAiming();
+    float GetFieldOfViewVehicleBump();
+    void  ResetFieldOfViewPlayer();
+    void  ResetFieldOfViewVehicle();
+    void  ResetFieldOfViewVehicleMax();
+    void  ResetFieldOfViewSniperAiming();
+    void  ResetFieldOfView1stPersonAiming();
+    void  ResetFieldOfViewVehicleBump();
 
     void SetVehiclesLODDistance(float fVehiclesLODDistance, float fTrainsPlanesLODDistance, bool bFromScript);
     void ResetVehiclesLODDistance(bool bForceDefault = false);
diff --git a/Client/mods/deathmatch/logic/lua/CLuaFunctionParseHelpers.cpp b/Client/mods/deathmatch/logic/lua/CLuaFunctionParseHelpers.cpp
index eb3cb08904..be04ff5bc4 100644
--- a/Client/mods/deathmatch/logic/lua/CLuaFunctionParseHelpers.cpp
+++ b/Client/mods/deathmatch/logic/lua/CLuaFunctionParseHelpers.cpp
@@ -554,6 +554,9 @@ ADD_ENUM(FOV_MODE_PLAYER, "player")
 ADD_ENUM(FOV_MODE_VEHICLE, "vehicle")
 ADD_ENUM(FOV_MODE_VEHICLE_MAX, "vehicle_max")
 ADD_ENUM(FOV_MODE_AIMING, "aiming")
+ADD_ENUM(FOV_MODE_SNIPER_AIMING, "sniper_aiming")
+ADD_ENUM(FOV_MODE_1ST_PERSON_AIMING, "1stperson_aiming")
+ADD_ENUM(FOV_MODE_VEHICLE_BUMP, "vehicle_bump")
 IMPLEMENT_ENUM_END("fieldofview-mode")
 
 IMPLEMENT_ENUM_BEGIN(eTrayIconType)
diff --git a/Client/mods/deathmatch/logic/lua/CLuaFunctionParseHelpers.h b/Client/mods/deathmatch/logic/lua/CLuaFunctionParseHelpers.h
index da35c0d1cc..b81a380321 100644
--- a/Client/mods/deathmatch/logic/lua/CLuaFunctionParseHelpers.h
+++ b/Client/mods/deathmatch/logic/lua/CLuaFunctionParseHelpers.h
@@ -130,7 +130,10 @@ enum eFieldOfViewMode
     FOV_MODE_PLAYER,
     FOV_MODE_VEHICLE,
     FOV_MODE_VEHICLE_MAX,
-    FOV_MODE_AIMING
+    FOV_MODE_AIMING,
+    FOV_MODE_SNIPER_AIMING,
+    FOV_MODE_1ST_PERSON_AIMING,
+    FOV_MODE_VEHICLE_BUMP,
 };
 DECLARE_ENUM(eFieldOfViewMode);
 
diff --git a/Client/mods/deathmatch/logic/luadefs/CLuaCameraDefs.cpp b/Client/mods/deathmatch/logic/luadefs/CLuaCameraDefs.cpp
index 9c8cb6cd83..fdb6f781a7 100644
--- a/Client/mods/deathmatch/logic/luadefs/CLuaCameraDefs.cpp
+++ b/Client/mods/deathmatch/logic/luadefs/CLuaCameraDefs.cpp
@@ -28,12 +28,13 @@ void CLuaCameraDefs::LoadFunctions()
         {"getCameraTarget", ArgumentParserWarn<false, GetCameraTarget>},
         {"getCameraInterior", ArgumentParserWarn<false, GetCameraInterior>},
         {"getCameraGoggleEffect", ArgumentParserWarn<false, GetCameraGoggleEffect>},
-        {"getCameraFieldOfView", GetCameraFieldOfView},
+        {"getCameraFieldOfView", ArgumentParserWarn<false, GetCameraFieldOfView>},
         {"getCameraDrunkLevel", ArgumentParserWarn<false, GetCameraDrunkLevel>},
 
         // Cam set funcs
         {"setCameraMatrix", SetCameraMatrix},
-        {"setCameraFieldOfView", SetCameraFieldOfView},
+        {"setCameraFieldOfView", ArgumentParserWarn<false, SetCameraFieldOfView>},
+        {"resetCameraFieldOfView", ArgumentParser<ResetCameraFieldOfView>},
         {"setCameraTarget", SetCameraTarget},
         {"setCameraInterior", SetCameraInterior},
         {"fadeCamera", FadeCamera},
@@ -77,6 +78,7 @@ void CLuaCameraDefs::AddClass(lua_State* luaVM)
     lua_classfunction(luaVM, "setRotation", OOP_SetCameraRotation);
     lua_classfunction(luaVM, "setMatrix", "setCameraMatrix");
     lua_classfunction(luaVM, "setFieldOfView", "setCameraFieldOfView");
+    lua_classfunction(luaVM, "resetFieldOfView", "resetCameraFieldOfView");
     lua_classfunction(luaVM, "setInterior", "setCameraInterior");
     lua_classfunction(luaVM, "setTarget", "setCameraTarget");
     lua_classfunction(luaVM, "setViewMode", "setCameraViewMode");
@@ -161,6 +163,29 @@ std::string CLuaCameraDefs::GetCameraGoggleEffect()
         return "normal";
 }
 
+std::variant<float, bool> CLuaCameraDefs::GetCameraFieldOfView(eFieldOfViewMode mode)
+{
+    switch (mode)
+    {
+        case FOV_MODE_PLAYER:
+            return g_pGame->GetSettings()->GetFieldOfViewPlayer();
+        case FOV_MODE_VEHICLE:
+            return g_pGame->GetSettings()->GetFieldOfViewVehicle();
+        case FOV_MODE_VEHICLE_MAX:
+            return g_pGame->GetSettings()->GetFieldOfViewVehicleMax();
+        case FOV_MODE_AIMING:
+            return g_pGame->GetSettings()->GetFieldOfViewAiming();
+        case FOV_MODE_SNIPER_AIMING:
+            return g_pGame->GetSettings()->GetFieldOfViewSniperAiming();
+        case FOV_MODE_1ST_PERSON_AIMING:
+            return g_pGame->GetSettings()->GetFieldOfView1stPersonAiming();
+        case FOV_MODE_VEHICLE_BUMP:
+            return g_pGame->GetSettings()->GetFieldOfViewVehicleBump();
+        default:
+            return false;
+    }
+}
+
 unsigned char CLuaCameraDefs::GetCameraDrunkLevel()
 {
     return g_pGame->GetPlayerInfo()->GetCamDrunkLevel();
@@ -211,88 +236,60 @@ int CLuaCameraDefs::SetCameraMatrix(lua_State* luaVM)
     return 1;
 }
 
-// Only when onfoot/invehicle
-int CLuaCameraDefs::SetCameraFieldOfView(lua_State* luaVM)
+bool CLuaCameraDefs::SetCameraFieldOfView(eFieldOfViewMode mode, float fov, std::optional<bool> instant)
 {
-    float            fFOV;
-    eFieldOfViewMode eMode;
-    bool             instant;
-    CScriptArgReader argStream(luaVM);
-    argStream.ReadEnumString(eMode);
-    argStream.ReadNumber(fFOV);
-    argStream.ReadBool(instant, false);
+    if (fov < 0 || fov > 179)
+        throw std::invalid_argument("Invalid FOV range (0-179)");
 
-    if (!argStream.HasErrors())
+    switch (mode)
     {
-        while (true)
-        {
-            if (fFOV < 0 || fFOV > 179)
-            {
-                argStream.SetCustomError("Invalid FOV range (0-179)");
-                break;
-            }
-
-            if (eMode == FOV_MODE_PLAYER)
-            {
-                g_pGame->GetSettings()->SetFieldOfViewPlayer(fFOV, true, instant);
-            }
-            else if (eMode == FOV_MODE_VEHICLE)
-            {
-                g_pGame->GetSettings()->SetFieldOfViewVehicle(fFOV, true, instant);
-            }
-            else if (eMode == FOV_MODE_VEHICLE_MAX)
-            {
-                g_pGame->GetSettings()->SetFieldOfViewVehicleMax(fFOV, true, instant);
-            }
-            else
-            {
-                argStream.m_iIndex = 1;
-                argStream.SetCustomError(SString("Enum not yet implemented: " + EnumToString(eMode)));
-                break;
-            }
-
-            lua_pushboolean(luaVM, true);
-            return 1;
-        }
+        case FOV_MODE_PLAYER:
+            g_pGame->GetSettings()->SetFieldOfViewPlayer(fov, true, instant.value_or(false));
+            break;
+        case FOV_MODE_VEHICLE:
+            g_pGame->GetSettings()->SetFieldOfViewVehicle(fov, true, instant.value_or(false));
+            break;
+        case FOV_MODE_VEHICLE_MAX:
+            g_pGame->GetSettings()->SetFieldOfViewVehicleMax(fov, true, instant.value_or(false));
+            break;
+        case FOV_MODE_AIMING:
+            return g_pGame->GetSettings()->SetFieldOfViewAiming(fov, true);
+        case FOV_MODE_SNIPER_AIMING:
+            return g_pGame->GetSettings()->SetFieldOfViewSniperAiming(fov, true);
+        case FOV_MODE_1ST_PERSON_AIMING:
+            return g_pGame->GetSettings()->SetFieldOfView1stPersonAiming(fov, true);
+        case FOV_MODE_VEHICLE_BUMP:
+            return g_pGame->GetSettings()->SetFieldOfViewVehicleBump(fov, true);
     }
 
-    m_pScriptDebugging->LogCustom(luaVM, argStream.GetFullErrorMessage());
-    lua_pushboolean(luaVM, false);
-    return 1;
+    return true;
 }
 
-// Only when onfoot/invehicle
-int CLuaCameraDefs::GetCameraFieldOfView(lua_State* luaVM)
+void CLuaCameraDefs::ResetCameraFieldOfView(eFieldOfViewMode mode)
 {
-    eFieldOfViewMode eMode;
-    CScriptArgReader argStream(luaVM);
-
-    argStream.ReadEnumString(eMode);
-
-    if (!argStream.HasErrors())
+    switch (mode)
     {
-        float fFOV;
-        if (eMode == FOV_MODE_PLAYER)
-            fFOV = g_pGame->GetSettings()->GetFieldOfViewPlayer();
-        else if (eMode == FOV_MODE_VEHICLE)
-            fFOV = g_pGame->GetSettings()->GetFieldOfViewVehicle();
-        else if (eMode == FOV_MODE_VEHICLE_MAX)
-            fFOV = g_pGame->GetSettings()->GetFieldOfViewVehicleMax();
-        else
-        {
-            argStream.m_iIndex = 1;
-            m_pScriptDebugging->LogCustom(luaVM, SString("Enum not yet implemented: " + EnumToString(eMode)));
-            lua_pushboolean(luaVM, false);
-            return 1;
-        }
-
-        lua_pushnumber(luaVM, fFOV);
-        return 1;
+        case FOV_MODE_PLAYER:
+            g_pGame->GetSettings()->ResetFieldOfViewPlayer();
+            break;
+        case FOV_MODE_VEHICLE:
+            g_pGame->GetSettings()->ResetFieldOfViewVehicle();
+            break;
+        case FOV_MODE_VEHICLE_MAX:
+            g_pGame->GetSettings()->ResetFieldOfViewVehicleMax();
+            break;
+        case FOV_MODE_AIMING:
+            break;
+        case FOV_MODE_SNIPER_AIMING:
+            g_pGame->GetSettings()->ResetFieldOfViewSniperAiming();
+            break;
+        case FOV_MODE_1ST_PERSON_AIMING:
+            g_pGame->GetSettings()->ResetFieldOfView1stPersonAiming();
+            break;
+        case FOV_MODE_VEHICLE_BUMP:
+            g_pGame->GetSettings()->ResetFieldOfViewVehicleBump();
+            break;
     }
-
-    m_pScriptDebugging->LogCustom(luaVM, argStream.GetFullErrorMessage());
-    lua_pushboolean(luaVM, false);
-    return 1;
 }
 
 int CLuaCameraDefs::SetCameraTarget(lua_State* luaVM)
diff --git a/Client/mods/deathmatch/logic/luadefs/CLuaCameraDefs.h b/Client/mods/deathmatch/logic/luadefs/CLuaCameraDefs.h
index b233d4e39c..713a9f6379 100644
--- a/Client/mods/deathmatch/logic/luadefs/CLuaCameraDefs.h
+++ b/Client/mods/deathmatch/logic/luadefs/CLuaCameraDefs.h
@@ -29,14 +29,15 @@ class CLuaCameraDefs : public CLuaDefs
     static std::variant<CClientEntity*, bool>                                      GetCameraTarget();
     static unsigned char                                                           GetCameraInterior();
     static std::string                                                             GetCameraGoggleEffect();
-    LUA_DECLARE(GetCameraFieldOfView);
+    static std::variant<float, bool>                                               GetCameraFieldOfView(eFieldOfViewMode mode);
     static unsigned char GetCameraDrunkLevel();
 
     // Cam set funcs
     LUA_DECLARE(SetCameraMatrix);
     LUA_DECLARE(SetCameraTarget);
     LUA_DECLARE(SetCameraInterior);
-    LUA_DECLARE(SetCameraFieldOfView);
+    static bool SetCameraFieldOfView(eFieldOfViewMode mode, float fov, std::optional<bool> instant);
+    static void ResetCameraFieldOfView(eFieldOfViewMode mode);
     LUA_DECLARE(FadeCamera);
     LUA_DECLARE(SetCameraClip);
     LUA_DECLARE(GetCameraClip);
diff --git a/Client/sdk/game/CSettings.h b/Client/sdk/game/CSettings.h
index 624b166fb5..4861b8d328 100644
--- a/Client/sdk/game/CSettings.h
+++ b/Client/sdk/game/CSettings.h
@@ -158,10 +158,25 @@ class CGameSettings
     virtual void SetFieldOfViewPlayer(float fAngle, bool bFromScript, bool instant = false) = 0;
     virtual void SetFieldOfViewVehicle(float fAngle, bool bFromScript, bool instant = false) = 0;
     virtual void SetFieldOfViewVehicleMax(float fAngle, bool bFromScript, bool instant = false) = 0;
+    virtual bool SetFieldOfViewAiming(float angle, bool fromScript) = 0;
+    virtual bool SetFieldOfViewSniperAiming(float angle, bool fromScript) = 0;
+    virtual bool SetFieldOfView1stPersonAiming(float angle, bool fromScript) = 0;
+    virtual bool SetFieldOfViewVehicleBump(float angle, bool fromScript) = 0;
 
     virtual float GetFieldOfViewPlayer() = 0;
     virtual float GetFieldOfViewVehicle() = 0;
     virtual float GetFieldOfViewVehicleMax() = 0;
+    virtual float GetFieldOfViewAiming() = 0;
+    virtual float GetFieldOfViewSniperAiming() = 0;
+    virtual float GetFieldOfView1stPersonAiming() = 0;
+    virtual float GetFieldOfViewVehicleBump() = 0;
+
+    virtual void ResetFieldOfViewPlayer() = 0;
+    virtual void ResetFieldOfViewVehicle() = 0;
+    virtual void ResetFieldOfViewVehicleMax() = 0;
+    virtual void ResetFieldOfViewSniperAiming() = 0;
+    virtual void ResetFieldOfView1stPersonAiming() = 0;
+    virtual void ResetFieldOfViewVehicleBump() = 0;
 
     virtual void SetVehiclesLODDistance(float fVehiclesLODDistance, float fTrainsPlanesLODDistance, bool bFromScript) = 0;
     virtual void ResetVehiclesLODDistance(bool bForceDefault = false) = 0;