Дуэль на ножах

#define PLUGINNAME      "Automatic knife duel teleport"
#define VERSION         "0.3.1"
#define AUTHOR          "JGHG"
 
#include <amxmodx>
#include <fakemeta>
#include <fun>
#include <hamsandwich>
 
#define DEBUG
 
#if defined DEBUG
#include <amxmisc>
#endif // defined DEBUG
 
#define MENUSELECT1                             0
#define MENUSELECT2                             1
#define TASKID_CHALLENGING              2348923
#define TASKID_BOTTHINK                 3242321
#define DECIDESECONDS                   10
#define ALLOWED_WEAPONS                 2
#define KNIFESLASHES                    3 // the nr of slashes within a short amount of time until a challenge starts...
// Globals below
new g_allowedWeapons[ALLOWED_WEAPONS] = {CSW_KNIFE, CSW_C4}
new g_MAXPLAYERS
new bool:g_challenging = false
new bool:g_knifeArena = false
new bool:g_noChallengingForAWhile = false
new g_challengemenu
new g_challenger
new g_challenged
new g_challenges[33]
 
new Float:g_vKnifeOrigin[2][3];
new const g_szSpawnClassname[] = "info_player_deathmatch";
 
enum _:max_cvars {
        
        CVAR_COUNT = 0,
        CVAR_TIMER,
        CVAR_MAXDISTANCE,
        CVAR_ANNOUNCE,
        CVAR_RESET
};
new g_Pcvar[max_cvars];
 
new g_iFwdSpawn;
new g_iMaxPlayers;
 
public plugin_modules()
{
        require_module("fakemeta")
        require_module("fun")
}
 
public plugin_precache()
{
        g_iFwdSpawn = register_forward(FM_Spawn,"fwd_Spawn",1);
}
 
public fwd_Spawn(ent)
{
        if(!pev_valid(ent))
                return FMRES_IGNORED;
        
        static szClassname[32];
        pev(ent,pev_classname,szClassname,sizeof szClassname - 1);
        
        if(equal(szClassname,g_szSpawnClassname))
        {
                if(vec_null(g_vKnifeOrigin[0]))
                {
                        pev(ent,pev_origin,g_vKnifeOrigin[0]);
                }
                else if(!vec_null(g_vKnifeOrigin[0]) && vec_null(g_vKnifeOrigin[1]))
                {
                        static Float:vTmp[3];
                        pev(ent,pev_origin,vTmp);
                        
                        if((300.0 <= vector_distance(g_vKnifeOrigin[0],vTmp) < 600.0))
                                g_vKnifeOrigin[1] = vTmp;
                }
        }
        return FMRES_IGNORED;
}
        
public forward_emitsound(const PIRATE, const Onceuponatimetherewasaverysmall, noise[], const Float:turtlewhoateabiggerturtleand, const Float:afterthatthesmallturtlegot, const veryveryverybig, const theend) {
        if (g_noChallengingForAWhile || g_knifeArena || g_challenging || PIRATE < 1 || PIRATE > g_MAXPLAYERS || !is_user_alive(PIRATE) || !equal(noise, "weapons/knife_hitwall1.wav"))
                return FMRES_IGNORED
 
        new team = get_user_team(PIRATE), otherteam = 0, matchingOpponent = 0
        // Make sure exactly one person on each team is alive.
        for (new i = 1; i <= g_MAXPLAYERS; i++) {
                if (!is_user_connected(i) || !is_user_alive(i) || PIRATE == i)
                        continue
                if (get_user_team(i) == team) {
                        // No fun.
                        return FMRES_IGNORED
                }
                else {
                        if (++otherteam > 1) {
                                // No fun.
                                return FMRES_IGNORED
                        }
                        matchingOpponent = i
                }
        }
 
        if (matchingOpponent == 0)
                return FMRES_IGNORED
 
        if (++g_challenges[PIRATE] >= KNIFESLASHES) {
                Challenge(PIRATE, matchingOpponent)
                if (is_user_bot(matchingOpponent)) {
                        new Float:val = float(DECIDESECONDS)
                        if (val < 2.0)
                                val = 2.0
                        remove_task(TASKID_BOTTHINK)
                        set_task(random_float(1.0, float(DECIDESECONDS) - 1.0), "BotDecides", TASKID_BOTTHINK)
                }
                g_challenges[PIRATE] = 0
        }
        else
                set_task(1.0, "decreaseChallenges", PIRATE)
 
        //client_print(PIRATE, print_chat, "Your challenges: %d", g_challenges[PIRATE])
 
        return FMRES_IGNORED
}
 
public decreaseChallenges(id) {
        if (--g_challenges[id] < 0)
                g_challenges[id] = 0
}
 
public BotDecides() {
        if (!g_challenging)
                return
 
        if (random_num(0,9) > 0)
                Accept()
        else {
                DeclineMsg()
        }
        g_challenging = false
        remove_task(TASKID_CHALLENGING)
}
 
Challenge(challenger, challenged) {
        g_challenger = challenger
        g_challenged = challenged
        g_challenging = true
        new challenger_name[32], challenged_name[32]
        get_user_name(challenger, challenger_name, 31)
        get_user_name(challenged, challenged_name, 31)
 
        client_print(challenger, print_chat, "Вы бросаете вызов %s на дуэль! Ждите ответа в течении %d секунд...", challenged_name, DECIDESECONDS)
 
        new menu[1024], keys = MENU_KEY_1 | MENU_KEY_2
        format(menu, 1023, "Вам вызов от %s на дуэль!^n^nЧто же это будет? У вас есть %d секунд, чтобы ответить!^n^n\y1\w. Bring it on!^n\y2\w. Нет, я лучше постреляю!", challenger_name, DECIDESECONDS)
        show_menu(challenged, keys, menu, DECIDESECONDS, "JGHG's automatic knife duel")
        set_task(float(DECIDESECONDS), "timed_toolate", TASKID_CHALLENGING)
}
 
public timed_toolate() {
        if (g_challenging) {
                new challenger_name[32], challenged_name[32]
                get_user_name(g_challenger, challenger_name, 31)
                get_user_name(g_challenged, challenged_name, 31)
                client_print(0, print_chat, "%s не отвечает на %s's дуэль на ножах большая трудность...", challenged_name, challenger_name)
                CancelAll()
        }
}
 
public client_putinserver(id) {
        set_task(25.0, "Announcement", id)
 
        return PLUGIN_CONTINUE
}
 
public Announcement(id) {
        client_print(id, print_chat, "Если вы 1 на 1 из врагом, то бейте об стену ножом для вызова на knife дуэль.")
}
 
public challenged_menu(id, key) {
        switch (key) {
                case MENUSELECT1: {
                        // Accept
                        Accept()
                }
                case MENUSELECT2: {
                        // Decline
                        DeclineMsg()
                }
        }
        g_challenging = false
        remove_task(TASKID_CHALLENGING)
 
        return PLUGIN_HANDLED
}
 
DeclineMsg() {
        new challenger_name[32], challenged_name[32]
        get_user_name(g_challenger, challenger_name, 31)
        get_user_name(g_challenged, challenged_name, 31)
        client_print(0, print_chat, "%s turns down %s's knife duel challenge...", challenged_name, challenger_name)
}
 
Accept() {
        new challenger_name[32], challenged_name[32]
        get_user_name(g_challenger, challenger_name, 31)
        get_user_name(g_challenged, challenged_name, 31)
 
        client_print(0, print_chat, "%s принимает %s's вызов!", challenged_name, challenger_name)
        g_knifeArena = true
        give_item(g_challenger, "weapon_knife")
        give_item(g_challenged, "weapon_knife")
        engclient_cmd(g_challenger, "weapon_knife")
        engclient_cmd(g_challenged, "weapon_knife")
        engfunc(EngFunc_SetOrigin,g_challenged,g_vKnifeOrigin[0]);
        engfunc(EngFunc_SetOrigin,g_challenger,g_vKnifeOrigin[1]);
        
        fm_entity_set_aim(g_challenged,g_challenger,0);
        fm_entity_set_aim(g_challenger,g_challenged,0);
        
        if(get_pcvar_num(g_Pcvar[CVAR_RESET]))
        {
                set_pev(g_challenged,pev_health,100.0);
                set_pev(g_challenger,pev_health,100.0);
        }
}
 
public event_holdwpn(id) {
        if (!g_knifeArena || !is_user_alive(id))
                return PLUGIN_CONTINUE
 
        new weaponType = read_data(2)
 
        for (new i = 0; i < ALLOWED_WEAPONS; i++) {
                if (weaponType == g_allowedWeapons[i])
                        return PLUGIN_CONTINUE
        }
 
        engclient_cmd(id, "weapon_knife")
 
        return PLUGIN_CONTINUE
}
 
public event_roundend() {
        if (g_challenging || g_knifeArena)
                CancelAll()
        g_noChallengingForAWhile = true
        set_task(4.0, "NoChallengingForAWhileToFalse")
 
        return PLUGIN_CONTINUE
}
 
public NoChallengingForAWhileToFalse() {
        g_noChallengingForAWhile = false
}
 
CancelAll() {
        if (g_challenging) {
                g_challenging = false
                // Close menu of challenged
                if (is_user_connected(g_challenged)) {
                        new usermenu, userkeys
                        get_user_menu(g_challenged, usermenu, userkeys) // get user menu
 
                        // Hmm this ain't working :-/
                        if (usermenu == g_challengemenu) // Close it!
                                show_menu(g_challenged, 0, "blabla") // show empty menu
                }
        }
        if (g_knifeArena) {
                g_knifeArena = false
        }
        remove_task(TASKID_BOTTHINK)
        remove_task(TASKID_CHALLENGING)
}
 
public event_death() {
        if (g_challenging || g_knifeArena)
                CancelAll()
 
        return PLUGIN_CONTINUE
}
 
#if defined DEBUG
public challengefn(id, level, cid) {
        if (!cmd_access(id, level, cid, 3))
                return PLUGIN_HANDLED
 
        new challenger[64], challenged[64]
        read_argv(1, challenger, 63)
        read_argv(2, challenged, 63)
 
        console_print(id, "challenger: %s, challenged: %s", challenger, challenged)
 
        new r = str_to_num(challenger)
        new d = str_to_num(challenged)
        Challenge(r, d)
        if (is_user_bot(d))
                Accept()
 
        return PLUGIN_HANDLED
}
#endif // defined DEBUG
 
public plugin_init() {
        register_plugin(PLUGINNAME, VERSION, AUTHOR)
        register_event("CurWeapon", "event_holdwpn", "be", "1=1")
        register_forward(FM_EmitSound, "forward_emitsound")
        g_MAXPLAYERS = get_maxplayers()
 
        g_challengemenu = register_menuid("JGHG's automatic knife duel"/*"You are challenged"*/)
        register_menucmd(g_challengemenu, MENU_KEY_1 | MENU_KEY_2, "challenged_menu")
 
        register_event("DeathMsg", "event_death", "a")
        register_event("SendAudio", "event_roundend", "a", "2&%!MRAD_terwin")
        register_event("SendAudio", "event_roundend", "a", "2&%!MRAD_ctwin")
        register_event("SendAudio", "event_roundend", "a", "2&%!MRAD_rounddraw")
        unregister_forward(FM_Spawn,g_iFwdSpawn,1);
        g_Pcvar[CVAR_COUNT] = register_cvar("kd_knifecount","3");
        g_Pcvar[CVAR_TIMER] = register_cvar("kd_preparetime","3");
        g_Pcvar[CVAR_MAXDISTANCE] = register_cvar("kd_maxdistance","550");
        g_Pcvar[CVAR_ANNOUNCE] = register_cvar("kd_announce","1");
        g_Pcvar[CVAR_RESET] = register_cvar("kd_resethp","1");
        g_iMaxPlayers = get_maxplayers();
        
        #if defined DEBUG
        register_clcmd("0challenge", "challengefn", ADMIN_CFG, "<challenger> <challenged> - start knife duel challenge")
        #endif // defined DEBUG
 
        new Float:maptime = get_cvar_float("mp_timelimit")
        if (maptime == 0.0)
                maptime = 15.0
 
        new Float:anntime = 60.0 * 5.0 // 5 minutes
        if (maptime < 5.0)
                anntime = maptime / 3.0
 
        set_task(anntime, "Announcement", 0, "", 0, "b")
}
 
stock fm_entity_set_aim(id,ent,bone = 0)
{
        if(!is_user_connected(id) || !pev_valid(ent))
        return 0;
        
        new Float:vOrigin[3];
        pev(ent,pev_origin,vOrigin);
        
        new Float:vEntOrigin[3],Float:vAngles[3];
        
        if(bone)
                engfunc(EngFunc_GetBonePosition,id,bone,vEntOrigin,vAngles);
        else
                pev(id,pev_origin,vEntOrigin);
        
        vOrigin[0] -= vEntOrigin[0];
        vOrigin[1] -= vEntOrigin[1];
        vOrigin[2] -= vEntOrigin[2];
        
        new Float:v_length;
        v_length = vector_length(vOrigin);
        
        new Float:vAimVector[3];
        vAimVector[0] = vOrigin[0] / v_length;
        vAimVector[1] = vOrigin[1] / v_length;
        vAimVector[2] = vOrigin[2] / v_length;
        
        new Float:vNewAngles[3];
        vector_to_angle(vAimVector,vNewAngles);
        
        vNewAngles[0] *= -1;
        
        if(vNewAngles[1] > 180.0) vNewAngles[1] -= 360;
        if(vNewAngles[1] < -180.0) vNewAngles[1] += 360;
        if(vNewAngles[1] == 180.0 || vNewAngles[1] == -180.0) vNewAngles[1] = -179.9;
        
        set_pev(id,pev_angles,vNewAngles);
        set_pev(id,pev_fixangle,1);
        
        return 1;
}
 
stock vec_null(Float:vec[3])
{
        if(!vec[0] && !vec[1] && !vec[2])
 
        return 1;
        return 0;
}
 
stock bool:check_players()
{
        new iNum[2];
        for(new i = 1 ; i <= g_iMaxPlayers ; i++)
        {
                if(!is_user_alive(i))
                        continue;
                
                if(get_user_team(i) == 1)
                        ++iNum[0];
                else if(get_user_team(i) == 2)
                        ++iNum[1];
        }
        if((iNum[0] == 1) && (iNum[1] == 1))
                return true;
        
        return false;
}
 
stock get_opponent(team)
{
        for(new i = 0 ; i <= g_iMaxPlayers ; i++)
        {
                if(!is_user_alive(i))
                        continue;
                
                if(get_user_team(i) == team)
                        return i;
        }
        return 0;
}
 
stock fm_get_speed_vector2(ent1,ent2,Float:speed,Float:new_velocity[3])
{
        if(!pev_valid(ent1) || !pev_valid(ent2))
        return 0;
        
        static Float:vOrigin1[3];
        pev(ent1,pev_origin,vOrigin1);
        static Float:vOrigin2[3];
        pev(ent2,pev_origin,vOrigin2);
        
        new_velocity[0] = vOrigin2[0] - vOrigin1[0];
        new_velocity[1] = vOrigin2[1] - vOrigin1[1];
        new_velocity[2] = vOrigin2[2] - vOrigin1[2];
        new Float:fNum = floatsqroot(speed * speed / (new_velocity[0] * new_velocity[0] + new_velocity[1] * new_velocity[1] + new_velocity[2] * new_velocity[2]));
        new_velocity[0] *= fNum;
        new_velocity[1] *= fNum;
        new_velocity[2] *= fNum;
 
        return 1;
}
 
stock Float:fm_get_entity_distance(ent1,ent2)
{
        if(!pev_valid(ent1) || !pev_valid(ent2))
        return 0.0;
        
        static Float:vOrigin1[3];
        pev(ent1,pev_origin,vOrigin1);
        static Float:vOrigin2[3];
        pev(ent2,pev_origin,vOrigin2);
        
        return vector_distance(vOrigin1,vOrigin2);
}