diff options
Diffstat (limited to 'sourcemod/scripting/gokz-core/misc.sp')
| -rw-r--r-- | sourcemod/scripting/gokz-core/misc.sp | 803 |
1 files changed, 803 insertions, 0 deletions
diff --git a/sourcemod/scripting/gokz-core/misc.sp b/sourcemod/scripting/gokz-core/misc.sp new file mode 100644 index 0000000..a117880 --- /dev/null +++ b/sourcemod/scripting/gokz-core/misc.sp @@ -0,0 +1,803 @@ +/* + Small features that aren't worth splitting into their own file. +*/ + + + +// =====[ GOKZ.CFG ]===== + +void OnMapStart_KZConfig() +{ + char gokzCfgFullPath[PLATFORM_MAX_PATH]; + FormatEx(gokzCfgFullPath, sizeof(gokzCfgFullPath), "cfg/%s", GOKZ_CFG_SERVER); + + if (FileExists(gokzCfgFullPath)) + { + ServerCommand("exec %s", GOKZ_CFG_SERVER); + } + else + { + SetFailState("Failed to load file: \"%s\". Check that it exists.", gokzCfgFullPath); + } +} + + + +// =====[ GODMODE ]===== + +void OnPlayerSpawn_GodMode(int client) +{ + // Stop players from taking damage + SetEntProp(client, Prop_Data, "m_takedamage", 0); + SetEntityFlags(client, GetEntityFlags(client) | FL_GODMODE); +} + + + +// =====[ NOCLIP ]===== + +int noclipReleaseTime[MAXPLAYERS + 1]; + +void ToggleNoclip(int client) +{ + if (Movement_GetMovetype(client) != MOVETYPE_NOCLIP) + { + EnableNoclip(client); + } + else + { + DisableNoclip(client); + } +} + +void EnableNoclip(int client) +{ + if (IsValidClient(client) && IsPlayerAlive(client)) + { + if (GOKZ_GetCoreOption(client, Option_Safeguard) > Safeguard_Disabled && GOKZ_GetTimerRunning(client) && GOKZ_GetValidTimer(client)) + { + GOKZ_PrintToChat(client, true, "%t", "Safeguard - Blocked"); + GOKZ_PlayErrorSound(client); + return; + } + Movement_SetMovetype(client, MOVETYPE_NOCLIP); + GOKZ_StopTimer(client); + } +} + +void DisableNoclip(int client) +{ + if (IsValidClient(client) && IsPlayerAlive(client) && Movement_GetMovetype(client) == MOVETYPE_NOCLIP) + { + noclipReleaseTime[client] = GetGameTickCount(); + Movement_SetMovetype(client, MOVETYPE_WALK); + SetEntProp(client, Prop_Send, "m_CollisionGroup", GOKZ_COLLISION_GROUP_STANDARD); + + // Prevents an exploit that would let you noclip out of start zones + RemoveNoclipGroundFlag(client); + } +} + +void ToggleNoclipNotrigger(int client) +{ + if (Movement_GetMovetype(client) != MOVETYPE_NOCLIP) + { + EnableNoclipNotrigger(client); + } + else + { + DisableNoclipNotrigger(client); + } +} + +void EnableNoclipNotrigger(int client) +{ + if (IsValidClient(client) && IsPlayerAlive(client)) + { + if (GOKZ_GetCoreOption(client, Option_Safeguard) > Safeguard_Disabled && GOKZ_GetTimerRunning(client) && GOKZ_GetValidTimer(client)) + { + GOKZ_PrintToChat(client, true, "%t", "Safeguard - Blocked"); + GOKZ_PlayErrorSound(client); + return; + } + Movement_SetMovetype(client, MOVETYPE_NOCLIP); + SetEntProp(client, Prop_Send, "m_CollisionGroup", GOKZ_COLLISION_GROUP_NOTRIGGER); + GOKZ_StopTimer(client); + } +} + +void DisableNoclipNotrigger(int client) +{ + if (IsValidClient(client) && IsPlayerAlive(client) && Movement_GetMovetype(client) == MOVETYPE_NOCLIP) + { + noclipReleaseTime[client] = GetGameTickCount(); + Movement_SetMovetype(client, MOVETYPE_WALK); + SetEntProp(client, Prop_Send, "m_CollisionGroup", GOKZ_COLLISION_GROUP_STANDARD); + + // Prevents an exploit that would let you noclip out of start zones + RemoveNoclipGroundFlag(client); + } +} + +void RemoveNoclipGroundFlag(int client) +{ + float startPosition[3], endPosition[3]; + GetClientAbsOrigin(client, startPosition); + endPosition = startPosition; + endPosition[2] = startPosition[2] - 2.0; + Handle trace = TR_TraceHullFilterEx( + startPosition, + endPosition, + view_as<float>( { -16.0, -16.0, 0.0 } ), + view_as<float>( { 16.0, 16.0, 72.0 } ), + MASK_PLAYERSOLID, + TraceEntityFilterPlayers, + client); + + if (!TR_DidHit(trace)) + { + SetEntityFlags(client, GetEntityFlags(client) & ~FL_ONGROUND); + } + delete trace; +} + +bool JustNoclipped(int client) +{ + return GetGameTickCount() - noclipReleaseTime[client] <= GOKZ_TIMER_START_NOCLIP_TICKS; +} + +void OnClientPutInServer_Noclip(int client) +{ + noclipReleaseTime[client] = 0; +} + +// =====[ TURNBINDS ]===== + +static int turnbindsLastLeftStart[MAXPLAYERS + 1]; +static int turnbindsLastRightStart[MAXPLAYERS + 1]; +static float turnbindsLastValidYaw[MAXPLAYERS + 1]; +static int turnbindsOldButtons[MAXPLAYERS + 1]; + +void OnClientPutInServer_Turnbinds(int client) +{ + turnbindsLastLeftStart[client] = 0; + turnbindsLastRightStart[client] = 0; +} +// Ensures that there is a minimum time between starting to turnbind in one direction +// and then starting to turnbind in the other direction +void OnPlayerRunCmd_Turnbinds(int client, int buttons, int tickcount, float angles[3]) +{ + if (IsFakeClient(client)) + { + return; + } + if (buttons & IN_LEFT && tickcount < turnbindsLastRightStart[client] + RoundToNearest(GOKZ_TURNBIND_COOLDOWN / GetTickInterval())) + { + angles[1] = turnbindsLastValidYaw[client]; + TeleportEntity(client, NULL_VECTOR, angles, NULL_VECTOR); + buttons = 0; + } + else if (buttons & IN_RIGHT && tickcount < turnbindsLastLeftStart[client] + RoundToNearest(GOKZ_TURNBIND_COOLDOWN / GetTickInterval())) + { + angles[1] = turnbindsLastValidYaw[client]; + TeleportEntity(client, NULL_VECTOR, angles, NULL_VECTOR); + buttons = 0; + } + else + { + turnbindsLastValidYaw[client] = angles[1]; + + if (!(turnbindsOldButtons[client] & IN_LEFT) && (buttons & IN_LEFT)) + { + turnbindsLastLeftStart[client] = tickcount; + } + + if (!(turnbindsOldButtons[client] & IN_RIGHT) && (buttons & IN_RIGHT)) + { + turnbindsLastRightStart[client] = tickcount; + } + + turnbindsOldButtons[client] = buttons; + } +} + + + +// =====[ PLAYER COLLISION ]===== + +void OnPlayerSpawn_PlayerCollision(int client) +{ + // Let players go through other players + SetEntProp(client, Prop_Send, "m_CollisionGroup", GOKZ_COLLISION_GROUP_STANDARD); +} + +void OnSetModel_PlayerCollision(int client) +{ + // Fix custom models temporarily changing player collisions + SetEntPropVector(client, Prop_Data, "m_vecMins", PLAYER_MINS); + if (GetEntityFlags(client) & FL_DUCKING == 0) + { + SetEntPropVector(client, Prop_Data, "m_vecMaxs", PLAYER_MAXS); + } + else + { + SetEntPropVector(client, Prop_Data, "m_vecMaxs", PLAYER_MAXS_DUCKED); + } +} + + +// =====[ FORCE SV_FULL_ALLTALK 1 ]===== + +void OnRoundStart_ForceAllTalk() +{ + gCV_sv_full_alltalk.BoolValue = true; +} + + + +// =====[ ERROR SOUNDS ]===== + +#define SOUND_ERROR "buttons/button10.wav" + +void PlayErrorSound(int client) +{ + if (GOKZ_GetCoreOption(client, Option_ErrorSounds) == ErrorSounds_Enabled) + { + GOKZ_EmitSoundToClient(client, SOUND_ERROR, _, "Error"); + } +} + + + +// =====[ STOP SOUNDS ]===== + +Action OnNormalSound_StopSounds(int entity) +{ + char className[20]; + GetEntityClassname(entity, className, sizeof(className)); + if (StrEqual(className, "func_button", false)) + { + return Plugin_Handled; // No sounds directly from func_button + } + return Plugin_Continue; +} + + + +// =====[ JOIN TEAM HANDLING ]===== + +static bool hasSavedPosition[MAXPLAYERS + 1]; +static float savedOrigin[MAXPLAYERS + 1][3]; +static float savedAngles[MAXPLAYERS + 1][3]; +static bool savedOnLadder[MAXPLAYERS + 1]; + +void OnClientPutInServer_JoinTeam(int client) +{ + // Automatically put the player on a team if he doesn't choose one. + // The mp_force_pick_time convar is the built in way to do this, but that obviously + // does not call GOKZ_JoinTeam which includes a fix for spawning in the void when + // there is no valid spawns available. + CreateTimer(12.0, Timer_ForceJoinTeam, GetClientUserId(client), TIMER_FLAG_NO_MAPCHANGE); + + hasSavedPosition[client] = false; +} + +public Action Timer_ForceJoinTeam(Handle timer, int userid) +{ + int client = GetClientOfUserId(userid); + if (IsValidClient(client)) + { + int team = GetClientTeam(client); + if (team == CS_TEAM_NONE) + { + GOKZ_JoinTeam(client, CS_TEAM_SPECTATOR, false); + } + } + return Plugin_Stop; +} + +void OnTimerStart_JoinTeam(int client) +{ + hasSavedPosition[client] = false; +} + +void JoinTeam(int client, int newTeam, bool restorePos, bool forceBroadcast = false) +{ + KZPlayer player = KZPlayer(client); + int currentTeam = GetClientTeam(client); + + // Don't use CS_TEAM_NONE + if (newTeam == CS_TEAM_NONE) + { + newTeam = CS_TEAM_SPECTATOR; + } + + if (newTeam == CS_TEAM_SPECTATOR && currentTeam != CS_TEAM_SPECTATOR) + { + if (currentTeam != CS_TEAM_NONE) + { + player.GetOrigin(savedOrigin[client]); + player.GetEyeAngles(savedAngles[client]); + savedOnLadder[client] = player.Movetype == MOVETYPE_LADDER; + hasSavedPosition[client] = true; + } + + if (!player.Paused && !player.CanPause) + { + player.StopTimer(); + } + ChangeClientTeam(client, CS_TEAM_SPECTATOR); + Call_GOKZ_OnJoinTeam(client, newTeam); + } + else if (newTeam == CS_TEAM_CT && currentTeam != CS_TEAM_CT + || newTeam == CS_TEAM_T && currentTeam != CS_TEAM_T) + { + ForcePlayerSuicide(client); + CS_SwitchTeam(client, newTeam); + CS_RespawnPlayer(client); + if (restorePos && hasSavedPosition[client]) + { + TeleportPlayer(client, savedOrigin[client], savedAngles[client]); + if (savedOnLadder[client]) + { + player.Movetype = MOVETYPE_LADDER; + } + } + else + { + player.StopTimer(); + // Just joining a team alone can put you into weird invalid spawns. + // Need to teleport the player to a valid one. + float spawnOrigin[3]; + float spawnAngles[3]; + GetValidSpawn(spawnOrigin, spawnAngles); + TeleportPlayer(client, spawnOrigin, spawnAngles); + } + hasSavedPosition[client] = false; + Call_GOKZ_OnJoinTeam(client, newTeam); + } + else if (forceBroadcast) + { + Call_GOKZ_OnJoinTeam(client, newTeam); + } +} + +void SendFakeTeamEvent(int client) +{ + // Send a fake event to close the team menu + Event event = CreateEvent("player_team"); + event.SetInt("userid", GetClientUserId(client)); + event.FireToClient(client); + event.Cancel(); +} + +// =====[ VALID JUMP TRACKING ]===== + +/* + Valid jump tracking is intended to detect when the player + has performed a normal jump that hasn't been affected by + (unexpected) teleports or other cases that may result in + the player becoming airborne, such as spawning. + + There are ways to trick the plugin, but it is rather + unlikely to happen during normal gameplay. +*/ + +static bool validJump[MAXPLAYERS + 1]; +static float validJumpTeleportOrigin[MAXPLAYERS + 1][3]; +static int lastInvalidatedTick[MAXPLAYERS + 1]; +bool GetValidJump(int client) +{ + return validJump[client]; +} + +static void InvalidateJump(int client) +{ + lastInvalidatedTick[client] = GetGameTickCount(); + if (validJump[client]) + { + validJump[client] = false; + Call_GOKZ_OnJumpInvalidated(client); + } +} + +void OnStopTouchGround_ValidJump(int client, bool jumped, bool ladderJump, bool jumpbug) +{ + if (Movement_GetMovetype(client) == MOVETYPE_WALK && lastInvalidatedTick[client] != GetGameTickCount()) + { + validJump[client] = true; + Call_GOKZ_OnJumpValidated(client, jumped, ladderJump, jumpbug); + } + else + { + InvalidateJump(client); + } +} + +void OnPlayerRunCmdPost_ValidJump(int client) +{ + if (gB_VelocityTeleported[client] || gB_OriginTeleported[client]) + { + InvalidateJump(client); + } +} + +void OnChangeMovetype_ValidJump(int client, MoveType oldMovetype, MoveType newMovetype) +{ + if (oldMovetype == MOVETYPE_LADDER && newMovetype == MOVETYPE_WALK && lastInvalidatedTick[client] != GetGameTickCount()) // Ladderjump + { + validJump[client] = true; + Call_GOKZ_OnJumpValidated(client, false, true, false); + } + else + { + InvalidateJump(client); + } +} + +void OnClientDisconnect_ValidJump(int client) +{ + InvalidateJump(client); +} + +void OnPlayerSpawn_ValidJump(int client) +{ + // That should definitely be out of bounds + CopyVector({ 40000.0, 40000.0, 40000.0 }, validJumpTeleportOrigin[client]); + InvalidateJump(client); +} + +void OnPlayerDeath_ValidJump(int client) +{ + InvalidateJump(client); +} + +void OnValidOriginChange_ValidJump(int client, const float origin[3]) +{ + CopyVector(origin, validJumpTeleportOrigin[client]); +} + +void OnTeleport_ValidJump(int client) +{ + float origin[3]; + Movement_GetOrigin(client, origin); + if (gB_OriginTeleported[client] && GetVectorDistance(validJumpTeleportOrigin[client], origin, true) <= EPSILON) + { + gB_OriginTeleported[client] = false; + CopyVector({ 40000.0, 40000.0, 40000.0 }, validJumpTeleportOrigin[client]); + return; + } + + if (gB_OriginTeleported[client]) + { + InvalidateJump(client); + Call_GOKZ_OnTeleport(client); + } + + if (gB_VelocityTeleported[client]) + { + InvalidateJump(client); + } +} + + + +// =====[ FIRST SPAWN ]===== + +static bool hasSpawned[MAXPLAYERS + 1]; + +void OnClientPutInServer_FirstSpawn(int client) +{ + hasSpawned[client] = false; +} + +void OnPlayerSpawn_FirstSpawn(int client) +{ + int team = GetClientTeam(client); + if (!hasSpawned[client] && (team == CS_TEAM_CT || team == CS_TEAM_T)) + { + hasSpawned[client] = true; + Call_GOKZ_OnFirstSpawn(client); + } +} + + + +// =====[ TIME LIMIT ]===== + +void OnConfigsExecuted_TimeLimit() +{ + CreateTimer(1.0, Timer_TimeLimit, _, TIMER_REPEAT); +} + +public Action Timer_TimeLimit(Handle timer) +{ + int timelimit; + if (!GetMapTimeLimit(timelimit) || timelimit == 0) + { + return Plugin_Continue; + } + + int timeleft; + // Check for less than -1 in case we miss 0 - ignore -1 because that means infinite time limit + if (GetMapTimeLeft(timeleft) && (timeleft == 0 || timeleft < -1)) + { + CreateTimer(5.0, Timer_EndRound); // End the round after a delay or it won't end the map + return Plugin_Stop; + } + + return Plugin_Continue; +} + +public Action Timer_EndRound(Handle timer) +{ + CS_TerminateRound(1.0, CSRoundEnd_Draw, true); + return Plugin_Continue; +} + + + +// =====[ COURSE REGISTER ]===== + +static bool startRegistered[GOKZ_MAX_COURSES]; +static bool endRegistered[GOKZ_MAX_COURSES]; +static bool courseRegistered[GOKZ_MAX_COURSES]; + +bool GetCourseRegistered(int course) +{ + return courseRegistered[course]; +} + +void RegisterCourseStart(int course) +{ + startRegistered[course] = true; + TryRegisterCourse(course); +} + +void RegisterCourseEnd(int course) +{ + endRegistered[course] = true; + TryRegisterCourse(course); +} + +void OnMapStart_CourseRegister() +{ + for (int course = 0; course < GOKZ_MAX_COURSES; course++) + { + courseRegistered[course] = false; + } +} + +static void TryRegisterCourse(int course) +{ + if (!courseRegistered[course] && startRegistered[course] && endRegistered[course]) + { + courseRegistered[course] = true; + Call_GOKZ_OnCourseRegistered(course); + } +} + + + +// =====[ SPAWN FIXES ]===== + +void OnMapStart_FixMissingSpawns() +{ + int tSpawn = FindEntityByClassname(-1, "info_player_terrorist"); + int ctSpawn = FindEntityByClassname(-1, "info_player_counterterrorist"); + + if (tSpawn == -1 && ctSpawn == -1) + { + LogMessage("Couldn't fix spawns because none exist."); + return; + } + + if (tSpawn == -1 || ctSpawn == -1) + { + float origin[3], angles[3]; + GetValidSpawn(origin, angles); + + int newSpawn = CreateEntityByName((tSpawn == -1) ? "info_player_terrorist" : "info_player_counterterrorist"); + if (DispatchSpawn(newSpawn)) + { + TeleportEntity(newSpawn, origin, angles, NULL_VECTOR); + } + } +} + +// =====[ BUTTONS ]===== + +void OnClientPreThinkPost_UseButtons(int client) +{ + if (GOKZ_GetCoreOption(client, Option_ButtonThroughPlayers) == ButtonThroughPlayers_Enabled && GetEntProp(client, Prop_Data, "m_afButtonPressed") & IN_USE) + { + int entity = FindUseEntity(client); + if (entity != -1) + { + AcceptEntityInput(entity, "Use", client, client, 1); + } + } +} + +static int FindUseEntity(int client) +{ + float fwd[3]; + float angles[3]; + GetClientEyeAngles(client, angles); + GetAngleVectors(angles, fwd, NULL_VECTOR, NULL_VECTOR); + + Handle trace; + + float eyeOrigin[3]; + GetClientEyePosition(client, eyeOrigin); + int useableContents = (MASK_NPCSOLID_BRUSHONLY | MASK_OPAQUE_AND_NPCS) & ~CONTENTS_OPAQUE; + + float endpos[3]; + + // Check if +use trace collide with a player first, so we don't activate any button twice + trace = TR_TraceRayFilterEx(eyeOrigin, angles, useableContents, RayType_Infinite, TRFOtherPlayersOnly, client); + if (TR_DidHit(trace)) + { + int ent = TR_GetEntityIndex(trace); + if (ent < 1 || ent > MaxClients) + { + return -1; + } + // Search for a button behind it. + trace = TR_TraceRayFilterEx(eyeOrigin, angles, useableContents, RayType_Infinite, TraceEntityFilterPlayers); + if (TR_DidHit(trace)) + { + char buffer[20]; + ent = TR_GetEntityIndex(trace); + // Make sure that it is a button, and this button activates when pressed. + // If it is not a button, check its parent to see if it is a button. + bool isButton; + while (ent != -1) + { + GetEntityClassname(ent, buffer, sizeof(buffer)); + if (StrEqual("func_button", buffer, false) && GetEntProp(ent, Prop_Data, "m_spawnflags") & SF_BUTTON_USE_ACTIVATES) + { + isButton = true; + break; + } + else + { + ent = GetEntPropEnt(ent, Prop_Data, "m_hMoveParent"); + } + } + if (isButton) + { + TR_GetEndPosition(endpos, trace); + float delta[3]; + for (int i = 0; i < 2; i++) + { + delta[i] = endpos[i] - eyeOrigin[i]; + } + // Z distance is treated differently. + float m_vecMins[3]; + float m_vecMaxs[3]; + float m_vecOrigin[3]; + GetEntPropVector(ent, Prop_Send, "m_vecOrigin", m_vecOrigin); + GetEntPropVector(ent, Prop_Send, "m_vecMins", m_vecMins); + GetEntPropVector(ent, Prop_Send, "m_vecMaxs", m_vecMaxs); + + delta[2] = IntervalDistance(endpos[2], m_vecOrigin[2] + m_vecMins[2], m_vecOrigin[2] + m_vecMaxs[2]); + if (GetVectorLength(delta) < 80.0) + { + return ent; + } + } + } + } + + int nearestEntity; + float nearestPoint[3]; + float nearestDist = FLOAT_MAX; + ArrayList entities = new ArrayList(); + TR_EnumerateEntitiesSphere(eyeOrigin, 80.0, 1<<5, AddEntities, entities); + for (int i = 0; i < entities.Length; i++) + { + char buffer[64]; + int ent = entities.Get(i); + GetEntityClassname(ent, buffer, sizeof(buffer)); + // Check if the entity is a button and it is pressable. + if (StrEqual("func_button", buffer, false) && GetEntProp(ent, Prop_Data, "m_spawnflags") & SF_BUTTON_USE_ACTIVATES) + { + float point[3]; + CalcNearestPoint(ent, eyeOrigin, point); + + float dir[3]; + for (int j = 0; j < 3; j++) + { + dir[j] = point[j] - eyeOrigin[2]; + } + // Check the maximum angle the player can be away from the button. + float minimumDot = GetEntPropFloat(ent, Prop_Send, "m_flUseLookAtAngle"); + NormalizeVector(dir, dir); + float dot = GetVectorDotProduct(dir, fwd); + if (dot < minimumDot) + { + continue; + } + + float dist = CalcDistanceToLine(point, eyeOrigin, fwd); + if (dist < nearestDist) + { + trace = TR_TraceRayFilterEx(eyeOrigin, point, useableContents, RayType_EndPoint, TraceEntityFilterPlayers); + if (TR_GetFraction(trace) == 1.0 || TR_GetEntityIndex(trace) == ent) + { + CopyVector(point, nearestPoint); + nearestDist = dist; + nearestEntity = ent; + } + } + } + } + // We found the closest button, but we still need to check if there is a player in front of it or not. + // In the case that there isn't a player inbetween, we don't return the entity index, because that button will be pressed by the game function anyway. + // If there is, we will press two buttons at once, the "right" button found by this function and the "wrong" button that we only happen to press because + // there is a player in the way. + + trace = TR_TraceRayFilterEx(eyeOrigin, nearestPoint, useableContents, RayType_EndPoint, TRFOtherPlayersOnly); + if (TR_DidHit(trace)) + { + return nearestEntity; + } + return -1; +} + +public bool AddEntities(int entity, ArrayList entities) +{ + entities.Push(entity); + return true; +} + +static float IntervalDistance(float x, float x0, float x1) +{ + if (x0 > x1) + { + float tmp = x0; + x0 = x1; + x1 = tmp; + } + if (x < x0) + { + return x0 - x; + } + else if (x > x1) + { + return x - x1; + } + return 0.0; +} +// TraceRay filter for other players exclusively. +public bool TRFOtherPlayersOnly(int entity, int contentmask, int client) +{ + return (0 < entity <= MaxClients) && (entity != client); +} + +// =====[ SAFE MODE ]===== + +void ToggleNubSafeGuard(int client) +{ + if (GOKZ_GetCoreOption(client, Option_Safeguard) == Safeguard_EnabledNUB) + { + GOKZ_SetCoreOption(client, Option_Safeguard, Safeguard_Disabled); + } + else + { + GOKZ_SetCoreOption(client, Option_Safeguard, Safeguard_EnabledNUB); + } +} + +void ToggleProSafeGuard(int client) +{ + if (GOKZ_GetCoreOption(client, Option_Safeguard) == Safeguard_EnabledPRO) + { + GOKZ_SetCoreOption(client, Option_Safeguard, Safeguard_Disabled); + } + else + { + GOKZ_SetCoreOption(client, Option_Safeguard, Safeguard_EnabledPRO); + } +} |