564 lines
15 KiB
SourcePawn
Executable File
564 lines
15 KiB
SourcePawn
Executable File
/**
|
|
* vim: set ts=4 :
|
|
* =============================================================================
|
|
* Rock The Vote Extended
|
|
* Creates a map vote when the required number of players have requested one.
|
|
*
|
|
* Rock The Vote Extended (C)2012-2013 Powerlord (Ross Bemrose)
|
|
* SourceMod (C)2004-2007 AlliedModders LLC. All rights reserved.
|
|
* =============================================================================
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify it under
|
|
* the terms of the GNU General Public License, version 3.0, as published by the
|
|
* Free Software Foundation.
|
|
*
|
|
* This program is distributed in the hope that it will be useful, but WITHOUT
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
|
|
* FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
|
|
* details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License along with
|
|
* this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*
|
|
* As a special exception, AlliedModders LLC gives you permission to link the
|
|
* code of this program (as well as its derivative works) to "Half-Life 2," the
|
|
* "Source Engine," the "SourcePawn JIT," and any Game MODs that run on software
|
|
* by the Valve Corporation. You must obey the GNU General Public License in
|
|
* all respects for all other code used. Additionally, AlliedModders LLC grants
|
|
* this exception to all derivative works. AlliedModders LLC defines further
|
|
* exceptions, found in LICENSE.txt (as of this writing, version JULY-31-2007),
|
|
* or <http://www.sourcemod.net/license.php>.
|
|
*
|
|
* Version: $Id$
|
|
*/
|
|
|
|
#pragma semicolon 1
|
|
#pragma newdecls required
|
|
|
|
#include <sourcemod>
|
|
#include <sdktools_functions>
|
|
#include <mapchooser>
|
|
#include <nextmap>
|
|
#include <AFKManager>
|
|
#include <PlayerManager>
|
|
#include <unloze_playtime>
|
|
|
|
#define MCE_VERSION "1.3.1"
|
|
|
|
public Plugin myinfo =
|
|
{
|
|
name = "Rock The Vote Extended",
|
|
author = "Powerlord and AlliedModders LLC",
|
|
description = "Provides RTV Map Voting",
|
|
version = MCE_VERSION,
|
|
url = "https://forums.alliedmods.net/showthread.php?t=156974"
|
|
};
|
|
|
|
ConVar g_Cvar_Steam_Needed;
|
|
ConVar g_Cvar_MinPlayers;
|
|
ConVar g_Cvar_InitialDelay;
|
|
ConVar g_Cvar_Interval;
|
|
ConVar g_Cvar_ChangeTime;
|
|
ConVar g_Cvar_RTVPostVoteAction;
|
|
ConVar g_Cvar_RTVAutoDisable;
|
|
ConVar g_Cvar_AFKTime;
|
|
ConVar g_Cvar_RTVRevoteDelay;
|
|
|
|
//check if autismbot
|
|
bool is_bot_player[MAXPLAYERS + 1];
|
|
bool g_CanRTV = false; // True if RTV loaded maps and is active.
|
|
bool g_RTVAllowed = false; // True if RTV is available to players. Used to delay rtv votes.
|
|
int g_VotesNeeded = 0; // Necessary votes before map vote begins. (2023: voters average hour count * percent_needed)
|
|
bool g_Voted[MAXPLAYERS+1] = {false, ...};
|
|
int g_iTimeTillRTV[MAXPLAYERS+1] = {0, ...};
|
|
|
|
bool g_InChange = false;
|
|
|
|
public void OnPluginStart()
|
|
{
|
|
LoadTranslations("common.phrases");
|
|
LoadTranslations("rockthevote_extended.phrases");
|
|
LoadTranslations("basevotes.phrases");
|
|
|
|
g_Cvar_Steam_Needed = CreateConVar("sm_rtv_steam_needed", "0.65", "Percentage of Steam players added to rockthevote calculation (Def 65%)", 0, true, 0.05, true, 1.0);
|
|
g_Cvar_MinPlayers = CreateConVar("sm_rtv_minplayers", "0", "Number of players required before RTV will be enabled.", 0, true, 0.0, true, float(MAXPLAYERS));
|
|
g_Cvar_InitialDelay = CreateConVar("sm_rtv_initialdelay", "30.0", "Time (in seconds) before first RTV can be held", 0, true, 0.00);
|
|
g_Cvar_Interval = CreateConVar("sm_rtv_interval", "240.0", "Time (in seconds) after a failed RTV before another can be held", 0, true, 0.00);
|
|
g_Cvar_ChangeTime = CreateConVar("sm_rtv_changetime", "0", "When to change the map after a succesful RTV: 0 - Instant, 1 - RoundEnd, 2 - MapEnd", _, true, 0.0, true, 2.0);
|
|
g_Cvar_RTVPostVoteAction = CreateConVar("sm_rtv_postvoteaction", "0", "What to do with RTVs after a mapvote has completed. 0 - Allow, success = instant change, 1 - Deny", _, true, 0.0, true, 1.0);
|
|
g_Cvar_RTVAutoDisable = CreateConVar("sm_rtv_autodisable", "0", "Automatically disable RTV when map time is over.", _, true, 0.0, true, 1.0);
|
|
g_Cvar_AFKTime = CreateConVar("sm_rtv_afk_time", "180", "AFK Time in seconds after which a player is not counted in the rtv ratio");
|
|
g_Cvar_RTVRevoteDelay = CreateConVar("sm_rtv_revote_delay", "5", "Delay in seconds before a player can vote for RTV after undoing");
|
|
|
|
RegConsoleCmd("sm_rtv", Command_RTV);
|
|
RegConsoleCmd("sm_unrtv", Command_UnRTV);
|
|
|
|
RegAdminCmd("sm_forcertv", Command_ForceRTV, ADMFLAG_CHANGEMAP, "Force an RTV vote");
|
|
RegAdminCmd("sm_disablertv", Command_DisableRTV, ADMFLAG_CHANGEMAP, "Disable the RTV command");
|
|
RegAdminCmd("sm_enablertv", Command_EnableRTV, ADMFLAG_CHANGEMAP, "Enable the RTV command");
|
|
RegAdminCmd("sm_debugrtv", Command_DebugRTV, ADMFLAG_CHANGEMAP, "Check the current RTV calculation");
|
|
|
|
HookEvent("player_team", OnPlayerChangedTeam, EventHookMode_PostNoCopy);
|
|
|
|
AutoExecConfig(true, "rtv");
|
|
}
|
|
|
|
public void OnMapStart()
|
|
{
|
|
g_VotesNeeded = 0;
|
|
g_InChange = false;
|
|
|
|
/* Handle late load */
|
|
for (int i=1; i<=MaxClients; i++)
|
|
{
|
|
if (IsClientInGame(i))
|
|
{
|
|
OnClientPutInServer(i);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void OnMapEnd()
|
|
{
|
|
g_CanRTV = false;
|
|
g_RTVAllowed = false;
|
|
}
|
|
|
|
public void OnConfigsExecuted()
|
|
{
|
|
g_CanRTV = true;
|
|
g_RTVAllowed = false;
|
|
CreateTimer(g_Cvar_InitialDelay.FloatValue, Timer_DelayRTV, _, TIMER_FLAG_NO_MAPCHANGE);
|
|
}
|
|
|
|
public void OnClientPutInServer(int client)
|
|
{
|
|
g_iTimeTillRTV[client] = 0;
|
|
UpdateRTV();
|
|
}
|
|
|
|
public void OnClientDisconnect(int client)
|
|
{
|
|
is_bot_player[client] = false;
|
|
if (g_Voted[client])
|
|
{
|
|
g_Voted[client] = false;
|
|
g_iTimeTillRTV[client] = 0;
|
|
}
|
|
|
|
UpdateRTV();
|
|
}
|
|
|
|
public void OnClientPostAdminCheck(int client)
|
|
{
|
|
is_bot_player[client] = false;
|
|
char auth[50];
|
|
GetClientAuthId(client, AuthId_Engine, auth, sizeof(auth));
|
|
if (StrEqual("[U:1:1221121532]", auth, false) || StrEqual("STEAM_0:0:610560766", auth, false))
|
|
{
|
|
is_bot_player[client] = true;
|
|
}
|
|
if (StrEqual("[U:1:408797742]", auth, false) || StrEqual("STEAM_0:0:204398871", auth, false))
|
|
{
|
|
is_bot_player[client] = true;
|
|
}
|
|
if (StrEqual("[U:1:1036189204]", auth, false) || StrEqual("STEAM_0:0:518094602", auth, false))
|
|
{
|
|
is_bot_player[client] = true;
|
|
}
|
|
if (StrEqual("[U:1:120378081]", auth, false) || StrEqual("STEAM_0:1:60189040", auth, false))
|
|
{
|
|
is_bot_player[client] = true;
|
|
}
|
|
}
|
|
|
|
public void OnPlayerChangedTeam(Handle event, const char[] name, bool dontBroadcast)
|
|
{
|
|
UpdateRTV();
|
|
}
|
|
|
|
public APLRes AskPluginLoad2(Handle myself, bool late, char [] error, int err_max)
|
|
{
|
|
CreateNative("GetRtvPercentage", Native_GetRtvPercentageForClient);
|
|
return APLRes_Success;
|
|
}
|
|
|
|
public int Native_GetRtvPercentageForClient(Handle plugin, int numParams)
|
|
{
|
|
int client = GetNativeCell(1);
|
|
|
|
if(client > MaxClients || client <= 0)
|
|
{
|
|
ThrowNativeError(SP_ERROR_NATIVE, "Client is not valid.");
|
|
return -1;
|
|
}
|
|
|
|
if(!IsClientInGame(client))
|
|
{
|
|
ThrowNativeError(SP_ERROR_NATIVE, "Client is not in-game.");
|
|
return -1;
|
|
}
|
|
|
|
UpdateRTV();
|
|
int clients_percentage = 0;
|
|
if (g_VotesNeeded == 0)
|
|
{
|
|
clients_percentage = RoundToFloor((GetPlayerWorthRTV_(client) / float(100)) * 100);
|
|
}
|
|
else
|
|
{
|
|
clients_percentage = RoundToFloor((GetPlayerWorthRTV_(client) / float(g_VotesNeeded)) * 100);
|
|
}
|
|
if (clients_percentage > 100)
|
|
{
|
|
clients_percentage = 100;
|
|
}
|
|
return clients_percentage;
|
|
}
|
|
|
|
void UpdateRTV()
|
|
{
|
|
int iVotersSteam = 0;
|
|
for (int i=1; i<=MaxClients; i++)
|
|
{
|
|
if (IsClientInGame(i) && !IsFakeClient(i) && !is_bot_player[i])
|
|
{
|
|
if (GetClientIdleTime(i) >= g_Cvar_AFKTime.IntValue)
|
|
continue;
|
|
|
|
if (PM_IsPlayerSteam(i))
|
|
iVotersSteam++;
|
|
}
|
|
}
|
|
|
|
g_VotesNeeded = RoundToFloor(float(iVotersSteam) * GetConVarFloat(g_Cvar_Steam_Needed));
|
|
|
|
g_VotesNeeded *= GetAveragePlayerTimeOnServerRTV();
|
|
|
|
if (!g_CanRTV)
|
|
{
|
|
return;
|
|
}
|
|
|
|
int Votes = get_voted_rtv();
|
|
if (Votes &&
|
|
iVotersSteam &&
|
|
Votes >= g_VotesNeeded &&
|
|
RTVAllowed())
|
|
{
|
|
if (g_Cvar_RTVPostVoteAction.IntValue == 1 && HasEndOfMapVoteFinished())
|
|
{
|
|
return;
|
|
}
|
|
|
|
StartRTV();
|
|
}
|
|
}
|
|
|
|
public int get_voted_rtv()
|
|
{
|
|
int Votes = 0;
|
|
for (int i = 0; i < MaxClients; i++)
|
|
{
|
|
if (IsValidClient(i) && g_Voted[i])
|
|
{
|
|
Votes += GetPlayerWorthRTV_(i);
|
|
}
|
|
}
|
|
return Votes;
|
|
}
|
|
|
|
public void OnClientSayCommand_Post(int client, const char[] command, const char[] sArgs)
|
|
{
|
|
if (!g_CanRTV || !client)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (strcmp(sArgs, "rtv", false) == 0 || strcmp(sArgs, "rockthevote", false) == 0)
|
|
{
|
|
ReplySource old = SetCmdReplySource(SM_REPLY_TO_CHAT);
|
|
|
|
AttemptRTV(client);
|
|
|
|
SetCmdReplySource(old);
|
|
}
|
|
}
|
|
|
|
public Action Command_RTV(int client, int args)
|
|
{
|
|
if (!g_CanRTV || !client)
|
|
{
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
AttemptRTV(client);
|
|
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
void AttemptRTV(int client)
|
|
{
|
|
if (!RTVAllowed() || (g_Cvar_RTVPostVoteAction.IntValue == 1 && HasEndOfMapVoteFinished()))
|
|
{
|
|
ReplyToCommand(client, "[RTVE] %t", "RTV Not Allowed");
|
|
return;
|
|
}
|
|
|
|
if (!CanMapChooserStartVote())
|
|
{
|
|
ReplyToCommand(client, "[RTVE] %t", "RTV Started");
|
|
return;
|
|
}
|
|
|
|
if (GetClientCount(true) < g_Cvar_MinPlayers.IntValue)
|
|
{
|
|
ReplyToCommand(client, "[RTVE] %t", "Minimal Players Not Met");
|
|
return;
|
|
}
|
|
|
|
if (GetTime() < g_iTimeTillRTV[client])
|
|
{
|
|
ReplyToCommand(client, "[RTVE] %t", "Wait Before Revoting", g_iTimeTillRTV[client] - GetTime());
|
|
return;
|
|
}
|
|
|
|
if (g_Voted[client])
|
|
{
|
|
float rtv_worth = GetPlayerWorthRTV_boost_(client);
|
|
int Votes = get_voted_rtv();
|
|
if (g_VotesNeeded == 0)
|
|
{
|
|
g_VotesNeeded = Votes;
|
|
}
|
|
int rtv_percentage_reached = RoundToFloor((float(Votes) / float(g_VotesNeeded)) * 100);
|
|
if (rtv_percentage_reached > 100)
|
|
{
|
|
rtv_percentage_reached = 100;
|
|
}
|
|
int clients_percentage = RoundToFloor((GetPlayerWorthRTV_(client) / float(g_VotesNeeded)) * 100);
|
|
if (clients_percentage > 100)
|
|
{
|
|
clients_percentage = 100;
|
|
}
|
|
ReplyToCommand(client, "[RTVE] %t", "Already Voted", rtv_percentage_reached, rtv_worth, clients_percentage);
|
|
return;
|
|
}
|
|
|
|
if (!PM_IsPlayerSteam(client))
|
|
{
|
|
ReplyToCommand(client, "Disabled rtv participation for nosteamers.");
|
|
return;
|
|
}
|
|
|
|
char name[MAX_NAME_LENGTH];
|
|
GetClientName(client, name, sizeof(name));
|
|
|
|
g_Voted[client] = true;
|
|
|
|
int Votes = get_voted_rtv();
|
|
float rtv_worth = GetPlayerWorthRTV_boost_(client);
|
|
if (g_VotesNeeded == 0)
|
|
{
|
|
g_VotesNeeded = Votes;
|
|
}
|
|
int rtv_percentage_reached = RoundToFloor((float(Votes) / float(g_VotesNeeded)) * 100);
|
|
if (rtv_percentage_reached > 100 || rtv_percentage_reached < 0)
|
|
{
|
|
rtv_percentage_reached = 100;
|
|
}
|
|
int clients_percentage = RoundToFloor((GetPlayerWorthRTV_(client) / float(g_VotesNeeded)) * 100);
|
|
if (clients_percentage > 100 || clients_percentage < 0)
|
|
{
|
|
clients_percentage = 100;
|
|
}
|
|
PrintToChatAll("[RTVE] %t", "RTV Requested", name, rtv_percentage_reached, rtv_worth, clients_percentage);
|
|
|
|
if (Votes >= g_VotesNeeded)
|
|
{
|
|
StartRTV();
|
|
}
|
|
}
|
|
|
|
public Action Command_UnRTV(int client, int args)
|
|
{
|
|
if (!g_CanRTV || !client)
|
|
{
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
AttemptUnRTV(client);
|
|
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
void AttemptUnRTV(int client)
|
|
{
|
|
if (!g_Voted[client])
|
|
{
|
|
ReplyToCommand(client, "[RTVE] %t", "Didn't RTV Yet"); //'
|
|
return;
|
|
}
|
|
|
|
char name[MAX_NAME_LENGTH];
|
|
GetClientName(client, name, sizeof(name));
|
|
|
|
g_Voted[client] = false;
|
|
g_iTimeTillRTV[client] = GetTime() + g_Cvar_RTVRevoteDelay.IntValue;
|
|
|
|
ReplyToCommand(client, "[RTVE] %t", "RTV Undone");
|
|
}
|
|
|
|
public Action Timer_DelayRTV(Handle timer)
|
|
{
|
|
g_RTVAllowed = true;
|
|
PrintToChatAll("[RTVE] RockTheVote is available now!");
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
void StartRTV()
|
|
{
|
|
if (g_InChange)
|
|
{
|
|
return;
|
|
}
|
|
|
|
|
|
if (EndOfMapVoteEnabled() && HasEndOfMapVoteFinished())
|
|
{
|
|
/* Change right now then */
|
|
char map[PLATFORM_MAX_PATH];
|
|
if (GetNextMap(map, sizeof(map)))
|
|
{
|
|
GetMapDisplayName(map, map, sizeof(map));
|
|
|
|
PrintToChatAll("[RTVE] %t", "Changing Maps", map);
|
|
CreateTimer(5.0, Timer_ChangeMap, _, TIMER_FLAG_NO_MAPCHANGE);
|
|
g_InChange = true;
|
|
|
|
ResetRTV();
|
|
|
|
g_RTVAllowed = false;
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (CanMapChooserStartVote())
|
|
{
|
|
PrintToChatAll("[RTVE] Rock The Vote has begun!");
|
|
MapChange when = view_as<MapChange>(g_Cvar_ChangeTime.IntValue);
|
|
InitiateMapChooserVote(when);
|
|
|
|
ResetRTV();
|
|
|
|
g_RTVAllowed = false;
|
|
CreateTimer(g_Cvar_Interval.FloatValue, Timer_DelayRTV, _, TIMER_FLAG_NO_MAPCHANGE);
|
|
}
|
|
}
|
|
|
|
void ResetRTV()
|
|
{
|
|
for (int i=1; i<=MAXPLAYERS; i++)
|
|
{
|
|
g_Voted[i] = false;
|
|
}
|
|
}
|
|
|
|
public Action Timer_ChangeMap(Handle hTimer)
|
|
{
|
|
g_InChange = false;
|
|
|
|
LogMessage("RTV changing map manually");
|
|
|
|
char map[PLATFORM_MAX_PATH];
|
|
if (GetNextMap(map, sizeof(map)))
|
|
{
|
|
ForceChangeLevel(map, "RTV after mapvote");
|
|
}
|
|
|
|
return Plugin_Stop;
|
|
}
|
|
|
|
public Action Command_ForceRTV(int client, int args)
|
|
{
|
|
if(!g_CanRTV)
|
|
return Plugin_Handled;
|
|
|
|
ShowActivity2(client, "[RTVE] ", "%t", "Initiated Vote Map");
|
|
|
|
StartRTV();
|
|
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
public Action Command_DisableRTV(int client, int args)
|
|
{
|
|
if(!g_RTVAllowed)
|
|
return Plugin_Handled;
|
|
|
|
ShowActivity2(client, "[RTVE] ", "disabled RockTheVote.");
|
|
|
|
g_RTVAllowed = false;
|
|
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
public Action Command_EnableRTV(int client, int args)
|
|
{
|
|
if(g_RTVAllowed)
|
|
return Plugin_Handled;
|
|
|
|
ShowActivity2(client, "[RTVE] ", "enabled RockTheVote");
|
|
|
|
g_RTVAllowed = true;
|
|
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
public Action Command_DebugRTV(int client, int args)
|
|
{
|
|
if(!g_RTVAllowed)
|
|
{
|
|
ReplyToCommand(client, "[RTVE] RockTheVote is currently disabled.");
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
int iVotersSteam = 0;
|
|
|
|
for (int i=1; i<=MaxClients; i++)
|
|
{
|
|
if (IsClientInGame(i) && !IsFakeClient(i) && !is_bot_player[i])
|
|
{
|
|
if (GetClientIdleTime(i) >= g_Cvar_AFKTime.IntValue)
|
|
continue;
|
|
|
|
if (PM_IsPlayerSteam(i))
|
|
iVotersSteam++;
|
|
}
|
|
}
|
|
|
|
int iVotesNeededTotal = RoundToFloor(float(iVotersSteam) * GetConVarFloat(g_Cvar_Steam_Needed));
|
|
ReplyToCommand(client, "[RTVE] Currently %d Players needed to start a RTV vote.", iVotesNeededTotal);
|
|
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
bool RTVAllowed()
|
|
{
|
|
if(!g_RTVAllowed)
|
|
return false;
|
|
|
|
int time;
|
|
if(g_Cvar_RTVAutoDisable.BoolValue && GetMapTimeLeft(time) && time == 0)
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
stock bool IsValidClient(int client)
|
|
{
|
|
if (client > 0 && client <= MaxClients && IsClientConnected(client) && IsClientInGame(client))
|
|
return true;
|
|
return false;
|
|
}
|