diff --git a/CHANGELOG.md b/CHANGELOG.md
index 9eebb405b..86e109931 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,36 @@
 
 Over here will be noted all the update change logs.
 
+## v1.6.6 - [Release](https://github.com/swiftly-solution/swiftly/releases/tag/v1.6.6)
+
+### Database
+
+- Add optional argument to skip connecting to `default_connection`
+
+### Crash Reporter
+
+- Add file location of the function from Call Stack
+
+### Utils
+
+- Added: GetPluginsList
+
+### Menus
+
+- Remove screen menus on windows as they crash without a dump
+
+### CCheckTransmitInfo
+
+- Fix self casting
+
+### Events
+
+- Fix event return values
+
+### SDK
+
+- Fix FollowServerRules check not working
+
 ## v1.6.5 - [Release](https://github.com/swiftly-solution/swiftly/releases/tag/v1.6.5)
 
 ### HTTP
diff --git a/plugin_files/gamedata/cs2/sdk.json b/plugin_files/gamedata/cs2/sdk.json
index 5e8f2d4e1..931ce740c 100644
--- a/plugin_files/gamedata/cs2/sdk.json
+++ b/plugin_files/gamedata/cs2/sdk.json
@@ -5598,18 +5598,6 @@
             "type": 11
         }
     },
-    "CBreachCharge": {
-        "Parent": {
-            "field": "CCSWeaponBase",
-            "type": 11
-        }
-    },
-    "CBreachChargeProjectile": {
-        "Parent": {
-            "field": "CBaseGrenade",
-            "type": 11
-        }
-    },
     "CBreakableStageHelper": {
         "CurrentStage": {
             "field": "m_nCurrentStage",
@@ -5620,18 +5608,6 @@
             "type": 2
         }
     },
-    "CBumpMine": {
-        "Parent": {
-            "field": "CCSWeaponBase",
-            "type": 11
-        }
-    },
-    "CBumpMineProjectile": {
-        "Parent": {
-            "field": "CBaseGrenade",
-            "type": 11
-        }
-    },
     "CBuoyancyHelper": {
         "FluidType": {
             "field": "m_nFluidType",
@@ -5821,6 +5797,10 @@
             "field": "m_bHasCommunicationAbuseMute",
             "type": 10
         },
+        "UiCommunicationMuteFlags": {
+            "field": "m_uiCommunicationMuteFlags",
+            "type": 6
+        },
         "CrosshairCodes": {
             "field": "m_szCrosshairCodes",
             "type": 13
@@ -5930,6 +5910,10 @@
             "field": "m_unActiveQuestId",
             "type": 5
         },
+        "RtActiveMissionPeriod": {
+            "field": "m_rtActiveMissionPeriod",
+            "type": 6
+        },
         "PlayerTvControlFlags": {
             "field": "m_unPlayerTvControlFlags",
             "type": 6
@@ -5946,6 +5930,10 @@
             "field": "m_uiAbandonRecordedReason",
             "type": 6
         },
+        "NetworkDisconnectionReason": {
+            "field": "m_eNetworkDisconnectionReason",
+            "type": 6
+        },
         "CannotBeKicked": {
             "field": "m_bCannotBeKicked",
             "type": 10
@@ -7026,6 +7014,12 @@
             "type": 11
         }
     },
+    "CCS_PortraitWorldCallbackHandler": {
+        "Parent": {
+            "field": "C_BaseEntity",
+            "type": 11
+        }
+    },
     "CCitadelSoundOpvarSetOBB": {
         "StackName": {
             "field": "m_iszStackName",
@@ -9827,12 +9821,6 @@
             "type": 11
         }
     },
-    "CTablet": {
-        "Parent": {
-            "field": "CCSWeaponBase",
-            "type": 11
-        }
-    },
     "CTakeDamageInfo": {
         "DamageForce": {
             "field": "m_vecDamageForce",
@@ -9987,30 +9975,12 @@
             "type": 11
         }
     },
-    "CTripWireFire": {
-        "Parent": {
-            "field": "CBaseCSGrenade",
-            "type": 11
-        }
-    },
-    "CTripWireFireProjectile": {
-        "Parent": {
-            "field": "CBaseGrenade",
-            "type": 11
-        }
-    },
     "CWaterSplasher": {
         "Parent": {
             "field": "C_BaseModelEntity",
             "type": 11
         }
     },
-    "CWeaponZoneRepulsor": {
-        "Parent": {
-            "field": "CCSWeaponBaseGun",
-            "type": 11
-        }
-    },
     "CWorldCompositionChunkReferenceElement_t": {
         "StrMapToLoad": {
             "field": "m_strMapToLoad",
@@ -21862,10 +21832,6 @@
             "type": 37,
             "size": 32
         },
-        "ServerQuestID": {
-            "field": "m_nServerQuestID",
-            "type": 2
-        },
         "MinimapMins": {
             "field": "m_vMinimapMins",
             "type": 21
@@ -21883,6 +21849,10 @@
             "field": "m_bSpawnedTerrorHuntHeavy",
             "type": 10
         },
+        "UllLocalMatchID": {
+            "field": "m_ullLocalMatchID",
+            "type": 7
+        },
         "EndMatchMapGroupVoteTypes": {
             "field": "m_nEndMatchMapGroupVoteTypes",
             "type": 31,
@@ -23193,10 +23163,6 @@
             "field": "m_flLastTimeInAir",
             "type": 8
         },
-        "LastDeployTime": {
-            "field": "m_flLastDeployTime",
-            "type": 8
-        },
         "LastEmptySoundCmdNum": {
             "field": "m_nLastEmptySoundCmdNum",
             "type": 2
@@ -26292,42 +26258,6 @@
             "type": 11
         }
     },
-    "CFists": {
-        "PlayingUninterruptableAct": {
-            "field": "m_bPlayingUninterruptableAct",
-            "type": 10
-        },
-        "UninterruptableActivity": {
-            "field": "m_nUninterruptableActivity",
-            "type": 6
-        },
-        "RestorePrevWep": {
-            "field": "m_bRestorePrevWep",
-            "type": 10
-        },
-        "WeaponBeforePrevious": {
-            "field": "m_hWeaponBeforePrevious",
-            "type": 17,
-            "classname": "CBasePlayerWeapon"
-        },
-        "WeaponPrevious": {
-            "field": "m_hWeaponPrevious",
-            "type": 17,
-            "classname": "CBasePlayerWeapon"
-        },
-        "DelayedHardPunchIncoming": {
-            "field": "m_bDelayedHardPunchIncoming",
-            "type": 10
-        },
-        "DestroyAfterTaunt": {
-            "field": "m_bDestroyAfterTaunt",
-            "type": 10
-        },
-        "Parent": {
-            "field": "CCSWeaponBase",
-            "type": 11
-        }
-    },
     "CFlashbang": {
         "Parent": {
             "field": "CBaseCSGrenade",
@@ -29729,12 +29659,6 @@
             "type": 11
         }
     },
-    "CMelee": {
-        "Parent": {
-            "field": "CCSWeaponBase",
-            "type": 11
-        }
-    },
     "CMessage": {
         "Message": {
             "field": "m_iszMessage",
@@ -33824,31 +33748,6 @@
             "type": 11
         }
     },
-    "CSensorGrenade": {
-        "Parent": {
-            "field": "CBaseCSGrenade",
-            "type": 11
-        }
-    },
-    "CSensorGrenadeProjectile": {
-        "ExpireTime": {
-            "field": "m_fExpireTime",
-            "type": 8
-        },
-        "NextDetectPlayerSound": {
-            "field": "m_fNextDetectPlayerSound",
-            "type": 8
-        },
-        "DisplayGrenade": {
-            "field": "m_hDisplayGrenade",
-            "type": 17,
-            "classname": "CBaseEntity"
-        },
-        "Parent": {
-            "field": "CBaseCSGrenadeProjectile",
-            "type": 11
-        }
-    },
     "CServerOnlyEntity": {
         "Parent": {
             "field": "CBaseEntity",
@@ -35794,12 +35693,6 @@
             "type": 11
         }
     },
-    "CTriggerTripWire": {
-        "Parent": {
-            "field": "CBaseTrigger",
-            "type": 11
-        }
-    },
     "CTriggerVolume": {
         "FilterName": {
             "field": "m_iFilterName",
@@ -36004,24 +35897,6 @@
             "type": 11
         }
     },
-    "CWeaponShield": {
-        "BulletDamageAbsorbed": {
-            "field": "m_flBulletDamageAbsorbed",
-            "type": 8
-        },
-        "LastBulletHitSoundTime": {
-            "field": "m_flLastBulletHitSoundTime",
-            "type": 8
-        },
-        "DisplayHealth": {
-            "field": "m_flDisplayHealth",
-            "type": 8
-        },
-        "Parent": {
-            "field": "CCSWeaponBaseGun",
-            "type": 11
-        }
-    },
     "CWeaponTaser": {
         "FireTime": {
             "field": "m_fFireTime",
diff --git a/plugin_files/gamedata/cs2/sdk_types.json b/plugin_files/gamedata/cs2/sdk_types.json
index 88824b27a..134b32335 100644
--- a/plugin_files/gamedata/cs2/sdk_types.json
+++ b/plugin_files/gamedata/cs2/sdk_types.json
@@ -605,19 +605,11 @@
         "k_CSPlayerBlockingUseAction_DefusingWithKit": 2,
         "k_CSPlayerBlockingUseAction_HostageGrabbing": 3,
         "k_CSPlayerBlockingUseAction_HostageDropping": 4,
-        "k_CSPlayerBlockingUseAction_OpeningSafe": 5,
-        "k_CSPlayerBlockingUseAction_EquippingParachute": 6,
-        "k_CSPlayerBlockingUseAction_EquippingHeavyArmor": 7,
-        "k_CSPlayerBlockingUseAction_EquippingContract": 8,
-        "k_CSPlayerBlockingUseAction_EquippingTabletUpgrade": 9,
-        "k_CSPlayerBlockingUseAction_TakingOffHeavyArmor": 10,
-        "k_CSPlayerBlockingUseAction_PayingToOpenDoor": 11,
-        "k_CSPlayerBlockingUseAction_CancelingSpawnRappelling": 12,
-        "k_CSPlayerBlockingUseAction_EquippingExoJump": 13,
-        "k_CSPlayerBlockingUseAction_PickingUpBumpMine": 14,
-        "k_CSPlayerBlockingUseAction_MapLongUseEntity_Pickup": 15,
-        "k_CSPlayerBlockingUseAction_MapLongUseEntity_Place": 16,
-        "k_CSPlayerBlockingUseAction_MaxCount": 17
+        "k_CSPlayerBlockingUseAction_EquippingHeavyArmor": 5,
+        "k_CSPlayerBlockingUseAction_TakingOffHeavyArmor": 6,
+        "k_CSPlayerBlockingUseAction_MapLongUseEntity_Pickup": 7,
+        "k_CSPlayerBlockingUseAction_MapLongUseEntity_Place": 8,
+        "k_CSPlayerBlockingUseAction_MaxCount": 9
     },
     "CSPlayerState": {
         "STATE_ACTIVE": 0,
@@ -668,14 +660,7 @@
         "WEAPONTYPE_GRENADE": 9,
         "WEAPONTYPE_EQUIPMENT": 10,
         "WEAPONTYPE_STACKABLEITEM": 11,
-        "WEAPONTYPE_FISTS": 12,
-        "WEAPONTYPE_BREACHCHARGE": 13,
-        "WEAPONTYPE_BUMPMINE": 14,
-        "WEAPONTYPE_TABLET": 15,
-        "WEAPONTYPE_MELEE": 16,
-        "WEAPONTYPE_SHIELD": 17,
-        "WEAPONTYPE_ZONE_REPULSOR": 18,
-        "WEAPONTYPE_UNKNOWN": 19
+        "WEAPONTYPE_UNKNOWN": 12
     },
     "CanPlaySequence_t": {
         "CANNOT_PLAY": 0,
@@ -988,9 +973,7 @@
         "GRENADE_TYPE_FIRE": 2,
         "GRENADE_TYPE_DECOY": 3,
         "GRENADE_TYPE_SMOKE": 4,
-        "GRENADE_TYPE_SENSOR": 5,
-        "GRENADE_TYPE_SNOWBALL": 6,
-        "GRENADE_TYPE_TOTAL": 7
+        "GRENADE_TYPE_TOTAL": 5
     },
     "HierarchyType_t": {
         "HIERARCHY_NONE": 0,
diff --git a/protobufs/cs2/cstrike15_gcmessages.proto b/protobufs/cs2/cstrike15_gcmessages.proto
index 485974efd..308bd9f19 100644
--- a/protobufs/cs2/cstrike15_gcmessages.proto
+++ b/protobufs/cs2/cstrike15_gcmessages.proto
@@ -109,6 +109,8 @@ enum ECsgoGCMsg {
 	k_EMsgGCCStrike15_v2_Client2GcAckXPShopTracks = 9222;
 	k_EMsgGCCStrike15_v2_MatchmakingGC2ClientSearchStats = 9223;
 	k_EMsgGCCStrike15_v2_PremierSeasonSummary = 9224;
+	k_EMsgGCCStrike15_v2_RequestRecurringMissionSchedule = 9225;
+	k_EMsgGCCStrike15_v2_RecurringMissionSchema = 9226;
 }
 
 enum ECsgoSteamUserStat {
@@ -117,6 +119,11 @@ enum ECsgoSteamUserStat {
 	k_ECsgoSteamUserStat_SurvivedDangerZone = 3;
 }
 
+enum QuestType {
+	k_EQuestType_Operation = 1;
+	k_EQuestType_RecurringMission = 2;
+}
+
 enum EClientReportingVersion {
 	k_EClientReportingVersion_OldVersion = 0;
 	k_EClientReportingVersion_BetaVersion = 1;
@@ -345,6 +352,10 @@ message PlayerQuestData {
 		optional uint64 quest_id = 1;
 		optional int32 quest_normal_points_earned = 2;
 		optional int32 quest_bonus_points_earned = 3;
+		optional int32 quest_normal_points_required = 4;
+		optional int32 quest_reward_xp = 5;
+		optional int32 quest_period = 6;
+		optional .QuestType quest_type = 7 [default = k_EQuestType_Operation];
 	}
 
 	optional uint32 quester_account_id = 1;
@@ -541,6 +552,7 @@ message CMsgGCCStrike15_v2_MatchmakingGC2ServerReserve {
 	repeated .OperationalVarValue op_var_values = 19;
 	optional uint32 socache_control = 20;
 	repeated int32 teammate_colors = 21;
+	optional uint32 match_id_additional = 22;
 }
 
 message CMsgGCCStrike15_v2_MatchmakingServerReservationResponse {
@@ -1193,6 +1205,12 @@ message CSOAccountRecurringSubscription {
 	optional uint32 time_initiated = 2;
 }
 
+message CSOGameAccountSteamChina {
+	optional uint32 time_last_update = 1;
+	optional uint32 time_comms_ban = 2;
+	optional uint32 time_play_ban = 3;
+}
+
 message CSOPersonaDataPublic {
 	optional int32 player_level = 1;
 	optional .PlayerCommendationInfo commendation = 2;
@@ -1201,6 +1219,13 @@ message CSOPersonaDataPublic {
 	optional uint32 xp_trail_level = 5;
 }
 
+message CSOAccountRecurringMission {
+	optional uint32 account_id = 1;
+	optional uint32 mission_id = 2;
+	optional uint32 period = 3;
+	optional uint32 progress = 4;
+}
+
 message CMsgGCCStrike15_v2_GC2ClientNotifyXPShop {
 	optional .CSOAccountXpShop prematch = 1;
 	optional .CSOAccountXpShop postmatch = 2;
@@ -1503,3 +1528,15 @@ message CMsgGCCStrike15_v2_GC2ClientInitSystem_Response {
 message CMsgGCCStrike15_v2_SetPlayerLeaderboardSafeName {
 	optional string leaderboard_safe_name = 1;
 }
+
+message CMsgRequestRecurringMissionSchedule {
+}
+
+message CMsgRecurringMissionSchema {
+	message MissionTemplateList {
+		optional uint32 period = 1;
+		repeated bytes mission_templates = 2;
+	}
+
+	repeated .CMsgRecurringMissionSchema.MissionTemplateList missions = 1;
+}
diff --git a/protobufs/cs2/cstrike15_usermessages.proto b/protobufs/cs2/cstrike15_usermessages.proto
index 9bba307a7..5fb05d90b 100644
--- a/protobufs/cs2/cstrike15_usermessages.proto
+++ b/protobufs/cs2/cstrike15_usermessages.proto
@@ -79,6 +79,7 @@ enum ECstrike15UserMessages {
 	CS_UM_ShootInfo = 383;
 	CS_UM_CounterStrafe = 385;
 	CS_UM_DamagePrediction = 386;
+	CS_UM_RecurringMissionSchema = 387;
 }
 
 enum ECSUsrMsg_DisconnectToLobby_Action {
@@ -611,3 +612,8 @@ message CCSUsrMsg_DamagePrediction {
 	optional .CMsgQAngle shoot_dir = 7;
 	optional .CMsgQAngle aim_punch = 8;
 }
+
+message CCSUsrMsg_RecurringMissionSchema {
+	optional uint32 period = 1;
+	optional bytes mission_schema = 2;
+}
diff --git a/src/core/entrypoint.cpp b/src/core/entrypoint.cpp
index 2f6a28c25..da608c666 100644
--- a/src/core/entrypoint.cpp
+++ b/src/core/entrypoint.cpp
@@ -243,7 +243,7 @@ bool OnClientCommand(int playerid, std::string command)
     bool response = true;
     try
     {
-        response = std::any_cast<bool>(data.GetData<std::any>("event_return"));
+        response = std::any_cast<bool>(data.GetAnyData("event_return"));
     }
     catch (std::bad_any_cast& e)
     {
diff --git a/src/plugins/manager.cpp b/src/plugins/manager.cpp
index 8b36cba28..8b718918d 100644
--- a/src/plugins/manager.cpp
+++ b/src/plugins/manager.cpp
@@ -214,7 +214,7 @@ EXT_API int swiftly_TriggerEvent(const char* ext_name, const char* evName, void*
 {
     ClassData data({ { "plugin_name", std::string(ext_name) } }, "Event", nullptr);
     auto result = g_pluginManager.ExecuteEvent(ext_name, evName, *(std::vector<std::any>*)args, &data);
-    *reinterpret_cast<std::any*>(eventReturn) = data.GetData<std::any>("event_return");
+    *reinterpret_cast<std::any*>(eventReturn) = data.GetAnyData("event_return");
 
     return (int)result;
 }
\ No newline at end of file
diff --git a/src/scripting/core.cpp b/src/scripting/core.cpp
index e9cb1612a..ff3f06359 100644
--- a/src/scripting/core.cpp
+++ b/src/scripting/core.cpp
@@ -77,6 +77,17 @@ void SetupScriptingEnvironment(PluginObject plugin, EContext* ctx)
             arguments.push_back(context->GetArgumentAsString(i));
         function_call += "(" + implode(arguments, ", ") + ")";
 
+        if (context->GetPluginContext()->GetKind() == ContextKinds::Lua) {
+            lua_Debug ar;
+            lua_State* L = context->GetPluginContext()->GetLuaState();
+
+            if (lua_getstack(L, 1, &ar)) {
+                if (lua_getinfo(L, "Sl", &ar)) {
+                    function_call += string_format(" -> %s:%d", ar.short_src, ar.currentline);
+                }
+            }
+        }
+
         context->temporaryData.push_back(g_callStack.RegisterPluginCallstack(FetchPluginName(context->GetPluginContext()), function_call));
         g_ResourceMonitor.StartTime("core", replace(context->GetFunctionKey(), " ", "::"));
     });
diff --git a/src/scripting/engine/gameevents.cpp b/src/scripting/engine/gameevents.cpp
index 6e11492de..092309861 100644
--- a/src/scripting/engine/gameevents.cpp
+++ b/src/scripting/engine/gameevents.cpp
@@ -32,7 +32,7 @@ bool OnClientChat(int playerid, std::string text, bool teamonly)
     bool response = true;
     try
     {
-        response = std::any_cast<bool>(data.GetData<std::any>("event_return"));
+        response = std::any_cast<bool>(data.GetAnyData("event_return"));
     }
     catch (std::bad_any_cast& e)
     {
@@ -55,7 +55,7 @@ dyno::ReturnAction Hook_CGameRules_TerminateRound(dyno::CallbackType type, dyno:
     bool response = true;
     try
     {
-        response = std::any_cast<bool>(data.GetData<std::any>("event_return"));
+        response = std::any_cast<bool>(data.GetAnyData("event_return"));
     }
     catch (std::bad_any_cast& e)
     {
@@ -81,7 +81,7 @@ dyno::ReturnAction Hook_CEntityIdentity_AcceptInput(dyno::CallbackType type, dyn
     bool response = true;
     try
     {
-        response = std::any_cast<bool>(data.GetData<std::any>("event_return"));
+        response = std::any_cast<bool>(data.GetAnyData("event_return"));
     }
     catch (std::bad_any_cast& e)
     {
@@ -123,7 +123,7 @@ dyno::ReturnAction Hook_CBaseEntity_TakeDamage(dyno::CallbackType type, dyno::IH
     bool response = true;
     try
     {
-        response = std::any_cast<bool>(data.GetData<std::any>("event_return"));
+        response = std::any_cast<bool>(data.GetAnyData("event_return"));
     }
     catch (std::bad_any_cast& e)
     {
diff --git a/src/scripting/network/database.cpp b/src/scripting/network/database.cpp
index b3c6a7b83..59d9b860c 100644
--- a/src/scripting/network/database.cpp
+++ b/src/scripting/network/database.cpp
@@ -36,17 +36,21 @@ LoadScriptingComponent(database, [](PluginObject plugin, EContext* ctx) -> void
 
     ADD_CLASS_FUNCTION("Database", "Database", [](FunctionContext* context, ClassData* data) -> void {
         std::string connection_name = context->GetArgumentOr<std::string>(0, "default_connection");
+        bool shouldSkipDefaultConnection = context->GetArgumentOr<bool>(1, false);
+
         auto db = g_dbManager.GetDatabase(connection_name);
         if (!db && connection_name != "default_connection") {
             PRINTF("Database connection \"%s\" doesn't exists inside the database configurations. Automatically falling back to \"default_connection\".\n", connection_name.c_str());
-            db = g_dbManager.GetDatabase("default_connection");
+            if (!shouldSkipDefaultConnection) db = g_dbManager.GetDatabase("default_connection");
         }
 
-        if (!db->Connect()) {
+        if (!db) {
+            PRINTF("An error has occured while trying to connect to database \"%s\":\nError: Invalid connection inside `addons/swiftly/configs/databases.json`\n", connection_name.c_str());
+        }
+        else if (!db->Connect()) {
             PRINTF("An error has occured while trying to connect to database \"%s\":\nError: %s\n", connection_name.c_str(), db->GetError().c_str());
         }
 
-        data->SetData("connection_name", connection_name);
         data->SetData("db", db);
     });
 
diff --git a/src/scripting/sdk/checktransmit.cpp b/src/scripting/sdk/checktransmit.cpp
index 0fb704263..daf839f10 100644
--- a/src/scripting/sdk/checktransmit.cpp
+++ b/src/scripting/sdk/checktransmit.cpp
@@ -13,17 +13,24 @@ LoadScriptingComponent(checktransmit, [](PluginObject plugin, EContext* ctx) ->
 
     ADD_CLASS_FUNCTION("CCheckTransmitInfo", "CCheckTransmitInfo", [](FunctionContext* context, ClassData* data) -> void {
         auto classData = context->GetArgumentOr<ClassData*>(0, nullptr);
-        if(classData) {
-            if(classData->HasData("transmit_ptr")) {
+        if (classData) {
+            if (classData->HasData("class_ptr")) {
                 data->SetData("transmit_ptr", classData->GetData<void*>("class_ptr"));
-            } else if(classData->HasData("ptr")) {
+            }
+            else if (classData->HasData("ptr")) {
                 data->SetData("transmit_ptr", classData->GetData<void*>("ptr"));
-            } else data->SetData("transmit_ptr", (void*)nullptr);
-        } else {
+            }
+            else if (classData->HasData("transmit_ptr")) {
+                data->SetData("transmit_ptr", classData->GetData<void*>("transmit_ptr"));
+            }
+            else data->SetData("transmit_ptr", (void*)nullptr);
+        }
+        else {
             auto strptr = context->GetArgumentOr<std::string>(0, "");
-            if(starts_with(strptr, "0x")) {
+            if (starts_with(strptr, "0x")) {
                 data->SetData("transmit_ptr", (void*)StringToPtr(strptr));
-            } else data->SetData("transmit_ptr", (void*)nullptr);
+            }
+            else data->SetData("transmit_ptr", (void*)nullptr);
         }
     });
 
@@ -32,11 +39,11 @@ LoadScriptingComponent(checktransmit, [](PluginObject plugin, EContext* ctx) ->
 
         for (int i = 0; i < GetMaxGameClients(); i++) {
             CEntityInstance* controller = g_pEntitySystem->GetEntityInstance(CEntityIndex(i + 1));
-            if(!controller) continue;
+            if (!controller) continue;
 
             CHandle<CEntityInstance> pawnHandle = schema::GetProp<CHandle<CEntityInstance>>(controller, "CCSPlayerController", "m_hPlayerPawn");
             if (!pawnHandle) continue;
-    
+
             player_entindex.insert({ i, pawnHandle->m_pEntity->m_EHandle.GetEntryIndex() });
         }
 
@@ -50,7 +57,7 @@ LoadScriptingComponent(checktransmit, [](PluginObject plugin, EContext* ctx) ->
         for (int i = 0; i < MAX_EDICTS; i++)
             if (m_ptr->m_pTransmitEntity->IsBitSet(i))
                 entities_list.push_back(i);
-    
+
         context->SetReturn(entities_list);
     });
 
@@ -67,7 +74,7 @@ LoadScriptingComponent(checktransmit, [](PluginObject plugin, EContext* ctx) ->
         int entindex = context->GetArgumentOr<int>(0, 0);
         CCheckTransmitInfo* m_ptr = (CCheckTransmitInfo*)data->GetData<void*>("transmit_ptr");
 
-        if(!m_ptr->m_pTransmitEntity->IsBitSet(entindex))
+        if (!m_ptr->m_pTransmitEntity->IsBitSet(entindex))
             m_ptr->m_pTransmitEntity->Set(entindex);
     });
 
@@ -75,7 +82,7 @@ LoadScriptingComponent(checktransmit, [](PluginObject plugin, EContext* ctx) ->
         int entindex = context->GetArgumentOr<int>(0, 0);
         CCheckTransmitInfo* m_ptr = (CCheckTransmitInfo*)data->GetData<void*>("transmit_ptr");
 
-        if(m_ptr->m_pTransmitEntity->IsBitSet(entindex))
+        if (m_ptr->m_pTransmitEntity->IsBitSet(entindex))
             m_ptr->m_pTransmitEntity->Clear(entindex);
     });
 
diff --git a/src/scripting/sdk/schema_access.cpp b/src/scripting/sdk/schema_access.cpp
index bdfd69630..ad6b9dd50 100644
--- a/src/scripting/sdk/schema_access.cpp
+++ b/src/scripting/sdk/schema_access.cpp
@@ -15,404 +15,404 @@ extern bool followServerGuidelines;
 
 EValue AccessSDK(void* ptr, std::string className, std::string fieldName, uint64_t path, EContext* state)
 {
-    if (followServerGuidelines && g_sdk.IsFieldBlocked(fieldName))
+    if (!g_sdk.ExistsField(path)) return EValue(state);
+
+    std::string field = g_sdk.GetFieldName(path);
+
+    if (followServerGuidelines && g_sdk.IsFieldBlocked(field))
     {
         PRINTF("Getting or setting %s::%s is not permitted due to %s Server Guidelines violation.\nTo get or set this value, switch to false the \"core.Follow%sServerGuidelines\" field.\nNote: Using non-compliant field values can result in a GSLT ban.\nNote: We are not providing any kind of support for people which are using these fields.\n", className.c_str(), fieldName.c_str(), str_toupper(GetGameName()).c_str(), str_toupper(GetGameName()).c_str());
         return EValue(state);
     }
 
-    if (!g_sdk.ExistsField(path)) return EValue(state);
-
-    std::string field = g_sdk.GetFieldName(path);
-
     switch (g_sdk.GetFieldType(path))
     {
-        case Bool:
-            return EValue(state, schema::GetProp<bool>(ptr, className.c_str(), field.c_str()));
-        case Int8:
-            return EValue(state, schema::GetProp<int8_t>(ptr, className.c_str(), field.c_str()));
-        case Int16:
-            return EValue(state, schema::GetProp<int16_t>(ptr, className.c_str(), field.c_str()));
-        case Int32:
-            return EValue(state, schema::GetProp<int32_t>(ptr, className.c_str(), field.c_str()));
-        case Int64:
-            return EValue(state, schema::GetProp<int64_t>(ptr, className.c_str(), field.c_str()));
-        case UInt8:
-            return EValue(state, schema::GetProp<uint8_t>(ptr, className.c_str(), field.c_str()));
-        case UInt16:
-            return EValue(state, schema::GetProp<uint16_t>(ptr, className.c_str(), field.c_str()));
-        case UInt32:
-            return EValue(state, schema::GetProp<uint32_t>(ptr, className.c_str(), field.c_str()));
-        case UInt64:
-            return EValue(state, schema::GetProp<uint64_t>(ptr, className.c_str(), field.c_str()));
-        case Float:
-            return EValue(state, schema::GetProp<float>(ptr, className.c_str(), field.c_str()));
-        case Double:
-            return EValue(state, schema::GetProp<double>(ptr, className.c_str(), field.c_str()));
-        case Parent:
-            return MakeSDKClassInstance(field, ptr, state);
-        case StringToken:
-            return EValue(state, schema::GetProp<CUtlStringToken>(ptr, className.c_str(), field.c_str()).GetHashCode());
-        case StringSymbolLarge:
-            return EValue(state, std::string(schema::GetProp<CUtlSymbolLarge>(ptr, className.c_str(), field.c_str()).String()));
-        case StringUtl:
-            return EValue(state, std::string(schema::GetProp<CUtlString>(ptr, className.c_str(), field.c_str()).Get()));
-        case String:
-            return EValue(state, std::string(schema::GetPropPtr<char>(ptr, className.c_str(), field.c_str())));
-        case Class:
-            return MakeSDKClassInstance(g_sdk.GetFieldClass(path), schema::GetSchemaPtr(ptr, className.c_str(), field.c_str()), state);
-        case SDKCHandle:
-            return MakeSDKClassInstance(g_sdk.GetFieldClass(path), (void*)(schema::GetProp<CHandle<CEntityInstance>>(ptr, className.c_str(), field.c_str()).Get()), state);
-        case EntityIndex:
-            return EValue(state, schema::GetProp<CEntityIndex>(ptr, className.c_str(), field.c_str()).Get());
-        case SColor:
-            return MAKE_CLASS_INSTANCE_CTX(state, "Color", { { "Color_ptr", schema::GetProp<Color>(ptr, className.c_str(), field.c_str()) } });
-        case SQAngle:
-            return MAKE_CLASS_INSTANCE_CTX(state, "QAngle", { { "QAngle_ptr", schema::GetProp<QAngle>(ptr, className.c_str(), field.c_str()) } });
-        case SVector:
-            return MAKE_CLASS_INSTANCE_CTX(state, "Vector", { { "vector_ptr", schema::GetProp<Vector>(ptr, className.c_str(), field.c_str()) } });
-        case SVector2D:
-            return MAKE_CLASS_INSTANCE_CTX(state, "Vector2D", { { "Vector2D_ptr", schema::GetProp<Vector2D>(ptr, className.c_str(), field.c_str()) } });
-        case SVector4D:
-            return MAKE_CLASS_INSTANCE_CTX(state, "Vector4D", { { "Vector4D_ptr", schema::GetProp<Vector4D>(ptr, className.c_str(), field.c_str()) } });
-        case ClassPointer:
-            return MakeSDKClassInstance(g_sdk.GetFieldClass(path), *(void**)schema::GetSchemaPtr(ptr, className.c_str(), field.c_str()), state);
-        case RawListEntityIndex: {
-            CEntityIndex* outValue = schema::GetPropPtr<CEntityIndex>(ptr, className.c_str(), field.c_str());
-            std::vector<int> ret;
-            for (uint32_t i = 0; i < g_sdk.GetFieldSize(path); i++)
-                ret.push_back(outValue[i].Get());
-
-            return EValue(state, ret);
-        }
-        case StringSymbolLargeArray: {
-            CUtlSymbolLarge* outValue = schema::GetPropPtr<CUtlSymbolLarge>(ptr, className.c_str(), field.c_str());
-            std::vector<std::string> ret;
-            for (uint32_t i = 0; i < g_sdk.GetFieldSize(path); i++)
-                ret.push_back(outValue[i].String());
+    case Bool:
+        return EValue(state, schema::GetProp<bool>(ptr, className.c_str(), field.c_str()));
+    case Int8:
+        return EValue(state, schema::GetProp<int8_t>(ptr, className.c_str(), field.c_str()));
+    case Int16:
+        return EValue(state, schema::GetProp<int16_t>(ptr, className.c_str(), field.c_str()));
+    case Int32:
+        return EValue(state, schema::GetProp<int32_t>(ptr, className.c_str(), field.c_str()));
+    case Int64:
+        return EValue(state, schema::GetProp<int64_t>(ptr, className.c_str(), field.c_str()));
+    case UInt8:
+        return EValue(state, schema::GetProp<uint8_t>(ptr, className.c_str(), field.c_str()));
+    case UInt16:
+        return EValue(state, schema::GetProp<uint16_t>(ptr, className.c_str(), field.c_str()));
+    case UInt32:
+        return EValue(state, schema::GetProp<uint32_t>(ptr, className.c_str(), field.c_str()));
+    case UInt64:
+        return EValue(state, schema::GetProp<uint64_t>(ptr, className.c_str(), field.c_str()));
+    case Float:
+        return EValue(state, schema::GetProp<float>(ptr, className.c_str(), field.c_str()));
+    case Double:
+        return EValue(state, schema::GetProp<double>(ptr, className.c_str(), field.c_str()));
+    case Parent:
+        return MakeSDKClassInstance(field, ptr, state);
+    case StringToken:
+        return EValue(state, schema::GetProp<CUtlStringToken>(ptr, className.c_str(), field.c_str()).GetHashCode());
+    case StringSymbolLarge:
+        return EValue(state, std::string(schema::GetProp<CUtlSymbolLarge>(ptr, className.c_str(), field.c_str()).String()));
+    case StringUtl:
+        return EValue(state, std::string(schema::GetProp<CUtlString>(ptr, className.c_str(), field.c_str()).Get()));
+    case String:
+        return EValue(state, std::string(schema::GetPropPtr<char>(ptr, className.c_str(), field.c_str())));
+    case Class:
+        return MakeSDKClassInstance(g_sdk.GetFieldClass(path), schema::GetSchemaPtr(ptr, className.c_str(), field.c_str()), state);
+    case SDKCHandle:
+        return MakeSDKClassInstance(g_sdk.GetFieldClass(path), (void*)(schema::GetProp<CHandle<CEntityInstance>>(ptr, className.c_str(), field.c_str()).Get()), state);
+    case EntityIndex:
+        return EValue(state, schema::GetProp<CEntityIndex>(ptr, className.c_str(), field.c_str()).Get());
+    case SColor:
+        return MAKE_CLASS_INSTANCE_CTX(state, "Color", { { "Color_ptr", schema::GetProp<Color>(ptr, className.c_str(), field.c_str()) } });
+    case SQAngle:
+        return MAKE_CLASS_INSTANCE_CTX(state, "QAngle", { { "QAngle_ptr", schema::GetProp<QAngle>(ptr, className.c_str(), field.c_str()) } });
+    case SVector:
+        return MAKE_CLASS_INSTANCE_CTX(state, "Vector", { { "vector_ptr", schema::GetProp<Vector>(ptr, className.c_str(), field.c_str()) } });
+    case SVector2D:
+        return MAKE_CLASS_INSTANCE_CTX(state, "Vector2D", { { "Vector2D_ptr", schema::GetProp<Vector2D>(ptr, className.c_str(), field.c_str()) } });
+    case SVector4D:
+        return MAKE_CLASS_INSTANCE_CTX(state, "Vector4D", { { "Vector4D_ptr", schema::GetProp<Vector4D>(ptr, className.c_str(), field.c_str()) } });
+    case ClassPointer:
+        return MakeSDKClassInstance(g_sdk.GetFieldClass(path), *(void**)schema::GetSchemaPtr(ptr, className.c_str(), field.c_str()), state);
+    case RawListEntityIndex: {
+        CEntityIndex* outValue = schema::GetPropPtr<CEntityIndex>(ptr, className.c_str(), field.c_str());
+        std::vector<int> ret;
+        for (uint32_t i = 0; i < g_sdk.GetFieldSize(path); i++)
+            ret.push_back(outValue[i].Get());
 
-            return EValue(state, ret);
-        }
-        case StringTokenArray: {
-            CUtlStringToken* outValue = schema::GetPropPtr<CUtlStringToken>(ptr, className.c_str(), field.c_str());
-            std::vector<uint32_t> ret;
-            for (uint32_t i = 0; i < g_sdk.GetFieldSize(path); i++)
-                ret.push_back(outValue[i].GetHashCode());
+        return EValue(state, ret);
+    }
+    case StringSymbolLargeArray: {
+        CUtlSymbolLarge* outValue = schema::GetPropPtr<CUtlSymbolLarge>(ptr, className.c_str(), field.c_str());
+        std::vector<std::string> ret;
+        for (uint32_t i = 0; i < g_sdk.GetFieldSize(path); i++)
+            ret.push_back(outValue[i].String());
 
-            return EValue(state, ret);
-        }
-        case StringUtlArray: {
-            CUtlString* outValue = schema::GetPropPtr<CUtlString>(ptr, className.c_str(), field.c_str());
-            std::vector<std::string> ret;
-            for (uint32_t i = 0; i < g_sdk.GetFieldSize(path); i++)
-                ret.push_back(outValue[i].Get());
+        return EValue(state, ret);
+    }
+    case StringTokenArray: {
+        CUtlStringToken* outValue = schema::GetPropPtr<CUtlStringToken>(ptr, className.c_str(), field.c_str());
+        std::vector<uint32_t> ret;
+        for (uint32_t i = 0; i < g_sdk.GetFieldSize(path); i++)
+            ret.push_back(outValue[i].GetHashCode());
 
-            return EValue(state, ret);
-        }
-        case Int8Array: {
-            int8_t* outValue = schema::GetPropPtr<int8_t>(ptr, className.c_str(), field.c_str());
-            std::vector<int8_t> ret;
-            for (uint32_t i = 0; i < g_sdk.GetFieldSize(path); i++)
-                ret.push_back(outValue[i]);
+        return EValue(state, ret);
+    }
+    case StringUtlArray: {
+        CUtlString* outValue = schema::GetPropPtr<CUtlString>(ptr, className.c_str(), field.c_str());
+        std::vector<std::string> ret;
+        for (uint32_t i = 0; i < g_sdk.GetFieldSize(path); i++)
+            ret.push_back(outValue[i].Get());
 
-            return EValue(state, ret);
-        }
-        case Int16Array: {
-            int16_t* outValue = schema::GetPropPtr<int16_t>(ptr, className.c_str(), field.c_str());
-            std::vector<int16_t> ret;
-            for (uint32_t i = 0; i < g_sdk.GetFieldSize(path); i++)
-                ret.push_back(outValue[i]);
+        return EValue(state, ret);
+    }
+    case Int8Array: {
+        int8_t* outValue = schema::GetPropPtr<int8_t>(ptr, className.c_str(), field.c_str());
+        std::vector<int8_t> ret;
+        for (uint32_t i = 0; i < g_sdk.GetFieldSize(path); i++)
+            ret.push_back(outValue[i]);
 
-            return EValue(state, ret);
-        }
-        case Int32Array: {
-            int32_t* outValue = schema::GetPropPtr<int32_t>(ptr, className.c_str(), field.c_str());
-            std::vector<int32_t> ret;
-            for (uint32_t i = 0; i < g_sdk.GetFieldSize(path); i++)
-                ret.push_back(outValue[i]);
+        return EValue(state, ret);
+    }
+    case Int16Array: {
+        int16_t* outValue = schema::GetPropPtr<int16_t>(ptr, className.c_str(), field.c_str());
+        std::vector<int16_t> ret;
+        for (uint32_t i = 0; i < g_sdk.GetFieldSize(path); i++)
+            ret.push_back(outValue[i]);
 
-            return EValue(state, ret);
-        }
-        case Int64Array: {
-            int64_t* outValue = schema::GetPropPtr<int64_t>(ptr, className.c_str(), field.c_str());
-            std::vector<int64_t> ret;
-            for (uint32_t i = 0; i < g_sdk.GetFieldSize(path); i++)
-                ret.push_back(outValue[i]);
+        return EValue(state, ret);
+    }
+    case Int32Array: {
+        int32_t* outValue = schema::GetPropPtr<int32_t>(ptr, className.c_str(), field.c_str());
+        std::vector<int32_t> ret;
+        for (uint32_t i = 0; i < g_sdk.GetFieldSize(path); i++)
+            ret.push_back(outValue[i]);
 
-            return EValue(state, ret);
-        }
-        case UInt8Array: {
-            uint8_t* outValue = schema::GetPropPtr<uint8_t>(ptr, className.c_str(), field.c_str());
-            std::vector<uint8_t> ret;
-            for (uint32_t i = 0; i < g_sdk.GetFieldSize(path); i++)
-                ret.push_back(outValue[i]);
+        return EValue(state, ret);
+    }
+    case Int64Array: {
+        int64_t* outValue = schema::GetPropPtr<int64_t>(ptr, className.c_str(), field.c_str());
+        std::vector<int64_t> ret;
+        for (uint32_t i = 0; i < g_sdk.GetFieldSize(path); i++)
+            ret.push_back(outValue[i]);
 
-            return EValue(state, ret);
-        }
-        case UInt16Array: {
-            uint16_t* outValue = schema::GetPropPtr<uint16_t>(ptr, className.c_str(), field.c_str());
-            std::vector<uint16_t> ret;
-            for (uint32_t i = 0; i < g_sdk.GetFieldSize(path); i++)
-                ret.push_back(outValue[i]);
+        return EValue(state, ret);
+    }
+    case UInt8Array: {
+        uint8_t* outValue = schema::GetPropPtr<uint8_t>(ptr, className.c_str(), field.c_str());
+        std::vector<uint8_t> ret;
+        for (uint32_t i = 0; i < g_sdk.GetFieldSize(path); i++)
+            ret.push_back(outValue[i]);
 
-            return EValue(state, ret);
-        }
-        case UInt32Array: {
-            uint32_t* outValue = schema::GetPropPtr<uint32_t>(ptr, className.c_str(), field.c_str());
-            std::vector<uint32_t> ret;
-            for (uint32_t i = 0; i < g_sdk.GetFieldSize(path); i++)
-                ret.push_back(outValue[i]);
+        return EValue(state, ret);
+    }
+    case UInt16Array: {
+        uint16_t* outValue = schema::GetPropPtr<uint16_t>(ptr, className.c_str(), field.c_str());
+        std::vector<uint16_t> ret;
+        for (uint32_t i = 0; i < g_sdk.GetFieldSize(path); i++)
+            ret.push_back(outValue[i]);
 
-            return EValue(state, ret);
-        }
-        case UInt64Array: {
-            uint64_t* outValue = schema::GetPropPtr<uint64_t>(ptr, className.c_str(), field.c_str());
-            std::vector<uint64_t> ret;
-            for (uint32_t i = 0; i < g_sdk.GetFieldSize(path); i++)
-                ret.push_back(outValue[i]);
+        return EValue(state, ret);
+    }
+    case UInt32Array: {
+        uint32_t* outValue = schema::GetPropPtr<uint32_t>(ptr, className.c_str(), field.c_str());
+        std::vector<uint32_t> ret;
+        for (uint32_t i = 0; i < g_sdk.GetFieldSize(path); i++)
+            ret.push_back(outValue[i]);
 
-            return EValue(state, ret);
-        }
-        case FloatArray: {
-            float* outValue = schema::GetPropPtr<float>(ptr, className.c_str(), field.c_str());
-            std::vector<float> ret;
-            for (uint32_t i = 0; i < g_sdk.GetFieldSize(path); i++)
-                ret.push_back(outValue[i]);
+        return EValue(state, ret);
+    }
+    case UInt64Array: {
+        uint64_t* outValue = schema::GetPropPtr<uint64_t>(ptr, className.c_str(), field.c_str());
+        std::vector<uint64_t> ret;
+        for (uint32_t i = 0; i < g_sdk.GetFieldSize(path); i++)
+            ret.push_back(outValue[i]);
 
-            return EValue(state, ret);
-        }
-        case DoubleArray: {
-            double* outValue = schema::GetPropPtr<double>(ptr, className.c_str(), field.c_str());
-            std::vector<double> ret;
-            for (uint32_t i = 0; i < g_sdk.GetFieldSize(path); i++)
-                ret.push_back(outValue[i]);
+        return EValue(state, ret);
+    }
+    case FloatArray: {
+        float* outValue = schema::GetPropPtr<float>(ptr, className.c_str(), field.c_str());
+        std::vector<float> ret;
+        for (uint32_t i = 0; i < g_sdk.GetFieldSize(path); i++)
+            ret.push_back(outValue[i]);
 
-            return EValue(state, ret);
-        }
-        case BoolArray: {
-            bool* outValue = schema::GetPropPtr<bool>(ptr, className.c_str(), field.c_str());
-            std::vector<bool> ret;
-            for (uint32_t i = 0; i < g_sdk.GetFieldSize(path); i++)
-                ret.push_back(outValue[i]);
+        return EValue(state, ret);
+    }
+    case DoubleArray: {
+        double* outValue = schema::GetPropPtr<double>(ptr, className.c_str(), field.c_str());
+        std::vector<double> ret;
+        for (uint32_t i = 0; i < g_sdk.GetFieldSize(path); i++)
+            ret.push_back(outValue[i]);
 
-            return EValue(state, ret);
-        }
-        case SColorArray: {
-            Color* outValue = schema::GetPropPtr<Color>(ptr, className.c_str(), field.c_str());
-            std::vector<EValue> ret;
-            for (uint32_t i = 0; i < g_sdk.GetFieldSize(path); i++)
-                ret.push_back(MAKE_CLASS_INSTANCE_CTX(state, "Color", { { "Color_ptr", outValue[i] } }));
+        return EValue(state, ret);
+    }
+    case BoolArray: {
+        bool* outValue = schema::GetPropPtr<bool>(ptr, className.c_str(), field.c_str());
+        std::vector<bool> ret;
+        for (uint32_t i = 0; i < g_sdk.GetFieldSize(path); i++)
+            ret.push_back(outValue[i]);
 
-            return EValue(state, ret);
-        }
-        case SQAngleArray: {
-            QAngle* outValue = schema::GetPropPtr<QAngle>(ptr, className.c_str(), field.c_str());
-            std::vector<EValue> ret;
-            for (uint32_t i = 0; i < g_sdk.GetFieldSize(path); i++)
-                ret.push_back(MAKE_CLASS_INSTANCE_CTX(state, "QAngle", { { "QAngle_ptr", outValue[i] } }));
+        return EValue(state, ret);
+    }
+    case SColorArray: {
+        Color* outValue = schema::GetPropPtr<Color>(ptr, className.c_str(), field.c_str());
+        std::vector<EValue> ret;
+        for (uint32_t i = 0; i < g_sdk.GetFieldSize(path); i++)
+            ret.push_back(MAKE_CLASS_INSTANCE_CTX(state, "Color", { { "Color_ptr", outValue[i] } }));
 
-            return EValue(state, ret);
-        }
-        case SVectorArray: {
-            Vector* outValue = schema::GetPropPtr<Vector>(ptr, className.c_str(), field.c_str());
-            std::vector<EValue> ret;
-            for (uint32_t i = 0; i < g_sdk.GetFieldSize(path); i++)
-                ret.push_back(MAKE_CLASS_INSTANCE_CTX(state, "Vector", { { "vector_ptr", outValue[i] } }));
+        return EValue(state, ret);
+    }
+    case SQAngleArray: {
+        QAngle* outValue = schema::GetPropPtr<QAngle>(ptr, className.c_str(), field.c_str());
+        std::vector<EValue> ret;
+        for (uint32_t i = 0; i < g_sdk.GetFieldSize(path); i++)
+            ret.push_back(MAKE_CLASS_INSTANCE_CTX(state, "QAngle", { { "QAngle_ptr", outValue[i] } }));
 
-            return EValue(state, ret);
-        }
-        case SVector2DArray: {
-            Vector2D* outValue = schema::GetPropPtr<Vector2D>(ptr, className.c_str(), field.c_str());
-            std::vector<EValue> ret;
-            for (uint32_t i = 0; i < g_sdk.GetFieldSize(path); i++)
-                ret.push_back(MAKE_CLASS_INSTANCE_CTX(state, "Vector2D", { { "Vector2D_ptr", outValue[i] } }));
+        return EValue(state, ret);
+    }
+    case SVectorArray: {
+        Vector* outValue = schema::GetPropPtr<Vector>(ptr, className.c_str(), field.c_str());
+        std::vector<EValue> ret;
+        for (uint32_t i = 0; i < g_sdk.GetFieldSize(path); i++)
+            ret.push_back(MAKE_CLASS_INSTANCE_CTX(state, "Vector", { { "vector_ptr", outValue[i] } }));
 
-            return EValue(state, ret);
-        }
-        case SVector4DArray: {
-            Vector4D* outValue = schema::GetPropPtr<Vector4D>(ptr, className.c_str(), field.c_str());
-            std::vector<EValue> ret;
-            for (uint32_t i = 0; i < g_sdk.GetFieldSize(path); i++)
-                ret.push_back(MAKE_CLASS_INSTANCE_CTX(state, "Vector4D", { { "Vector4D_ptr", outValue[i] } }));
+        return EValue(state, ret);
+    }
+    case SVector2DArray: {
+        Vector2D* outValue = schema::GetPropPtr<Vector2D>(ptr, className.c_str(), field.c_str());
+        std::vector<EValue> ret;
+        for (uint32_t i = 0; i < g_sdk.GetFieldSize(path); i++)
+            ret.push_back(MAKE_CLASS_INSTANCE_CTX(state, "Vector2D", { { "Vector2D_ptr", outValue[i] } }));
 
-            return EValue(state, ret);
-        }
-        case ClassArray: {
-            void** outValue = schema::GetPropPtr<void*>(ptr, className.c_str(), field.c_str());
-            std::vector<EValue> ret;
-            for (uint32_t i = 0; i < g_sdk.GetFieldSize(path); i++)
-                ret.push_back(MakeSDKClassInstance(g_sdk.GetFieldClass(path), outValue[i], state));
+        return EValue(state, ret);
+    }
+    case SVector4DArray: {
+        Vector4D* outValue = schema::GetPropPtr<Vector4D>(ptr, className.c_str(), field.c_str());
+        std::vector<EValue> ret;
+        for (uint32_t i = 0; i < g_sdk.GetFieldSize(path); i++)
+            ret.push_back(MAKE_CLASS_INSTANCE_CTX(state, "Vector4D", { { "Vector4D_ptr", outValue[i] } }));
 
-            return EValue(state, ret);
-        }
-        case CHandleArray: {
-            CHandle<CEntityInstance>* outValue = schema::GetPropPtr<CHandle<CEntityInstance>>(ptr, className.c_str(), field.c_str());
-            std::vector<EValue> ret;
-            for (uint32_t i = 0; i < g_sdk.GetFieldSize(path); i++)
-                ret.push_back(MakeSDKClassInstance(g_sdk.GetFieldClass(path), (void*)outValue[i].Get(), state));
+        return EValue(state, ret);
+    }
+    case ClassArray: {
+        void** outValue = schema::GetPropPtr<void*>(ptr, className.c_str(), field.c_str());
+        std::vector<EValue> ret;
+        for (uint32_t i = 0; i < g_sdk.GetFieldSize(path); i++)
+            ret.push_back(MakeSDKClassInstance(g_sdk.GetFieldClass(path), outValue[i], state));
 
-            return EValue(state, ret);
-        }
-        case CHandleCUtlVector: {
-            CUtlVector<CHandle<CEntityInstance>>* vec = schema::GetPropPtr<CUtlVector<CHandle<CEntityInstance>>>(ptr, className.c_str(), field.c_str());
-            std::vector<EValue> ret;
-            for (int i = 0; i < vec->Count(); i++)
-                ret.push_back(MakeSDKClassInstance(g_sdk.GetFieldClass(path), (void*)(vec->Element(i).Get()), state));
+        return EValue(state, ret);
+    }
+    case CHandleArray: {
+        CHandle<CEntityInstance>* outValue = schema::GetPropPtr<CHandle<CEntityInstance>>(ptr, className.c_str(), field.c_str());
+        std::vector<EValue> ret;
+        for (uint32_t i = 0; i < g_sdk.GetFieldSize(path); i++)
+            ret.push_back(MakeSDKClassInstance(g_sdk.GetFieldClass(path), (void*)outValue[i].Get(), state));
 
-            return EValue(state, ret);
-        }
-        case StringSymbolLargeCUtlVector: {
-            CUtlVector<CUtlSymbolLarge>* outValue = schema::GetPropPtr<CUtlVector<CUtlSymbolLarge>>(ptr, className.c_str(), field.c_str());
-            std::vector<std::string> ret;
-            for (int i = 0; i < outValue->Count(); i++)
-                ret.push_back(outValue->Element(i).String());
+        return EValue(state, ret);
+    }
+    case CHandleCUtlVector: {
+        CUtlVector<CHandle<CEntityInstance>>* vec = schema::GetPropPtr<CUtlVector<CHandle<CEntityInstance>>>(ptr, className.c_str(), field.c_str());
+        std::vector<EValue> ret;
+        for (int i = 0; i < vec->Count(); i++)
+            ret.push_back(MakeSDKClassInstance(g_sdk.GetFieldClass(path), (void*)(vec->Element(i).Get()), state));
 
-            return EValue(state, ret);
-        }
-        case StringTokenCUtlVector: {
-            CUtlVector<CUtlStringToken>* outValue = schema::GetPropPtr<CUtlVector<CUtlStringToken>>(ptr, className.c_str(), field.c_str());
-            std::vector<uint32_t> ret;
-            for (int i = 0; i < outValue->Count(); i++)
-                ret.push_back(outValue->Element(i).GetHashCode());
+        return EValue(state, ret);
+    }
+    case StringSymbolLargeCUtlVector: {
+        CUtlVector<CUtlSymbolLarge>* outValue = schema::GetPropPtr<CUtlVector<CUtlSymbolLarge>>(ptr, className.c_str(), field.c_str());
+        std::vector<std::string> ret;
+        for (int i = 0; i < outValue->Count(); i++)
+            ret.push_back(outValue->Element(i).String());
 
-            return EValue(state, ret);
-        }
-        case StringUtlCUtlVector: {
-            CUtlVector<CUtlString>* outValue = schema::GetPropPtr<CUtlVector<CUtlString>>(ptr, className.c_str(), field.c_str());
-            std::vector<std::string> ret;
-            for (int i = 0; i < outValue->Count(); i++)
-                ret.push_back(outValue->Element(i).Get());
+        return EValue(state, ret);
+    }
+    case StringTokenCUtlVector: {
+        CUtlVector<CUtlStringToken>* outValue = schema::GetPropPtr<CUtlVector<CUtlStringToken>>(ptr, className.c_str(), field.c_str());
+        std::vector<uint32_t> ret;
+        for (int i = 0; i < outValue->Count(); i++)
+            ret.push_back(outValue->Element(i).GetHashCode());
 
-            return EValue(state, ret);
-        }
-        case Int8CUtlVector: {
-            CUtlVector<int8_t>* vec = schema::GetPropPtr<CUtlVector<int8_t>>(ptr, className.c_str(), field.c_str());
-            std::vector<int8_t> ret;
-            for (int i = 0; i < vec->Count(); i++)
-                ret.push_back(vec->Element(i));
+        return EValue(state, ret);
+    }
+    case StringUtlCUtlVector: {
+        CUtlVector<CUtlString>* outValue = schema::GetPropPtr<CUtlVector<CUtlString>>(ptr, className.c_str(), field.c_str());
+        std::vector<std::string> ret;
+        for (int i = 0; i < outValue->Count(); i++)
+            ret.push_back(outValue->Element(i).Get());
 
-            return EValue(state, ret);
-        }
-        case Int16CUtlVector: {
-            CUtlVector<int16_t>* vec = schema::GetPropPtr<CUtlVector<int16_t>>(ptr, className.c_str(), field.c_str());
-            std::vector<int16_t> ret;
-            for (int i = 0; i < vec->Count(); i++)
-                ret.push_back(vec->Element(i));
+        return EValue(state, ret);
+    }
+    case Int8CUtlVector: {
+        CUtlVector<int8_t>* vec = schema::GetPropPtr<CUtlVector<int8_t>>(ptr, className.c_str(), field.c_str());
+        std::vector<int8_t> ret;
+        for (int i = 0; i < vec->Count(); i++)
+            ret.push_back(vec->Element(i));
 
-            return EValue(state, ret);
-        }
-        case Int32CUtlVector: {
-            CUtlVector<int32_t>* vec = schema::GetPropPtr<CUtlVector<int32_t>>(ptr, className.c_str(), field.c_str());
-            std::vector<int32_t> ret;
-            for (int i = 0; i < vec->Count(); i++)
-                ret.push_back(vec->Element(i));
+        return EValue(state, ret);
+    }
+    case Int16CUtlVector: {
+        CUtlVector<int16_t>* vec = schema::GetPropPtr<CUtlVector<int16_t>>(ptr, className.c_str(), field.c_str());
+        std::vector<int16_t> ret;
+        for (int i = 0; i < vec->Count(); i++)
+            ret.push_back(vec->Element(i));
 
-            return EValue(state, ret);
-        }
-        case Int64CUtlVector: {
-            CUtlVector<int64_t>* vec = schema::GetPropPtr<CUtlVector<int64_t>>(ptr, className.c_str(), field.c_str());
-            std::vector<int64_t> ret;
-            for (int i = 0; i < vec->Count(); i++)
-                ret.push_back(vec->Element(i));
+        return EValue(state, ret);
+    }
+    case Int32CUtlVector: {
+        CUtlVector<int32_t>* vec = schema::GetPropPtr<CUtlVector<int32_t>>(ptr, className.c_str(), field.c_str());
+        std::vector<int32_t> ret;
+        for (int i = 0; i < vec->Count(); i++)
+            ret.push_back(vec->Element(i));
 
-            return EValue(state, ret);
-        }
-        case UInt8CUtlVector: {
-            CUtlVector<uint8_t>* vec = schema::GetPropPtr<CUtlVector<uint8_t>>(ptr, className.c_str(), field.c_str());
-            std::vector<uint8_t> ret;
-            for (int i = 0; i < vec->Count(); i++)
-                ret.push_back(vec->Element(i));
+        return EValue(state, ret);
+    }
+    case Int64CUtlVector: {
+        CUtlVector<int64_t>* vec = schema::GetPropPtr<CUtlVector<int64_t>>(ptr, className.c_str(), field.c_str());
+        std::vector<int64_t> ret;
+        for (int i = 0; i < vec->Count(); i++)
+            ret.push_back(vec->Element(i));
 
-            return EValue(state, ret);
-        }
-        case UInt16CUtlVector: {
-            CUtlVector<uint16_t>* vec = schema::GetPropPtr<CUtlVector<uint16_t>>(ptr, className.c_str(), field.c_str());
-            std::vector<uint16_t> ret;
-            for (int i = 0; i < vec->Count(); i++)
-                ret.push_back(vec->Element(i));
+        return EValue(state, ret);
+    }
+    case UInt8CUtlVector: {
+        CUtlVector<uint8_t>* vec = schema::GetPropPtr<CUtlVector<uint8_t>>(ptr, className.c_str(), field.c_str());
+        std::vector<uint8_t> ret;
+        for (int i = 0; i < vec->Count(); i++)
+            ret.push_back(vec->Element(i));
 
-            return EValue(state, ret);
-        }
-        case UInt32CUtlVector: {
-            CUtlVector<uint32_t>* vec = schema::GetPropPtr<CUtlVector<uint32_t>>(ptr, className.c_str(), field.c_str());
-            std::vector<uint32_t> ret;
-            for (int i = 0; i < vec->Count(); i++)
-                ret.push_back(vec->Element(i));
+        return EValue(state, ret);
+    }
+    case UInt16CUtlVector: {
+        CUtlVector<uint16_t>* vec = schema::GetPropPtr<CUtlVector<uint16_t>>(ptr, className.c_str(), field.c_str());
+        std::vector<uint16_t> ret;
+        for (int i = 0; i < vec->Count(); i++)
+            ret.push_back(vec->Element(i));
 
-            return EValue(state, ret);
-        }
-        case UInt64CUtlVector: {
-            CUtlVector<uint64_t>* vec = schema::GetPropPtr<CUtlVector<uint64_t>>(ptr, className.c_str(), field.c_str());
-            std::vector<uint64_t> ret;
-            for (int i = 0; i < vec->Count(); i++)
-                ret.push_back(vec->Element(i));
+        return EValue(state, ret);
+    }
+    case UInt32CUtlVector: {
+        CUtlVector<uint32_t>* vec = schema::GetPropPtr<CUtlVector<uint32_t>>(ptr, className.c_str(), field.c_str());
+        std::vector<uint32_t> ret;
+        for (int i = 0; i < vec->Count(); i++)
+            ret.push_back(vec->Element(i));
 
-            return EValue(state, ret);
-        }
-        case FloatCUtlVector: {
-            CUtlVector<float>* vec = schema::GetPropPtr<CUtlVector<float>>(ptr, className.c_str(), field.c_str());
-            std::vector<float> ret;
-            for (int i = 0; i < vec->Count(); i++)
-                ret.push_back(vec->Element(i));
+        return EValue(state, ret);
+    }
+    case UInt64CUtlVector: {
+        CUtlVector<uint64_t>* vec = schema::GetPropPtr<CUtlVector<uint64_t>>(ptr, className.c_str(), field.c_str());
+        std::vector<uint64_t> ret;
+        for (int i = 0; i < vec->Count(); i++)
+            ret.push_back(vec->Element(i));
 
-            return EValue(state, ret);
-        }
-        case DoubleCUtlVector: {
-            CUtlVector<double>* vec = schema::GetPropPtr<CUtlVector<double>>(ptr, className.c_str(), field.c_str());
-            std::vector<double> ret;
-            for (int i = 0; i < vec->Count(); i++)
-                ret.push_back(vec->Element(i));
+        return EValue(state, ret);
+    }
+    case FloatCUtlVector: {
+        CUtlVector<float>* vec = schema::GetPropPtr<CUtlVector<float>>(ptr, className.c_str(), field.c_str());
+        std::vector<float> ret;
+        for (int i = 0; i < vec->Count(); i++)
+            ret.push_back(vec->Element(i));
 
-            return EValue(state, ret);
-        }
-        case SColorCUtlVector: {
-            CUtlVector<Color>* vec = schema::GetPropPtr<CUtlVector<Color>>(ptr, className.c_str(), field.c_str());
-            std::vector<EValue> ret;
-            for (int i = 0; i < vec->Count(); i++)
-                ret.push_back(MAKE_CLASS_INSTANCE_CTX(state, "Color", { { "Color_ptr", vec->Element(i) } }));
+        return EValue(state, ret);
+    }
+    case DoubleCUtlVector: {
+        CUtlVector<double>* vec = schema::GetPropPtr<CUtlVector<double>>(ptr, className.c_str(), field.c_str());
+        std::vector<double> ret;
+        for (int i = 0; i < vec->Count(); i++)
+            ret.push_back(vec->Element(i));
 
-            return EValue(state, ret);
-        }
-        case SQAngleCUtlVector: {
-            CUtlVector<QAngle>* vec = schema::GetPropPtr<CUtlVector<QAngle>>(ptr, className.c_str(), field.c_str());
-            std::vector<EValue> ret;
-            for (int i = 0; i < vec->Count(); i++)
-                ret.push_back(MAKE_CLASS_INSTANCE_CTX(state, "QAngle", { { "QAngle_ptr", vec->Element(i) } }));
+        return EValue(state, ret);
+    }
+    case SColorCUtlVector: {
+        CUtlVector<Color>* vec = schema::GetPropPtr<CUtlVector<Color>>(ptr, className.c_str(), field.c_str());
+        std::vector<EValue> ret;
+        for (int i = 0; i < vec->Count(); i++)
+            ret.push_back(MAKE_CLASS_INSTANCE_CTX(state, "Color", { { "Color_ptr", vec->Element(i) } }));
 
-            return EValue(state, ret);
-        }
-        case SVectorCUtlVector: {
-            CUtlVector<Vector>* vec = schema::GetPropPtr<CUtlVector<Vector>>(ptr, className.c_str(), field.c_str());
-            std::vector<EValue> ret;
-            for (int i = 0; i < vec->Count(); i++)
-                ret.push_back(MAKE_CLASS_INSTANCE_CTX(state, "Vector", { { "vector_ptr", vec->Element(i) } }));
+        return EValue(state, ret);
+    }
+    case SQAngleCUtlVector: {
+        CUtlVector<QAngle>* vec = schema::GetPropPtr<CUtlVector<QAngle>>(ptr, className.c_str(), field.c_str());
+        std::vector<EValue> ret;
+        for (int i = 0; i < vec->Count(); i++)
+            ret.push_back(MAKE_CLASS_INSTANCE_CTX(state, "QAngle", { { "QAngle_ptr", vec->Element(i) } }));
 
-            return EValue(state, ret);
-        }
-        case SVector2DCUtlVector: {
-            CUtlVector<Vector2D>* vec = schema::GetPropPtr<CUtlVector<Vector2D>>(ptr, className.c_str(), field.c_str());
-            std::vector<EValue> ret;
-            for (int i = 0; i < vec->Count(); i++)
-                ret.push_back(MAKE_CLASS_INSTANCE_CTX(state, "Vector2D", { { "Vector2D_ptr", vec->Element(i) } }));
+        return EValue(state, ret);
+    }
+    case SVectorCUtlVector: {
+        CUtlVector<Vector>* vec = schema::GetPropPtr<CUtlVector<Vector>>(ptr, className.c_str(), field.c_str());
+        std::vector<EValue> ret;
+        for (int i = 0; i < vec->Count(); i++)
+            ret.push_back(MAKE_CLASS_INSTANCE_CTX(state, "Vector", { { "vector_ptr", vec->Element(i) } }));
 
-            return EValue(state, ret);
-        }
-        case SVector4DCUtlVector: {
-            CUtlVector<Vector4D>* vec = schema::GetPropPtr<CUtlVector<Vector4D>>(ptr, className.c_str(), field.c_str());
-            std::vector<EValue> ret;
-            for (int i = 0; i < vec->Count(); i++)
-                ret.push_back(MAKE_CLASS_INSTANCE_CTX(state, "Vector4D", { { "Vector4D_ptr", vec->Element(i) } }));
+        return EValue(state, ret);
+    }
+    case SVector2DCUtlVector: {
+        CUtlVector<Vector2D>* vec = schema::GetPropPtr<CUtlVector<Vector2D>>(ptr, className.c_str(), field.c_str());
+        std::vector<EValue> ret;
+        for (int i = 0; i < vec->Count(); i++)
+            ret.push_back(MAKE_CLASS_INSTANCE_CTX(state, "Vector2D", { { "Vector2D_ptr", vec->Element(i) } }));
 
-            return EValue(state, ret);
-        }
-        case BoolCUtlVector: {
-            CUtlVector<bool>* vec = schema::GetPropPtr<CUtlVector<bool>>(ptr, className.c_str(), field.c_str());
-            std::vector<bool> ret;
-            for (int i = 0; i < vec->Count(); i++)
-                ret.push_back(vec->Element(i));
+        return EValue(state, ret);
+    }
+    case SVector4DCUtlVector: {
+        CUtlVector<Vector4D>* vec = schema::GetPropPtr<CUtlVector<Vector4D>>(ptr, className.c_str(), field.c_str());
+        std::vector<EValue> ret;
+        for (int i = 0; i < vec->Count(); i++)
+            ret.push_back(MAKE_CLASS_INSTANCE_CTX(state, "Vector4D", { { "Vector4D_ptr", vec->Element(i) } }));
 
-            return EValue(state, ret);
-        }
+        return EValue(state, ret);
+    }
+    case BoolCUtlVector: {
+        CUtlVector<bool>* vec = schema::GetPropPtr<CUtlVector<bool>>(ptr, className.c_str(), field.c_str());
+        std::vector<bool> ret;
+        for (int i = 0; i < vec->Count(); i++)
+            ret.push_back(vec->Element(i));
+
+        return EValue(state, ret);
+    }
     }
 
     return EValue(state, fieldName);
@@ -420,17 +420,17 @@ EValue AccessSDK(void* ptr, std::string className, std::string fieldName, uint64
 
 void UpdateSDK(void* ptr, std::string className, std::string fieldName, EValue value, EContext* state)
 {
-    if (followServerGuidelines && g_sdk.IsFieldBlocked(fieldName))
-    {
-        PRINTF("Getting or setting %s::%s is not permitted due to %s Server Guidelines violation.\nTo get or set this value, switch to false the \"core.Follow%sServerGuidelines\" field.\nNote: Using non-compliant field values can result in a GSLT ban.\nNote: We are not providing any kind of support for people which are using these fields.\n", className.c_str(), fieldName.c_str(), str_toupper(GetGameName()).c_str(), str_toupper(GetGameName()).c_str());
-        return;
-    }
-
     uint64 path = ((uint64_t)hash_32_fnv1a_const(className.c_str()) << 32 | hash_32_fnv1a_const(fieldName.c_str()));
     if (!g_sdk.ExistsField(path)) return;
 
     std::string field = g_sdk.GetFieldName(path);
 
+    if (followServerGuidelines && g_sdk.IsFieldBlocked(field))
+    {
+        PRINTF("Getting or setting %s::%s is not permitted due to %s Server Guidelines violation.\nTo get or set this value, switch to false the \"core.Follow%sServerGuidelines\" field.\nNote: Using non-compliant field values can result in a GSLT ban.\nNote: We are not providing any kind of support for people which are using these fields.\n", className.c_str(), fieldName.c_str(), str_toupper(GetGameName()).c_str(), str_toupper(GetGameName()).c_str());
+        return;
+    }
+
     switch (g_sdk.GetFieldType(path))
     {
     case Bool:
@@ -603,7 +603,7 @@ void UpdateSDK(void* ptr, std::string className, std::string fieldName, EValue v
         return;
     }
     case SDKCHandle: {
-        if(!value.isInstance<ClassData*>()) return;
+        if (!value.isInstance<ClassData*>()) return;
 
         auto outVal = schema::GetPropPtr<CHandle<CEntityInstance>>(ptr, className.c_str(), field.c_str());
         outVal->Set((CEntityInstance*)(value.cast<ClassData*>()->GetDataOr<void*>("class_ptr", nullptr)));
@@ -615,7 +615,7 @@ void UpdateSDK(void* ptr, std::string className, std::string fieldName, EValue v
         auto outValue = schema::GetPropPtr<CHandle<CEntityInstance>>(ptr, className.c_str(), field.c_str());
         auto ret = value.cast<std::vector<EValue>>();
         for (uint32_t i = 0; i < g_sdk.GetFieldSize(path); i++) {
-            if(!ret[i].isInstance<ClassData*>()) continue;
+            if (!ret[i].isInstance<ClassData*>()) continue;
             outValue[i].Set((CEntityInstance*)(ret[i].cast<ClassData*>()->GetDataOr<void*>("class_ptr", nullptr)));
         }
 
@@ -631,7 +631,7 @@ void UpdateSDK(void* ptr, std::string className, std::string fieldName, EValue v
 
         CUtlVector<CHandle<CEntityInstance>>* vec = reinterpret_cast<CUtlVector<CHandle<CEntityInstance>> *>((uintptr_t)(ptr)+m_key);
         FOR_EACH_VEC(*vec, i) {
-            if(!ret[i].isInstance<ClassData*>()) continue;
+            if (!ret[i].isInstance<ClassData*>()) continue;
             vec->Element(i).Set((CEntityInstance*)(ret[i].cast<ClassData*>()->GetDataOr<void*>("class_ptr", nullptr)));
         }
 
@@ -652,7 +652,7 @@ void UpdateSDK(void* ptr, std::string className, std::string fieldName, EValue v
         auto outValue = schema::GetPropPtr<Color>(ptr, className.c_str(), field.c_str());
         auto ret = value.cast<std::vector<EValue>>();
         for (uint32_t i = 0; i < g_sdk.GetFieldSize(path); i++) {
-            if(!ret[i].isInstance<ClassData*>()) continue;
+            if (!ret[i].isInstance<ClassData*>()) continue;
             outValue[i] = ret[i].cast<ClassData*>()->GetDataOr<Color>("Color_ptr", outValue[i]);
         }
 
@@ -663,7 +663,7 @@ void UpdateSDK(void* ptr, std::string className, std::string fieldName, EValue v
         auto outValue = schema::GetPropPtr<QAngle>(ptr, className.c_str(), field.c_str());
         auto ret = value.cast<std::vector<EValue>>();
         for (uint32_t i = 0; i < g_sdk.GetFieldSize(path); i++) {
-            if(!ret[i].isInstance<ClassData*>()) continue;
+            if (!ret[i].isInstance<ClassData*>()) continue;
             outValue[i] = ret[i].cast<ClassData*>()->GetDataOr<QAngle>("QAngle_ptr", outValue[i]);
         }
 
@@ -674,7 +674,7 @@ void UpdateSDK(void* ptr, std::string className, std::string fieldName, EValue v
         auto outValue = schema::GetPropPtr<Vector>(ptr, className.c_str(), field.c_str());
         auto ret = value.cast<std::vector<EValue>>();
         for (uint32_t i = 0; i < g_sdk.GetFieldSize(path); i++) {
-            if(!ret[i].isInstance<ClassData*>()) continue;
+            if (!ret[i].isInstance<ClassData*>()) continue;
             outValue[i] = ret[i].cast<ClassData*>()->GetDataOr<Vector>("vector_ptr", outValue[i]);
         }
 
@@ -685,7 +685,7 @@ void UpdateSDK(void* ptr, std::string className, std::string fieldName, EValue v
         auto outValue = schema::GetPropPtr<Vector2D>(ptr, className.c_str(), field.c_str());
         auto ret = value.cast<std::vector<EValue>>();
         for (uint32_t i = 0; i < g_sdk.GetFieldSize(path); i++) {
-            if(!ret[i].isInstance<ClassData*>()) continue;
+            if (!ret[i].isInstance<ClassData*>()) continue;
             outValue[i] = ret[i].cast<ClassData*>()->GetDataOr<Vector2D>("Vector2D_ptr", outValue[i]);
         }
 
@@ -696,7 +696,7 @@ void UpdateSDK(void* ptr, std::string className, std::string fieldName, EValue v
         auto outValue = schema::GetPropPtr<Vector4D>(ptr, className.c_str(), field.c_str());
         auto ret = value.cast<std::vector<EValue>>();
         for (uint32_t i = 0; i < g_sdk.GetFieldSize(path); i++) {
-            if(!ret[i].isInstance<ClassData*>()) continue;
+            if (!ret[i].isInstance<ClassData*>()) continue;
             outValue[i] = ret[i].cast<ClassData*>()->GetDataOr<Vector4D>("Vector4D_ptr", outValue[i]);
         }
 
diff --git a/src/scripting/server/menus.cpp b/src/scripting/server/menus.cpp
index 4163644e4..9d44b3265 100644
--- a/src/scripting/server/menus.cpp
+++ b/src/scripting/server/menus.cpp
@@ -3,6 +3,14 @@
 #include <server/configuration/configuration.h>
 #include <server/menus/MenuManager.h>
 
+#ifndef WIN_LINUX
+#ifdef _WIN32
+#define WIN_LINUX(win,linux) win
+#else
+#define WIN_LINUX(win,linux) linux
+#endif
+#endif
+
 LoadScriptingComponent(menus, [](PluginObject plugin, EContext* ctx) -> void {
     ADD_CLASS("Menus");
 
@@ -13,7 +21,7 @@ LoadScriptingComponent(menus, [](PluginObject plugin, EContext* ctx) -> void {
         std::string title = context->GetArgumentOr<std::string>(1, "");
         std::string color = context->GetArgumentOr<std::string>(2, "");
         std::vector<std::pair<std::string, std::string>> options = context->GetArgumentOr<std::vector<std::pair<std::string, std::string>>>(3, std::vector<std::pair<std::string, std::string>>{});
-        std::string menuKind = context->GetArgumentOr<std::string>(4, g_Config.FetchValue<std::string>("core.menu.kind"));
+        std::string menuKind = WIN_LINUX("center", context->GetArgumentOr<std::string>(4, g_Config.FetchValue<std::string>("core.menu.kind")));
 
         g_MenuManager.RegisterMenu(FetchPluginName(context->GetPluginContext()), menuid, title, color, options, false, menuKind);
     });
diff --git a/src/scripting/server/utils.cpp b/src/scripting/server/utils.cpp
index e5e5b555d..80c72c173 100644
--- a/src/scripting/server/utils.cpp
+++ b/src/scripting/server/utils.cpp
@@ -12,6 +12,31 @@
 #include <texttable/TextTable.h>
 #include <sdk/schema.h>
 
+#include <vector>
+#include <map>
+
+void GetPluginListFunc(FunctionContext* context) {
+    std::vector<std::map<std::string, std::string>> returnMap;
+
+    for (auto plugin : g_pluginManager.GetPluginsList()) {
+        if (plugin->GetPluginState() == PluginState_t::Started) {
+            std::string website = plugin->GetWebsite();
+
+            returnMap.push_back({
+                { "name", plugin->GetPlName() },
+                { "id", plugin->GetName() },
+                { "version", plugin->GetVersion() },
+                { "author", plugin->GetAuthor() },
+                { "website", (website == "") ? std::string("Not Present") : website },
+                { "loaded", plugin->GetPluginState() == PluginState_t::Started ? "yes" : "no" },
+                { "error", plugin->GetLoadError() }
+            });
+        }
+    }
+
+    context->SetReturn(returnMap);
+}
+
 LoadScriptingComponent(utils, [](PluginObject plugin, EContext* ctx) -> void {
     ADD_FUNCTION("AddTimeout", [](FunctionContext* context) -> void {
         int64_t delay = context->GetArgumentOr<int64_t>(0, 0);
@@ -145,4 +170,6 @@ LoadScriptingComponent(utils, [](PluginObject plugin, EContext* ctx) -> void {
 
         g_callStack.UnregisterPluginCallstack(plugin_name, stackid);
     });
+
+    ADD_FUNCTION("GetPluginsList", GetPluginListFunc);
 })
\ No newline at end of file
diff --git a/src/sdk/components/CTakeDamageInfo.h b/src/sdk/components/CTakeDamageInfo.h
index 9b3c539e9..9cfac7a3f 100644
--- a/src/sdk/components/CTakeDamageInfo.h
+++ b/src/sdk/components/CTakeDamageInfo.h
@@ -94,7 +94,7 @@ class CTakeDamageInfo
 	uint8_t m_iAmmoType;
 
 private:
-	[[maybe_unused]] uint8_t __pad0059[0xf];
+	[[maybe_unused]] uint8_t _x51[15];
 
 public:
 	float m_flOriginalDamage;
@@ -102,27 +102,23 @@ class CTakeDamageInfo
 	bool m_bShouldSpark;
 
 private:
-	[[maybe_unused]] uint8_t __pad006e[0x2];
+	[[maybe_unused]] uint8_t _x6e[0x2];
 
 public:
 	float m_flDamageAbsorbed;
-
-private:
-	[[maybe_unused]] uint8_t __pad0074[0x8];
-
-public:
+	CGameTrace* m_pTrace;
 	TTakeDamageFlags_t m_nDamageFlags;
+	int32_t m_nNumObjectsPenetrated;
+	float m_flFriendlyFireDamageReductionRatio;
 
 private:
-	[[maybe_unused]] uint8_t __pad0084[0x4];
+	[[maybe_unused]] uint8_t _x8c[0x58];
 
 public:
-	int32_t m_nNumObjectsPenetrated;
-	float m_flFriendlyFireDamageReductionRatio;
-	uint64_t m_hScriptInstance;
+	void* m_hScriptInstance;
 	AttackerInfo_t m_AttackerInfo;
 	bool m_bInTakeDamageFlow;
 
 private:
-	[[maybe_unused]] uint8_t __pad00ad[0x4];
+	[[maybe_unused]] int32_t m_nUnknown2;
 };
\ No newline at end of file
diff --git a/src/server/player/manager.cpp b/src/server/player/manager.cpp
index e9233740e..f0ffe6acd 100644
--- a/src/server/player/manager.cpp
+++ b/src/server/player/manager.cpp
@@ -123,7 +123,7 @@ bool PlayerManager::ClientConnect(CPlayerSlot slot, const char* pszName, uint64
     bool response = true;
     try
     {
-        response = std::any_cast<bool>(data.GetData<std::any>("event_return"));
+        response = std::any_cast<bool>(data.GetAnyData("event_return"));
     }
     catch (std::bad_any_cast& e)
     {
diff --git a/vendor/embedder b/vendor/embedder
index 844c09af9..0eb4407d5 160000
--- a/vendor/embedder
+++ b/vendor/embedder
@@ -1 +1 @@
-Subproject commit 844c09af981ff27d9222ded147996ae7fcb022ce
+Subproject commit 0eb4407d5c985648243a077b2f118d466af66d73