View difference between Paste ID: GnXyahrV and Cuuubkde

 #include <sourcemod>
 #include <sdkhooks>
 #include <tf2>
 #include <tf2_stocks>
 #include <sdktools>
 
 #undef REQUIRE_PLUGIN
 #include <adminmenu>
 #define REQUIRE_PLUGIN
-new Handle:h_Mode = INVALID_HANDLE;
+
-new Handle:h_MaxValue = INVALID_HANDLE;
+//* * * * * * * * * * * * * * * * * * * * * * * * * *
-new Handle:h_MinValue = INVALID_HANDLE;
+//Defines
 //* * * * * * * * * * * * * * * * * * * * * * * * * *
-new RoundWin = 1;
+//- The default Field of Vision to apply to clients.
-new Adding = 1;
+#define cDefaultVision 90
-new TheValue = 90;
+
-new bool:ShowFov[MAXPLAYERS + 1];
+//* * * * * * * * * * * * * * * * * * * * * * * * * *
 //Handles
-new bool:sfov_check[MAXPLAYERS + 1];
+//* * * * * * * * * * * * * * * * * * * * * * * * * *
-new bool:sfov_on[MAXPLAYERS + 1];
+new Handle:h_Mode = INVALID_HANDLE;				//ConVar for fov order.
-new sfovmode;
+new Handle:h_MaxValue = INVALID_HANDLE;			//ConVar for max fov.
-new Max;
+new Handle:h_MinValue = INVALID_HANDLE;			//ConVar for min fov.
-new Min;
+new Handle:hTopMenu = INVALID_HANDLE;			//AdminMenu
 
-new Handle:hTopMenu = INVALID_HANDLE;
+//* * * * * * * * * * * * * * * * * * * * * * * * * *
 //Variables
-public Plugin:myinfo =
+//* * * * * * * * * * * * * * * * * * * * * * * * * *
 new g_bEnding;									//Stores the state of round end.
 new g_bLateLoad;								//Stores the state of load.
 
 //* * * * * * * * * * * * * * * * * * * * * * * * * *
 //Clients
 //* * * * * * * * * * * * * * * * * * * * * * * * * *
 new g_iCurrentVision[MAXPLAYERS + 1] = { cDefaultVision, ... };			//Stores current FoV.
 new bool:g_bActiveVision[MAXPLAYERS + 1];		//Stores whether FoV is modified.
 new bool:g_bForcedVision[MAXPLAYERS + 1];		//Stores whether FoV is active from admin.
 new bool:g_bZoomVision[MAXPLAYERS + 1];			//
-	RegAdminCmd("sm_sfov_reload", Command_reload, ADMFLAG_GENERIC);
+
-	h_Mode = CreateConVar("sm_sfov_mode", "1", "Max FoV.", FCVAR_PLUGIN, true, 1.0, true, 2.0);
+public Plugin:myinfo =
-	h_MaxValue = CreateConVar("sm_sfov_max", "170", "Max FoV.", FCVAR_PLUGIN, true, 90.0, true, 180.0);
+
-	h_MinValue = CreateConVar("sm_sfov_min", "20", "Min FoV.", FCVAR_PLUGIN, true, 0.0, true, 90.0);
+
 	author = "Benjamin",
-	LoadTranslations("sFoV_player.phrases");
+
-	RegAdminCmd("sm_fov", CmdFovStrange, ADMFLAG_SLAY);
+
-	HookEvent("teamplay_round_win", Event_teamplay_round_win);
+
-	HookEvent("arena_round_start", Event_teamplay_round_start);
+
 
 public APLRes:AskPluginLoad2(Handle:myself, bool:late, String:error[], err_max)
 {
 	g_bLateLoad = late;
-		ShowFov[i] = false;
+	return APLRes_Success;
 }
 
 public OnPluginStart()
-		sfov_on[i] = false;
+
 	LoadTranslations("common.phrases");
 	//LoadTranslations("sFoV_player.phrases");
 
-		sfov_check[i] = false;
+	h_Mode = CreateConVar("sm_sfov_mode", "1", "Max FoV.", FCVAR_PLUGIN, true, 1.0, true, 2.0);
 	h_MaxValue = CreateConVar("sm_sfov_max", "170", "Max FoV.", FCVAR_PLUGIN, true, 90.0, true, 180.0);
 	h_MinValue = CreateConVar("sm_sfov_min", "20", "Min FoV.", FCVAR_PLUGIN, true, 0.0, true, 90.0);
 
 	RegAdminCmd("sm_fov", Command_Vision, ADMFLAG_SLAY);
 
 	AddCommandListener(attack2CallBack, "-attack2");
 
 	//Client Events
 	HookEvent("player_spawn", Event_OnPlayerSpawn);
 	HookEvent("player_death", Event_OnPlayerDeath);
 	HookEvent("player_team", Event_OnPlayerTeam);
-	sfovmode = GetConVarInt(h_Mode);
+
-	Max = GetConVarInt(h_MaxValue);
+	//Round Events
-	Min = GetConVarInt(h_MinValue);
+	HookEvent("teamplay_round_start", Event_OnRoundStart);
 	HookEvent("teamplay_round_win", Event_OnRoundEnd);
 	HookEvent("arena_round_start", Event_OnRoundStart);
 	HookEvent("arena_win_panel", Event_OnRoundEnd);
 
 	new Handle:topmenu;
 	if (LibraryExists("adminmenu") && ((topmenu = GetAdminTopMenu()) != INVALID_HANDLE))
-		ShowFov[i] = false;
+
 		OnAdminMenuReady(topmenu);
 	}
 }
-		sfov_on[i] = false;
+
 //* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 //* Fires when the plugin is unloaded.
 public OnPluginEnd()
-public Action:Event_teamplay_round_win(Handle:event, const String:name[], bool:dontBroadcast)
+
 	for(new i = 1; i <= MaxClients; i++)
 	{
 		if(!IsClientInGame(i) || IsFakeClient(i))
-	ShowFov[i] = false;
+			continue;
 
-	RoundWin = 2;
+		//Disable the vision effect for anyone that has it enabled.
 		if(g_bActiveVision[i])
 		{
-public Action:Event_teamplay_round_start(Handle:event, const String:name[], bool:dontBroadcast)
+			SetClientVision(i, 0);
 		}
-	RoundWin = 1;
+
 }
 
 //* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 //* Fires after OnMapStart when all configs are executed.
-	ShowFov[client] = false;
+public OnConfigsExecuted()
 {
 	if(g_bLateLoad)
-public Action:CmdFovStrange(client, args) {
+
-	if(RoundWin == 1)
+		//Loop through valid clients, hook them.
 		for(new i = 1; i <= MaxClients; i++)
-        if(args != 0 && args != 1 && args != 2) {
+
-                ReplyToCommand(client, "[SM] Usage: sm_fov <target> [1/0]");
+			if(!IsClientInGame(i) || IsFakeClient(i))
-                return Plugin_Handled;
+				continue;
-        }
+
-        if(args == 0) {
+			SDKHook(i, SDKHook_PostThink, OnPostThink);
-				if(ShowFov[client]) {
+
-						ShowFov[client] = false;
+
-				} else {
+		g_bLateLoad = false;
-						ShowFov[client] = true;
+
 }
-				ShowActivity2(client, "[SM] ", "Toggled StrangeFoV on self.");
+
-				LogAction(client, client, "%L toggled StrangeFoV on themself", client);
+//* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
-				return Plugin_Handled;
+//* Fires at the start of a new map, or after the plugin has been loaded.
-        }
+
-        if(!CheckCommandAccess(client, "StrangeFoVOther", ADMFLAG_GENERIC)) {
+
-                ReplyToCommand(client, "[SM] Usage: sm_fov");
+	//Set the end of the round to False.
-                return Plugin_Handled;
+	g_bEnding = false;
-        }
+
-        if(args == 1) {
+
-                decl String:target_name[MAX_NAME_LENGTH];
+//* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
-                new target_list[MAXPLAYERS];
+//* Fires at the end of the map, after everyone has disconnected but before map changes.
-                new target_count;
+
-                new bool:tn_is_ml;
+
-                decl String:arg1[MAX_NAME_LENGTH];
+	//Set the end of the round to True.
-                GetCmdArg(1, arg1, sizeof(arg1));
+	g_bEnding = true;
-                if((target_count = ProcessTargetString(arg1, client, target_list, MAXPLAYERS, COMMAND_FILTER_NO_BOTS, target_name, sizeof(target_name), tn_is_ml)) <= 0) {
+
-                        ReplyToTargetError(client, target_count);
+
-                        return Plugin_Handled;
+//* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
-                }
+//* Fires when a client physically disconnects or when the map is changing.
-                for(new i = 0; i < target_count; i++) {
+
-                        if(ShowFov[target_list[i]]) {
+
-                                ShowFov[target_list[i]] = false;
+	//Ignore if it wasn't a valid client (rare).
-                        } else {
+	if(!IsClientInGame(client))
-                                ShowFov[target_list[i]] = true;
+
-                        }
+
-                        LogAction(client, target_list[i], "%L toggled StrangeFoV on %L", client, target_list[i]);
+	//Reset data back to defaults for next client.
-                }
+	g_bActiveVision[client] = false;
-                ShowActivity2(client, "[SM] ", "Toggled StrangeFoV on %s.", target_name);
+	g_bForcedVision[client] = false;
-                return Plugin_Handled;
+
-        }
+
-        if(args == 2) {
+//* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
-                decl String:target_name[MAX_NAME_LENGTH];
+//* Fires when a client is officially in-game and is a valid target.
-                new target_list[MAXPLAYERS];
+
-                new target_count;
+
-                new bool:tn_is_ml;
+	//Ignore if it wasn't a valid client (rare).
-                decl String:arg1[MAX_NAME_LENGTH], String:arg2[4];
+	if(!IsClientInGame(client))
-                GetCmdArg(1, arg1, sizeof(arg1));
+
-                GetCmdArg(2, arg2, sizeof(arg2));
+
-                new iState = StringToInt(arg2);
+	g_iCurrentVision[client] = cDefaultVision;
-                if(iState != 0 && iState != 1) {
+
-                        ReplyToCommand(client, "[SM] Usage: sm_fov <target> [1/0]");
+
-                        return Plugin_Handled;
+
-                }
+//* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
-                new bool:bState = false;
+//* SDKHook_PostThink CallBack
-                if(iState == 1) {
+
-					bState = true;
+
-                }
+	//Ignore if ending, their vision is disabled, they're in the process of disconnecting, or dying.
-                decl String:sState[8];
+	if(g_bEnding || !g_bActiveVision[client] || !IsClientInGame(client) || !IsPlayerAlive(client))
-                if(bState) {
+
-                        strcopy(sState, sizeof(sState), "on");
+
-                } else {
+	//If their current vision is negative, don't use that value!
-                        strcopy(sState, sizeof(sState), "off");
+	new iVision = g_iCurrentVision[client];
-                }
+	if(iVision < 0)
-                if((target_count = ProcessTargetString(arg1, client, target_list, MAXPLAYERS, COMMAND_FILTER_NO_BOTS, target_name, sizeof(target_name), tn_is_ml)) <= 0) {
+
-                        ReplyToTargetError(client, target_count);
+		iVision *= -1;
-                        return Plugin_Handled;
+
-                }
+
-                for(new i = 0; i < target_count; i++) {
+	PrintHintText(client, "%d %d", g_iCurrentVision[client], iVision);
-                        ShowFov[target_list[i]] = bState;
+
-                        LogAction(client, target_list[i], "%L set StrangeFoV on %L %s", client, target_list[i], sState);
+	//Apply the FoV.
-                }
+	SetEntProp(client, Prop_Send, "m_iFOV", iVision);
-                ShowActivity2(client, "[SM] ", "Set StrangeFoV on %s %s", target_name, sState);
+
-                return Plugin_Handled;
+	//Determine FoV order
-        }
+	switch(GetConVarInt(h_Mode))
-        ReplyToCommand(client, "[SM] An unknown error occurred.");
+
 		case 1:
 		{
 			//If the client is at the upper bounds, reverse.
 			if(iVision >= GetConVarInt(h_MaxValue))
 			{
 				//If their vision is 170, set it to -170 so that it counts down.
-public Action:Command_reload(client, args)
+				g_iCurrentVision[client] *= -1;
 			}
-	sfovmode = GetConVarInt(h_Mode);
+
-	Max = GetConVarInt(h_MaxValue);
+			//If the client is at the lower bounds, reverse.
-	Min = GetConVarInt(h_MinValue);
+			if(iVision <= GetConVarInt(h_MinValue))
-	ReplyToCommand(client, "[SM] Reloaded sFoV successfully")
+			{
 				//If their vision is -20, set it to 20 so that it counts up
 				g_iCurrentVision[client] *= -1;
 			}
 		}
 		case 2:
 		{
 			if(g_iCurrentVision[client] >= GetConVarInt(h_MaxValue))
-public OnGameFrame()
+			{
 				g_iCurrentVision[client] = GetConVarInt(h_MinValue);
-	if(sfovmode == 1)
+			}
 		}
-		if(TheValue > Max)
+
 
-			Adding = -1;
+	//Increment their current FoV by one every frame.
 	g_iCurrentVision[client] += 1;
-		if(TheValue < Min)
+
 
-			Adding = 1;
+//* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 //* Fires at the end of Team Play or Arena. (Can't Confirm)
-		TheValue += Adding;
+public Action:Event_OnRoundEnd(Handle:event, const String:name[], bool:dontBroadcast)
 {
-	if(sfovmode == 2)
+	//Set the end of the round to True.
 	g_bEnding = true;
-		Adding = 1;
+
-		if(TheValue > 180)
+	//Loop through all active players in-game.
 	for (new i = 1; i < MaxClients; i++)
-			TheValue = 0;
+
 		if(!IsClientInGame(i) || IsFakeClient(i))
-		TheValue += Adding;
+			continue;
-	}
+
 		//Disable any active effects, reset their vision.
 		if(g_bActiveVision[i])
-/*public Action:OnPlayerRunCmd(client, &buttons, &impulse, Float:vel[3], Float:angles[3], &weapon)
+
 			SetClientVision(i, 0);
-	if (buttons & IN_ATTACK2 && sfov_check[client] == false)
+
-    {
+
-		sfov_on[client] = true;
+
 
-}*/
+//* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 //* Fires at the start of Team Play or Arena. (Can't Confirm)
 public Action:Event_OnRoundStart(Handle:event, const String:name[], bool:dontBroadcast)
-	sfov_check[client] = !sfov_check[client];
+
-	if(GetEntProp(client, Prop_Send, "m_iFOV") == 90 && sfov_check[client] == false)
+	//Set the end of the round to false.
 	g_bEnding = false;
-		sfov_on[client] = false;
+
 
 //* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 //* Fires on connection as well as every time a player spawns.
-		sfov_on[client] = true;
+public Action:Event_OnPlayerSpawn(Handle:event, const String:name[], bool:dontBroadcast)
 {
-	if(GetEntProp(client, Prop_Send, "m_iFOV") == 90 && sfov_check[client] == true)
+	//Get the client from the event.
 	new client = GetClientOfUserId(GetEventInt(event, "userid"));
-		sfov_check[client] = !sfov_check[client];
+	if(!client || !IsClientInGame(client))
 	{
 		return Plugin_Continue;
 	}
 
 	//Ignore any spawning attempts while the player is not alive (i.e. connecting)
-	if(IsClientInGame(client) && IsPlayerAlive(client) && sfov_on[client] == false)
+	if(!IsPlayerAlive(client))
 	{
-		if(ShowFov[client])
+		return Plugin_Continue;
 	}
-			SetEntProp(client, Prop_Send, "m_iFOV", TheValue);
+
 	//Re-apply the FoV effect if the client has had their state enabled.
 	if(g_bForcedVision[client])
 	{
-			SetEntProp(client, Prop_Send, "m_iFOV", 90);
+		SetClientVision(client, g_iCurrentVision[client]);
 	}
 
-	if(IsClientInGame(client) && !IsPlayerAlive(client))
+	return Plugin_Continue;
 }
-		if(ShowFov[client])
+
 //* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
-			ShowFov[client] = !ShowFov[client];
+//* Fires whenever a player dies in-game.
-			PrintToChat(client, "");
+public Action:Event_OnPlayerDeath(Handle:event, const String:name[], bool:dontBroadcast)
-			SetEntProp(client, Prop_Send, "m_iFOV", 90);
+
 	//Get the client from the event.
 	new client = GetClientOfUserId(GetEventInt(event, "userid"));
 	if(!client || !IsClientInGame(client))
 	{
 		return Plugin_Continue;
 	}
 
 	//Reset the client's FoV if they had an active effect & disable it.
 	if(g_bActiveVision[client])
 	{
 		SetClientVision(client, 0);
 	}
 
 	return Plugin_Continue;
 }
 
 //* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 //* Fires whenever a player changes their team.
 public Action:Event_OnPlayerTeam(Handle:event, const String:name[], bool:dontBroadcast)
 {
 	//Get the client from the event.
 	new client = GetClientOfUserId(GetEventInt(event, "userid"));
 	if(!client || !IsClientInGame(client))
 	{
 		return Plugin_Continue;
 	}
-			ADMFLAG_SLAY);
+
 	//Reset the client's FoV if they join Spectate.
 	if(GetEventInt(event, "team") == _:TFTeam_Spectator)
 	{
 		SetClientVision(client, 0);
-PerformFoV(client, target)
+
 	//Re-apply the FoV effect on team change just to be safe.
-	if(ShowFov[target] == true)
+	else if(g_bForcedVision[client])
 	{
-		LogAction(client, target, "\"%L\" set a Strange Field of View on \"%L\"", client, target);
+		SetClientVision(client, g_iCurrentVision[client]);
-		ShowFov[target] = false;
+
-	}
+
-	else
+	return Plugin_Continue;
 }
-		ShowFov[target] = true;
+
-		LogAction(client, target, "\"%L\" removed the Strange Field of View from \"%L\"", client, target);
+//* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 //* Simple stock for modifying the client's FoV.
 stock SetClientVision(client, range)
 {
 	if(range == 0)
 	{
 		g_bActiveVision[client] = false;
 		SetEntProp(client, Prop_Send, "m_iFOV", cDefaultVision);
 	}
 	else
 	{
 		g_bActiveVision[client] = true;
-public AdminMenu_FoV(Handle:topmenu,
+		SetEntProp(client, Prop_Send, "m_iFOV", range);
-					  TopMenuAction:action,
+
-					  TopMenuObject:object_id,
+
-					  param,
+
-					  String:buffer[],
+//* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
-					  maxlength)
+//* CallBack for the vision command.
 public Action:Command_Vision(client, args)
-	if (action == TopMenuAction_DisplayOption)
+
 	//Ignore the command if it's used during the end of the round.
-		Format(buffer, maxlength, "%T", "sFoV player", param);
+	if(g_bEnding)
 	{
-	else if (action == TopMenuAction_SelectOption)
+		ReplyToCommand(client, "[SM] This command can only be used during the round!");
 		return Plugin_Handled;
-		DisplayFoVMenu(param);
+
 
 	if(!args)
 	{
 		//Console has no reason to toggle effects, nor do invalid clients.
 		if(!client || GetClientTeam(client) <= _:TFTeam_Spectator || !IsPlayerAlive(client))
-	new Handle:menu = CreateMenu(MenuHandler_FoV);
+
 			ReplyToCommand(client, "[SM] This command cannot be toggled on invalid clients!");
-	decl String:title[100];
+			return Plugin_Handled;
-	Format(title, sizeof(title), "%T:", "sFoV player", client);
+
-	SetMenuTitle(menu, title);
+
-	SetMenuExitBackButton(menu, true);
+		//Check to see if the client has self-access.
 		if(client && !CheckCommandAccess(client, "StrangeFoVSelf", ADMFLAG_GENERIC))
-	AddTargetsToMenu(menu, client, true, true);
+
 			ReplyToCommand(client, "[SM] Usage: sm_fov");
-	DisplayMenu(menu, client, MENU_TIME_FOREVER);
+			return Plugin_Handled;
 		}
 
 		g_bForcedVision[client] = !g_bForcedVision[client];
 		ShowActivity2(client, "[SM] ", "Set his/her StrangeFoV state to %s", g_bForcedVision[client] ? "on" : "off");
-	if (action == MenuAction_End)
+		LogAction(client, client, "%L set his/her StrangeFoV state to %s", client, g_bForcedVision[client] ? "on" : "off");
 		if(g_bForcedVision[client])
-		CloseHandle(menu);
+			SetClientVision(client, g_iCurrentVision[client]);
 		else
-	else if (action == MenuAction_Cancel)
+			SetClientVision(client, 0);
 
-		if (param2 == MenuCancel_ExitBack && hTopMenu != INVALID_HANDLE)
+		return Plugin_Handled;
 	}
-			DisplayTopMenu(hTopMenu, param1, TopMenuPosition_LastCategory);
+
 	if(args)
 	{
-	else if (action == MenuAction_Select)
+		//Notify on the event of invalid.
 		if(args > 2)
-		decl String:info[32];
+
-		new userid, target;
+			ReplyToCommand(client, "[SM] This command cannot be toggled on invalid clients!");
 			return Plugin_Handled;
-		GetMenuItem(menu, param2, info, sizeof(info));
+
-		userid = StringToInt(info);
+
 		//Check to see if the client has other-access.
-		if ((target = GetClientOfUserId(userid)) == 0)
+		if(client && !CheckCommandAccess(client, "StrangeFoVOther", ADMFLAG_GENERIC))
 		{
-			PrintToChat(param1, "[SM] %t", "Player no longer available");
+			ReplyToCommand(client, "[SM] Usage: sm_fov <target> [optional: 0|1]");
 			return Plugin_Handled;
-		else if (!CanUserTarget(param1, target))
+
 
-			PrintToChat(param1, "[SM] %t", "Unable to target");
+		//Declare necessary information to process command; grab argument string.
 		decl iBreak, String:sText[192], String:sPattern[64], String:sBuffer[64];
 		new iTargets[MAXPLAYERS + 1], bool:bTemp, bool:bState;
 		GetCmdArgString(sText, sizeof(sText));
-			new String:name[32];
+
-			GetClientName(target, name, sizeof(name));
+		//Store pattern, check to see if there's an additional argument.
 		iBreak = BreakString(sText, sPattern, sizeof(sPattern));
-			PerformFoV(param1, target);
+		if(iBreak != -1)
-			ShowActivity2(param1, "[SM] ", "%t", "Toggled Strange Field of View on target", "_s", name);
+
 			iBreak += BreakString(sText[iBreak], sBuffer, sizeof(sBuffer));
 			bState = bool:StringToInt(sBuffer);
-		/* Re-draw the menu if they're still valid */
+
-		if (IsClientInGame(param1) && !IsClientInKickQueue(param1))
+
 		//Only let the command target non-bots currently in-game.
-			DisplayFoVMenu(param1);
+		new iCount = ProcessTargetString(sPattern, client, iTargets, sizeof(iTargets), COMMAND_FILTER_NO_BOTS|COMMAND_FILTER_CONNECTED, sBuffer, sizeof(sBuffer), bTemp);
 		if(iCount)
 		{
 			//Loop through all clients currently in-game.
 			for (new i = 0; i < iCount; i++)
 			{
 				if(!IsClientInGame(iTargets[i]))
 				{
 					continue;
 				}
 
 				//BreakString returns -1 if there was no string to break, thus 1 parameter.
 				if(iBreak == -1)
 				{
 					//No parameters, so toggle the client's current state.
 					if(g_bForcedVision[iTargets[i]])
 					{
 						SetClientVision(iTargets[i], 0);
 					}
 					else
 					{
 						SetClientVision(iTargets[i], g_iCurrentVision[iTargets[i]]);
 					}
 
 					g_bForcedVision[iTargets[i]] = !g_bForcedVision[iTargets[i]];
 					LogAction(client, iTargets[i], "%L set StrangeFoV on %L to %s", client, iTargets[i], g_bForcedVision[iTargets[i]] ? "on" : "off");
 					ShowActivity2(client, "[SM] ", "Set StrangeFoV on %N to %s", iTargets[i], g_bForcedVision[iTargets[i]] ? "on" : "off");
 				}
 				else
 				{
 					//Second argument was specified, force whatever values are desired.
 					if(bState)
 					{
 						//It's being enabled, ignore anyone that already has it.
 						if(g_bForcedVision[iTargets[i]])
 						{
 							if(!g_bActiveVision[iTargets[i]])
 								SetClientVision(iTargets[i], g_iCurrentVision[iTargets[i]]);
 
 							continue;
 						}
 
 						g_bForcedVision[iTargets[i]] = true;
 						SetClientVision(iTargets[i], g_iCurrentVision[iTargets[i]]);
 						LogAction(client, iTargets[i], "%L set StrangeFoV on %L to %s", client, iTargets[i], g_bForcedVision[iTargets[i]] ? "on" : "off");
 						ShowActivity2(client, "[SM] ", "Set StrangeFoV on %N to %s", iTargets[i], g_bForcedVision[iTargets[i]] ? "on" : "off");
 					}
 					else
 					{
 						//It's being disabled, ignore anyone that already doesn't have it.
 						if(!g_bForcedVision[iTargets[i]])
 						{
 							if(g_bActiveVision[iTargets[i]])
 								SetClientVision(iTargets[i], 0);
 
 							continue;
 						}
 
 						g_bForcedVision[iTargets[i]] = false;
 						SetClientVision(iTargets[i], 0);
 						LogAction(client, iTargets[i], "%L set StrangeFoV on %L to %s", client, iTargets[i], g_bForcedVision[iTargets[i]] ? "on" : "off");
 						ShowActivity2(client, "[SM] ", "Set StrangeFoV on %N to %s", iTargets[i], g_bForcedVision[iTargets[i]] ? "on" : "off");
 					}
 				}
 			}
 		}
 	}
 
 	return Plugin_Handled;
 }
 
 public Action:attack2CallBack(client, const String:command[], argc)
 {
 	g_bForcedVision[client] = !g_bForcedVision[client];
 	if(GetEntProp(client, Prop_Send, "m_iFOV") == 90 && g_bForcedVision[client] == false)
 	{
 		g_bZoomVision[client] = false;
 	}
 	else
 	{
 		g_bZoomVision[client] = true;
 	}
 	if(GetEntProp(client, Prop_Send, "m_iFOV") == 90 && g_bForcedVision[client] == true)
 	{
 		g_bForcedVision[client] = !g_bForcedVision[client];
 	}
 }
 
 public OnAdminMenuReady(Handle:topmenu)
 {
 	/* Block us from being called twice */
 	if (topmenu == hTopMenu)
 	{
 		return;
 	}
 
 	/* Save the Handle */
 	hTopMenu = topmenu;
 
 	/* Build the "Player Commands" category */
 	new TopMenuObject:player_commands = FindTopMenuCategory(hTopMenu, ADMINMENU_PLAYERCOMMANDS);
 
 	if (player_commands != INVALID_TOPMENUOBJECT)
 	{
 		AddToTopMenu(hTopMenu,
 			"sm_fov",
 			TopMenuObject_Item,
 			AdminMenu_FoV,
 			player_commands,
 			"sm_fov",
 			ADMFLAG_SLAY);
 	}
 }
 
 public OnLibraryRemoved(const String:name[])
 {
 	if (strcmp(name, "adminmenu") == 0)
 	{
 		hTopMenu = INVALID_HANDLE;
 	}
 }
 
 //* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 //* AdminMenu Callback - Only re-written cause of OCD.
 public AdminMenu_FoV(Handle:topmenu, TopMenuAction:action, TopMenuObject:object_id, param, String:buffer[], maxlength)
 {
 	switch(action)
 	{
 		case TopMenuAction_DisplayOption:
 		{
 			Format(buffer, maxlength, "Set Strange FoV", param);
 			//Format(buffer, maxlength, "%T", "sFoV player", param);
 		}
 		case TopMenuAction_SelectOption:
 		{
 			DisplayFoVMenu(param);
 		}
 	}
 }
 
 DisplayFoVMenu(client)
 {
 	new Handle:hMenu = CreateMenu(MenuHandler_FoV);
 
 	decl String:sBuffer[128], String:sDisplay[64], String:sUser[4];
 	Format(sBuffer, sizeof(sBuffer), "Select Player:", client);
 	//Format(sBuffer, sizeof(sBuffer), "%T:", "sFoV player", client);
 	SetMenuTitle(hMenu, sBuffer);
 	SetMenuExitBackButton(hMenu, true);
 
 	//These should be translations, but for now, just graphics.
 	new String:sActive[] = "[*]";
 	new String:sDisabled[] = "[  ]";
 
 	//Loop through all active clients. Ignore bots and players the admin can't target.
 	// We're making our own loop instad of using AddTargetsToMenu to display the state
 	//  of the effect prior to toggling.
 
 	for(new i = 1; i <= MaxClients; i++)
 	{
 		if(!IsClientInGame(i) || IsFakeClient(i) || (client != i && !CanUserTarget(client, i)))
 			continue;
 
 		//Format the string so it shows who has it enabled/disabled.
 		//1) [ ] Panda
 		//2) [*] Benja
 		Format(sDisplay, sizeof(sDisplay), "%s %N", g_bForcedVision[i] ? sActive : sDisabled, i);
 
 		//Pass the userid along so it's available.
 		IntToString(GetClientUserId(i), sUser, sizeof(sUser));
 		AddMenuItem(hMenu, sUser, sDisplay);
 	}
 
 	DisplayMenu(hMenu, client, MENU_TIME_FOREVER);
 }
 
 //* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 //* Menu Callback - Only re-written cause of OCD.
 public MenuHandler_FoV(Handle:menu, MenuAction:action, param1, param2)
 {
 	switch(action)
 	{
 		case MenuAction_End:
 		{
 			CloseHandle(menu);
 		}
 		case MenuAction_Cancel:
 		{
 			if (param2 == MenuCancel_ExitBack && hTopMenu != INVALID_HANDLE)
 			{
 				DisplayTopMenu(hTopMenu, param1, TopMenuPosition_LastCategory);
 			}
 		}
 		case MenuAction_Select:
 		{
 			decl String:info[32];
 			GetMenuItem(menu, param2, info, sizeof(info));
 
 			new userid = StringToInt(info);
 			new target = GetClientOfUserId(userid);
 
 			if(!target)
 			{
 				PrintToChat(param1, "[SM] The player you were targeting is no longer available.");
 				//PrintToChat(param1, "[SM] %t", "Player no longer available");
 			}
 			else if(!CanUserTarget(param1, target))
 			{
 				PrintToChat(param1, "[SM] You are unable to target %N!", target);
 				//PrintToChat(param1, "[SM] %t", "Unable to target");
 			}
 			else
 			{
 				//Toggle the effect based on the current state.
 				if(g_bForcedVision[target])
 					SetClientVision(target, 0);
 				else
 					SetClientVision(target, g_iCurrentVision[target]);
 
 				g_bForcedVision[target] = !g_bForcedVision[target];
 				LogAction(param1, target, "%L set StrangeFoV on %L to %s", param1, target, g_bForcedVision[target] ? "on" : "off");
 				ShowActivity2(param1, "[SM] ", "Set StrangeFoV on %N to %s", target, g_bForcedVision[target] ? "on" : "off");
 			}
 
 			//Display the menu back to the admin, if possible.
 			if (IsClientInGame(param1) && !IsClientInKickQueue(param1))
 			{
 				DisplayFoVMenu(param1);
 			}
 		}
 	}
 }