ScorpionBoss

Место свободно

Здесь вы сможете купить рекламу на данном форуме

Стоимость за 1 день 12 ₽

: ScorpionBoss.zip
3.95 MБ; Другие ресурсы пользователя Host-v

Metamod-r
Metamod-r основан на оригинальном метамоде от Will Day для Half-Life 1 с некоторыми улучшениями Jussi Kivilinna. Он содержит огромное количество оптимизаций производительности и намного более чистый к

AMX Mod X 1.9.0
Первые разработчики

Custom Player Models
Требования:

Reapi
Требования ReHLDS, ReGameDLL_CS,

CS-Bans
Требования PHP версии 5.3 и выше Расширения PHP: PDO, PDO-mysql, mbstring и gd Функции PHP: chmod, mkdir, copy Включенный mod_rewrite MySQL версии 5.0 и выше CS:Bans - веб часть для плагина AmxBans и

ДобавилHost-v • 15 фев 2024, 08:59
АвторAlexander.3
Версия1.0.1
Статистика 14232 просмотра • 2 комментария • 32 скачивания

Требования:
AMX Mod X 1.9.0

Описание:
Плагин позволяет в определенное время вызвать Scorpion Босса

Видео

PS:
Дополнительный плагин который позволяет получать бонусы от плагина Army Ranks Ultimate За победу над босом можно найти здесь Boss Bonus

Scorpionboss

Исходный код

zl_boss_scorpion.sma

Код: [Выделить всё] [Развернуть/Свернуть]

#include < zl_scorpion >
 
#define NAME    "ScorpionBoss"
#define AUTHOR  "Alexander.3"
 
#define PLAYER_HP
 
#define STORM   5
#define NUM_TENTACLE    9
#define OFFSET_TENTACLE 150.0
 
static g_Resource[][] = {
    "models/zl/npc/scorpion/zl_scorpion_f.mdl",
    "models/zl/npc/scorpion/zl_tornado.mdl",
    "sprites/zl/npc/scorpion/zl_healthbar.spr",
    "models/zl/npc/scorpion/zl_swing.mdl", // 3
    "models/zl/npc/scorpion/zl_tentacle.mdl",
    "models/zl/npc/scorpion/zl_hole.mdl",
    "sprites/laserbeam.spr",                // 6
    "sprites/zl/npc/scorpion/zl_focus.spr",
    "sprites/zl/npc/scorpion/zl_healing.spr",   
    "models/zl/npc/scorpion/zl_tentacle_sign.mdl",      // 9
    "models/zl/npc/scorpion/zl_tentacle2.mdl"       // 10
    
    
}
 
new const g_SoundList[][] = {
    "zl/npc/scorpion/appear.wav",
    "zl/npc/scorpion/attack1.wav",
    "zl/npc/scorpion/attack2.wav",
    "zl/npc/scorpion/attack3.wav",      // 3
    "zl/npc/scorpion/dash_end.wav",     // 4
    "zl/npc/scorpion/dash_start.wav",       // 5
    "zl/npc/scorpion/death.wav",
    "zl/npc/scorpion/guard_start.wav",      // 7
    "zl/npc/scorpion/guard_loop.wav",
    "zl/npc/scorpion/guard_end.wav",
    "zl/npc/scorpion/idle.wav",     // 10
    "zl/npc/scorpion/step1.wav",
    "zl/npc/scorpion/step2.wav",
    "zl/npc/scorpion/storm_down.wav",
    "zl/npc/scorpion/storm_down2.wav",  // 14
    "zl/npc/scorpion/storm_prepare.wav",
    "zl/npc/scorpion/storm_end.wav",
    "zl/npc/scorpion/tentacle1.wav",
    "zl/npc/scorpion/tentacle2.wav",
    "zl/npc/scorpion/tentacle3.wav",    
    "zl/npc/scorpion/sandstorm.wav",        // 20
    "zl/npc/scorpion/windstorm.wav"
}
 
enum {
    IDLE,
    RUN,
    ATTACK,
    TENTACLE,
    DASH,
    DOWN0,
    DOWN1,
    TENTACLE2,
    REGENERATION
}
 
static g_Scorpion, g_Ability, g_Tentacle[NUM_TENTACLE]
static i_Resource[sizeof g_Resource], g_MaxPlayer
static e_storm_start[STORM + 1], e_storm_end[STORM + 1]
static e_down[3] // 0 - First, 1 - Phase2, 2 - Two
static Float:g_Damage, g_Phase = 0, Float:g_LiderDamage[33]
static zl_cvar[5], Float:zl_fcvar[2]
 
 
public plugin_init() {
    register_plugin(NAME, VERSION, AUTHOR)
    
    if (zl_boss_map() != 7) {
        pause("ad")
        return
    }
    
    map_load()
    
    register_think("scorpion_storm", "think_storm")
    register_think("scorpion_swing", "think_swing")
    register_think("scorpion_tornado", "think_tornado")
    register_think("scorpion_hole", "think_hole")
    register_think("scorpion_tentacle", "think_tentacle")
    register_think("scorpion_regeneration", "think_regeneration")
    register_think("scorpion_hpbar", "think_healthbar")
    register_think("boss_scorpion", "think_boss")   
    
    register_touch("boss_scorpion", "player", "touch_boss")
    
    RegisterHam(Ham_TakeDamage, "info_target", "Hook_Damage", 0)
    
    g_MaxPlayer = get_maxplayers()
}
 
public think_boss( boss ) {
    if (pev(boss, pev_deadflag) == DEAD_DYING) {
        return
    }
    
    if (zl_player_alive() < 1) {
        zl_anim(boss, 1, 1.0)
        set_pev(boss, pev_movetype, MOVETYPE_NONE)
        set_pev(boss, pev_nextthink, get_gametime() + 0.1)
        return
    }
    static Float:timer
    if (timer <= get_gametime() && pev(boss, pev_sequence) == 4 && g_Ability == RUN) {
        timer = get_gametime() + zl_fcvar[0]
        if (g_Phase < 5)
            g_Ability = TENTACLE
        else {
            switch(random(3)) {
                case 0: g_Ability = TENTACLE
                case 1: g_Ability = TENTACLE2
                case 2: g_Ability = DOWN0
            }
        }
    }
    
    switch(g_Ability) {
        case IDLE: zl_anim(boss, 2, 1.0)
        case RUN: {
            static victim
            
            if (!is_user_alive(victim)) {
                victim = zl_player_choose(boss, 0)
            }
            
            if (pev(boss, pev_sequence) != 4) {
                set_pev(boss, pev_movetype, MOVETYPE_PUSHSTEP)
                zl_anim(boss, 4, 1.0)
            }
            
            static Float:velocity[3], Float:angle[3]
            zl_move(boss, victim, float(zl_cvar[1]), velocity, angle)
            set_pev(boss, pev_velocity, velocity)
            set_pev(boss, pev_angles, angle)
            set_pev(boss, pev_nextthink, get_gametime() + 0.1)
        }
        case ATTACK: {
            set_pev(boss, pev_movetype, MOVETYPE_NONE)
            
            static rnd, victim
            
            if (!rnd) {
                rnd = random_num(1, 3)
                victim = pev(boss, pev_victim)
            }
            
            switch(rnd) {
                case 1: {
                    static num
                    switch(num) {
                        case 0: {
                            zl_anim(boss, 5, 1.0)
                            set_pev(boss, pev_nextthink, get_gametime() + 1.0)
                            num++
                        }
                        case 1: {
                            set_pev(boss, pev_nextthink, get_gametime() + 1.0)
                            
                            if (is_user_alive(victim)) {
                                if (entity_range(victim, boss) < 290)
                                    ExecuteHamB(Ham_Killed, victim, victim, 2)
                            }
                                
                            g_Ability = 1
                            num = 0
                            rnd = 0
                        }
                    }
                }
                case 2: {
                    static num
                    switch(num) {
                        case 0: {
                            zl_anim(boss, 6, 1.0)
                            set_pev(boss, pev_nextthink, get_gametime() + 1.3)
                            num++
                        }
                        case 1: {
                            set_pev(boss, pev_nextthink, get_gametime() + 1.0)
                            
                            if (is_user_alive(victim)) {
                                if (entity_range(victim, boss) < 320) {
                                    new i
                                    for (i = 1; i <= g_MaxPlayer; ++i) {
                                        if (i == victim)
                                            continue
                                            
                                        if (!is_user_alive(i))
                                            continue
                                            
                                        if( entity_range(victim, i) > 200)
                                            continue
                                            
                                        zl_slap(i, 1000, zl_cvar[2], 0)
                                        zl_screenfade(i, 1, 1, {50, 0, 0}, 50, 1)
                                        zl_screenshake(i, 15, 3)
                                    }
                                    ExecuteHamB(Ham_Killed, victim, victim, 2)
                                }
                            }
                            g_Ability = 1
                            num = 0
                            rnd = 0
                        }
                    }
                }
                case 3: {
                    static num
                    switch(num) {
                        case 0: {
                            zl_anim(boss, 7, 1.0)
                            set_pev(boss, pev_nextthink, get_gametime() + 1.6)
                            num++
                        }
                        case 1: {
                            set_pev(boss, pev_nextthink, get_gametime() + 3.0)
                            
                            new Float:origin[3]
                            pev(boss, pev_origin, origin)
                            origin[2] -= 33.0
                            
                            new swing = create_entity("info_target")
                            engfunc(EngFunc_SetModel, swing, g_Resource[3])                         
                            engfunc(EngFunc_SetOrigin, swing, origin)
                            set_rendering(swing, kRenderFxNone, 0, 0, 0, kRenderTransAdd, 255)
                            set_pev(swing, pev_classname, "scorpion_swing")
                            set_pev(swing, pev_nextthink, get_gametime() + 0.1)
                            zl_anim(swing, 0, 1.0)
                            
                            new i
                            for(i = 1; i<=g_MaxPlayer; ++i) {
                                if (!is_user_alive(i))
                                    continue
 
                                if (entity_range(i, boss) < 465) {
                                    zl_slap(i, 1000, zl_cvar[2], 0)
                                    zl_screenfade(i, 1, 1, {50, 0, 0}, 50, 1)
                                    zl_screenshake(i, 15, 3)
                                }
                            }   
                            g_Ability = 1
                            num = 0
                            rnd = 0
                        }
                    }
                }
            }
            
        }
        case TENTACLE: {
            static Float:origin[NUM_TENTACLE][3]
            static num
            
            switch(num) {
                case 0: {
                    set_pev(boss, pev_movetype, MOVETYPE_NONE)
                    set_pev(boss, pev_nextthink, get_gametime() + 0.1)
                    zl_anim(boss, 2, 1.0)                   
                    new i, s, TentaclePlayer[32]
                    for(i = 1; i<=g_MaxPlayer; ++i) {
                        if (!is_user_alive(i))
                            continue
                            
                        if (entity_range(i, boss) < 630) {
                            TentaclePlayer[s] = i
                            s++
                        }
                    }
                    if (s == 0) {
                        set_pev(boss, pev_victim, 0)
                        set_pev(boss, pev_nextthink, get_gametime() + 0.1)
                        g_Ability = DASH
                        return
                    }
                    
                    /* set origin victim */
                    new Float:origin_victim[3], Float:origin_boss[3], Float:vector[3]
                    
                    new victim = TentaclePlayer[((s == 1) ? 0 : (random(s)))]
                                        
                    pev(victim, pev_origin, origin_victim)
                    pev(boss, pev_origin, origin_boss)
                    xs_vec_sub(origin_victim, origin_boss, vector)
                    vector_to_angle(vector, vector)
                    set_pev(boss, pev_angles, vector)
                                        
                    for(i = 0; i < NUM_TENTACLE; ++i)
                        origin[i][2] = origin_victim[2] - 35.0
                    
                    origin[0][0] = origin_victim[0]
                    origin[0][1] = origin_victim[1]
                    
                    origin[1][0] = origin_victim[0] + OFFSET_TENTACLE
                    origin[1][1] = origin_victim[1] - OFFSET_TENTACLE
                    
                    origin[2][0] = origin_victim[0] - OFFSET_TENTACLE
                    origin[2][1] = origin_victim[1]
                    
                    origin[3][0] = origin_victim[0] 
                    origin[3][1] = origin_victim[1] - OFFSET_TENTACLE
                    
                    origin[4][0] = origin_victim[0] + OFFSET_TENTACLE
                    origin[4][1] = origin_victim[1]
                    
                    origin[5][0] = origin_victim[0] + OFFSET_TENTACLE
                    origin[5][1] = origin_victim[1] + OFFSET_TENTACLE
                    
                    origin[6][0] = origin_victim[0]
                    origin[6][1] = origin_victim[1] + OFFSET_TENTACLE
                    
                    origin[7][0] = origin_victim[0] - OFFSET_TENTACLE
                    origin[7][1] = origin_victim[1] + OFFSET_TENTACLE
                        
                    origin[8][0] = origin_victim[0] - OFFSET_TENTACLE
                    origin[8][1] = origin_victim[1] - OFFSET_TENTACLE
                    
                    num++
                }
                case 1: {
                    set_pev(boss, pev_nextthink, get_gametime() + 2.3)
                    zl_anim(boss, 8, 2.5)
                    zl_sound(0, g_SoundList[17], 0)
                    num++
                }
                case 2: {                   
                    new i
                    for (i = 0; i<NUM_TENTACLE; ++i) {
                        g_Tentacle[i] = create_entity("info_target")
                        engfunc(EngFunc_SetModel, g_Tentacle[i], g_Resource[4])
                        engfunc(EngFunc_SetOrigin, g_Tentacle[i], origin[i])
                        set_pev(g_Tentacle[i], pev_classname, "scorpion_tentacle")
                        zl_anim(g_Tentacle[i], 0, 1.0)
                    }
                    
                    new victim, player[32], count
                    
                    for(i = 1; i <= g_MaxPlayer; ++i) {
                        if(!is_user_alive(i))
                            continue
                            
                        if (entity_range(g_Tentacle[0], i) > 220)
                            continue
                        
                        set_rendering(i, kRenderFxGlowShell, 0, 0, 255, kRenderNormal, 50)
                        if(~pev(i, pev_flags) & FL_FROZEN) set_pev(i, pev_flags, pev(i, pev_flags) | FL_FROZEN)
                        player[count] = i
                        count++
                    }
                    
                    //clear
                    num = 0
                    set_pev(boss, pev_nextthink, get_gametime() + 2.0)
                    g_Ability = DASH
                    
                    if (count == 0) {
                        victim = zl_player_choose(boss, ZL_CHOOSE_RANDOM)
                        set_pev(boss, pev_victim, victim)
                        return
                    }
                    
                    victim = player[((count == 1) ? 0 : (random(count)))]
                    set_pev(boss, pev_victim, victim)
                }
            }
        }
        case DASH: {
            static num, Float:origin_end[3]
            switch(num) {
                case 0: {
                    new victim = pev(boss, pev_victim)
                    set_pev(boss, pev_nextthink, get_gametime() + 1.5)
                    set_pev(boss, pev_movetype, MOVETYPE_NONE)
                    zl_anim(boss, 17, 1.0)
                    num++
                    
                    if (!is_user_alive(victim))
                        victim = zl_player_choose(boss, ZL_CHOOSE_MAX)
                    
                    new Float:origin_start[3], Float:vector[3], Float:angle[3]
                    pev(boss, pev_origin, origin_start)
                    pev(victim, pev_origin, origin_end)
                    origin_end[2] = origin_start[2]
                    xs_vec_sub(origin_end, origin_start, vector)
                    vector_to_angle(vector, angle)
                    set_pev(boss, pev_angles, angle)
                }
                case 1: {
                    static Float:origin_boss[3], Float:vector[3], Float:len
                    pev(boss, pev_origin, origin_boss)
                    xs_vec_sub(origin_end, origin_boss, vector)
                    len = xs_vec_len(vector)
                    xs_vec_normalize(vector, vector)
                    xs_vec_mul_scalar(vector, 1500.0, vector)
                                        
                    if(pev(boss, pev_sequence) != 18) {
                        set_pev(boss, pev_movetype, MOVETYPE_FLY)
                        zl_anim(boss, 18, 1.0)
                    }
                    
                    if(len <= 100) {
                        static e
                        while ((e = engfunc(EngFunc_FindEntityByString, e, "classname", "scorpion_tentacle"))) {
                            if(pev_valid(e)) {
                                engfunc(EngFunc_RemoveEntity, e)
                            }
                        }
                        
                        new i
                        for(i=1; i<=g_MaxPlayer; ++i) {
                            if(!is_user_alive(i))
                                continue
                                
                            if(pev(i, pev_flags) & FL_FROZEN) {
                                set_rendering(i)
                                set_pev(i, pev_flags, pev(i, pev_flags) & ~FL_FROZEN)
                            }
                        }
                        
                        set_pev(boss, pev_nextthink, get_gametime() + 1.6)
                        set_pev(boss, pev_movetype, MOVETYPE_NONE)
                        zl_anim(boss, 19, 1.0)
                        g_Ability = RUN
                        num = 0
                        return
                    }
                    set_pev(boss, pev_nextthink, get_gametime() + 0.1)
                    set_pev(boss, pev_velocity, vector)
                }
            }
        }
        case DOWN0: { // FirstDown
            static num
            switch(num) {
                case 0: {
                    if (pev(boss, pev_movetype) != MOVETYPE_FLY)
                        set_pev(boss, pev_movetype, MOVETYPE_FLY)
                        
                    if (pev(boss, pev_sequence) != 4)
                        zl_anim(boss, 4, 1.0)
                    
                    static len, Float:velocity[3], Float:angle[3], Float:origin[3]
                    static rnd
                    if (rnd == 0) {
                        rnd = (random(2) ? e_down[0] : e_down[2])
                    }
                    len = zl_move(boss, rnd, float(zl_cvar[1]), velocity, angle)
                    set_pev(boss, pev_angles, angle)
                    set_pev(boss, pev_velocity, velocity)
                    
                    if(len < 70) {
                        pev(boss, pev_origin, origin)
                        new hole = create_entity("info_target")
                        origin[2] -= 30.0
                        engfunc(EngFunc_SetOrigin, hole, origin)
                        engfunc(EngFunc_SetModel, hole, g_Resource[5])
                        set_pev(boss, pev_solid, SOLID_NOT)
                        set_pev(boss, pev_nextthink, get_gametime() + 8.0)
                        set_pev(hole, pev_nextthink, get_gametime() + 0.1)
                        set_pev(hole, pev_classname, "scorpion_hole")
                        zl_anim(boss, 10, 3.0)
                        zl_anim(hole, 0, 0.2)
                        zl_sound(0, g_SoundList[13], 0)
                        num++
                        rnd = 0
                        return
                    }
                    set_pev(boss, pev_nextthink, get_gametime() + 0.1)
                }
                case 1: {
                    new Float:origin[3]
                    pev(e_down[random(3)], pev_origin, origin)
                    engfunc(EngFunc_SetOrigin, boss, origin)
                    set_pev(boss, pev_solid, SOLID_BBOX)
                    set_pev(boss, pev_nextthink, get_gametime() + 6.2)
                    zl_anim(boss, 12, 1.0)
                    g_Ability = RUN
                    num = 0
                }
            }
        }
        case DOWN1: { // Storm
            static num
            switch (num) {
                case 0: {
                    if (pev(boss, pev_movetype) != MOVETYPE_FLY)
                        set_pev(boss, pev_movetype, MOVETYPE_FLY)
                        
                    if (pev(boss, pev_sequence) != 4)
                        zl_anim(boss, 4, 1.0)
                    
                    static len, Float:velocity[3], Float:angle[3]
                    len = zl_move(boss, e_down[1], float(zl_cvar[1]), velocity, angle)
                    set_pev(boss, pev_angles, angle)
                    set_pev(boss, pev_velocity, velocity)
                    
                    if(len < 70) {
                        set_pev(boss, pev_solid, SOLID_NOT)
                        set_pev(boss, pev_nextthink, get_gametime() + 3.0)
                        zl_anim(boss, 11, 3.0)
                        zl_sound(0, g_SoundList[14], 0)
                        num++
                        return
                    }
                    set_pev(boss, pev_nextthink, get_gametime() + 0.1)
                }
                case 1: {
                    new i, j, b, a[STORM]
                    for(i = 0; i < sizeof a; i++)
                        a[i] = i
                            
                    for(i = 0; i < sizeof a; i++) {
                        j = random(sizeof a - 1)
                        b = a[i]
                        a[i] = a[j]
                        a[j] = b
                    }
                    
                    new s = 0
                    
                    static stage
                    switch(g_Phase) {
                        case 6: stage = 2
                        case 7: stage = 3
                        case 8: stage = 4
                        case 9: stage = 5
                    }
                    
                    for (s = 0; s < stage; ++s) {       
                        new storm = create_entity("info_target")
                                                
                        new Float:origin[3], Float:origin2[3], Float:vector[3]
                        new random_storm = 0
                        if(g_Ability == 9) random_storm = random(2)
                        
                        if (random_storm == 0) {
                            pev(e_storm_start[a[s]], pev_origin, origin)
                            pev(e_storm_end[a[s]], pev_origin, origin2)
                        } else {
                            pev(e_storm_end[a[s]], pev_origin, origin)
                            pev(e_storm_start[a[s]], pev_origin, origin2)
                        }
                        
                        engfunc(EngFunc_SetOrigin, storm, origin)
                        engfunc(EngFunc_SetModel, storm, g_Resource[1])
                        set_pev(storm, pev_classname, "scorpion_storm")
                        set_pev(storm, pev_nextthink, get_gametime() + 0.1)
                        set_pev(storm, pev_solid, SOLID_NOT)
                        set_pev(storm, pev_movetype, MOVETYPE_NOCLIP)
                        
                        xs_vec_sub(origin2, origin, vector)
                        xs_vec_normalize(vector, vector)
                        xs_vec_mul_scalar(vector, 500.0, vector)
                        set_pev(storm, pev_velocity, vector)
                        
                        zl_anim(storm, 0, 1.0)
                    }
                    zl_sound(0, g_SoundList[21], 0)
                    set_pev(boss, pev_nextthink, get_gametime() + 7.0)
                    num++
                    
                }
                case 2: {
                    static e
                    while ((e = engfunc(EngFunc_FindEntityByString, e, "classname", "scorpion_storm"))) {
                        if(pev_valid(e)) {
                            engfunc(EngFunc_RemoveEntity, e)
                        }
                    }
                    new Float:origin[3]
                    pev(e_down[random(3)], pev_origin, origin)
                    engfunc(EngFunc_SetOrigin, boss, origin)
                    set_pev(boss, pev_solid, SOLID_BBOX)
                    set_pev(boss, pev_nextthink, get_gametime() + 6.2)
                    zl_anim(boss, 12, 1.0)
                    g_Ability = RUN
                    num = 0
                    
                }
            }
        }
        case TENTACLE2: { // Tentacle
            static num
            switch(num) {
                case 0: {
                    set_pev(boss, pev_nextthink, get_gametime() + 3.0)
                    set_pev(boss, pev_movetype, MOVETYPE_NONE)
                    zl_anim(boss, 9, 1.0)
                    num++
                }
                case 1: {
                    new i, Float:origin[3], Float:end_origin[3]
                    for(i = 1; i<=g_MaxPlayer; ++i) {
                        if(!is_user_alive(i))
                            continue
                            
                        pev(i, pev_origin, origin)
                        
                        /* vector create */
                        origin[2] = origin[2] + 300.0
                        end_origin[0] = origin[0]
                        end_origin[1] = origin[1]
                        end_origin[2] = origin[2] - 600.0
                                    
                        new tr
                        engfunc(EngFunc_TraceLine, origin, end_origin, IGNORE_MONSTERS, -1, tr)
                        get_tr2(tr, TR_vecEndPos, end_origin)
                        end_origin[2] += 1.0
                        /* end vector create */
                                
                        new ts = create_entity("info_target")
                        engfunc(EngFunc_SetModel, ts, g_Resource[9])
                        engfunc(EngFunc_SetOrigin, ts, end_origin)
                        set_pev(ts, pev_classname, "scorpion_tentacle")
                    }
                    num++
                    set_pev(boss, pev_nextthink, get_gametime() + 3.0)
                    zl_sound(0, g_SoundList[19], 0)
                }
                case 2: {
                    static e
                    while ((e = engfunc(EngFunc_FindEntityByString, e, "classname", "scorpion_tentacle"))) {
                        if(pev_valid(e)) {
                            engfunc(EngFunc_SetModel, e, g_Resource[10])
                            zl_anim(e, 0, 0.8)
                            set_pev(e, pev_nextthink, get_gametime() + 0.1)
                        }
                    }
                    zl_sound(0, g_SoundList[18], 0)
                    set_pev(boss, pev_nextthink, get_gametime() + 1.3)
                    num++
                }
                case 3: {
                    static e
                    while ((e = engfunc(EngFunc_FindEntityByString, e, "classname", "scorpion_tentacle"))) {
                        if(pev_valid(e)) {
                            engfunc(EngFunc_RemoveEntity, e)
                        }
                    }
                    num = 0
                    g_Ability = RUN
                    set_pev(boss, pev_nextthink, get_gametime() + 1.0)
                }
            }
            
        }
        case REGENERATION: {
            static num, victim
            switch(num) {
                case 0: {
                    if (pev(boss, pev_sequence) != 2) {
                        set_pev(boss, pev_movetype, MOVETYPE_NONE)
                        zl_anim(boss, 2, 1.0)
                    }
                                        
                    new Float:dmg_buff, i = 1
                    for (i = 1; i <= g_MaxPlayer; ++i) {
                        if (!is_user_alive(i)) continue
                                
                        if (g_LiderDamage[i] > dmg_buff) {
                            dmg_buff = g_LiderDamage[i]
                            victim = i
                        }
                    }
                    
                    set_pev(boss, pev_victim, victim)
                    new Float:angle[3]
                    zl_move(boss, victim, _, _, angle)
                    set_pev(boss, pev_angles, angle)
                    
                    set_pev(boss, pev_nextthink, get_gametime() + 2.1)
                    zl_laser(boss | 0x3000, victim, {0, 255, 0}, 15, 0)
                    set_rendering(victim, kRenderFxGlowShell, 0, 255, 0, kRenderNormal, 50)
                    
                    new name[32]
                    get_user_name(victim, name, charsmax(name))
                    zl_colorchat(0, "!n[!gScorpion!n] Aggressor focused in !g%s", name)
                    zl_colorchat(victim, "!n[!gScorpion!n] !gYou !nfocused, please in laser")
                    
                    num++
                }
                case 1: {
                    new Float:angle[3]
                    pev(boss, pev_angles, angle)
                    angle[1] = random_float(-180.0, 180.0)
                    set_pev(boss, pev_angles, angle)
                    set_pev(boss, pev_nextthink, get_gametime() + 4.0)
                    zl_anim(boss, 13, 1.0)
                    num++
                }
                case 2: {
                    g_Damage = 0.0
                    zl_anim(boss, 14, 1.0)
                    
                    new Float:angle[3], Float:origin[3]
                    pev(boss, pev_angles, angle)
                    pev(boss, pev_origin, origin)
                    angle_vector(angle, ANGLEVECTOR_FORWARD, angle)
                    origin[0] = origin[0] + angle[0] * 400.0
                    origin[1] = origin[1] + angle[1] * 400.0
                    origin[2] -= 32.0
                    
                    new buff_ent = create_entity("info_target")
                    engfunc(EngFunc_SetOrigin, buff_ent, origin)
                    engfunc(EngFunc_SetModel, buff_ent, g_Resource[7])
                    set_pev(buff_ent, pev_classname, "scorpion_regeneration")
                    set_pev(buff_ent, pev_nextthink, get_gametime() + 0.1)
                    set_pev(boss, pev_nextthink, get_gametime() + 8.0)
                    set_pev(buff_ent, pev_angles, {90.0, 0.0, 0.0})
                    
                    zl_laser(boss | 0x3000, buff_ent, {255, 0, 0}, 80, 50)
                    num++
                }
                case 3: {
                    if (pev(boss, pev_sequence) == 16) {
                        set_pev(boss, pev_nextthink, get_gametime() + 1.9)
                        set_pev(boss, pev_victim, 0)
                        set_rendering(victim)
                        g_Ability = RUN
                        num = 0
                        victim = 0
                        return
                    }
                    zl_anim(boss, 15, 1.0)
                    set_pev(boss, pev_nextthink, get_gametime() + 2.0)
                    set_rendering(victim)
                    set_pev(boss, pev_victim, 0)
                    victim = 0
                    num++
                }
                case 4: {
                    new Float:origin[3]
                    pev(boss, pev_origin, origin)
                    
                    message_begin(MSG_BROADCAST,SVC_TEMPENTITY) 
                    write_byte(TE_SPRITE)
                    engfunc(EngFunc_WriteCoord, origin[0]) // x
                    engfunc(EngFunc_WriteCoord, origin[1]) // y
                    engfunc(EngFunc_WriteCoord, origin[2] + 50.0) // z
                    write_short(i_Resource[8]) // sprite index
                    write_byte(50) // scale in 0.1's
                    write_byte(200) // brightness
                    message_end()
                                        
                    zl_anim(boss, 2, 1.0)
                    num++
                    
                    set_pev(boss, pev_nextthink, get_gametime() + 0.1)
                }
                case 5..22: {
                    static Float:hp_max, Float:base_regen
                    static Float:hp, pre
                    pev(boss, pev_max_health, hp_max)
                    pev(boss, pev_health, hp)
                    
                    if (pre == 0) {
                        g_Damage = g_Damage * zl_fcvar[1]
                        g_Damage = g_Damage / 17.0
                        //base_regen = hp_max / 10.0
                        
                        set_pev(boss, pev_health, hp+base_regen)                        
                        pre = 1 
                        
                        /* Update information for bugfixed */
                        pev(boss, pev_health, hp)
                        pev(boss, pev_max_health, hp_max)
                    }
                    
                    if (hp <= hp_max) set_pev(boss, pev_health, hp+g_Damage)
 
                    set_pev(boss, pev_nextthink, get_gametime() + 0.1)
                    
                    if(num == 22) {
                        new Float:procent
                        procent = (g_Damage * 17.0) * 100.0 / hp_max
                        zl_colorchat(0, "!n[!gScorpion!n] Boss healing !g%d%%", floatround(procent))
                        pre = 0
                    }
                    
                    num++
                }
                case 23: {
                    g_Ability = RUN
                    set_pev(boss, pev_nextthink, get_gametime() + 0.1)
                    num = 0
                }
            }
        }
    }
}
 
public Hook_Damage(boss, w, player, Float:dmg, dt) {    
    if (!zl_boss_valid( boss ))
        return HAM_IGNORED
    
    g_LiderDamage[player] += dmg
    
    if (g_Ability != REGENERATION)
        return HAM_IGNORED
    
    g_Damage += dmg
    return HAM_SUPERCEDE
}
 
public think_regeneration( e ) {
    static num
    switch (num) {
        case 0..80: {
            static victim
            victim = pev(g_Scorpion, pev_victim)
            set_pev(e, pev_nextthink, get_gametime() + 0.1)
            
            if (victim == 0) {
                num = 81
                return
            }
            
            if (entity_range(victim, e) < 40) {
                zl_anim(g_Scorpion, 16, 1.0)
                set_pev(g_Scorpion, pev_nextthink, get_gametime() + 0.1)
                num = 51
                return
            }   
            num++
        }
        case 81: {
            num = 0
            engfunc(EngFunc_RemoveEntity, e)
        }
    }
}
 
public think_hole( hole ) {
    #define TORNADO 8
    #define TORNADO_DEF 15
    #define TORNADO_OFFSET  100.0
    static num
    switch (num) {
        case 0: {
            static i, n, Float:velocity[3]
            for(i = 1; i<=g_MaxPlayer; ++i) {
                if (!is_user_alive(i))
                    continue
                
                zl_move(i, hole, 900.0, velocity)
                set_pev(i, pev_velocity, velocity)
            }
            n++
            
            if(n > 30) {
                set_pev(hole, pev_effects, EF_NODRAW)
                set_pev(hole, pev_nextthink, get_gametime() + 3.0)
                n = 0
                num++
                return
            }
            set_pev(hole, pev_nextthink, get_gametime() + 0.1)
        }
        case 1: {
            new t, Float:origin[3], Float:origin_tornado[TORNADO][3]
            pev(hole, pev_origin, origin)
            
            origin_tornado[0][0] = origin[0] + TORNADO_OFFSET
            origin_tornado[0][1] = origin[1]
            
            origin_tornado[1][0] = origin[0] 
            origin_tornado[1][1] = origin[1] + TORNADO_OFFSET
            
            origin_tornado[2][0] = origin[0] + TORNADO_OFFSET
            origin_tornado[2][1] = origin[1] - TORNADO_OFFSET
            
            origin_tornado[3][0] = origin[0] - TORNADO_OFFSET
            origin_tornado[3][1] = origin[1] + TORNADO_OFFSET
            
            origin_tornado[4][0] = origin[0] + TORNADO_OFFSET
            origin_tornado[4][1] = origin[1] + TORNADO_OFFSET
            
            origin_tornado[5][0] = origin[0] - TORNADO_OFFSET
            origin_tornado[5][1] = origin[1] - TORNADO_OFFSET
            
            origin_tornado[6][0] = origin[0] - TORNADO_OFFSET
            origin_tornado[6][1] = origin[1]
            
            origin_tornado[7][0] = origin[0] 
            origin_tornado[7][1] = origin[1] - TORNADO_OFFSET           
        
            
            for (t = 0; t<TORNADO; ++t){
                origin_tornado[t][2] = origin[2]
                
                new Float:vector[3]
                xs_vec_sub(origin_tornado[t], origin, vector)
                xs_vec_normalize(vector, vector)
                xs_vec_mul_scalar(vector, 1500.0, vector)
                
                new tornado = create_entity("info_target")
                engfunc(EngFunc_SetModel, tornado, g_Resource[1])
                engfunc(EngFunc_SetOrigin, tornado, origin)
                set_pev(tornado, pev_movetype, MOVETYPE_FLY)
                set_pev(tornado, pev_solid, SOLID_NOT)
                set_pev(tornado, pev_velocity, vector)
                set_pev(tornado, pev_classname, "scorpion_tornado")
                set_pev(tornado, pev_nextthink, get_gametime() + 0.1)
                zl_anim(tornado, 0, 1.0)                
            }
            zl_sound(0, g_SoundList[20], 0)
            engfunc(EngFunc_RemoveEntity, hole)
            num = 0
        }
    }
}
 
public think_tornado( t ) {
    static n
    n++
    
    new i 
    for(i = 1; i<=g_MaxPlayer; ++i) {
        if(!is_user_alive(i))
            continue
        
        if (entity_range(i, t) < 260) {
            set_pev(i, pev_velocity, {0.0, 0.0, 900.0}) // Fucking nigga
        }
    }
    
    if (n > 50) {
        n = 0
        static e
        while ( (e = engfunc(EngFunc_FindEntityByString, e, "classname", "scorpion_tornado")) )
            if(pev_valid(e)) engfunc(EngFunc_RemoveEntity, e)
        return
    }
    
    set_pev(t, pev_nextthink, get_gametime() + 0.1)
}
 
public touch_boss(boss, player) {
    if (g_Ability == ATTACK || g_Ability == REGENERATION) return
    if (g_Ability == RUN) { 
        if (pev(boss, pev_sequence) != 4) return
        set_pev(boss, pev_victim, player)
        g_Ability = 2
        return
    }
    
    if (is_user_alive(player)) {
        ExecuteHamB(Ham_Killed, player, player, 2)
        set_rendering(player)
    }
}
 
public think_storm( tornado ) { 
    if (!pev_valid(tornado))
        return
        
    new i
    for(i = 1; i<=g_MaxPlayer; ++i) {
        if(!is_user_alive(i))
            continue
            
        if (entity_range(i, tornado) < 400) {
            zl_damage(i, zl_cvar[3], 0)
            set_pev(i, pev_velocity, {0.0, 0.0, 700.0})
        }
    }
    set_pev(tornado, pev_nextthink, get_gametime() + 0.1)
}
 
public think_tentacle( e ) {
    new i
    for(i = 1; i<=g_MaxPlayer; ++i) {
        if(!is_user_alive(i))
            continue
            
        if (entity_range(i, e) < 60) {
            zl_damage(i, zl_cvar[4], 0)
            set_pev(i, pev_velocity, {0.0, 0.0, 700.0})
        }
    }
}
 
public think_swing( swing ) {
    static a
    if (a <= 0) a = 255
    
    set_rendering(swing, kRenderFxNone, 0, 0, 0, kRenderTransAdd, a)
    
    a = a - 10
    
    if (a <= 0) {
        engfunc(EngFunc_RemoveEntity, swing)
        return
    }
    
    set_pev(swing, pev_nextthink, get_gametime() + 0.1)
}
 
public think_healthbar( e ) {
    if (!pev_valid(e))
        return
        
    if (pev(g_Scorpion, pev_deadflag) == DEAD_DYING) {
        engfunc(EngFunc_RemoveEntity, e)
        return
    }
    static Float:hp_current, Float:hp_maximum, Float:percent
    pev(g_Scorpion, pev_max_health, hp_maximum)
    pev(g_Scorpion, pev_health, hp_current)
    percent = 100 - hp_current * 100.0 / hp_maximum
    
    set_pev(e, pev_frame, percent)
    set_pev(e, pev_nextthink, get_gametime() + 0.1)
    
    if(pev(g_Scorpion, pev_sequence) != 4 && g_Ability != RUN)
        return
    
    switch(100 - floatround(percent)) {
        case 81..90: {
            if (g_Phase != 1) {
                g_Phase = 1
                g_Ability = TENTACLE2
            }
        }
        case 71..80: {
            if (g_Phase != 2) {
                g_Phase = 2
                g_Ability = DOWN0
            }
        }
        case 61..70: {
            if (g_Phase != 3) {
                g_Phase = 3
                g_Ability = TENTACLE2
            }
        }
        case 51..60: {
            if (g_Phase != 4) {
                g_Phase = 4
                g_Ability = DOWN0
            }
        }
        case 41..50: {
            if (g_Phase != 5) {
                g_Phase = 5
                g_Ability = REGENERATION
            }
        }
        case 31..40: {
            if (g_Phase != 6) {
                g_Phase = 6
                g_Ability = DOWN1
            }
        }
        case 21..30: {
            if (g_Phase != 7) {
                g_Phase = 7
                g_Ability = DOWN1
            }
        }
        case 11..20: {
            if (g_Phase != 8) {
                g_Phase = 8
                g_Ability = DOWN1
            }
        }
        case 1..10: {
            if (g_Phase != 9) {
                g_Phase = 9
                g_Ability = DOWN1
            }
        }
    }
}
 
public zl_timer(timer, prepare) {
    static bool:boss_spawn = false, hp
    if (prepare == 1) {
        set_pev(hp, pev_effects, pev(hp, pev_effects) & ~EF_NODRAW)
        set_pev(g_Scorpion, pev_deadflag, DEAD_NO)
        set_pev(g_Scorpion, pev_takedamage, DAMAGE_YES)
        set_pev(g_Scorpion, pev_nextthink, get_gametime() + 0.1)
        #if defined PLAYER_HP
        set_pev(g_Scorpion, pev_health, float(PlayerHp(zl_cvar[0])))
        set_pev(g_Scorpion, pev_max_health, float(PlayerHp(zl_cvar[0])))
        #else
        set_pev(g_Scorpion, pev_health, float(zl_cvar[0]))
        set_pev(g_Scorpion, pev_max_health, float(zl_cvar[0]))
        #endif
        g_Ability = 1
    }
    
    if (!boss_spawn) {
        // Boss
        engfunc(EngFunc_SetModel, g_Scorpion, g_Resource[0])
        engfunc(EngFunc_SetSize, g_Scorpion, Float:{-80.0, -80.0, -32.0}, Float:{80.0, 80.0, 96.0})
        
        
        set_pev(g_Scorpion, pev_deadflag, DEAD_RESPAWNABLE)
        set_pev(g_Scorpion, pev_takedamage, DAMAGE_NO)
        set_pev(g_Scorpion, pev_solid, SOLID_SLIDEBOX)
        set_pev(g_Scorpion, pev_movetype, MOVETYPE_TOSS)
        set_pev(g_Scorpion, pev_classname, "boss_scorpion")
        set_pev(g_Scorpion, pev_angles, {0.336914, 89.313354, 0.000000})
        set_pev(g_Scorpion, pev_euser2, 1)
        zl_anim(g_Scorpion, 1, 1.0) 
        
        // HpBar
        hp = create_entity("info_target")
        engfunc(EngFunc_SetModel, hp, g_Resource[2])
        set_pev(hp, pev_skin, g_Scorpion)
        set_pev(hp, pev_body, 1)
        set_pev(hp, pev_movetype, MOVETYPE_FOLLOW)
        set_pev(hp, pev_classname, "scorpion_hpbar")
        set_pev(hp, pev_effects, EF_NODRAW)
        set_pev(hp, pev_scale, 0.6)
        
        set_pev(g_Scorpion, pev_nextthink, get_gametime() + 12.0)
        set_pev(hp, pev_nextthink, get_gametime() + 0.1)
        boss_spawn = !boss_spawn
    }
}
 
PlayerHp(hp) {
    new Count, Hp, id
    for(id = 1; id <= g_MaxPlayer; id++)
        if (is_user_alive(id) && !is_user_bot(id))
            Count++
            
    Hp = hp * Count
    return Hp
}
 
public plugin_cfg() {           
    new path[64]
    get_localinfo("amxx_configsdir", path, charsmax(path))
    format(path, charsmax(path), "%s/zl/zl_scorpionboss.ini", path)
    
    if (!file_exists(path)) {
        new error[100]
        formatex(error, charsmax(error), "Cannot load customization file %s!", path)
        set_fail_state(error)
        return
    }
    
    new linedata[2048], key[64], value[960], section
    new file = fopen(path, "rt")
    
    while (file && !feof(file)) {
        fgets(file, linedata, charsmax(linedata))
        replace(linedata, charsmax(linedata), "^n", "")
       
        if (!linedata[0] || linedata[0] == '/') continue;
        if (linedata[0] == '[') { section++; continue; }
       
        strtok(linedata, key, charsmax(key), value, charsmax(value), '=')
        trim(key)
        trim(value)
        
        switch (section) { 
            case 1: { // GENERAL
                if (equal(key, "BOSS_HP"))
                    zl_cvar[0] = str_to_num(value)
                else if (equal(key, "BOSS_SPEED"))
                            zl_cvar[1] = str_to_num(value)
                else if (equal(key, "BOSS_TIME_ABILITY"))
                    zl_fcvar[0] = str_to_float(value)   
                else if (equal(key, "BOSS_DAMAGE_ATTACK"))
                    zl_cvar[2] = str_to_num(value)
                else if (equal(key, "BOSS_REGEN_M"))
                    zl_fcvar[1] = str_to_float(value)
                else if (equal(key, "BOSS_DAMAGE_STORM"))
                    zl_cvar[3] = str_to_num(value)
                else if (equal(key, "BOSS_DAMAGE_TENTACLE"))
                    zl_cvar[4] = str_to_num(value)
            }
        }
    }
    if (file) fclose(file)
}
 
map_load() {
    static i, szStrin[32]
    
    for (i = 0; i <= STORM; ++i) {
        format(szStrin, charsmax(szStrin), "go_%d", i + 1)
        e_storm_start[i] = engfunc(EngFunc_FindEntityByString, e_storm_start[i], "targetname", szStrin)
        
        format(szStrin, charsmax(szStrin), "go_end_%d", i + 1)
        e_storm_end[i] = engfunc(EngFunc_FindEntityByString, e_storm_end[i], "targetname", szStrin)
    }
    
    for (i = 0; i < 3; ++i) {
        format(szStrin, charsmax(szStrin), "down%d", i)
        e_down[i] = engfunc(EngFunc_FindEntityByString, e_down[i], "targetname", szStrin)
    }
    
    g_Scorpion = engfunc(EngFunc_FindEntityByString, g_Scorpion, "targetname", "boss_spawn")
}
 
public plugin_precache() {
    if (zl_boss_map() != 7)
        return
        
    static i
    for (i = 0; i < sizeof g_Resource; ++i)
        i_Resource[i] = precache_model(g_Resource[i])
        
    for (i = 0; i < sizeof g_SoundList; ++i)
        precache_sound(g_SoundList[i])
}
 
stock zl_laser(a, b, Color[3], timer, noise) {
    message_begin( MSG_BROADCAST, SVC_TEMPENTITY ) 
    write_byte( TE_BEAMENTS ) 
    write_short( a )
    write_short( b )
    write_short( i_Resource[6] )
    write_byte( 1 )     // framestart 
    write_byte( 1 )     // framerate 
    write_byte( timer ) // life in 0.1's 
    write_byte( 8 )     // width
    write_byte( noise )     // noise 
    write_byte( Color[0] )      // r, g, b 
    write_byte( Color[1] )  // r, g, b 
    write_byte( Color[2] )      // r, g, b 
    write_byte( 200 )   // brightness 
    write_byte( 0 )     // speed 
    message_end()
}
/* AMXX-Studio Notes - DO NOT MODIFY BELOW HERE
*{\\ rtf1\\ ansi\\ deff0{\\ fonttbl{\\ f0\\ fnil Tahoma;}}\n\\ viewkind4\\ uc1\\ pard\\ lang1049\\ f0\\ fs16 \n\\ par }
*/

zl_core.sma

Код: [Выделить всё] [Развернуть/Свернуть]

#include < amxmodx >
#include < fakemeta >
#include < hamsandwich >
#include < nvault >
#include < cstrike >
 
#define PLUGIN          "[ZL] CoreFunction"
#define VERSION         "2.0.2"
#define AUTHOR          "Alexander.3"
 
/* ALL SETTING */
#define CMD_BOSS        "say /boss"
 
/* Macro */
//#define MAPCHOOSER
//#define DEBUG
 
/* MAP SETTING */
#define MAP_ALIEN       "zl_boss_alien"
#define MAP_APACHE      "zl_boss_apache"
#define MAP_OBERON      "zl_boss_oberon_v2"
#define MAP_REVENANT        "zl_boss_revenant"
#define MAP_ANGRA       "zl_boss_angra"
#define MAP_ENVYMASK        "megaololo"
#define MAP_ILLIDAN     "zl_boss_illidan_alpha"
#define MAP_SCORPION        "zl_boss_scorpion_alpha"
 
#define MAP_P_REVENANT      "zl_boss_p_revenant_alpha"
 
 
////////////////////////
/*------- CODE -------*/
/*---- DONT CHANGE ---*/
////////////////////////
#define m_iId           43
#define m_iPrimaryAmmoType  49
#define m_iPlayerTeam       114
#define m_iNumRespawns      365
#define m_pActiveItem       373
#define m_rgAmmoCBasePlayer 376
#define b_mNum          10
#define b_bmin          1
#define b_bmax          2
#define v_name          "boss_time"
#define f_config        "zl_core.ini"
 
#if defined MAPCHOOSER
native zl_vote_start()
#endif
 
/* global */
static g_PlayerCount, g_MaxPlayer, g_timer_forward, g_blood[2],
    g_cvar[4], Float:g_fcvar, g_cfg_cvar[3], Float:g_cfg_fcvar,
    g_cfg_szmap[24]
 
/* vote */
static bool:g_vote_true, g_voteid[33], g_vote[b_mNum], g_CallBack,
    g_vote_all, g_vote_vault, g_vote_time, Array:BossMap
 
/* respawn */
static bool:g_respawn_preapre = true
 
public plugin_precache() {
    register_plugin(PLUGIN, VERSION, AUTHOR)
        
    g_cvar[0] = get_cvar_num("mp_autoteambalance")
    g_cvar[1] = get_cvar_num("mp_limitteams")
    g_cvar[2] = get_cvar_num("mp_startmoney")
    g_cvar[3] = get_cvar_num("mp_friendlyfire")
    g_fcvar = get_cvar_float("mp_buytime")
    g_MaxPlayer = get_maxplayers()
    config_load()
    
    if (native_zl_map_boss() > 0) {
        RegisterHam(Ham_TraceAttack, "info_target", "Hook_TraceAttack")
        RegisterHam(Ham_Killed, "info_target", "Hook_Killed")
        RegisterHam(Ham_Killed, "player", "Hook_Killed", 1)
        register_message(get_user_msgid("AmmoX"), "MSG_AmmoX")
        
        g_blood[0] = precache_model("sprites/blood.spr")
        g_blood[1] = precache_model("sprites/bloodspray.spr")
        g_timer_forward = CreateMultiForward("zl_timer", ET_CONTINUE, FP_CELL, FP_CELL)
        new task = engfunc(EngFunc_CreateNamedEntity, engfunc(EngFunc_AllocString, "func_wall"))
        set_pev(task, pev_classname, "zl_classname_timer")
        set_pev(task, pev_nextthink, get_gametime() + 1.0)
        RegisterHamFromEntity(Ham_Think, task, "Hook_Think")
            
        set_cvar_num("mp_autoteambalance", 0)
        set_cvar_num("mp_limitteams", 0)
        set_cvar_num("mp_startmoney", 16000)
        set_cvar_num("mp_friendlyfire", 0)
        set_cvar_float("mp_buytime", 99.99)
    } else {
        BossMap = ArrayCreate(128)
        
        if(is_plugin_loaded("zl_alienboss.amxx", true) != -1) ArrayPushString(BossMap, MAP_ALIEN)
        if(is_plugin_loaded("zl_apacheboss.amxx", true) != -1) ArrayPushString(BossMap, MAP_APACHE)
        if(is_plugin_loaded("zl_oberonboss.amxx", true) != -1) ArrayPushString(BossMap, MAP_OBERON)
        if(is_plugin_loaded("zl_revenantboss.amxx", true) != -1) ArrayPushString(BossMap, MAP_REVENANT)
        if(is_plugin_loaded("zl_boss_angra.amxx", true) != -1) ArrayPushString(BossMap, MAP_ANGRA)
        if(is_plugin_loaded("zl_boss_envymask.amxx", true) != -1) ArrayPushString(BossMap, MAP_ENVYMASK)
        if(is_plugin_loaded("zl_boss_illidan.amxx", true) != -1) ArrayPushString(BossMap, MAP_ILLIDAN)  
        if(is_plugin_loaded("zl_boss_scorpion.amxx", true) != -1) ArrayPushString(BossMap, MAP_SCORPION)
        if(is_plugin_loaded("zl_boss_p_revenant.amxx", true) != -1) ArrayPushString(BossMap, MAP_P_REVENANT)
        
        register_logevent("RoundEnd", 2, "1=Round_End")
        register_clcmd(CMD_BOSS, "vote_menu")
        g_CallBack = menu_makecallback("vote_menu_callback")
        g_vote_vault = nvault_open("zl_boss")
        g_vote_time = nvault_get(g_vote_vault, v_name)
    
        set_cvar_num("mp_autoteambalance", g_cvar[0])
        set_cvar_num("mp_limitteams", g_cvar[1])
        set_cvar_num("mp_startmoney", g_cvar[2])
        set_cvar_num("mp_friendlyfire", g_cvar[3])
        set_cvar_float("mp_buytime", g_fcvar)
    }
}
 
public RoundEnd() {
    if (!g_vote_true)
        return
    
    new szBossMap[32], szTime[16]
    formatex(szTime, charsmax(szTime), "%d", get_systime() + (g_cfg_cvar[1] * 60))
    nvault_pset(g_vote_vault, v_name, szTime)
    ArrayGetString(BossMap, (zl_vote_winner() == -1) ? 0 : zl_vote_winner(), szBossMap, charsmax(szBossMap))
    log_amx(szBossMap)
    server_cmd("amx_map ^"%s^"", szBossMap)
}
 
public vote_menu(id) {
    if (g_vote_true) {
        zl_colorchat(id, "!g[BOSS] !nГолосование завершено!")
        return
    }
    
    if (zl_vote_time() > 0) {
        zl_colorchat(id, "!g[BOSS] !nГолосование станет доступно через !g%d минут", ((zl_vote_time() / 60) > 0) ? (zl_vote_time() / 60) : 1)
        return
    }
        
    static menu
    
    if (!menu)menu = menu_create("^t", "vote_menu_handle")
    else { menu_display(id, menu); return; }
    
    formatex_title(menu)
    
    new i, BossNum = ArraySize(BossMap)
    
    for(i = 0; i < BossNum; ++i) menu_additem(menu, "", _, _, g_CallBack)
    menu_display(id, menu)
}
 
public vote_menu_handle(id, menu, key) {
/*  if (key == MENU_EXIT || g_vote_true) {
        //menu_destroy(menu)
        if (is_user_connected(id))
            menu_cancel(id)
            
        return PLUGIN_HANDLED
    }*/
    
    if (key == MENU_EXIT)
        return PLUGIN_HANDLED
  
    if (g_vote_true) {
        menu_cancel(id)
        return PLUGIN_HANDLED
    }
        
    if (g_voteid[id]) {
        g_vote[g_voteid[id]]--
        g_voteid[id] = key + 1
        g_vote[g_voteid[id]]++
    } else {
        static szName[32], szMap[32]
        get_user_name(id, szName, charsmax(szName))
        ArrayGetString(BossMap, key, szMap, charsmax(szMap))
        g_voteid[id] = key + 1
        g_vote[key + 1]++
        g_vote_all++
        zl_colorchat(0, "!g[BOSS] !t%s !nПроголосовал за!g %s !nСделано !g[%d/%d] !nголосов.", szName, szMap, g_vote_all, zl_vote_count(g_cfg_fcvar)) 
    }
        
    if (g_vote_all >= zl_vote_count(g_cfg_fcvar)) {
        static szWinner[32]
        ArrayGetString(BossMap, zl_vote_winner(), szWinner, charsmax(szWinner))
        set_hudmessage(227, 177, 168, 0.12, 0.05, 2, 1.0, 7.0, 0.1, 0.1, -1)
        show_hudmessage(0, "Голосование завершено!^n\
            Следующий босс: %s^n^n\
            Последний раунд!", szWinner)
    
        g_vote_true = true
        menu_destroy(menu)
        return PLUGIN_HANDLED
    }
    formatex_title(menu)
    menu_display(id, menu)
    return PLUGIN_CONTINUE
}
 
public vote_menu_callback(id, menu, key) {
    static szMap[64]
    ArrayGetString(BossMap, key, szMap, charsmax(szMap))
    
    if (g_voteid[id] == (key + 1) || g_vote_true) {
        format(szMap, charsmax(szMap), "\d%s \r[%d \y(%d%%)\r]", szMap, g_vote[key + 1], zl_vote_proc(key))
        menu_item_setname(menu, key, szMap)
        return ITEM_DISABLED
    } else {
        format(szMap, charsmax(szMap), "\w%s \r[%d \y(%d%%)\r]", szMap, g_vote[key + 1], zl_vote_proc(key))
        menu_item_setname(menu, key, szMap)
        return ITEM_ENABLED
    }
    return ITEM_IGNORE
}
 
public MSG_AmmoX(msg, dest, id) {
    if (dest != MSG_ONE || !is_user_alive(id)) 
        return PLUGIN_CONTINUE
        
    new AmmoIndex = get_msg_arg_int(1)
    
    if (AmmoIndex > 10) {
        set_pdata_int(id, m_rgAmmoCBasePlayer + AmmoIndex, 0, 5)
        return PLUGIN_CONTINUE
    }
    
    set_pdata_int(id, m_rgAmmoCBasePlayer + AmmoIndex, 250, 5)
    return PLUGIN_CONTINUE
}
 
public client_putinserver(id) {
    if (!g_respawn_preapre) {
        if (native_zl_player_alive() <= 0) {
            is_map_valid(g_cfg_szmap) ?  server_cmd("amx_map ^"%s^"", g_cfg_szmap) : server_cmd("restart")
            return
        }
        set_pdata_int(id, m_iNumRespawns, 1)
    }       
    g_PlayerCount++
}
 
public client_disconnect(id) {
    if (native_zl_map_boss() <= 0) {
        if (g_voteid[id]) {
            g_vote[g_voteid[id]] = 0
            g_voteid[id] = 0
            g_vote_all--
        }
    }
    g_PlayerCount-- 
}
 
public plugin_end() {
    if (native_zl_map_boss() > 0) {
        set_cvar_num("mp_autoteambalance", g_cvar[0])
        set_cvar_num("mp_limitteams", g_cvar[1])
        set_cvar_num("mp_startmoney", g_cvar[2])
        set_cvar_float("mp_buytime", g_fcvar)
    } else {    
        if (!g_vote_true) {
            new szTime[32]
            formatex(szTime, charsmax(szTime), "%d", (zl_vote_time() > 0) ? (get_systime() + zl_vote_time()) : (get_systime()))
            nvault_pset(g_vote_vault, v_name, szTime)
        }
        nvault_close(g_vote_vault)
    }
}
 
public plugin_natives() {
    register_native("zl_boss_map", "native_zl_map_boss", 1)
    register_native("zl_boss_valid", "native_zl_valid_boss", 1)
    register_native("zl_player_alive", "native_zl_player_alive", 1)
    register_native("zl_player_random", "native_zl_random_player", 1)
    register_native("zl_player_count", "native_zl_player_count", 1)
    register_native("zl_colorchat", "native_zl_color_chat", 1)
}
 
public native_zl_map_boss() {
    static MapName[64], Map_Boss
    
    if (MapName[0])
        return Map_Boss
    
    get_mapname(MapName, 63)
 
    if (contain(MapName, MAP_OBERON) != -1) Map_Boss = 1
    if (contain(MapName, MAP_ALIEN) != -1) Map_Boss = 2
    if (contain(MapName, MAP_ANGRA) != -1) Map_Boss = 3
    if (contain(MapName, MAP_REVENANT) != -1) Map_Boss = 4
    if (contain(MapName, MAP_ENVYMASK) != -1) Map_Boss = 5
    if (contain(MapName, MAP_ILLIDAN) != -1) Map_Boss = 6
    if (contain(MapName, MAP_SCORPION) != -1) Map_Boss = 7
    
    if (contain(MapName, MAP_P_REVENANT) != -1) Map_Boss = 50
    
    #if defined DEBUG
    log_amx("DEBUG: Map id: %d | Map Name: %s", Map_Boss, MapName)
    #endif
    
    return Map_Boss
}
 
public native_zl_valid_boss(index) {
    new ClassName[32]
    pev(index, pev_classname, ClassName, charsmax(ClassName))
 
    if (ClassName[0] == 'o' && ClassName[5] == 'n' && ClassName[7] == 'b') return 1
    if (ClassName[0] == 'a' && ClassName[4] == 'n' && ClassName[6] == 'b') return 2
    if (ClassName[0] == 'A' && ClassName[4] == 'a' && ClassName[5] == 'B') return 3
    if (ClassName[0] == 'R' && ClassName[2] == 'v' && ClassName[8] == 'B') return 4
    if (ClassName[0] == 'b' && ClassName[5] == 'z' && ClassName[9] == 's' || ClassName[0] == 'b' && ClassName[5] == 'n' && ClassName[8] == 'd') return 5
    if (ClassName[0] == 'b' && ClassName[5] == 'i' && ClassName[9] == 'd') return 6
    if (ClassName[0] == 'b' && ClassName[5] == 's' && ClassName[9] == 'p') return 7
    if (ClassName[0] == 'b' && ClassName[5] == 'p' && ClassName[14] == 't') return 50
    return 0
}
 
public native_zl_random_player() {
    new Index
    Index = GetRandomAlive(random_num(1, native_zl_player_alive()))
    return Index
}
 
public native_zl_player_alive() {
    new iAlive, id, CsTeams:team
    for (id = 1; id <= g_MaxPlayer; id++) {
        if (!is_user_alive(id) || is_user_bot(id))
            continue
            
        team = cs_get_user_team(id)
            
        if (team == CS_TEAM_SPECTATOR || team == CS_TEAM_UNASSIGNED)
            continue
        
        iAlive++
    }
    return iAlive
}
 
GetRandomAlive(target_index) {
    new iAlive, id, CsTeams:team
    for (id = 1; id <= g_MaxPlayer; id++) {
        if (!is_user_alive(id) || is_user_bot(id))
            continue
            
        team = cs_get_user_team(id)
            
        if (team == CS_TEAM_SPECTATOR || team == CS_TEAM_UNASSIGNED)
            continue
        
        
        iAlive++
        
        if (iAlive == target_index) 
            return id
    }
    return -1
}
 
public native_zl_player_count()
    return g_PlayerCount
    
public native_zl_color_chat( iPlayer, szMessage[ ], any:... ) {
    for( new i = 2; i <= numargs(); ++i )
        param_convert(i)
 
    static szBuffer[512]
    vformat(szBuffer, charsmax( szBuffer ), szMessage, 3)
    zl_colorchat(iPlayer, szBuffer)
}
    
stock zl_colorchat( iPlayer, szMessage[ ], any:... ) {
    static szBuffer[512]
    vformat(szBuffer, charsmax( szBuffer ), szMessage, 3 );
 
    replace_all(szBuffer, charsmax(szBuffer), "!t", "^3")
    replace_all(szBuffer, charsmax(szBuffer), "!n", "^1")
    replace_all(szBuffer, charsmax(szBuffer), "!g", "^4")
 
    if( iPlayer ) {
        message_begin( MSG_ONE, 76, _, iPlayer );
        write_byte( iPlayer );
        write_string( szBuffer );
        message_end( );
    } else {
        for( new iPlayers = 33; iPlayers > 0; iPlayers-- ) {
            if( !is_user_connected( iPlayers ) )
                continue;
 
            message_begin( MSG_ONE, 76, _, iPlayers );
            write_byte( iPlayers );
            write_string( szBuffer );
            message_end( );
        }
    }
}
 
formatex_title(menu) {
    static szTitle[64]
    formatex(szTitle, charsmax(szTitle), "\yVote\rBoss\wMenu ^nVoteNum: %d/%d [%d%%]", g_vote_all, zl_vote_count(g_cfg_fcvar), g_vote_all * 100 / zl_vote_count(g_cfg_fcvar))
    menu_setprop(menu, MPROP_TITLE, szTitle)
}
 
zl_vote_count(Float:procent)
    return floatround(procent / 100.0 * float(g_PlayerCount), floatround_ceil)
    
zl_vote_proc(key)
    return g_vote_all ? floatround(floatmul(float(g_vote[key + 1]) / float(g_vote_all), 100.0)) : 0
    
zl_vote_winner() {
    new buffer = 0, s = 0, i = 0, m = ArraySize(BossMap)
    for(i = 1; i <= m; ++i) {
        if (g_vote[i] > buffer) {
            buffer = g_vote[i]
            s = i
        }
    }
    return s - 1
}
 
zl_vote_time()
    return g_vote_time - get_systime()
 
public Hook_Think(ent) {
    if (!native_zl_player_alive()) {
        set_pev(ent, pev_nextthink, get_gametime() + 1.0)
        return
    }
    static szName[32]
    pev(ent, pev_classname, szName, charsmax(szName))
    if (szName[0] == 'z' && szName[1] == 'l' && szName[14] == 'i' && szName[17] == 'r') {
        static Prepare = 2, ret
        set_pev(ent, pev_nextthink, get_gametime() + 1.0)
        switch(Prepare) {
            case 2: {
                g_cfg_cvar[0]--
                client_print(0, print_center, "Ожидание до начала следующего раунда: %d секунд", g_cfg_cvar[0])
                if(g_cfg_cvar[0] <= 0) {
                    Prepare--
                    g_respawn_preapre = false
                }
            }
            case 1: {
                Prepare--
                g_cfg_cvar[0]++
            }
            case 0:g_cfg_cvar[0]++
            default: g_cfg_cvar[0]++
        }
                
        message_begin(MSG_ALL, get_user_msgid("RoundTime"))
        write_short(g_cfg_cvar[0])
        message_end()
        
        ExecuteForward(g_timer_forward, ret, g_cfg_cvar[0], Prepare)        
        if(ret) Prepare = ret
    }
}
 
config_load() {     
    static path[64]
    get_localinfo("amxx_configsdir", path, charsmax(path))
    format(path, charsmax(path), "%s/zl/%s", path, f_config)
    
    if (!file_exists(path)) {
        new error[100]
        formatex(error, charsmax(error), "Cannot load customization file %s!", path)
        set_fail_state(error)
        return
    }
    
    static linedata[1024], key[64], value[960]
    new file = fopen(path, "rt")
    
    while (file && !feof(file)) {
        fgets(file, linedata, charsmax(linedata))
        replace(linedata, charsmax(linedata), "^n", "")
       
        if (!linedata[0] || linedata[0] == '/') continue;
       
        strtok(linedata, key, charsmax(key), value, charsmax(value), '=')
        trim(key)
        trim(value)
        
        if (equal(key, "PREPARE"))
            g_cfg_cvar[0] = str_to_num(value)
        else if (equal(key, "BOSS_COLOR"))
            g_cfg_cvar[2] = str_to_num(value)
        else if (equal(key, "SZ_MAP"))
            parse(value, g_cfg_szmap, charsmax(g_cfg_szmap))
        else if (equal(key, "VOTE_PROCENT"))
            g_cfg_fcvar = str_to_float(value)
        else if (equal(key, "VOTE_TIME"))
            g_cfg_cvar[1] = str_to_num(value)
    }
    if (file) fclose(file)
}
 
public Hook_TraceAttack(boss, player, Float:dmg, Float:direction[3], tr, damage_type) {
    if (!native_zl_valid_boss( boss ))
        return HAM_IGNORED
    
    static Float:End[3]
    get_tr2(tr, TR_vecEndPos, End)
 
    if (pev(boss, pev_euser2) == 1) {
        message_begin(MSG_BROADCAST, SVC_TEMPENTITY)
        write_byte(TE_SPARKS)
        engfunc(EngFunc_WriteCoord, End[0])
        engfunc(EngFunc_WriteCoord, End[1])
        engfunc(EngFunc_WriteCoord, End[2])
        message_end()
        return HAM_IGNORED
    }   
    
    if (pev(boss, pev_deadflag) == DEAD_NO && pev(boss, pev_takedamage) == DAMAGE_NO) {
        message_begin(MSG_BROADCAST, SVC_TEMPENTITY)
        write_byte(TE_SPARKS)
        engfunc(EngFunc_WriteCoord, End[0])
        engfunc(EngFunc_WriteCoord, End[1])
        engfunc(EngFunc_WriteCoord, End[2])
        message_end()
        return HAM_SUPERCEDE
    }
    
    message_begin(MSG_BROADCAST, SVC_TEMPENTITY);
    write_byte(TE_BLOODSPRITE)
    engfunc(EngFunc_WriteCoord, End[0])
    engfunc(EngFunc_WriteCoord, End[1])
    engfunc(EngFunc_WriteCoord, End[2])
    write_short(g_blood[0])
    write_short(g_blood[1])
    write_byte(g_cfg_cvar[2])
    write_byte(random_num(b_bmin, b_bmax))
    message_end()
    return HAM_IGNORED
}
 
public Hook_Killed(victim, attacker, corpse) {
    if (native_zl_player_alive() <= 0) {
        set_task(6.0, "changemap")
        return HAM_IGNORED
    }
 
    if (!native_zl_valid_boss(victim))
        return HAM_IGNORED
        
    if (pev(victim, pev_deadflag) == DEAD_DYING)
        return HAM_IGNORED
    
 
    set_pev(victim, pev_solid, SOLID_NOT)
    set_pev(victim, pev_velocity, {0.0, 0.0, 0.0})
    
    static e = -1
    while ( (e = engfunc(EngFunc_FindEntityByString, e, "classname", "classname_zombie")) )
        if(pev_valid(e)) engfunc(EngFunc_RemoveEntity, e)
    
 
    switch(native_zl_map_boss()) {
        case 1: zl_anim(victim, 16, 1.0)
        case 2: zl_anim(victim, 1, 1.0)
        case 5: { // Neid and Zavist
            new szBossType[32], g_Neid, g_Zavist
            pev(victim, pev_classname, szBossType, charsmax(szBossType))
            
            g_Neid = engfunc(EngFunc_FindEntityByString, g_Neid, "classname", "boss_neid")
            g_Zavist = engfunc(EngFunc_FindEntityByString, g_Zavist, "classname", "boss_zavist")
            
            if (pev(g_Neid, pev_deadflag) == DEAD_DYING && pev(g_Zavist, pev_deadflag) == DEAD_DYING) {
                set_task(20.0, "changemap")
                return HAM_SUPERCEDE
            }
            
            set_pev(victim, pev_deadflag, DEAD_DYING)
            if (equal(szBossType, "boss_neid")) {
                zl_anim(victim, 35, 1.0)
                set_pev(g_Neid, pev_nextthink, get_gametime() + 7.4)
            }
            if (equal(szBossType, "boss_zavist")) {
                zl_anim(victim, 28, 1.0)
                set_pev(g_Zavist, pev_nextthink, get_gametime() + 13.2)
            }
            return HAM_SUPERCEDE
        }
        case 6: zl_anim(victim, 15, 1.0)
        case 7: zl_anim(victim, 20, 1.0)
    }
 
    set_pev(victim, pev_deadflag, DEAD_DYING)
    set_task(20.0, "changemap")
    return HAM_SUPERCEDE
}
 
public changemap() {
    #if defined MAPCHOOSER
    zl_vote_start()
    #else
    is_map_valid(g_cfg_szmap) ? server_cmd("changelevel ^"%s^"", g_cfg_szmap) : server_cmd("restart")
    #endif
}
 
stock zl_anim(ent, sequence, Float:speed) {     
    set_pev(ent, pev_sequence, sequence)
    set_pev(ent, pev_animtime, get_gametime())
    set_pev(ent, pev_framerate, speed)
}
/* AMXX-Studio Notes - DO NOT MODIFY BELOW HERE
*{\\ rtf1\\ ansi\\ deff0{\\ fonttbl{\\ f0\\ fnil Tahoma;}}\n\\ viewkind4\\ uc1\\ pard\\ lang1049\\ f0\\ fs16 \n\\ par }
*/

zl_rewardsystem.sma

Код: [Выделить всё] [Развернуть/Свернуть]

#include < amxmodx >
#include < hamsandwich >
#include < fakemeta >
 
#define NAME        "[ZL] RewardSystem"
#define VERSION     "1.3.2"
#define AUTHOR      "Alexander.3"
 
#define DMG
#define FRAG
#define KILL
 
#define CLASSIC
//#define BUYMENU
//#define ZP43
//#define ZP50
//#define WAR3FT
 
const spawn_money =      1000
 
// DamageFunc
const dmg_max =         1000
const dmg_reward =  500
 
// FragDamage
const frag_dmg =    500
const frag_add =    1
 
// KilledFunc
const kReward =     20000
const k_red =       255
const k_green =     0
const k_blue =      0
 
#if defined ZP43
#include < zombieplague >
#endif
#if defined ZP50
#include < zp50_ammopacks >
#endif
#if defined BUYMENU
native zp_cs_get_user_money(id)
native zp_cs_set_user_money(id, money)
#endif
 
native zl_boss_map()
native zl_boss_valid(ent)
 
public plugin_init() {
    register_plugin(NAME, VERSION, AUTHOR)
    
    if (!zl_boss_map()) {
        pause("ad")
        return
    }
    
    RegisterHam(Ham_TakeDamage, "info_target", "TakeDamage_Boss")
    RegisterHam(Ham_Spawn, "player", "Hook_Spawn", 1)
    register_dictionary("zl_rewardsystem.txt")
}
 
public Hook_Spawn(id) {
    if (!is_user_connected(id))
        return HAM_IGNORED
        
    GiveMoney(id, spawn_money)
    return HAM_HANDLED
}
 
public TakeDamage_Boss(victim, wpn, attacker, Float:damage, damagebyte) {
    if (!pev_valid(victim) || !is_user_alive(attacker))
        return HAM_IGNORED
        
    if (zl_boss_valid(victim)) {
        static Float:BossHealth
        pev(victim, pev_health, BossHealth)
        
        if (damage < BossHealth) {
            #if defined DMG
            static Float:PlayerDamage[33]
            PlayerDamage[attacker] += damage
            #endif
            
            #if defined FRAG
            static Float:PlayerDamage2[33]
            PlayerDamage2[attacker] += damage
            #endif
            
            #if defined DMG
            if (PlayerDamage[attacker] > dmg_max) {
                GiveMoney(attacker, dmg_reward)
                
                PlayerDamage[attacker] = 0.0
                return HAM_HANDLED
            }
            #endif
            
            #if defined FRAG
            if (PlayerDamage2[attacker] > frag_dmg) {
                set_pev(attacker, pev_frags, pev(attacker, pev_frags) + float(frag_add))
                
                message_begin(MSG_BROADCAST, get_user_msgid("ScoreInfo"))
                write_byte(attacker)
                write_short(pev(attacker, pev_frags))
                write_short(get_user_deaths(attacker))
                write_short(0)
                write_short(get_user_team(attacker))
                message_end()
                
                PlayerDamage2[attacker] = 0.0
                return HAM_HANDLED
            }
            #endif
            
        } else {
            #if defined KILL
            MessageKilled(attacker)
            GiveMoney(attacker, kReward)
            #endif
            return HAM_IGNORED
        }
    }
    return HAM_HANDLED
}
 
MessageKilled(attacker) {
    new kName[32]
    get_user_name(attacker, kName, charsmax(kName))
    
    set_hudmessage(k_red, k_green, k_blue, 0.29, 0.49, 0, 6.0, 12.0)
    show_hudmessage(0, "%L", LANG_SERVER, "REWARD_KILL", kName, kReward)
}
 
public plugin_natives()
    register_native("zl_give_reward", "GiveMoney", 1)
 
public GiveMoney(index, num) {
    if (!is_user_connected(index))
        return
        
    #if defined CLASSIC
    set_pdata_int(index, 115, floatround(get_pdata_int(index, 115) + float(num), floatround_round))
    
    message_begin(MSG_ONE_UNRELIABLE, get_user_msgid("Money"), _, index)
    write_long(floatround(get_pdata_int(index, 115) + float(num), floatround_round))
    write_byte(1)
    message_end()
    #endif
    
    #if defined BUYMENU
    zp_cs_set_user_money(index, zp_cs_get_user_money(index) + num)
    #endif
    
    #if defined ZP43
    zp_set_user_ammo_packs(index, zp_get_user_ammo_packs(index) + num)
    #endif
                
    #if defined ZP50
    zp_ammopacks_set(index, zp_ammopacks_get(index) + num)
    #endif
    
    #if defined WAR3FT
    new kName[32]
    get_user_name(index, kName, charsmax(kName))
    server_cmd( "wc3_givexp ^"%s^" ^"%d^"", kName, num)
    #endif
}
/* AMXX-Studio Notes - DO NOT MODIFY BELOW HERE
*{\\ rtf1\\ ansi\\ deff0{\\ fonttbl{\\ f0\\ fnil Tahoma;}}\n\\ viewkind4\\ uc1\\ pard\\ lang1049\\ f0\\ fs16 \n\\ par }
*/

zl_spawnsystem.sma

Код: [Выделить всё] [Развернуть/Свернуть]

#include < amxmodx >
#include < hamsandwich >
#include < fakemeta >
 
#define NAME            "[ZL] SpawnSystem"
#define VERSION         "1.5"
#define AUTHOR          "Alexander.3"
 
#define RESPAWN
 
const human_hp =        110
#if defined RESPAWN
const RespawnNum =      2
const RespawnTime =     10
 
static bool:buffResp[33]
static idRespTime[33]
#endif
static bool:idRespawn[33]
native zl_boss_map()
native zl_player_alive()
 
#if defined RESPAWN
forward zl_timer(timer, prepare)
static g_MaxPlayers
#endif
 
public plugin_init() {
    register_plugin(NAME, VERSION, AUTHOR)
    
    if (!zl_boss_map()) {
        pause("ad")
        return
    }   
    RegisterHam(Ham_Spawn, "player", "Hook_Spawn", 1)
    #if defined RESPAWN
    RegisterHam(Ham_Killed, "player", "Hook_Killed", 1)
    #endif
    register_dictionary("zl_spawnsystem.txt")
    
    #if defined RESPAWN
    g_MaxPlayers = get_maxplayers()
    #endif
}
 
public Hook_Spawn(id) {
    if (!is_user_connected(id) || is_user_bot(id))
        return HAM_IGNORED
            
    set_pev(id, pev_health, float(human_hp))
    idRespawn[id] = true
    return HAM_HANDLED
}
 
#if defined RESPAWN
public Hook_Killed(victim, attacker, corpse) {
    if (!is_user_connected(victim) || !(0 < victim <= 32))
        return HAM_IGNORED
                
    static Respawn[33], a[33]
    
    a[victim] = RespawnNum - Respawn[victim]
    
    if (!a[victim]) {
        client_print(victim, print_center, "%L", LANG_PLAYER, "RESP_END")
        return HAM_IGNORED
    }
    idRespTime[victim] = RespawnTime
    
    client_print(victim, print_chat, "%L", LANG_PLAYER, "RESP_NUM", a[victim] - 1)
    Respawn[victim]++
    buffResp[victim] = true
    return HAM_IGNORED
}
 
public zl_timer(t, p) {
    new id = 1
    for(id = 1; id <= g_MaxPlayers; id++) {
        if (is_user_alive(id) || is_user_bot(id))
            continue
        
        if (!idRespawn[id] || !buffResp[id])
            continue
        
        if (!idRespTime[id]) {
            idRespawn[id] = false
            buffResp[id] = false
            ExecuteHam(Ham_CS_RoundRespawn, id)
            continue
        }
        client_print(id, print_center, "%L", LANG_PLAYER, "RESP_ACTIVE", idRespTime[id])
        idRespTime[id]--
    }
}
#endif

zl_supplybox.sma

Код: [Выделить всё] [Развернуть/Свернуть]

#include < amxmodx >
#include < engine >
#include < hamsandwich >
#include <army_ranks_ultimate>
#define NAME            "SupplyBox"
#define VERSION         "2.2"
#define AUTHOR          "Alexander.3"
    
new GiftMdl[] =         "models/zl/supplybox.mdl"
const GiftNum =         10
const Float:GiftRad =       250.0
const min_rewards =     1000
const max_rewards =     10000
 
//Color HudMessage
new const h_color[] = {
                255, // RED
                0,   // GREEN
                0    // BLUE
}
 
//Glow Eff.
const g_true =          2   // 0 - NoRendering, 1 - CustomColor, 2 - RandomColor
new const g_color[] = {
                255, // RED
                0,   // GREEN
                0    // BLUE
}
const g_layer =         40  // Size
 
#define ONEBOX
 
native zl_give_reward(index, num)
native zl_boss_map()
native zl_boss_valid(index)
 
public plugin_init() {
    register_plugin(NAME, VERSION, AUTHOR)
    
    if (!zl_boss_map()) {
        pause("ad")
        return
    }
    
    RegisterHam(Ham_Killed, "info_target", "Hook_Killed")
    register_touch("classname_gift", "player", "Hook_Touch")
    register_dictionary("zl_supplybox.txt")
}
 
public Hook_Touch(e, p) {
    #if defined ONEBOX
    static bool:onebox[33]
    if (onebox[p]) return
    onebox[p] = true
    #endif
    set_hudmessage(h_color[0], h_color[1], h_color[2], 0.29, 0.59, 0, 6.0, 12.0)
    show_hudmessage(p, "%L", LANG_PLAYER, "SUPPLY_SPAWN", 1000)
    ar_set_user_addxp(p, 1000)
    remove_entity(e)
}
 
public Hook_Killed( it ) {
    if (!zl_boss_valid( it ))
        return HAM_IGNORED
        
    new Float: Origin[3]
    entity_get_vector(it, EV_VEC_origin, Origin)
    SupplySpawn( Origin, GiftNum )
    return HAM_HANDLED
}
 
public native_spawn(Float:Origin[3], num) {
    param_convert(1)
    SupplySpawn(Origin, num)
}
 
public SupplySpawn( Float:Origin[3], num) {
    new n = num
    while (n > 0) {
        new g = zl_create_entity(
            Origin, GiftMdl, _, 0.0, 
            SOLID_TRIGGER, MOVETYPE_TOSS, DAMAGE_NO, DEAD_NO, 
            "info_target", "classname_gift", Float:{-10.0, -10.0, -1.0}, Float:{10.0, 10.0, 10.0})
        
        new Float:velocity[3]
        velocity[0] = random_float(-(GiftRad), (GiftRad))   
        velocity[1] = random_float(-(GiftRad), (GiftRad))
        velocity[2] = GiftRad
        switch(g_true) {
            case 1: set_rendering(g, kRenderFxGlowShell, g_color[0], g_color[1], g_color[2], kRenderNormal, g_layer)
            case 2: set_rendering(g, kRenderFxGlowShell, random(255), random(255), random(255), kRenderNormal, g_layer)
        }
        entity_set_vector(g, EV_VEC_velocity, velocity)
        --n
    }
}
 
public plugin_precache()
    precache_model(GiftMdl)
 
public plugin_natives()
    register_native("zl_supplybox", "native_spawn", 1)
    
stock zl_create_entity 
    (
        Float:Origin[3], 
        Model[] = "models/player/sas/sas.mdl", 
        HP = 100,
        Float:NextThink = 1.0,
        SOLID_ = SOLID_BBOX, 
        MOVETYPE_ = MOVETYPE_PUSHSTEP, 
        Float:DAMAGE_ = DAMAGE_YES, 
        DEAD_ = DEAD_NO, 
        ClassNameOld[] = "info_target", 
        ClassNameNew[] = "player_entity", 
        Float:SizeMins[3] = {-32.0, -32.0, -36.0}, 
        Float:SizeMax[3] = {32.0, 32.0, 96.0}, 
        bool:invise = false
    ) {
    
    new Ent = create_entity(ClassNameOld)
    
    if (!is_valid_ent(Ent))
        return 0
    
    entity_set_model(Ent, Model)
    entity_set_size(Ent, SizeMins, SizeMax)
    entity_set_origin(Ent, Origin)
    if (NextThink > 0.0) entity_set_float(Ent, EV_FL_nextthink, get_gametime() + NextThink)
    if (invise) entity_set_int(Ent, EV_INT_effects, entity_get_int(Ent, EV_INT_effects) & ~EF_NODRAW)
    entity_set_string(Ent, EV_SZ_classname, ClassNameNew)
    entity_set_int(Ent, EV_INT_solid, SOLID_)
    entity_set_int(Ent, EV_INT_movetype, MOVETYPE_)
    entity_set_int(Ent, EV_INT_deadflag, DEAD_)
    entity_set_float(Ent, EV_FL_dmg_take, DAMAGE_)
    entity_set_float(Ent, EV_FL_max_health, float(HP))
    entity_set_float(Ent, EV_FL_health, float(HP))
    
    return Ent
}
/* AMXX-Studio Notes - DO NOT MODIFY BELOW HERE
*{\\ rtf1\\ ansi\\ deff0{\\ fonttbl{\\ f0\\ fnil Tahoma;}}\n\\ viewkind4\\ uc1\\ pard\\ lang1049\\ f0\\ fs16 \n\\ par }
*/

Инклуды

zl_scorpion.inc

Код: [Выделить всё] [Развернуть/Свернуть]

#include < amxmodx >
#include < engine >
#include < fakemeta >
#include < hamsandwich >
#include < xs >
 
#define VERSION         "1.0.1"
 
#define pev_victim      pev_weaponanim
#define pev_tornado     pev_iuser2      
 
#define ZL_CHOOSE_MIN       0
#define ZL_CHOOSE_MAX       1
#define ZL_CHOOSE_RANDOM    2
 
native zl_boss_map()
native zl_boss_valid( ent )
native zl_player_random()
native zl_player_alive()
native zl_colorchat(id, const msg[], any:...)
forward zl_timer(timer, prepare)
 
stock zl_anim(ent, sequence, Float:speed) {     
    set_pev(ent, pev_sequence, sequence)
    set_pev(ent, pev_animtime, halflife_time())
    set_pev(ent, pev_framerate, speed)
}
 
stock zl_radiusdmg(origin_start, maxdmg, radius) {
    new i = 1, p = get_maxplayers()
    new Float:origin[3], Float:vector[3], len
    new Float:dmg_len, Float:dmg_current
    for(i = 1; <= p; ++i) {
        if (!is_user_alive(i))
            continue
        
        pev(i, pev_origin, origin_end)
        xs_vec_sub(orign_end, origin_start, vector)
        len = xs_vec_len(vector)
        
        if (len > radius)
            continue
            
        dmg_len = len * 100 / radius
        dmg_len = 100 - dmg_len
        dmg_current = maxdmg * dmg_len / 100
        zl_damage(i, floatround(dmg_current))
    }
}
 
stock zl_slap(victim, slap, damage, sound) {
    if (!is_user_alive(victim))
        return
        
    new hp = pev(victim, pev_health)
    if (hp - damage <= 0) {
        ExecuteHamB(Ham_Killed, victim, victim, 2)
        return
    }
    
    new Float:origin1[3], Float:origin2[3], Float:angle[3]
    pev(victim, pev_origin, origin1)
    pev(victim, pev_angles, angle)
    angle_vector(angle, ANGLEVECTOR_FORWARD, angle)
    origin2[0] = origin1[0] + angle[0] * 65.0
    origin2[1] = origin1[1] + angle[1] * 65.0
    xs_vec_sub(origin1, origin2, origin2)
    xs_vec_normalize(origin2, origin2)
    xs_vec_mul_scalar(origin2, float(slap), origin2)
    origin2[2] = 250.0
    set_pev(victim, pev_velocity, origin2)
    zl_damage(victim, damage, sound)
}
 
stock zl_damage(id, damage, sound) {
    if (!is_user_alive(id))
        return
        
    new hp = pev(id, pev_health)
    if (hp - damage <= 0) {
        if (sound) zl_sound(id, "zl/npc/illidan/attack_killed.wav", 0)
        ExecuteHamB(Ham_Killed, id, id, 2)
    } else ExecuteHamB(Ham_TakeDamage, id, 0, id, float(damage), DMG_BLAST)
}
 
stock zl_player_choose(boss, type) {
    new i = 1
    new m = get_maxplayers()
    new v = 0
    new Float:dist = 9999.0
    new num = 0
    new player[33]
    
    new Float:len, Float:buffer
    new Float:origin_player[3], Float:origin_boss[3], Float:vector[3]
    pev(boss, pev_origin, origin_boss)
    
    for(i = 1; i <= m; ++i) {
        if (!is_user_alive(i))
            continue
                
        pev(i, pev_origin, origin_player)
        xs_vec_sub(origin_player, origin_boss, vector)
        len = xs_vec_len(vector)
        
        switch(type) {
            case ZL_CHOOSE_MIN: {
                if (len < dist) {
                    dist = len
                    v = i
                }
            }
            case ZL_CHOOSE_MAX: {
                if (len > buffer) {
                    buffer = len
                    v = i
                }
            }
            case ZL_CHOOSE_RANDOM: {
                player[num] = i
                num++
            }
        }
    }
    return (type == 2) ? player[random(num)] : v
}
 
stock zl_move(Start, End, Float:speed = 250.0, Float:Velocity[] = {0.0, 0.0, 0.0}, Float:Angles[] = {0.0, 0.0, 0.0}) {
    static Float:Origin[3], Float:Origin2[3], Float:Angle[3], Float:Vector[3], Float:Len
    pev(Start, pev_origin, Origin2)
    pev(End, pev_origin, Origin)
        
    xs_vec_sub(Origin, Origin2, Vector)
    Len = xs_vec_len(Vector)
    
    vector_to_angle(Vector, Angle)
    
    Angles[0] = 0.0
    Angles[1] = Angle[1]
    Angles[2] = 0.0
    
    xs_vec_normalize(Vector, Vector)
    xs_vec_mul_scalar(Vector, speed, Velocity)
        
    return floatround(Len, floatround_round)
}
 
stock bool:TraceCheckCollides(Float:origin[3], const Float:BOUNDS) {
    new Float:traceEnds[8][3], Float:traceHit[3], hitEnt
    traceEnds[0][0] = origin[0] - BOUNDS
    traceEnds[0][1] = origin[1] - BOUNDS
    traceEnds[0][2] = origin[2] - BOUNDS
 
    traceEnds[1][0] = origin[0] - BOUNDS
    traceEnds[1][1] = origin[1] - BOUNDS
    traceEnds[1][2] = origin[2] + BOUNDS
 
    traceEnds[2][0] = origin[0] + BOUNDS
    traceEnds[2][1] = origin[1] - BOUNDS
    traceEnds[2][2] = origin[2] + BOUNDS
 
    traceEnds[3][0] = origin[0] + BOUNDS
    traceEnds[3][1] = origin[1] - BOUNDS
    traceEnds[3][2] = origin[2] - BOUNDS
     
    traceEnds[4][0] = origin[0] - BOUNDS
    traceEnds[4][1] = origin[1] + BOUNDS
    traceEnds[4][2] = origin[2] - BOUNDS
 
    traceEnds[5][0] = origin[0] - BOUNDS
    traceEnds[5][1] = origin[1] + BOUNDS
    traceEnds[5][2] = origin[2] + BOUNDS
 
    traceEnds[6][0] = origin[0] + BOUNDS
    traceEnds[6][1] = origin[1] + BOUNDS
    traceEnds[6][2] = origin[2] + BOUNDS
 
    traceEnds[7][0] = origin[0] + BOUNDS
    traceEnds[7][1] = origin[1] + BOUNDS
    traceEnds[7][2] = origin[2] - BOUNDS
 
    for (new i = 0; i < 8; i++) {
        if (point_contents(traceEnds[i]) != CONTENTS_EMPTY)
            return true
 
        hitEnt = trace_line(0, origin, traceEnds[i], traceHit)
        if (hitEnt != 0) return true
        
        for (new j = 0; j < 3; j++) {
            if (traceEnds[i][j] != traceHit[j])
                return true
        }
    }
    return false
}
 
stock zl_position(id, Float:forw, Float:right, Float:up, Float:vStart[]) {
    new Float:vOrigin[3], Float:vAngle[3], Float:vForward[3], Float:vRight[3], Float:vUp[3]
    
    pev(id, pev_origin, vOrigin)
    pev(id, pev_view_ofs,vUp) //for player
    xs_vec_add(vOrigin,vUp,vOrigin)
    pev(id, pev_angles, vAngle) // if normal entity ,use pev_angles
    
    angle_vector(vAngle,ANGLEVECTOR_FORWARD,vForward) //or use EngFunc_AngleVectors
    angle_vector(vAngle,ANGLEVECTOR_RIGHT,vRight)
    angle_vector(vAngle,ANGLEVECTOR_UP,vUp)
    
    vStart[0] = vOrigin[0] + vForward[0] * forw + vRight[0] * right + vUp[0] * up
    vStart[1] = vOrigin[1] + vForward[1] * forw + vRight[1] * right + vUp[1] * up
    vStart[2] = vOrigin[2] + vForward[2] * forw + vRight[2] * right + vUp[2] * up
}
 
stock zl_screenshake(id, ampl, timer) {
    if(id) if(!is_user_alive(id)) return
    
    if (ampl > 15)
        ampl = 15
    
    message_begin(id ? MSG_ONE_UNRELIABLE : MSG_BROADCAST, get_user_msgid("ScreenShake"), _, id ? id : 0);
    write_short(ampl << 12)
    write_short(timer << 12)
    write_short(7 << 12)
    message_end()
}
 
stock zl_screenfade(id, Timer = 1, FadeTime = 1, Colors[3] = {0, 0, 0}, Alpha = 0, type = 1) {
    if(id) if(!is_user_connected(id)) return
 
    if (Timer > 0xFFFF) Timer = 0xFFFF
    if (FadeTime <= 0) FadeTime = 4
    
    message_begin(id ? MSG_ONE_UNRELIABLE : MSG_BROADCAST, get_user_msgid("ScreenFade"), _, id);
    write_short(Timer * 1 << 12)
    write_short(FadeTime * 1 << 12)
    switch (type) {
        case 1: write_short(0x0000)     // IN ( FFADE_IN )
        case 2: write_short(0x0001)     // OUT ( FFADE_OUT )
        case 3: write_short(0x0002)     // MODULATE ( FFADE_MODULATE )
        case 4: write_short(0x0004)     // STAYOUT ( FFADE_STAYOUT )
        default: write_short(0x0001)
    }
    write_byte(Colors[0])
    write_byte(Colors[1])
    write_byte(Colors[2])
    write_byte(Alpha)
    message_end()
}
 
stock zl_wreck(Float:Origin[3], Float:Size[3], Float:Velocity[3], RandomVelocity, Num, Life, Flag, index) {         
    message_begin(MSG_BROADCAST, SVC_TEMPENTITY)
    write_byte(TE_BREAKMODEL)
    engfunc(EngFunc_WriteCoord, Origin[0]) // Pos.X
    engfunc(EngFunc_WriteCoord, Origin[1]) // Pos Y
    engfunc(EngFunc_WriteCoord, Origin[2]) // Pos.Z
    engfunc(EngFunc_WriteCoord, Size[0]) // Size X
    engfunc(EngFunc_WriteCoord, Size[1]) // Size Y
    engfunc(EngFunc_WriteCoord, Size[2]) // Size Z
    engfunc(EngFunc_WriteCoord, Velocity[0]) // Velocity X
    engfunc(EngFunc_WriteCoord, Velocity[1]) // Velocity Y
    engfunc(EngFunc_WriteCoord, Velocity[2]) // Velocity Z
    write_byte(RandomVelocity) // Random velocity
    write_short(index) // Model/Sprite index
    write_byte(Num) // Num
    write_byte(Life) // Life
    write_byte(Flag) // Flags ( 0x02 )
    message_end()
}
 
stock zl_sound(index, sound[], type = 0) { // Type : 0 - Message, 1 - EntSound
    switch (type) {
        case 0: {
            if (contain(sound, ".wav") == -1) {
                client_cmd(index, "mp3 play ^"sound/%s^"", sound)
            } else {
                message_begin(index ? MSG_ONE_UNRELIABLE : MSG_BROADCAST, get_user_msgid("SendAudio"), _, index)    
                write_byte(index)
                write_string(sound)
                write_short(PITCH_NORM)
                message_end()
            }
        }
        case 1: engfunc(EngFunc_EmitSound, index, CHAN_VOICE, sound, VOL_NORM, ATTN_NORM, 0, PITCH_NORM)
        default: log_amx("[ERROR] SoundType ERROR")
    }
}
 
stock zl_boss_slap(boss, end) {
    static Float:origin_start[3], Float:origin_end[3], Float:angle[3], Float:velocity[3]
    
    pev(boss, pev_origin, origin_start)
    pev(end, pev_origin, origin_end)
        
    xs_vec_sub(origin_end, origin_start, velocity)
    vector_to_angle(velocity, angle)
    
    velocity[2] = 0.0
    angle[0] = 0.0
    angle[2] = 0.0
    
    xs_vec_normalize(velocity, velocity)
    xs_vec_mul_scalar(velocity, 700.0, velocity)
    
    set_pev(boss, pev_velocity, velocity)
    set_pev(boss, pev_angles, angle)
}
/* AMXX-Studio Notes - DO NOT MODIFY BELOW HERE
*{\\ rtf1\\ ansi\\ deff0{\\ fonttbl{\\ f0\\ fnil Tahoma;}}\n\\ viewkind4\\ uc1\\ pard\\ lang1049\\ f0\\ fs16 \n\\ par }
*/

Версия	Дата выхода	Размер	Скачиваний	Скачать
---	15 фев 2024, 08:52	3.95 MБ	32	ScorpionBoss.zip

Кто сейчас на конференции

Зарегистрированные пользователи: Ahrefs [Bot], Baidu [Spider], BlackSignature, Semrush [Bot]

Место свободно

Здесь вы сможете купить рекламу на данном форуме

Стоимость за 1 день 10 ₽

ScorpionBoss

Версия: --- 15.02.2024 08:52

Re: ScorpionBoss

Re: ScorpionBoss

Кто сейчас на конференции