682 lines
17 KiB
SourcePawn
Executable File
682 lines
17 KiB
SourcePawn
Executable File
// vim: set ts=4 sw=4 tw=99 noet:
|
|
//
|
|
// AMX Mod X, based on AMX Mod by Aleksander Naszko ("OLO").
|
|
// Copyright (C) The AMX Mod X Development Team.
|
|
//
|
|
// This software is licensed under the GNU General Public License, version 3 or higher.
|
|
// Additional exceptions apply. For full license details, see LICENSE.txt or visit:
|
|
// https://alliedmods.net/amxmodx-license
|
|
|
|
//
|
|
// Restrict Weapons Plugin
|
|
//
|
|
|
|
#include <amxmodx>
|
|
#include <amxmisc>
|
|
#include <cstrike>
|
|
|
|
new const PluginName[] = "Restrict Weapons";
|
|
|
|
const MaxAliasNameLength = 16;
|
|
const MaxItemNameLength = 32;
|
|
const MaxMenuTitleLength = 48;
|
|
const MaxCommandAliasLength = 12;
|
|
const MaxConfigFileLength = 48;
|
|
const MaxConsoleLength = 128;
|
|
const MaxMapLength = 32;
|
|
|
|
new bool:BlockedItems[CSI_MAX_COUNT];
|
|
new bool:ModifiedItem;
|
|
new bool:ConfigsExecuted;
|
|
|
|
new MenuPosition[MAX_PLAYERS + 1];
|
|
new MenuHandle [MAX_PLAYERS + 1] = { -1, ... };
|
|
new ConfigFilePath[PLATFORM_MAX_PATH];
|
|
|
|
new RestrictedBotWeapons[] = "00000000000000000000000000";
|
|
new RestrictedBotEquipAmmos[] = "000000000";
|
|
|
|
new CvarPointerAllowMapSettings;
|
|
new CvarPointerRestrictedWeapons;
|
|
new CvarPointerRestrictedEquipAmmos;
|
|
|
|
enum MenuTitle
|
|
{
|
|
m_Title[MaxMenuTitleLength],
|
|
m_Alias[MaxCommandAliasLength],
|
|
};
|
|
|
|
#define TITLE(%0) "MENU_TITLE_" + #%0
|
|
|
|
new const MenuInfos[][MenuTitle] =
|
|
{
|
|
{ TITLE(HANDGUNS) , "pistol" },
|
|
{ TITLE(SHOTGUNS) , "shotgun" },
|
|
{ TITLE(SUBMACHINES) , "sub" },
|
|
{ TITLE(RIFLES) , "rifle" },
|
|
{ TITLE(SNIPERS) , "sniper" },
|
|
{ TITLE(MACHINE) , "machine" },
|
|
{ TITLE(EQUIPMENT) , "equip" },
|
|
{ TITLE(AMMUNITION) , "ammo" },
|
|
}
|
|
|
|
enum MenuItem
|
|
{
|
|
m_Index,
|
|
m_Name[MaxItemNameLength],
|
|
};
|
|
|
|
#define ITEM(%0) { CSI_%0, "MENU_ITEM_" + #%0 }
|
|
#define ITEM_NONE { CSI_NONE, "" }
|
|
|
|
new const ItemsInfos[][][MenuItem] =
|
|
{
|
|
{ ITEM(USP) , ITEM(GLOCK18) , ITEM(DEAGLE) , ITEM(P228) , ITEM(ELITE) , ITEM(FIVESEVEN), ITEM_NONE , ITEM_NONE },
|
|
{ ITEM(M3) , ITEM(XM1014) , ITEM_NONE , ITEM_NONE , ITEM_NONE , ITEM_NONE , ITEM_NONE , ITEM_NONE },
|
|
{ ITEM(MP5NAVY), ITEM(TMP) , ITEM(P90) , ITEM(MAC10) , ITEM(UMP45) , ITEM_NONE , ITEM_NONE , ITEM_NONE },
|
|
{ ITEM(AK47) , ITEM(SG552) , ITEM(M4A1) , ITEM(GALIL) , ITEM(FAMAS) , ITEM(AUG) , ITEM_NONE , ITEM_NONE },
|
|
{ ITEM(SCOUT) , ITEM(AWP) , ITEM(G3SG1) , ITEM(SG550) , ITEM_NONE , ITEM_NONE , ITEM_NONE , ITEM_NONE },
|
|
{ ITEM(M249) , ITEM_NONE , ITEM_NONE , ITEM_NONE , ITEM_NONE , ITEM_NONE , ITEM_NONE , ITEM_NONE },
|
|
{ ITEM(VEST) , ITEM(VESTHELM), ITEM(FLASHBANG), ITEM(HEGRENADE), ITEM(SMOKEGRENADE), ITEM(DEFUSER) , ITEM(NVGS), ITEM(SHIELD) },
|
|
{ ITEM(PRIAMMO), ITEM(SECAMMO) , ITEM_NONE , ITEM_NONE , ITEM_NONE , ITEM_NONE , ITEM_NONE , ITEM_NONE },
|
|
};
|
|
|
|
|
|
public plugin_init()
|
|
{
|
|
register_plugin(PluginName, AMXX_VERSION_STR, "AMXX Dev Team");
|
|
|
|
register_dictionary("restmenu.txt");
|
|
register_dictionary("common.txt");
|
|
|
|
register_clcmd( "amx_restmenu", "@ClientCommand_MainMenu" , ADMIN_CFG, .info = "REG_CMD_MENU", .info_ml = true);
|
|
register_concmd("amx_restrict", "@ConsoleCommand_Restrict", ADMIN_CFG, .info = "REG_CMD_REST", .info_ml = true);
|
|
|
|
CvarPointerAllowMapSettings = register_cvar("amx_restrmapsettings", "0");
|
|
CvarPointerRestrictedWeapons = register_cvar("amx_restrweapons" , RestrictedBotWeapons);
|
|
CvarPointerRestrictedEquipAmmos = register_cvar("amx_restrequipammo" , RestrictedBotEquipAmmos);
|
|
}
|
|
|
|
public OnConfigsExecuted()
|
|
{
|
|
new const configFile[] = "weaprest";
|
|
new const configFileExt[] = "ini";
|
|
|
|
new configsDir[PLATFORM_MAX_PATH];
|
|
get_configsdir(configsDir, charsmax(configsDir));
|
|
|
|
if (get_pcvar_bool(CvarPointerAllowMapSettings))
|
|
{
|
|
new mapName[MaxMapLength];
|
|
get_mapname(mapName, charsmax(mapName));
|
|
|
|
formatex(ConfigFilePath, charsmax(ConfigFilePath), "%s/%s_%s.%s", configsDir, configFile, mapName, configFileExt);
|
|
}
|
|
else
|
|
{
|
|
formatex(ConfigFilePath, charsmax(ConfigFilePath), "%s/%s.%s", configsDir, configFile, configFileExt);
|
|
}
|
|
|
|
loadSettings(ConfigFilePath);
|
|
|
|
ConfigsExecuted = true;
|
|
}
|
|
|
|
public CS_OnBuyAttempt(player, itemid)
|
|
{
|
|
if (BlockedItems[itemid])
|
|
{
|
|
return blockcommand(player);
|
|
}
|
|
|
|
return PLUGIN_CONTINUE;
|
|
}
|
|
|
|
public blockcommand(const id) // Might be used by others plugins, so keep this for backward compatibility.
|
|
{
|
|
client_print(id, print_center, "%l", "RESTRICTED_ITEM");
|
|
return PLUGIN_HANDLED;
|
|
}
|
|
|
|
@ClientCommand_MainMenu(const id, const level, const cid)
|
|
{
|
|
if (cmd_access(id, level, cid, 1))
|
|
{
|
|
displayMenu(id, MenuPosition[id] = -1);
|
|
}
|
|
|
|
return PLUGIN_HANDLED;
|
|
}
|
|
|
|
@ConsoleCommand_Restrict(const id, const level, const cid)
|
|
{
|
|
if (!cmd_access(id, level, cid, 1))
|
|
{
|
|
return PLUGIN_HANDLED;
|
|
}
|
|
|
|
new const argumentsCount = read_argc();
|
|
|
|
if (argumentsCount <= 1) // Main command only, no arguments.
|
|
{
|
|
goto usage;
|
|
}
|
|
|
|
new action[8];
|
|
new argumentIndex;
|
|
new const actionLength = read_argv(++argumentIndex, action, charsmax(action)) - trim(action);
|
|
|
|
if (!actionLength || !isalpha(action[0])) // Empty argument or first character is not a letter.
|
|
{
|
|
goto usage;
|
|
}
|
|
|
|
new const ch1 = char_to_lower(action[0]);
|
|
new const ch2 = char_to_lower(action[1]);
|
|
|
|
if (ch1 == 'o' && (ch2 == 'n' || ch2 == 'f')) // [on]/[of]f
|
|
{
|
|
new const bool:restricted = (ch2 == 'n');
|
|
new bool:valid;
|
|
|
|
if (argumentsCount <= argumentIndex + 1) // No arguments, all items are concerned.
|
|
{
|
|
arrayset(BlockedItems, restricted, sizeof BlockedItems);
|
|
console_print(id, "%l", restricted ? "EQ_WE_RES" : "EQ_WE_UNRES");
|
|
|
|
ModifiedItem = valid = true;
|
|
refreshMenus(level);
|
|
}
|
|
else // Either item type or specific alias
|
|
{
|
|
new commands[MaxConsoleLength];
|
|
new itemName[MaxItemNameLength];
|
|
new argument[MaxAliasNameLength];
|
|
new position, class;
|
|
new itemid, slot;
|
|
new commandLength;
|
|
|
|
while (argumentIndex < argumentsCount)
|
|
{
|
|
// Ignore if the argument is empty or the first character is not a letter.
|
|
if ((commandLength = read_argv(++argumentIndex, commands, charsmax(commands)) - trim(commands)) <= 0 || !isalpha(commands[0]))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
strtolower(commands);
|
|
position = 0;
|
|
|
|
// In case argument contains several input between quotes.
|
|
while (position != commandLength && (position = argparse(commands, position, argument, charsmax(argument))) != -1)
|
|
{
|
|
if ((class = findMenuAliasId(argument)) != -1)
|
|
{
|
|
for (slot = 0; slot < sizeof ItemsInfos[] && (itemid = ItemsInfos[class][slot][m_Index]) != CSI_NONE; ++slot)
|
|
{
|
|
BlockedItems[itemid] = restricted;
|
|
}
|
|
|
|
console_print(id, "%l %l %l", MenuInfos[class], (class < 6) ? "HAVE_BEEN" : "HAS_BEEN", restricted ? "RESTRICTED" : "UNRESTRICTED");
|
|
ModifiedItem = valid = true;
|
|
}
|
|
else if ((itemid = cs_get_item_id(argument)) != CSI_NONE)
|
|
{
|
|
BlockedItems[itemid] = restricted;
|
|
findItemFullName(itemid, itemName, charsmax(itemName));
|
|
|
|
console_print(id, "%l %l %l", itemName, "HAS_BEEN", restricted ? "RESTRICTED" : "UNRESTRICTED");
|
|
ModifiedItem = valid = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!valid)
|
|
{
|
|
console_print(id, "%l", "NO_EQ_WE");
|
|
}
|
|
else
|
|
{
|
|
refreshMenus(level);
|
|
}
|
|
}
|
|
|
|
if (ConfigsExecuted && valid)
|
|
{
|
|
show_activity_key("ADMIN_UPD_RES_1", "ADMIN_UPD_RES_2", fmt("%n", id));
|
|
log_amx("%L", LANG_SERVER, "ADMIN_CMD_UPDATEDCFG", id);
|
|
}
|
|
}
|
|
else if (ch1 == 'l' && ch2 == 'i') // [li]st
|
|
{
|
|
// Items list.
|
|
if (argumentsCount > argumentIndex + 1) // Available arguments.
|
|
{
|
|
new const selection = read_argv_int(++argumentIndex) - 1; // Index starts from 0.
|
|
|
|
if (0 <= selection <= charsmax(ItemsInfos))
|
|
{
|
|
console_print(id, "^n----- %l: %l -----^n", "WEAP_RES", MenuInfos[selection][m_Title]);
|
|
|
|
SetGlobalTransTarget(id);
|
|
|
|
new alias[MaxAliasNameLength];
|
|
new itemid;
|
|
|
|
console_print(id, " %-32.31s %-10.9s %-9.8s", fmt("%l", "NAME"), fmt("%l", "VALUE"), fmt("%l", "STATUS"));
|
|
console_print(id, "");
|
|
|
|
for (new slot = 0; slot < sizeof ItemsInfos[] && (itemid = ItemsInfos[selection][slot][m_Index]) != CSI_NONE; ++slot)
|
|
{
|
|
cs_get_item_alias(itemid, alias, charsmax(alias));
|
|
|
|
console_print(id, " %-32.31s %-10.9s %-9.8s", fmt("%l", ItemsInfos[selection][slot][m_Name]), alias
|
|
, fmt("%l", BlockedItems[itemid] ? "ON" : "OFF"));
|
|
}
|
|
|
|
console_print(id, "");
|
|
return PLUGIN_HANDLED;
|
|
}
|
|
}
|
|
|
|
console_print(id, "^n----- %l -----^n", "WEAP_RES");
|
|
|
|
// Item types list.
|
|
for (new class = 0; class < sizeof MenuInfos; ++class)
|
|
{
|
|
console_print(id, "%3d: %l", class + 1, MenuInfos[class][m_Title]);
|
|
}
|
|
|
|
console_print(id, "^n----- %l -----^n", "REST_USE_HOW");
|
|
}
|
|
else if (ch1 == 's') // [s]ave
|
|
{
|
|
// If 'save' is used in a per-map config file, the plugin config file is not yet known as it depends on
|
|
// amx_restrmapsettings cvar value read after per-map configs are processed. Postponing the saving a little.
|
|
if (!ConfigsExecuted)
|
|
{
|
|
const taskId = 424242;
|
|
|
|
if (!task_exists(taskId))
|
|
{
|
|
set_task(0.1, "@Task_SaveConfig", taskId);
|
|
}
|
|
|
|
return PLUGIN_HANDLED;
|
|
}
|
|
|
|
new bool:saved = saveSettings(ConfigFilePath);
|
|
|
|
if (saved)
|
|
{
|
|
ModifiedItem = false;
|
|
refreshMenus(level, .displaySaveMessage = true);
|
|
|
|
if (ConfigsExecuted)
|
|
{
|
|
log_amx("%L", LANG_SERVER, "ADMIN_CMD_SAVEDCFG", id, ConfigFilePath);
|
|
}
|
|
}
|
|
|
|
console_print(id, "%l^n", saved ? "REST_CONF_SAVED" : "REST_COULDNT_SAVE", ConfigFilePath);
|
|
}
|
|
else if (ch1 == 'l' && ch2 == 'o') // [lo]ad
|
|
{
|
|
if (argumentsCount <= argumentIndex + 1) // No argument
|
|
{
|
|
goto usage;
|
|
}
|
|
|
|
new argument[MaxConfigFileLength];
|
|
read_argv(++argumentIndex, argument, charsmax(argument)) - trim(argument);
|
|
|
|
new filepath[PLATFORM_MAX_PATH];
|
|
new length = get_configsdir(filepath, charsmax(filepath));
|
|
formatex(filepath[length], charsmax(filepath) - length, "/%s", argument);
|
|
|
|
new bool:loaded = loadSettings(filepath);
|
|
|
|
if (loaded)
|
|
{
|
|
arrayset(BlockedItems, false, sizeof BlockedItems);
|
|
|
|
ModifiedItem = true;
|
|
refreshMenus(level);
|
|
|
|
if (ConfigsExecuted)
|
|
{
|
|
show_activity_key("ADMIN_UPD_RES_1", "ADMIN_UPD_RES_2", fmt("%n", id));
|
|
log_amx("%L", LANG_SERVER, "ADMIN_CMD_LOADEDCFG", id, ConfigFilePath);
|
|
}
|
|
}
|
|
|
|
console_print(id, "%l^n", loaded ? "REST_CONF_LOADED" : "REST_COULDNT_LOAD", filepath);
|
|
}
|
|
else
|
|
{
|
|
usage:
|
|
console_print(id, "%l", "COM_REST_USAGE");
|
|
console_print(id, "^n%l", "COM_REST_COMMANDS");
|
|
console_print(id, "%l", "COM_REST_ON");
|
|
console_print(id, "%l", "COM_REST_OFF");
|
|
console_print(id, "%l", "COM_REST_ONV");
|
|
console_print(id, "%l", "COM_REST_OFFV");
|
|
console_print(id, "%l", "COM_REST_LIST");
|
|
console_print(id, "%l", "COM_REST_SAVE");
|
|
console_print(id, "%l^n", "COM_REST_LOAD");
|
|
console_print(id, "%l^n", "COM_REST_VALUES");
|
|
console_print(id, "%l^n", "COM_REST_TYPE");
|
|
}
|
|
|
|
return PLUGIN_HANDLED;
|
|
}
|
|
|
|
@Task_SaveConfig()
|
|
{
|
|
server_cmd("amx_restrict save");
|
|
}
|
|
|
|
displayMenu(const id, const position)
|
|
{
|
|
SetGlobalTransTarget(id);
|
|
|
|
new menuTitle[MaxMenuTitleLength * 2];
|
|
formatex(menuTitle, charsmax(menuTitle), " \y%l", "REST_WEAP");
|
|
|
|
new const menu = MenuHandle[id] = menu_create(menuTitle, "@OnMenuAction");
|
|
|
|
if (position < 0) // Main menu
|
|
{
|
|
for (new class = 0; class < sizeof MenuInfos; ++class)
|
|
{
|
|
menu_additem(menu, fmt("%l", MenuInfos[class][m_Title]));
|
|
}
|
|
}
|
|
else // Sub-menus
|
|
{
|
|
menu_setprop(menu, MPROP_TITLE, fmt("%s > \d%l", menuTitle, MenuInfos[position][m_Title]));
|
|
|
|
for (new slot = 0, data[MenuItem], index; slot < sizeof ItemsInfos[]; ++slot)
|
|
{
|
|
data = ItemsInfos[position][slot];
|
|
|
|
if ((index = data[m_Index]))
|
|
{
|
|
menu_additem(menu, fmt("%l\R%s%l", data[m_Name], BlockedItems[index] ? "\y" : "\r", BlockedItems[index] ? "ON" : "OFF"));
|
|
continue;
|
|
}
|
|
|
|
menu_addblank2(menu);
|
|
}
|
|
}
|
|
|
|
menu_addblank(menu, .slot = false);
|
|
menu_additem(menu, fmt("%s%l \y\R%s", ModifiedItem ? "\y" : "\d", "SAVE_SET", ModifiedItem ? "*" : ""));
|
|
|
|
if (position >= 0) // Inside a sub-menu
|
|
{
|
|
menu_addblank(menu, .slot = false);
|
|
menu_additem(menu, fmt("%l", "BACK"));
|
|
}
|
|
else // Main menu
|
|
{
|
|
menu_setprop(menu, MPROP_EXITNAME, fmt("%l", "EXIT"));
|
|
menu_setprop(menu, MPROP_EXIT, MEXIT_FORCE); // Force an EXIT item since pagination is disabled.
|
|
}
|
|
|
|
menu_setprop(menu, MPROP_PERPAGE, 0); // Disable pagination.
|
|
menu_setprop(menu, MPROP_NUMBER_COLOR, " \r"); // Small QoL change to avoid menu overlapping with left icons.
|
|
|
|
menu_display(id, menu);
|
|
|
|
return menu;
|
|
}
|
|
|
|
@OnMenuAction(const id, const menu, const key)
|
|
{
|
|
new position = MenuPosition[id];
|
|
|
|
if (key >= 0)
|
|
{
|
|
switch (key + 1)
|
|
{
|
|
case 1 .. sizeof ItemsInfos[]:
|
|
{
|
|
if (position < 0) // We are right now in the main menu, go to sub-menu.
|
|
{
|
|
position = key;
|
|
}
|
|
else // We are in a sub-menu.
|
|
{
|
|
ModifiedItem = true;
|
|
|
|
new const itemid = ItemsInfos[any:position][key][m_Index];
|
|
BlockedItems[itemid] = !BlockedItems[itemid];
|
|
|
|
restrictPodbotItem(itemid, .toggle = true);
|
|
updatePodbotCvars();
|
|
}
|
|
}
|
|
case sizeof ItemsInfos[] + 1: // Save option.
|
|
{
|
|
if (saveSettings(ConfigFilePath))
|
|
{
|
|
show_activity_key("ADMIN_UPD_RES_1", "ADMIN_UPD_RES_2", fmt("%n", id));
|
|
log_amx("%L", LANG_SERVER, "ADMIN_MENU_SAVEDCFG", id ,ConfigFilePath);
|
|
|
|
ModifiedItem = false;
|
|
}
|
|
|
|
client_print(id, print_chat, "* %l", ModifiedItem ? "CONF_SAV_FAIL" : "CONF_SAV_SUC");
|
|
}
|
|
default:
|
|
{
|
|
position = -1; // Back to main menu.
|
|
}
|
|
}
|
|
}
|
|
|
|
MenuHandle[id] = -1;
|
|
|
|
menu_destroy(menu);
|
|
|
|
if (position != MenuPosition[id] || key >= 0)
|
|
{
|
|
displayMenu(id, MenuPosition[id] = position);
|
|
}
|
|
|
|
return PLUGIN_HANDLED;
|
|
}
|
|
|
|
findAdminsWithMenu(playersList[MAX_PLAYERS], &playersCount, const commandLevel = -1)
|
|
{
|
|
new player, adminsCount;
|
|
new menu, newmenu;
|
|
|
|
get_players(playersList, playersCount, "ch");
|
|
|
|
for (new i = 0; i < playersCount; ++i)
|
|
{
|
|
player = playersList[i]
|
|
|
|
if (player_menu_info(player, menu, newmenu) && newmenu != -1 && newmenu == MenuHandle[player])
|
|
{
|
|
if (commandLevel == -1 || access(player, commandLevel)) // extra safety
|
|
{
|
|
playersList[adminsCount++] = player;
|
|
}
|
|
}
|
|
}
|
|
|
|
playersCount = adminsCount;
|
|
}
|
|
|
|
refreshMenus(const commandLevel = 0, const bool:displaySaveMessage = false)
|
|
{
|
|
new playersList[MAX_PLAYERS], playersCount;
|
|
findAdminsWithMenu(playersList, playersCount, commandLevel);
|
|
|
|
if (!playersCount)
|
|
{
|
|
return;
|
|
}
|
|
|
|
for (new i = 0, player; i < playersCount; ++i)
|
|
{
|
|
player = playersList[i]
|
|
|
|
MenuHandle[player] = displayMenu(player, MenuPosition[player]);
|
|
|
|
if (displaySaveMessage)
|
|
{
|
|
client_print(playersList[i], print_chat, "* %l (amx_restrict)", "CONF_SAV_SUC");
|
|
}
|
|
}
|
|
}
|
|
|
|
bool:saveSettings(const filename[])
|
|
{
|
|
new const fp = fopen(filename, "wt");
|
|
|
|
if (!fp)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
fprintf(fp, "%L", LANG_SERVER, "CONFIG_FILE_HEADER", PluginName);
|
|
|
|
new alias[MaxAliasNameLength];
|
|
new itemid;
|
|
new bool:showCategory;
|
|
|
|
for (new class = 0, slot; class < sizeof ItemsInfos; ++class)
|
|
{
|
|
showCategory = true;
|
|
|
|
for (slot = 0; slot < sizeof ItemsInfos[]; ++slot)
|
|
{
|
|
if ((itemid = ItemsInfos[class][slot][m_Index]) == CSI_NONE)
|
|
{
|
|
break;
|
|
}
|
|
|
|
if (BlockedItems[itemid])
|
|
{
|
|
if (showCategory)
|
|
{
|
|
showCategory = false;
|
|
fprintf(fp, "^n; %l^n; -^n", MenuInfos[class][m_Title]);
|
|
}
|
|
|
|
cs_get_item_alias(itemid, alias, charsmax(alias));
|
|
fprintf(fp, "%-16.15s ; %L^n", alias, LANG_SERVER, ItemsInfos[class][slot][m_Name]);
|
|
}
|
|
}
|
|
}
|
|
|
|
fclose(fp);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool:loadSettings(const filename[])
|
|
{
|
|
new const fp = fopen(filename, "rt");
|
|
|
|
if (!fp)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
new lineRead[MaxAliasNameLength], alias[MaxAliasNameLength];
|
|
new itemid, ch;
|
|
|
|
arrayset(RestrictedBotEquipAmmos, '0', charsmax(RestrictedBotEquipAmmos));
|
|
arrayset(RestrictedBotWeapons, '0', charsmax(RestrictedBotWeapons));
|
|
|
|
while (fgets(fp, lineRead, charsmax(lineRead)))
|
|
{
|
|
trim(lineRead)
|
|
|
|
if (!lineRead[0])
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if ((ch = lineRead[0]) == ';' || ch == '/' || ch == '#')
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (parse(lineRead, alias, charsmax(alias)) == 1 && (itemid = cs_get_item_id(alias)) != CSI_NONE)
|
|
{
|
|
BlockedItems[itemid] = true;
|
|
restrictPodbotItem(itemid);
|
|
}
|
|
}
|
|
|
|
fclose (fp);
|
|
|
|
updatePodbotCvars();
|
|
|
|
return true;
|
|
}
|
|
|
|
findMenuAliasId(const name[])
|
|
{
|
|
for (new i = 0; i < sizeof MenuInfos; ++i)
|
|
{
|
|
if (equal(name, MenuInfos[i][m_Alias]))
|
|
{
|
|
return i;
|
|
}
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
findItemFullName(const itemid, name[], const maxlen)
|
|
{
|
|
for (new class = 0, slot; class < sizeof ItemsInfos; ++class)
|
|
{
|
|
for (slot = 0; slot < sizeof ItemsInfos[]; ++slot)
|
|
{
|
|
if (ItemsInfos[class][slot][m_Index] == itemid)
|
|
{
|
|
copy(name, maxlen, ItemsInfos[class][slot][m_Name]);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
restrictPodbotItem(const itemid, const bool:toggle = false)
|
|
{
|
|
new const translatedItems[CSI_MAX_COUNT] =
|
|
{
|
|
// CSI ids -> string indexes of pb_restrweapons and pb_restrequipammo cvars. See podbot.cfg.
|
|
-1, 4, -1, 20, 3, 8, -1, 12, 19, 4, 5, 6, 13, 23, 17, 18, 1, 2, 21, 9, 24, 7, 16, 10, 22, 2, 3, 15, 14, 0, 11, 0, 1, 5, 6, 25, 7, 8
|
|
};
|
|
|
|
new const index = translatedItems[itemid];
|
|
|
|
if (index >= 0)
|
|
{
|
|
if ((itemid <= CSI_LAST_WEAPON && !(1 << itemid & CSI_ALL_GRENADES)) || itemid == CSI_SHIELD)
|
|
{
|
|
RestrictedBotWeapons[index] = toggle && RestrictedBotWeapons[index] == '1' ? '0' : '1';
|
|
}
|
|
else
|
|
{
|
|
RestrictedBotEquipAmmos[index] = toggle && RestrictedBotEquipAmmos[index] == '1' ? '0' : '1';
|
|
}
|
|
}
|
|
}
|
|
|
|
updatePodbotCvars()
|
|
{
|
|
set_pcvar_string(CvarPointerRestrictedWeapons, RestrictedBotWeapons);
|
|
set_pcvar_string(CvarPointerRestrictedEquipAmmos, RestrictedBotEquipAmmos);
|
|
}
|
|
|