Мод: publick
Оплата договорная
ТЗ: Нужен скриптер чтоб переделал плагин на AMX 1.8.2
- Код: Выделить всё
*/
#include <amxmodx>
#include <amxmisc>
#include <time>
#pragma semicolon 1
new const PLUGIN_NAME[] = "DayNight Mode Switcher";
new const PLUGIN_VERSION[] = "1.0.6";
new const CONFIG_FILE[] = "addons/amxmodx/configs/daynight_switcher.ini";
const TIME_LEN = 6;
const HUD_MAX_LEN = 128;
const TASK_CHECK_TIME = 8816;
const Float:CHECK_TIME_INTERVAL = 60.0;
enum _:Command
{
Id,
Value[HUD_MAX_LEN]
}
enum
{
ExecCmd,
ExecCfg,
BlockCmd,
StopPlugin,
PausePlugin,
UnpausePlugin
}
new const COMMANDS[][] =
{
"EXEC_CMD",
"EXEC_CFG",
"BLOCK_CMD",
"STOP_PLUGIN",
"PAUSE_PLUGIN",
"UNPAUSE_PLUGIN"
};
enum
{
Day,
Night,
Tasks
}
new const MODES[][] =
{
"day",
"night"
};
new const MODE_KEY[] = "dns_user_mode";
new const TASK_KEY[] = "dns_last_task";
new g_iCurrentMode;
new bool:g_isUserMode;
new g_iCurrentSection;
new Array:g_arrTasks;
new Array:g_arrDayMode;
new Array:g_arrNightMode;
new Trie:g_arrBlockedCmd;
new g_iEnabled;
new g_iChangeMap;
new g_iSwitchMode;
new g_iSwitchSpeak;
new g_iAnnounceTime;
new g_iRestartLimit;
new g_iHudInformer;
new g_iHudInformerR;
new g_iHudInformerG;
new g_iHudInformerB;
new Float:g_flHudInformerX;
new Float:g_flHudInformerY;
new g_szDayTime[TIME_LEN];
new g_szNightTime[TIME_LEN];
new g_szCurMap[MAX_NAME_LENGTH];
new g_szChangeMapName[MAX_NAME_LENGTH];
public plugin_precache()
{
if (!file_exists(CONFIG_FILE))
{
set_fail_state("Config file not found! ^"%s^"", CONFIG_FILE);
return PLUGIN_CONTINUE;
}
new INIParser:hParser = INI_CreateParser();
INI_SetReaders(hParser, "on_prase_key_value", "on_prase_new_section");
INI_ParseFile(hParser, CONFIG_FILE);
INI_DestroyParser(hParser);
precache_sound("vox/day.wav");
precache_sound("vox/mode.wav");
precache_sound("vox/night.wav");
precache_sound("vox/activated.wav");
precache_sound("vox/deactivated.wav");
return PLUGIN_CONTINUE;
}
public plugin_init()
{
register_plugin(PLUGIN_NAME, PLUGIN_VERSION, "the_hunter");
register_dictionary("daynight_switcher.txt");
register_event("30", "event_intermission", "a");
register_event("ResetHUD", "event_reset_hud", "be", "1=1");
register_event("HLTV", "event_new_round", "a", "1=0", "2=0");
// dns_enabled
new pcvEnabled = create_cvar("dns_enabled", "1", FCVAR_ARCHIVE);
bind_pcvar_num(pcvEnabled, g_iEnabled);
hook_cvar_change(pcvEnabled, "on_enabled_cvar_change");
// dns_day_time
new pcvDayTime = create_cvar("dns_day_time", "07:00", FCVAR_NOEXTRAWHITEPACE);
bind_pcvar_string(pcvDayTime, g_szDayTime, TIME_LEN - 1);
hook_cvar_change(pcvDayTime, "on_hud_informer_change");
// dns_night_time
new pcvNightTime = create_cvar("dns_night_time", "00:00", FCVAR_NOEXTRAWHITEPACE);
bind_pcvar_string(pcvNightTime, g_szNightTime, TIME_LEN - 1);
hook_cvar_change(pcvNightTime, "on_hud_informer_change");
// dns_switch_mode
new pcvSwitchMode = create_cvar("dns_switch_mode", "0");
bind_pcvar_num(pcvSwitchMode, g_iSwitchMode);
// dns_restart_limit
new pcvRestartLimit = create_cvar("dns_restart_limit", "3");
bind_pcvar_num(pcvRestartLimit, g_iRestartLimit);
// dns_change_map
new pcvChangeMap = create_cvar("dns_change_map", "0");
bind_pcvar_num(pcvChangeMap, g_iChangeMap);
// dns_change_map_name
new pcvChangeMapName = create_cvar("dns_change_map_name", "");
bind_pcvar_string(pcvChangeMapName, g_szChangeMapName, MAX_NAME_LENGTH - 1);
// dns_switch_speak
new pcvSwitchSpeak = create_cvar("dns_switch_speak", "1");
bind_pcvar_num(pcvSwitchSpeak, g_iSwitchSpeak);
// dns_announce_time
new pcvAnnounceTime = create_cvar("dns_announce_time", "5");
bind_pcvar_num(pcvAnnounceTime, g_iAnnounceTime);
// dns_hud_informer
new pcvHudInformer = create_cvar("dns_hud_informer", "1");
bind_pcvar_num(pcvHudInformer, g_iHudInformer);
hook_cvar_change(pcvHudInformer, "on_hud_informer_change");
// dns_hud_informer_pos_x
new pcvHudInformerX = create_cvar("dns_hud_informer_pos_x", "0.011");
bind_pcvar_float(pcvHudInformerX, g_flHudInformerX);
hook_cvar_change(pcvHudInformerX, "on_hud_informer_change");
// dns_hud_informer_pos_y
new pcvHudInformerY = create_cvar("dns_hud_informer_pos_y", "0.24");
bind_pcvar_float(pcvHudInformerY, g_flHudInformerY);
hook_cvar_change(pcvHudInformerY, "on_hud_informer_change");
// dns_hud_informer_r
new pcvHudInformerR = create_cvar("dns_hud_informer_r", "127");
bind_pcvar_num(pcvHudInformerR, g_iHudInformerR);
hook_cvar_change(pcvHudInformerR, "on_hud_informer_change");
// dns_hud_informer_g
new pcvHudInformerG = create_cvar("dns_hud_informer_g", "127");
bind_pcvar_num(pcvHudInformerG, g_iHudInformerG);
hook_cvar_change(pcvHudInformerG, "on_hud_informer_change");
// dns_hud_informer_b
new pcvHudInformerB = create_cvar("dns_hud_informer_b", "127");
bind_pcvar_num(pcvHudInformerB, g_iHudInformerB);
hook_cvar_change(pcvHudInformerB, "on_hud_informer_change");
register_concmd("dns_enable", "cmd_enable", ADMIN_CVAR);
register_concmd("dns_disable", "cmd_disable", ADMIN_CVAR);
register_concmd("dns_set_mode", "cmd_set_mode", ADMIN_CVAR, "day/night/time");
}
public plugin_cfg()
{
get_mapname(g_szCurMap, MAX_NAME_LENGTH - 1);
if (g_iEnabled)
{
plugin_enable();
}
return PLUGIN_CONTINUE;
}
public plugin_end()
{
if (g_arrDayMode != Invalid_Array)
{
ArrayDestroy(g_arrDayMode);
}
if (g_arrNightMode != Invalid_Array)
{
ArrayDestroy(g_arrNightMode);
}
if (g_arrTasks != Invalid_Array)
{
ArrayDestroy(g_arrTasks);
}
if (g_arrBlockedCmd != Invalid_Trie)
{
TrieDestroy(g_arrBlockedCmd);
}
if (task_exists(TASK_CHECK_TIME))
{
remove_task(TASK_CHECK_TIME);
}
}
plugin_enable()
{
check_tasks();
set_task(CHECK_TIME_INTERVAL, "task_check_time",
TASK_CHECK_TIME, .flags = "b");
if (!vaultdata_exists(MODE_KEY))
{
g_isUserMode = false;
set_mode(get_mode_time());
return;
}
g_isUserMode = true;
new szData[TIME_LEN];
get_vaultdata(MODE_KEY, szData, TIME_LEN - 1);
if (equali(szData, MODES[Day]))
{
set_mode(Day);
}
else if (equali(szData, MODES[Night]))
{
set_mode(Night);
}
}
//////////////
// EVENTS //
//////////////
public event_intermission()
{
if (task_exists(TASK_CHECK_TIME))
{
remove_task(TASK_CHECK_TIME);
}
}
public event_reset_hud(iPlayer)
{
// en/disable_event may not work properly :S
if (!g_iEnabled || !g_iHudInformer || is_user_bot(iPlayer))
return;
static szMessage[HUD_MAX_LEN];
if (g_iCurrentMode == Day)
{
switch (g_iHudInformer)
{
case 2:
{
formatex(szMessage, HUD_MAX_LEN - 1, "%L", iPlayer,
"HUD_INFORMER_DAY2", g_szDayTime, g_szNightTime);
}
case 3:
{
formatex(szMessage, HUD_MAX_LEN - 1, "%L", iPlayer,
"HUD_INFORMER_DAY3", g_szCurMap, g_szDayTime, g_szNightTime);
}
default:
{
formatex(szMessage, HUD_MAX_LEN - 1, "%L", iPlayer, "HUD_INFORMER_DAY1");
}
}
}
else
{
switch (g_iHudInformer)
{
case 2:
{
formatex(szMessage, HUD_MAX_LEN - 1, "%L", iPlayer,
"HUD_INFORMER_NIGHT2", g_szNightTime, g_szDayTime);
}
case 3:
{
formatex(szMessage, HUD_MAX_LEN - 1, "%L", iPlayer,
"HUD_INFORMER_NIGHT3", g_szCurMap, g_szNightTime, g_szDayTime);
}
default:
{
formatex(szMessage, HUD_MAX_LEN - 1, "%L", iPlayer, "HUD_INFORMER_NIGHT1");
}
}
}
set_task(0.3, "msg_hud_informer", iPlayer, szMessage, HUD_MAX_LEN);
}
public event_new_round()
{
// en/disable_event may not work properly :S
if (g_iEnabled && g_iSwitchMode == 1 && !g_isUserMode)
{
check_mode_time();
}
}
public task_check_time()
{
check_tasks();
if (g_iAnnounceTime && g_iSwitchMode && !g_isUserMode)
{
check_announce();
}
if (g_iSwitchMode == 2 && !g_isUserMode)
{
check_mode_time();
}
}
check_tasks()
{
if (g_arrTasks == Invalid_Array)
return;
new iSysTime = get_systime();
new iCurTime = get_cur_time_int();
new iTaskNum = ArraySize(g_arrTasks);
new iLastTaskTime = get_vaultdata(TASK_KEY);
for (new i = 0, task[Command]; i < iTaskNum; i++)
{
ArrayGetArray(g_arrTasks, i, task);
if (task[Id] == iCurTime && iSysTime - iLastTaskTime > 60)
{
new szTime[11];
num_to_str(iSysTime, szTime, charsmax(szTime));
set_vaultdata(TASK_KEY, szTime);
server_print("=> Executing task: %s", task[Value]);
server_cmd(task[Value]);
}
}
}
check_announce()
{
if (g_iCurrentMode == Day)
{
new iCurTime = get_cur_time_int();
new iNightTime = parse_time(g_szNightTime, "%H:%M", 0);
if (iNightTime < iCurTime)
{
iNightTime += SECONDS_IN_DAY;
}
if (iNightTime - iCurTime == g_iAnnounceTime * 60)
{
new szMessage[HUD_MAX_LEN];
formatex(szMessage, HUD_MAX_LEN - 1, "%L", LANG_PLAYER,
"HUD_ANNOUNCE_NIGHT", g_iAnnounceTime);
msg_hud_change_mode(szMessage, 0);
client_cmd(0, "spk ^"buttons/bell1^"");
}
}
else
{
new iCurTime = get_cur_time_int();
new iDayTime = parse_time(g_szDayTime, "%H:%M", 0);
if (iDayTime < iCurTime)
{
iDayTime += SECONDS_IN_DAY;
}
if (iDayTime - iCurTime == g_iAnnounceTime * 60)
{
new szMessage[HUD_MAX_LEN];
formatex(szMessage, HUD_MAX_LEN - 1, "%L", LANG_PLAYER,
"HUD_ANNOUNCE_DAY", g_iAnnounceTime);
msg_hud_change_mode(szMessage, 0);
client_cmd(0, "spk ^"buttons/bell1^"");
}
}
}
///////////////////
// PARSE INI //
///////////////////
public bool:on_prase_new_section(hParser, const szSection[])
{
if (equali(szSection, "day"))
{
g_arrDayMode = ArrayCreate(Command);
g_iCurrentSection = Day;
return true;
}
else if (equali(szSection, "night"))
{
g_arrNightMode = ArrayCreate(Command);
g_iCurrentSection = Night;
return true;
}
else if (equali(szSection, "tasks"))
{
g_arrTasks = ArrayCreate(Command);
g_iCurrentSection = Tasks;
return true;
}
g_iCurrentSection = -1;
return false;
}
public bool:on_prase_key_value(hParser, const szKey[], const szValue[])
{
if (g_iCurrentSection == Day)
{
add_command(g_arrDayMode, szKey, szValue);
return true;
}
if (g_iCurrentSection == Night)
{
add_command(g_arrNightMode, szKey, szValue);
return true;
}
if (g_iCurrentSection == Tasks)
{
add_task(g_arrTasks, szKey, szValue);
return true;
}
return false;
}
add_command(Array:arrMode, const szCmd[], const szValue[])
{
new iCmdId = -1;
if (equali(szCmd, COMMANDS[ExecCmd]))
{
iCmdId = ExecCmd;
}
else if (equali(szCmd, COMMANDS[ExecCfg]))
{
iCmdId = ExecCfg;
}
else if (equali(szCmd, COMMANDS[BlockCmd]))
{
iCmdId = BlockCmd;
register_concmd(szValue, "cmd_blocked");
if (g_arrBlockedCmd == Invalid_Trie)
{
g_arrBlockedCmd = TrieCreate();
}
}
else if (equali(szCmd, COMMANDS[StopPlugin]))
{
iCmdId = StopPlugin;
}
else if (equali(szCmd, COMMANDS[PausePlugin]))
{
iCmdId = PausePlugin;
}
else if (equali(szCmd, COMMANDS[UnpausePlugin]))
{
iCmdId = UnpausePlugin;
}
if (iCmdId != -1)
{
new cmd[Command];
cmd[Id] = iCmdId;
copy(cmd[Value], charsmax(cmd[Value]), szValue);
ArrayPushArray(arrMode, cmd);
}
}
add_task(Array:arrTasks, const szTime[], const szValue[])
{
new task[Command];
task[Id] = parse_time(szTime, "%H:%M", 0);
copy(task[Value], charsmax(task[Value]), szValue);
ArrayPushArray(arrTasks, task);
}
//////////////////////
// SWITCH MODE //
//////////////////////
check_mode_time()
{
new iTimeMode = get_mode_time();
if (iTimeMode != g_iCurrentMode)
{
set_mode(iTimeMode);
}
}
get_mode_time()
{
new iCurTime = get_cur_time_int();
new iDayTime = parse_time(g_szDayTime, "%H:%M", 0);
new iNightTime = parse_time(g_szNightTime, "%H:%M", 0);
return iNightTime > iDayTime
? iCurTime >= iNightTime || iCurTime < iDayTime
: iCurTime >= iNightTime && iCurTime < iDayTime;
}
set_mode(iMode)
{
g_iCurrentMode = iMode;
new Array:arrMode = iMode == Day ? g_arrDayMode : g_arrNightMode;
server_print("^n****** %s v%s ******", PLUGIN_NAME, PLUGIN_VERSION);
server_print("=> Applying %s mode", iMode == Day ? "DAY" : "NIGHT");
if (g_arrBlockedCmd != Invalid_Trie)
{
TrieClear(g_arrBlockedCmd);
}
for (new i = 0, iNum = ArraySize(arrMode), cmd[Command]; i < iNum; i++)
{
ArrayGetArray(arrMode, i, cmd);
switch (cmd[Id])
{
case ExecCmd:
{
server_print("=> Executing command: %s", cmd[Value]);
server_cmd(cmd[Value]);
}
case ExecCfg:
{
server_print("=> Executing config: %s", cmd[Value]);
server_cmd("exec ^"%s^"", cmd[Value]);
}
case BlockCmd:
{
strtolower(cmd[Value]);
server_print("=> Blocking command: %s", cmd[Value]);
TrieSetCell(g_arrBlockedCmd, cmd[Value], 1);
}
case StopPlugin:
{
server_print("=> Stoping plugin: %s", cmd[Value]);
pause("cd", cmd[Value]);
}
case PausePlugin:
{
server_print("=> Pausing plugin: %s", cmd[Value]);
pause("ac", cmd[Value]);
}
case UnpausePlugin:
{
server_print("=> Unpausing plugin: %s", cmd[Value]);
unpause("ac", cmd[Value]);
}
}
}
if (get_gametime() > 5.0)
{
set_task(1.0, "on_set_mode", iMode);
}
server_print("");
}
public on_set_mode(iMode)
{
if (g_iChangeMap)
{
set_task(5.0, "change_map", 0);
}
else if (g_iRestartLimit > 0)
{
set_task(5.0, "make_restart", g_iRestartLimit);
}
if (g_iSwitchSpeak)
{
client_cmd(0, "spk ^"buttons/bell1^"");
client_cmd(0, "spk ^"%s^"", iMode == Day
? "vox/_period day mode activated"
: "vox/_period night mode activated");
}
new players[MAX_PLAYERS], iNum;
get_players(players, iNum, "ch");
// because LANG_PLAYER is not working here (wtf?)
for (new i = 0, iPlayer, szMessage[HUD_MAX_LEN]; i < iNum; i++)
{
iPlayer = players[i];
formatex(szMessage, HUD_MAX_LEN - 1, "%L", iPlayer, iMode == Day
? "HUD_DAY_MODE_ACTIVATED" : "HUD_NIGHT_MODE_ACTIVATED");
msg_hud_change_mode(szMessage, iPlayer);
}
}
public change_map(iIntermission)
{
if (!iIntermission)
{
if (!is_map_valid(g_szChangeMapName))
{
copy(g_szChangeMapName, MAX_NAME_LENGTH - 1, g_szCurMap);
}
send_msg_intermission();
set_task(2.0, "change_map", 1);
}
else
{
engine_changelevel(g_szChangeMapName);
}
}
public make_restart(iNum)
{
static pcvRestart;
pcvRestart || (pcvRestart = get_cvar_pointer("sv_restart"));
const Float:flRestart = 1.0;
set_pcvar_float(pcvRestart, flRestart);
if (--iNum > 0)
{
set_task(flRestart, "make_restart", iNum);
}
}
//////////////////
// COMMANDS //
//////////////////
public cmd_enable(iPlayer, iLevel, iCmd)
{
if (cmd_access(iPlayer, iLevel, iCmd, 1))
{
server_cmd("dns_enabled 1");
}
return PLUGIN_HANDLED;
}
public cmd_disable(iPlayer, iLevel, iCmd)
{
if (cmd_access(iPlayer, iLevel, iCmd, 1))
{
server_cmd("dns_enabled 0");
client_cmd(iPlayer, "spk ^"vox/deactivated^"");
}
return PLUGIN_HANDLED;
}
public cmd_set_mode(iPlayer, iLevel, iCmd)
{
if (!cmd_access(iPlayer, iLevel, iCmd, 2))
return PLUGIN_HANDLED;
new szArgs[8];
read_args(szArgs, charsmax(szArgs));
remove_quotes(szArgs);
if (equali(szArgs, "day"))
{
g_isUserMode = true;
set_vaultdata(MODE_KEY, MODES[Day]);
set_mode(Day);
}
else if (equali(szArgs, "night"))
{
g_isUserMode = true;
set_vaultdata(MODE_KEY, MODES[Night]);
set_mode(Night);
}
else if (equali(szArgs, "time"))
{
g_isUserMode = false;
remove_vaultdata(MODE_KEY);
set_mode(get_mode_time());
}
return PLUGIN_HANDLED;
}
public cmd_blocked(iPlayer)
{
if (!g_iEnabled)
return PLUGIN_CONTINUE;
if (!is_user_connected(iPlayer))
return PLUGIN_HANDLED;
static szArgs[192];
if (read_argc() > 1)
{
static szCmd[64];
read_argv(0, szCmd, charsmax(szCmd));
read_args(szArgs, charsmax(szArgs));
remove_quotes(szArgs);
format(szArgs, charsmax(szArgs), "%s %s", szCmd, szArgs);
strtolower(szArgs);
}
else
{
read_argv(0, szArgs, charsmax(szArgs));
strtolower(szArgs);
}
if (TrieKeyExists(g_arrBlockedCmd, szArgs))
{
client_print_color(iPlayer, print_team_red,
"%L", iPlayer, "CMD_BLOCKED");
client_print(iPlayer, print_console,
"This command is temporarily unavailable!");
return PLUGIN_HANDLED;
}
return PLUGIN_CONTINUE;
}
///////////////
// CVARS //
///////////////
public on_enabled_cvar_change(pCvar, const szOldValue[], const szNewValue[])
{
if (str_to_num(szNewValue))
{
plugin_enable();
}
else
{
remove_task(TASK_CHECK_TIME);
}
on_hud_informer_change();
return PLUGIN_HANDLED;
}
public on_hud_informer_change()
{
new players[MAX_PLAYERS], iNum;
get_players(players, iNum, "ach");
for (new i = 0; i < iNum; i++)
{
engclient_cmd(players[i], "fullupdate");
}
return PLUGIN_HANDLED;
}
//////////////////////
// HUD MESSAGES //
//////////////////////
public msg_hud_change_mode(const szMessage[], iPlayer)
{
const iRed = 0;
const iGreen = 255;
const iBlue = 102;
const iEffect = 2;
const Float:flX = -1.0;
const Float:flY = 0.2;
const Float:flFxTime = 6.0;
const Float:flHoldTime = 7.0;
const Float:flFadeInTime = 0.1;
const Float:flFadeOutTime = 1.5;
set_dhudmessage(iRed, iGreen, iBlue, flX, flY,
iEffect, flFxTime, flHoldTime, flFadeInTime, flFadeOutTime);
show_dhudmessage(iPlayer, szMessage);
}
public msg_hud_informer(const szMessage[], iPlayer)
{
if (!is_user_connected(iPlayer))
return;
const iEffect = 0;
const Float:flFxTime = 0.0;
const Float:flHoldTime = 9999.0;
const Float:flFadeInTime = 0.0;
const Float:flFadeOutTime = 0.0;
set_hudmessage(
g_iHudInformerR, g_iHudInformerG, g_iHudInformerB,
g_flHudInformerX, g_flHudInformerY,
iEffect, flFxTime, flHoldTime, flFadeInTime, flFadeOutTime);
show_hudmessage(iPlayer, szMessage);
}
///////////////////////////////
// UTILS and REUSABLE CODE //
///////////////////////////////
stock get_cur_time_int()
{
new iHours, iMinutes;
time(iHours, iMinutes);
return iHours * 60 * 60 + iMinutes * 60;
}
stock send_msg_intermission()
{
emessage_begin(MSG_ALL, SVC_INTERMISSION);
emessage_end();
}