ZORO escreveu:Pessoal eu tenho um plugin de um boss o Oberon, eu queria colocar para ele dar packs, igual a um sv que eu jogo, aos sabados tem eventos com o Oberon, e ele da muitos packs, muito packs mesmo, entre 100 a 50 a cada tiro, alguém poderia modificar ele para dar packs???

Alguém pode me ajudar, Eu agradeço!

esta e a sma

Código:

#include <amxmodx>
#include <engine>
#include <fakemeta>
#include <hamsandwich>
#include <  xs >

#define OBERON_CLASSNAME "oberon"
#define OBERON_HEALTH 40000.0

#define TASK_SKILL 123123123
#define TASK_HOOKINGUP 123312312
#define TASK_HOOKINGDOWN 123312313

new const oberon_model[] = "models/oberon/zbs_bossl_big02.mdl"
new const oberon_knife_effect[] = "models/oberon/ef_knife.mdl"
new const oberon_hole_effect[] = "models/oberon/ef_hole.mdl"
new const oberon_bomb_model[] = "models/oberon/zbs_bossl_big02_bomb.mdl"

new const oberon_appear_sound[] = "oberon/appear.wav"
new const oberon_death_sound[] = "oberon/death.wav"
new const oberon_evolution_sound[] = "oberon/knife.wav"
new const oberon_attack_sound[8][] =
{
   "oberon/attack1.wav",
   "oberon/attack2.wav",
   "oberon/attack3_jump.wav",
   "oberon/attack3.wav",
   "oberon/knife_attack1.wav",
   "oberon/knife_attack2.wav",
   "oberon/knife_attack3_jump.wav",
   "oberon/knife_attack3.wav"
}
new const oberon_hole_sound[] = "oberon/hole.wav"
new const oberon_bomb_sound[] = "oberon/attack_bomb.wav"

new oberon_model_id, g_reg, m_iBlood[2], exp_spr_id
new Float:g_cur_origin[3], Float:g_cur_angles[3], Float:g_cur_v_angle[3]
new g_evolution, g_evoluting, g_doing_other, g_attacking3, Float:g_attacking3_origin[3]

public plugin_init()
{
   register_plugin("[Dias's NPC] Oberon", "1.0", "Dias")
   
   register_event("HLTV", "event_newround", "a", "1=0", "2=0")
   register_touch(OBERON_CLASSNAME, "*", "fw_touch")
   
   register_clcmd("say /get_origin", "get_origin")
   register_clcmd("say /make", "create_oberon")
}

public plugin_precache()
{
   oberon_model_id = precache_model(oberon_model)
   precache_model(oberon_knife_effect)
   precache_model(oberon_hole_effect)
   precache_model(oberon_bomb_model)
   
   precache_sound(oberon_appear_sound)
   precache_sound(oberon_death_sound)
   precache_sound(oberon_evolution_sound)
   for(new i = 0; i < sizeof(oberon_attack_sound); i++)
   {
      precache_sound(oberon_attack_sound[i])
   }
   precache_sound(oberon_hole_sound)
   precache_sound(oberon_bomb_sound)
   
   m_iBlood[0] = precache_model("sprites/blood.spr")
   m_iBlood[1] = precache_model("sprites/bloodspray.spr")   
   exp_spr_id = precache_model("sprites/zerogxplode.spr")
}

public event_newround()
{
   static ent
   ent = find_ent_by_class(-1, OBERON_CLASSNAME)
   
   if(task_exists(ent+TASK_SKILL)) remove_task(ent+TASK_SKILL)
}

public get_origin(id)
{
   pev(id, pev_origin, g_cur_origin)
   pev(id, pev_angles, g_cur_angles)
   pev(id, pev_v_angle, g_cur_v_angle)
   
   client_print(id, print_chat, "ORIGEM SALVA!")
}

public create_oberon(id)
{
   new ent = create_entity("info_target")
   
   entity_set_origin(ent, g_cur_origin)
   entity_set_vector(ent, EV_VEC_angles, g_cur_angles)
   //entity_set_vector(ent, EV_VEC_v_angle, g_cur_v_angle)
   
   entity_set_float(ent, EV_FL_takedamage, 1.0)
   entity_set_float(ent, EV_FL_health, OBERON_HEALTH + 1000.0)
   
   entity_set_string(ent,EV_SZ_classname, OBERON_CLASSNAME)
   entity_set_model(ent, oberon_model)
   entity_set_int(ent, EV_INT_solid, SOLID_SLIDEBOX)
   entity_set_int(ent, EV_INT_movetype, MOVETYPE_STEP)
   
   new Float:maxs[3] = {100.0, 100.0, 100.0}
   new Float:mins[3] = {-100.0, -100.0, -30.0}
   entity_set_size(ent, mins, maxs)
   entity_set_int(ent, EV_INT_modelindex, oberon_model_id)
   
   set_entity_anim(ent, 1)
   
   set_pev(ent, pev_iuser4, 0)
   
   entity_set_float(ent, EV_FL_nextthink, halflife_time() + 6.0)
   set_task(5.0, "start_oberon", ent)
   
   set_task(15.0, "do_random_skill", ent, _, _, "b")
   
   if(!g_reg)
   {
      RegisterHamFromEntity(Ham_TakeDamage, ent, "fw_takedmg", 1)
      RegisterHamFromEntity(Ham_Think, ent, "fw_think")
      g_reg = 1
   }   
   
   g_evolution = 0
   g_evoluting = 0
   g_doing_other = 0
   
   drop_to_floor(ent)
   emit_sound(ent, CHAN_BODY, oberon_appear_sound, 1.0, ATTN_NORM, 0, PITCH_NORM)
}

public start_oberon(ent)
{
   set_entity_anim(ent, 2)
}

public fw_think(ent)
{
   if(!is_valid_ent(ent))
      return HAM_IGNORED
      
   if(pev(ent, pev_iuser4) == 1) // Oberon is dead
      return HAM_IGNORED
      
   if(g_evoluting || g_doing_other)
      return HAM_IGNORED
      
   if(pev(ent, pev_health) - 1000.0 <= 0.0)
   {
      set_pev(ent, pev_iuser4, 1)
      set_entity_anim(ent, 20)
      set_task(15.0, "move_entity", ent)
      entity_set_int(ent, EV_INT_solid, SOLID_NOT)
      entity_set_float(ent, EV_FL_takedamage, 0.0)
      
      emit_sound(ent, CHAN_BODY, oberon_death_sound, 1.0, ATTN_NORM, 0, PITCH_NORM)
      
      return HAM_IGNORED
   }
   if((pev(ent, pev_health) - 1000.0 <= OBERON_HEALTH / 2.0) && !g_evolution)
   {
      g_evoluting = 1
      set_entity_anim(ent, 11)
      
      emit_sound(ent, CHAN_BODY, oberon_evolution_sound, 1.0, ATTN_NORM, 0, PITCH_NORM)
      set_task(8.0, "set_new_idle", ent)
      
      return HAM_IGNORED
   }   
   
   static victim
   static Float:Origin[3], Float:VicOrigin[3], Float:distance
   
   victim = FindClosesEnemy(ent)
   pev(ent, pev_origin, Origin)
   pev(victim, pev_origin, VicOrigin)
   
   distance = get_distance_f(Origin, VicOrigin)
   
   if(is_user_alive(victim))
   {
      if(distance <= 250.0)
      {
         if(!is_valid_ent(ent))
            return FMRES_IGNORED   
      
         new Float:Ent_Origin[3], Float:Vic_Origin[3]
         
         pev(ent, pev_origin, Ent_Origin)
         pev(victim, pev_origin, Vic_Origin)         
      
         npc_turntotarget(ent, Ent_Origin, victim, Vic_Origin)
         
         static Attack_Type, attack_anim, attack_sound
         Attack_Type = random_num(1, 2)
         
         if(Attack_Type == 1)
         {
            if(g_evolution)
            {
               attack_anim = 14
               attack_sound = 4
            } else {
               attack_anim = 6
               attack_sound = 0
            }
            
            set_entity_anim(ent, attack_anim)
            emit_sound(ent, CHAN_BODY, oberon_attack_sound[attack_sound], 1.0, ATTN_NORM, 0, PITCH_NORM)
            
            set_task(1.0, "do_takedmg", ent)
            
            entity_set_float(ent, EV_FL_nextthink, get_gametime() + 3.0)
         } else {
            if(g_evolution)
            {
               attack_anim = 15
               attack_sound = 5
            } else {
               attack_anim = 7
               attack_sound = 1
            }
               
            set_entity_anim(ent, attack_anim)   
            emit_sound(ent, CHAN_BODY, oberon_attack_sound[attack_sound], 1.0, ATTN_NORM, 0, PITCH_NORM)
            
            set_task(0.5, "do_takedmg", ent)         
            
            entity_set_float(ent, EV_FL_nextthink, get_gametime() + 3.0)
         }
         
      } else {
         static moving_anim
         
         if(g_evolution)
            moving_anim = 13
         else
            moving_anim = 3      
      
         if(pev(ent, pev_sequence) != moving_anim)
         {
            entity_set_float(ent, EV_FL_animtime, get_gametime())
            entity_set_float(ent, EV_FL_framerate, 1.0)
            entity_set_int(ent, EV_INT_sequence, moving_anim)
         }
            
         new Float:Ent_Origin[3], Float:Vic_Origin[3]
         
         pev(ent, pev_origin, Ent_Origin)
         pev(victim, pev_origin, Vic_Origin)
         
         npc_turntotarget(ent, Ent_Origin, victim, Vic_Origin)
         hook_ent(ent, victim, 100.0)
         
         entity_set_float(ent, EV_FL_nextthink, get_gametime() + 0.1)
      }
   } else {
      static idle_anim
      
      if(g_evolution)
         idle_anim = 12
      else
         idle_anim = 2
         
      if(pev(ent, pev_sequence) != idle_anim)
      {
         set_entity_anim(ent, idle_anim)
      }   
         
      entity_set_float(ent, EV_FL_nextthink, get_gametime() + 1.0)
   }   
      
   return HAM_HANDLED
}

public do_random_skill(ent)
{
   if(!pev_valid(ent))
      return PLUGIN_HANDLED
      
   if(g_evoluting)
      return PLUGIN_HANDLED
      
   if(pev(ent, pev_health) - 1000.0 <= 0.0)
      return PLUGIN_HANDLED
   
   static random_skill
   random_skill = random_num(0, 100)
   
   g_doing_other = 1
   
   switch(random_skill)
   {
      case 0..37: {
         do_attack3(ent)
         
      }
      case 38..72: {
         do_hole(ent)
      }
      case 73..100: {
         do_bomb(ent)
      }      
   }   
   
   return PLUGIN_CONTINUE
}

public do_bomb(oberon)
{
   g_doing_other = 1
   
   static bomb_anim
   if(g_evolution)
      bomb_anim = 18
   else
      bomb_anim = 9
      
   set_entity_anim(oberon, bomb_anim)
   
   set_task(3.0, "do_skill_bomb", oberon+2015, _, _, "b")
   set_task(10.0, "stop_skill_bomb", oberon)
}

public stop_skill_bomb(oberon)
{
   remove_task(oberon+2015)
   
   static idle_anim
   
   if(g_evolution)
      idle_anim = 12
   else
      idle_anim = 2
      
   set_entity_anim(oberon, idle_anim)
   set_task(2.0, "reset_think", oberon)
}

public do_skill_bomb(oberon)
{
   oberon -= 2015
   static Float:StartOrigin[3], Float:TempOrigin[6][3], Float:VicOrigin[6][3], Float:Random1
   
   pev(oberon, pev_origin, StartOrigin)
   emit_sound(oberon, CHAN_BODY, oberon_bomb_sound, 1.0, ATTN_NORM, 0, PITCH_NORM)
   
   // 1st Bomb
   Random1 = random_float(100.0, 500.0)
   VicOrigin[0][0] = StartOrigin[0] + Random1
   VicOrigin[0][1] = StartOrigin[1]
   VicOrigin[0][2] = StartOrigin[2]
   
   TempOrigin[0][0] = VicOrigin[0][0] - (Random1 / 2.0)
   TempOrigin[0][1] = VicOrigin[0][1]
   TempOrigin[0][2] = VicOrigin[0][2] + 500.0
   
   // 2nd Bomb
   Random1 = random_float(100.0, 500.0)
   VicOrigin[1][0] = StartOrigin[0]
   VicOrigin[1][1] = StartOrigin[1] + Random1
   VicOrigin[1][2] = StartOrigin[2]
   
   TempOrigin[1][0] = VicOrigin[1][0]
   TempOrigin[1][1] = VicOrigin[1][1] - (Random1 / 2.0)
   TempOrigin[1][2] = VicOrigin[1][2] + 500.0   
   
   // 3rd Bomb
   Random1 = random_float(100.0, 500.0)
   VicOrigin[2][0] = StartOrigin[0] - Random1
   VicOrigin[2][1] = StartOrigin[1]
   VicOrigin[2][2] = StartOrigin[2]
   
   TempOrigin[2][0] = VicOrigin[2][0] - (Random1 / 2.0)
   TempOrigin[2][1] = VicOrigin[2][1]
   TempOrigin[2][2] = VicOrigin[2][2] + 500.0   
   
   // 4th Bomb
   VicOrigin[3][0] = StartOrigin[0]
   VicOrigin[3][1] = StartOrigin[1] - Random1
   VicOrigin[3][2] = StartOrigin[2]
   
   TempOrigin[3][0] = VicOrigin[3][0]
   TempOrigin[3][1] = VicOrigin[3][1] - (Random1 / 2.0)
   TempOrigin[3][2] = VicOrigin[3][2] + 500.0
   
   // 5th Bomb
   VicOrigin[4][0] = StartOrigin[0] + Random1
   VicOrigin[4][1] = StartOrigin[1] + Random1
   VicOrigin[4][2] = StartOrigin[2]
   
   TempOrigin[4][0] = VicOrigin[4][0] - (Random1 / 2.0)
   TempOrigin[4][1] = VicOrigin[4][1] - (Random1 / 2.0)
   TempOrigin[4][2] = VicOrigin[4][2] + 500.0
   
   // 6th Bomb
   VicOrigin[5][0] = StartOrigin[0] + Random1
   VicOrigin[5][1] = StartOrigin[1] - Random1
   VicOrigin[5][2] = StartOrigin[2]
   
   TempOrigin[5][0] = VicOrigin[5][0] + (Random1 / 2.0)
   TempOrigin[5][1] = VicOrigin[5][1] - (Random1 / 2.0)
   TempOrigin[5][2] = VicOrigin[5][2] + 500.0   
   
   for(new i = 0; i < 6; i++)
   {
      make_bomb(StartOrigin, TempOrigin[i], VicOrigin[i])
   }   
}

public make_bomb(Float:StartOrigin[3], Float:TempOrigin[3], Float:VicOrigin[3])
{
   new ent = create_entity("info_target")
   
   StartOrigin[2] += 20.0
   
   entity_set_origin(ent, StartOrigin)
   
   entity_set_string(ent,EV_SZ_classname, "oberon_bomb")
   entity_set_model(ent, oberon_bomb_model)
   entity_set_int(ent, EV_INT_solid, SOLID_NOT)
   entity_set_int(ent, EV_INT_movetype, MOVETYPE_BOUNCE)
   
   new Float:maxs[3] = {10.0,10.0,10.0}
   new Float:mins[3] = {-10.0,-10.0,-5.0}
   entity_set_size(ent, mins, maxs)
   
   entity_set_float(ent, EV_FL_animtime, get_gametime())
   entity_set_float(ent, EV_FL_framerate, 1.0)   
   entity_set_int(ent, EV_INT_sequence, 0)      
   
   static arg[4], arg2[4]
   
   arg[0] = ent
   arg[1] = floatround(TempOrigin[0])
   arg[2] = floatround(TempOrigin[1])
   arg[3] = floatround(TempOrigin[2])

   arg2[0] = ent
   arg2[1] = floatround(VicOrigin[0])
   arg2[2] = floatround(VicOrigin[1])
   arg2[3] = floatround(VicOrigin[2])   
   
   set_task(0.01, "do_hook_bomb_up", TASK_HOOKINGUP, arg, sizeof(arg), "b")
   set_task(1.0, "do_hook_bomb_down", _, arg2, sizeof(arg2))
   set_task(2.0, "bomb_explode", ent)
}

public bomb_explode(ent)
{
   remove_task(TASK_HOOKINGUP)
   remove_task(TASK_HOOKINGDOWN)
   
   static Float:Origin[3]
   pev(ent, pev_origin, Origin)
   
   message_begin(MSG_BROADCAST ,SVC_TEMPENTITY)
   write_byte(TE_EXPLOSION)
   engfunc(EngFunc_WriteCoord, Origin[0])
   engfunc(EngFunc_WriteCoord, Origin[1])
   engfunc(EngFunc_WriteCoord, Origin[2])
   write_short(exp_spr_id)   // sprite index
   write_byte(20)   // scale in 0.1's
   write_byte(30)   // framerate
   write_byte(0)   // flags
   message_end()   
   
   for(new i = 1; i < get_maxplayers(); i++)
   {
      if(is_user_alive(i) && entity_range(i, ent) <= 300.0)
      {
         static Float:Damage
         Damage = random_float(10.0, 30.0)
         
         if(g_evolution)
            Damage *= 2.0
            
         ExecuteHam(Ham_TakeDamage, i, 0, i, Damage, DMG_BLAST)
         hit_screen(i)
      }
   }   
   
   remove_entity(ent)
}

public do_hook_bomb_down(arg[4])
{
   remove_task(TASK_HOOKINGUP)
   set_task(0.01, "do_hook_bomb_down2", TASK_HOOKINGDOWN, arg, sizeof(arg), "b")
}

public do_hook_bomb_down2(arg[4])
{
   static ent, Float:VicOrigin[3]
   
   ent = arg[0]
   VicOrigin[0] = float(arg[1])
   VicOrigin[1] = float(arg[2])
   VicOrigin[2] = float(arg[3])   
   
   hook_ent2(ent, VicOrigin, 500.0)
}

public do_hook_bomb_up(arg[4])
{
   static ent, Float:TempOrigin[3]
   
   ent = arg[0]
   TempOrigin[0] = float(arg[1])
   TempOrigin[1] = float(arg[2])
   TempOrigin[2] = float(arg[3])
   
   hook_ent2(ent, TempOrigin, 500.0)
}

public do_hole(oberon)
{
   static hole_anim
   
   if(g_evolution)
      hole_anim = 19
   else
      hole_anim = 10
      
   set_entity_anim(oberon, hole_anim)
   emit_sound(oberon, CHAN_BODY, oberon_hole_sound, 1.0, ATTN_NORM, 0, PITCH_NORM)
   
   new ent = create_entity("info_target")
   
   static Float:Origin[3]
   pev(oberon, pev_origin, Origin)
   
   Origin[2] -= 10.0
   
   entity_set_origin(ent, Origin)
   
   entity_set_string(ent,EV_SZ_classname, "hole_hook")
   entity_set_model(ent, oberon_hole_effect)
   entity_set_int(ent, EV_INT_solid, SOLID_NOT)
   entity_set_int(ent, EV_INT_movetype, MOVETYPE_NONE)
   
   new Float:maxs[3] = {1.0,1.0,1.0}
   new Float:mins[3] = {-1.0,-1.0,-1.0}
   entity_set_size(ent, mins, maxs)
   
   entity_set_float(ent, EV_FL_animtime, get_gametime())
   entity_set_float(ent, EV_FL_framerate, 1.0)   
   entity_set_int(ent, EV_INT_sequence, 0)   
   
   set_pev(ent, pev_rendermode, kRenderTransAdd)
   set_pev(ent, pev_renderamt, 255.0)   
   
   drop_to_floor(ent)
   
   for(new i = 0; i < get_maxplayers(); i++)
   {
      if(is_user_alive(i) && entity_range(oberon, i) <= 1000.0)
      {
         static arg[2]
         arg[0] = oberon
         arg[1] = i
         
         set_task(0.01, "do_hook_player", 512512, arg, sizeof(arg), "b")
      }
   }
   
   set_task(5.0, "stop_hook", oberon+2012)   
}

public do_hook_player(arg[2])
{
   static Float:Origin[3], Float:Speed
   pev(arg[0], pev_origin, Origin)
   
   Speed = (1000.0 / entity_range(arg[0], arg[1])) * 75.0
   
   hook_ent2(arg[1], Origin, Speed)
}

public stop_hook(oberon)
{
   oberon -= 2012
   
   static ent
   ent = find_ent_by_class(-1, "hole_hook")
   
   remove_entity(ent)
   remove_task(512512)
   
   do_takedmg(oberon)
   set_task(1.0, "reset_think", oberon)
}

public do_attack3(ent)
{
   static attack3_anim, attack3_sound
   
   if(g_evolution)
   {
      attack3_anim = 16
      attack3_sound = 6
   } else {
      attack3_anim = 8
      attack3_sound = 2
   }   
   
   g_attacking3 = 1
   
   set_entity_anim(ent, attack3_anim)
   
   emit_sound(ent, CHAN_BODY, oberon_attack_sound[attack3_sound], 1.0, ATTN_NORM, 0, PITCH_NORM)
   set_task(0.1, "attack3_jump", ent)
}

public attack3_jump(ent)
{
   set_task(0.01, "hookingup", ent+TASK_HOOKINGUP, _, _, "b")
   set_task(1.0, "hookingdown", ent+TASK_HOOKINGDOWN)   
   
   static Enemy
   Enemy = FindClosesEnemy(ent)   
   
   pev(Enemy, pev_origin, g_attacking3_origin)
}

public hookingup(ent)
{
   ent -= TASK_HOOKINGUP
   
   static Float:Origin[3]
   pev(ent, pev_origin, Origin)
   
   Origin[2] += 1000.0
   
   hook_ent2(ent, Origin, 1000.0)
   
   static Enemy
   Enemy = FindClosesEnemy(ent)   
   
   new Float:Ent_Origin[3], Float:Vic_Origin[3]
   
   pev(ent, pev_origin, Ent_Origin)
   pev(Enemy, pev_origin, Vic_Origin)
   
   npc_turntotarget(ent, Ent_Origin, Enemy, Vic_Origin)   
}

public hookingdown(ent)
{
   ent -= TASK_HOOKINGDOWN
   
   remove_task(ent+TASK_HOOKINGUP)
   set_task(0.5, "set_func1", ent)
   
   set_task(0.01, "hookingdown2", ent+TASK_HOOKINGDOWN, _, _, "b")
}

public set_func1(ent)
{
   set_pev(ent, pev_iuser3, 1)
}

public hookingdown2(ent)
{
   ent -= TASK_HOOKINGDOWN
   
   static Enemy
   Enemy = FindClosesEnemy(ent)
   
   hook_ent2(ent, g_attacking3_origin, 1000.0)
   
   new Float:Ent_Origin[3], Float:Vic_Origin[3]
   
   pev(ent, pev_origin, Ent_Origin)
   pev(Enemy, pev_origin, Vic_Origin)
   
   npc_turntotarget(ent, Ent_Origin, Enemy, Vic_Origin)      
}

public fw_touch(ent, touch)
{
   if(!pev_valid(ent))
      return FMRES_IGNORED
      
   if(g_attacking3 && pev(ent, pev_iuser3) == 1)
   {
      remove_task(ent+TASK_HOOKINGDOWN)
      
      if(is_user_alive(touch))
         user_kill(touch)
         
      g_attacking3 = 0
      set_pev(ent, pev_iuser3, 0)
      
      set_task(0.75, "reset_think", ent)
      
      for(new i = 1; i < get_maxplayers(); i++)
      {
         if(is_user_alive(i) && entity_range(ent, i) <= 300.0)
         {
            hit_screen(i)
            
            static Float:Damage
            Damage = random_float(10.0, 25.0)
            
            if(g_evolution)
               Damage *= 1.5
            
            ExecuteHam(Ham_TakeDamage, i, 0, i, Damage, DMG_BLAST)
         }
      }   
      
      static attack3_sound
      if(g_evolution)
         attack3_sound = 7
      else
         attack3_sound = 3
      
      emit_sound(ent, CHAN_BODY, oberon_attack_sound[attack3_sound], 1.0, ATTN_NORM, 0, PITCH_NORM)      
         
      drop_to_floor(ent)
   }
      
   return FMRES_HANDLED
}

public do_takedmg(ent2)
{
   if(g_evolution)
   {
      new ent = create_entity("info_target")
   
      static Float:Origin[3], Float:Angles[3]
      pev(ent2, pev_origin, Origin)
      pev(ent2, pev_angles, Angles)
      
      entity_set_origin(ent, Origin)
      entity_set_vector(ent, EV_VEC_angles, Angles)
      
      entity_set_string(ent,EV_SZ_classname, "knife_effect")
      entity_set_model(ent, oberon_knife_effect)
      entity_set_int(ent, EV_INT_solid, SOLID_NOT)
      entity_set_int(ent, EV_INT_movetype, MOVETYPE_NONE)
      
      new Float:maxs[3] = {40.0, 40.0, 1.0}
      new Float:mins[3] = {-40.0, -40.0, -1.0}
      entity_set_size(ent, mins, maxs)
      
      drop_to_floor(ent)
      
      set_task(1.0, "remove_knife_effect", ent)
   }
   
   for(new i = 1; i < get_maxplayers(); i++)
   {
      if(is_user_alive(i) && entity_range(ent2, i) <= 300.0)
      {
         hit_screen(i)
         
         static Float:Damage
         Damage = random_float(7.5, 15.0)
         
         if(g_evolution)
            Damage *= 2.0
         
         ExecuteHam(Ham_TakeDamage, i, 0, i, Damage, DMG_BLAST)
      }
   }   
}

public remove_knife_effect(ent)
{
   remove_entity(ent)
}

public set_new_idle(ent)
{
   g_evoluting = 0
   g_evolution = 1
   set_entity_anim(ent, 12)
   
   entity_set_float(ent, EV_FL_nextthink, get_gametime() + 0.1)
}

public move_entity(ent)
{
   static Float:Origin[3]
   
   Origin[0] = 4290.0
   Origin[1] = 4290.0
   Origin[2] = 4290.0
   
   set_pev(ent, pev_origin, Origin)
   entity_set_float(ent, EV_FL_nextthink, halflife_time() + 99999999.0)
}

public fw_takedmg(victim, inflictor, attacker, Float:damage, damagebits)
{
   static Float:Origin[3]
   fm_get_aimorigin(attacker, Origin)
   
   client_print(attacker, print_center, "Remain Health: %i", floatround(pev(victim, pev_health) - 1000.0))
   
   create_blood(Origin)   
}

stock set_entity_anim(ent, anim)
{
   entity_set_float(ent, EV_FL_animtime, get_gametime())
   entity_set_float(ent, EV_FL_framerate, 1.0)
   entity_set_int(ent, EV_INT_sequence, anim)   
}

stock create_blood(const Float:origin[3])
{
   // Show some blood :)
   message_begin(MSG_BROADCAST, SVC_TEMPENTITY)
   write_byte(TE_BLOODSPRITE)
   engfunc(EngFunc_WriteCoord, origin[0])
   engfunc(EngFunc_WriteCoord, origin[1])
   engfunc(EngFunc_WriteCoord, origin[2])
   write_short(m_iBlood[1])
   write_short(m_iBlood[0])
   write_byte(75)
   write_byte(5)
   message_end()
}

stock fm_get_aimorigin(index, Float:origin[3])
{
   new Float:start[3], Float:view_ofs[3];
   pev(index, pev_origin, start);
   pev(index, pev_view_ofs, view_ofs);
   xs_vec_add(start, view_ofs, start);
   
   new Float:dest[3];
   pev(index, pev_v_angle, dest);
   engfunc(EngFunc_MakeVectors, dest);
   global_get(glb_v_forward, dest);
   xs_vec_mul_scalar(dest, 9999.0, dest);
   xs_vec_add(start, dest, dest);
   
   engfunc(EngFunc_TraceLine, start, dest, 0, index, 0);
   get_tr2(0, TR_vecEndPos, origin);
   
   return 1;
}  

public FindClosesEnemy(entid)
{
   new Float:Dist
   new Float:maxdistance=4000.0
   new indexid=0   
   for(new i=1;i<=get_maxplayers();i++){
      if(is_user_alive(i) && is_valid_ent(i) && can_see_fm(entid, i))
      {
         Dist = entity_range(entid, i)
         if(Dist <= maxdistance)
         {
            maxdistance=Dist
            indexid=i
            
            return indexid
         }
      }   
   }   
   return 0
}

public npc_turntotarget(ent, Float:Ent_Origin[3], target, Float:Vic_Origin[3])
{
   if(target)
   {
      new Float:newAngle[3]
      entity_get_vector(ent, EV_VEC_angles, newAngle)
      new Float:x = Vic_Origin[0] - Ent_Origin[0]
      new Float:z = Vic_Origin[1] - Ent_Origin[1]

      new Float:radians = floatatan(z/x, radian)
      newAngle[1] = radians * (180 / 3.14)
      if (Vic_Origin[0] < Ent_Origin[0])
         newAngle[1] -= 180.0
        
      entity_set_vector(ent, EV_VEC_angles, newAngle)
   }
}

public bool:can_see_fm(entindex1, entindex2)
{
   if (!entindex1 || !entindex2)
      return false

   if (pev_valid(entindex1) && pev_valid(entindex1))
   {
      new flags = pev(entindex1, pev_flags)
      if (flags & EF_NODRAW || flags & FL_NOTARGET)
      {
         return false
      }

      new Float:lookerOrig[3]
      new Float:targetBaseOrig[3]
      new Float:targetOrig[3]
      new Float:temp[3]

      pev(entindex1, pev_origin, lookerOrig)
      pev(entindex1, pev_view_ofs, temp)
      lookerOrig[0] += temp[0]
      lookerOrig[1] += temp[1]
      lookerOrig[2] += temp[2]

      pev(entindex2, pev_origin, targetBaseOrig)
      pev(entindex2, pev_view_ofs, temp)
      targetOrig[0] = targetBaseOrig [0] + temp[0]
      targetOrig[1] = targetBaseOrig [1] + temp[1]
      targetOrig[2] = targetBaseOrig [2] + temp[2]

      engfunc(EngFunc_TraceLine, lookerOrig, targetOrig, 0, entindex1, 0) //  checks the had of seen player
      if (get_tr2(0, TraceResult:TR_InOpen) && get_tr2(0, TraceResult:TR_InWater))
      {
         return false
      }
      else
      {
         new Float:flFraction
         get_tr2(0, TraceResult:TR_flFraction, flFraction)
         if (flFraction == 1.0 || (get_tr2(0, TraceResult:TR_pHit) == entindex2))
         {
            return true
         }
         else
         {
            targetOrig[0] = targetBaseOrig [0]
            targetOrig[1] = targetBaseOrig [1]
            targetOrig[2] = targetBaseOrig [2]
            engfunc(EngFunc_TraceLine, lookerOrig, targetOrig, 0, entindex1, 0) //  checks the body of seen player
            get_tr2(0, TraceResult:TR_flFraction, flFraction)
            if (flFraction == 1.0 || (get_tr2(0, TraceResult:TR_pHit) == entindex2))
            {
               return true
            }
            else
            {
               targetOrig[0] = targetBaseOrig [0]
               targetOrig[1] = targetBaseOrig [1]
               targetOrig[2] = targetBaseOrig [2] - 17.0
               engfunc(EngFunc_TraceLine, lookerOrig, targetOrig, 0, entindex1, 0) //  checks the legs of seen player
               get_tr2(0, TraceResult:TR_flFraction, flFraction)
               if (flFraction == 1.0 || (get_tr2(0, TraceResult:TR_pHit) == entindex2))
               {
                  return true
               }
            }
         }
      }
   }
   return false
}

public hook_ent(ent, victim, Float:speed)
{
   static Float:fl_Velocity[3]
   static Float:VicOrigin[3], Float:EntOrigin[3]

   pev(ent, pev_origin, EntOrigin)
   pev(victim, pev_origin, VicOrigin)
   
   static Float:distance_f
   distance_f = get_distance_f(EntOrigin, VicOrigin)

   if (distance_f > 60.0)
   {
      new Float:fl_Time = distance_f / speed

      fl_Velocity[0] = (VicOrigin[0] - EntOrigin[0]) / fl_Time
      fl_Velocity[1] = (VicOrigin[1] - EntOrigin[1]) / fl_Time
      fl_Velocity[2] = (VicOrigin[2] - EntOrigin[2]) / fl_Time
   } else
   {
      fl_Velocity[0] = 0.0
      fl_Velocity[1] = 0.0
      fl_Velocity[2] = 0.0
   }

   entity_set_vector(ent, EV_VEC_velocity, fl_Velocity)
}

public hook_ent2(ent, Float:VicOrigin[3], Float:speed)
{
   static Float:fl_Velocity[3]
   static Float:EntOrigin[3]

   pev(ent, pev_origin, EntOrigin)
   
   static Float:distance_f
   distance_f = get_distance_f(EntOrigin, VicOrigin)

   if (distance_f > 60.0)
   {
      new Float:fl_Time = distance_f / speed

      fl_Velocity[0] = (VicOrigin[0] - EntOrigin[0]) / fl_Time
      fl_Velocity[1] = (VicOrigin[1] - EntOrigin[1]) / fl_Time
      fl_Velocity[2] = (VicOrigin[2] - EntOrigin[2]) / fl_Time
   } else
   {
      fl_Velocity[0] = 0.0
      fl_Velocity[1] = 0.0
      fl_Velocity[2] = 0.0
   }

   entity_set_vector(ent, EV_VEC_velocity, fl_Velocity)
}

public hit_screen(id)
{
   message_begin(MSG_ONE, get_user_msgid("ScreenShake"),{0,0,0}, id)
   write_short(1<<14)
   write_short(1<<13)
   write_short(1<<13)
   message_end()   
}

public reset_think(ent)
{
   g_doing_other = 0
   entity_set_float(ent, EV_FL_nextthink, get_gametime() + 0.1)
}


Feelipe:: escreveu:Claro Que tem como colocar mais muito complicado de fazer so pagando
se vai conseguir isso

Feelipe:: escreveu:Claro Que tem como colocar mais muito complicado de fazer so pagando
se vai conseguir isso

Código:

// Боss скачан с сайта Zombie-Mod.ru
#include <amxmodx>
#include <amxmisc>
#include <engine>
#include <cstrike>
#include <hamsandwich>
#include <fakemeta>
#include < fun >
#include <zombieplague>

#define PLUGIN "[ZS] Alien Boss"
#define VERSION "3.0"
#define AUTHOR "Remake muxaz"

#define ANIM_DUMMY 0
#define ANIM_DEATH 1
#define ANIM_IDLE 2
#define ANIM_WALK 3
#define ANIM_RUN 4
#define ANIM_SHOCKWAVE 5
#define ANIM_JUSTICESWING 6
#define ANIM_MAHADASH 7

#define ALIEN_HEALTH 100000.0 // Жизнь Босса
//#define ALIEN_BONUS_KILL 5000 // Бонус для убийства Босса
#define ALIEN_ATTACK_DELAY 1.0 // Промежуток между атаками Босса
#define ALIEN_ATTACK_DISTANCE 160.0 // Дистанция для атаки Босса
#define ALIEN_DASH_DISTANCE 200.0 // Дистанция на каторую Босс прыгает

#define ALIEN_JUMP_AFTER_SWING_COUNT 4 // Отсчет между скиллами

#define ALIEN_TASK 231211
#define ALIEN_TASK1 113713
#define ALIEN_TASK2 123714
#define ALIEN_TASK3 133715
#define ALIEN_TASK4 143716

// Agression one - 1-ый уровенить агресси
#define ALIEN_SPEED_AG1 220 // Скорость Босса при 1 агрессии
#define ALIEN_DAMAGE_ATTACK_AG1 100.0 // Урон Босса при 1 агрессии
#define ALIEN_DASH_DAMAGE_AG1 100 // Урон Босса при использование скилла в 1 агрессии
#define ALIEN_SHOCK_SCREEN_RADIUS_AGRES1 800 // Радиус тряски и урона при волне в 1 агрессии
#define ALIEN_SHOCK_SCREEN_DAMAGE_AGRES1 50 // Урон от волны в 1 агрессии

// Agression two - 2-ой уровень агресси когда мень 50 % жизни у алиена
#define ALIEN_SPEED_AG2   260 // Скорость Босса при 2 агрессии
#define ALIEN_DAMAGE_ATTACK_AG2 100.0 // Урон Босса при 2 агрессии
#define ALIEN_DASH_DAMAGE_AG2 150 // Урон Босса при использование скилла в 2 агрессии
#define ALIEN_SHOCK_SCREEN_RADIUS_AGRES2 500 // Радиус тряски и урона при волне в 1 агрессии
#define ALIEN_SHOCK_SCREEN_DAMAGE_AGRES2 200 // Урон от волны в 2 агрессии

#define npc_classname    "zs_alien"
#define npc_model       "models/zombie_plague/boss_alien.mdl" // Модель Босса
#define npc_sprite      "sprites/zombie_plague/boss_health.spr" // Спрайт жизни Босса
#define SPRITE_Z       250 // Высота спрайта жизни

new const g_AlienSound[][] =
{
   "zombie_plague/boss_death.wav",
   "zombie_plague/boss_dash.wav",
   "zombie_plague/boss_swing.wav",
   "zombie_plague/boss_shokwave.wav"
}

new const g_CountSound[][] =
{
   "zombie_plague/vox/1.wav",
   "zombie_plague/vox/2.wav",
   "zombie_plague/vox/3.wav",
   "zombie_plague/vox/4.wav",
   "zombie_plague/vox/5.wav",
   "zombie_plague/vox/6.wav",
   "zombie_plague/vox/7.wav",
   "zombie_plague/vox/8.wav",
   "zombie_plague/vox/9.wav",
   "zombie_plague/vox/10.wav"
}

enum
{
   FM_CS_TEAM_UNASSIGNED = 0,
   FM_CS_TEAM_T,
   FM_CS_TEAM_CT,
   FM_CS_TEAM_SPECTATOR
}

new Float:g_dmg[512]
new Float:g_distance[512]
new Float:g_lastat[512]
new Float:g_atdelay[512]
new g_speed[512]
new g_moves[512]
new g_alive[512]
new g_target[512]
//new g_reward[512]
new g_animrun[512]
new g_exprew[512]
new g_animattack[512]
new g_ability
new g_timer
new g_game_start
new g_can_jump
new g_maxplayers
new g_pBeam
new g_pSprite
new g_jump_count[512]
new bool:start_swing[512]
new bool:start_knock[512]
new bool:g_bAlienLevel
new spr_blood_drop, spr_blood_spray
new g_screenshake
new const UNIT_SECOND = (1<<12)

// HoLLyWooD
#define TASK_CREATE_NPC    123124
#define ALIEN_CREATE_TASK    21341
new Float:g_fUserDamage[33]
new g_iRandomSkills = ALIEN_JUMP_AFTER_SWING_COUNT;
new bool:g_bChangeLevel = false;

// Command for changelevel
new const g_sVoteCommand[] = "amx_map de_cityrush";

new msgID_deathMsg, msgID_sayText;
new g_szName[33][32]

public plugin_init()
{
   register_plugin(PLUGIN, VERSION, AUTHOR)

   RegisterHam(Ham_Killed, "info_target", "npc_killed");
   RegisterHam(Ham_Killed, "player", "player_killed");
   RegisterHam(Ham_Think, "info_target", "npc_think");
   RegisterHam(Ham_TraceAttack, "info_target", "npc_traceattack");
   RegisterHam(Ham_TakeDamage, "info_target", "npc_takedamage")

   register_forward(FM_PlayerPreThink, "fw_PlayerPreThink");
   register_forward(FM_UpdateClientData, "fwd_UpdateClientData", 1);

   register_logevent("round_end", 2, "1=Round_End")
   register_event("DeathMsg", "event_death", "ae")

   register_clcmd("+attack", "block", g_timer)

   g_screenshake = get_user_msgid("ScreenShake")
   
   g_maxplayers = get_maxplayers()
   
   g_pSprite = create_entity("info_target");
   
   entity_set_model(g_pSprite, npc_sprite);
   
   entity_set_int(g_pSprite, EV_INT_rendermode, kRenderTransTexture);
   entity_set_float(g_pSprite, EV_FL_renderamt, 0.0);
   
   msgID_deathMsg = get_user_msgid("DeathMsg");
   msgID_sayText = get_user_msgid("SayText");
   
   register_message(msgID_deathMsg, "msg_deathMsg")
}

public plugin_precache()
{
   new mapname[32]
   get_mapname(mapname, charsmax(mapname))
   
   if(equali(mapname, "zp_boss_city"))
   {
      set_task(15.0, "begin_create_npc", TASK_CREATE_NPC);
   }else{
      pause("ad");
   }
   
   precache_model(npc_model)
   precache_model(npc_sprite)

   new i;
   for(i = 0 ; i < sizeof g_CountSound ; i++)
   precache_sound(g_CountSound[i]);

   for(i = 0 ; i < sizeof g_AlienSound ; i++)
   precache_sound(g_AlienSound[i]);
   
   spr_blood_drop = precache_model("sprites/blood.spr")
   spr_blood_spray = precache_model("sprites/bloodspray.spr")
   g_pBeam = precache_model( "sprites/shockwave.spr" )
}

public block(id)
   return PLUGIN_HANDLED;

public begin_create_npc(){
   spawn_alien();
}

public client_connect(id){
   g_fUserDamage[id] = 0.0
}

public spawn_alien()
{   
   set_task(1.0, "count_start", ALIEN_TASK)
   g_timer = 15 //26
   
   set_task(16.0, "create_alien", ALIEN_CREATE_TASK);
}

public create_alien()
{
   new Float:origin[3];
   
   // Origins for center map
   origin[0] = -27.0
   origin[0] = 24.0
   origin[2] = 460.0

   origin[1] += 50.0
   
   new ent = npc_alien_spawn(1, 1);
   
   set_pev(ent, pev_origin, origin);
   
   start_swing[ent] = false
   start_knock[ent] = false
   g_ability = false
   g_game_start = false
   g_jump_count[ent] = 0
   
   origin[2] += SPRITE_Z;
   
   entity_set_origin(g_pSprite, origin);
   
   entity_set_int(g_pSprite, EV_INT_rendermode, kRenderNormal);
   entity_set_float(g_pSprite, EV_FL_renderamt, 16.0);
   
   entity_set_float(g_pSprite, EV_FL_frame, 100.0);
   
   g_game_start = true;
}

public npc_alien_spawn(anim_run, exprew)
{
   new ent = create_entity("info_target");
   
   if(!ent) return 0;
   
   entity_set_string(ent, EV_SZ_classname, npc_classname);
   entity_set_model(ent, npc_model);
   
   entity_set_int(ent, EV_INT_iuser4, 0);
   entity_set_int(ent, EV_INT_solid, SOLID_BBOX);
   entity_set_int(ent, EV_INT_movetype, MOVETYPE_PUSHSTEP);
   
   entity_set_float(ent, EV_FL_takedamage, 1.0);
   entity_set_float(ent, EV_FL_gravity, 1.0);
   entity_set_float(ent, EV_FL_health, ALIEN_HEALTH);
   entity_set_float(ent, EV_FL_animtime, get_gametime());
   entity_set_float(ent, EV_FL_nextthink, get_gametime() + 1.0)
   
   Util_PlayAnimation(ent, ANIM_SHOCKWAVE);

   new Float: maxs[3] = { 16.0, 16.0, 60.0 }
   new Float: mins[3] = {-16.0, -16.0, -36.0}

   entity_set_size(ent, mins, maxs)

   g_alive[ent] = 1
   g_dmg[ent] = ALIEN_DAMAGE_ATTACK_AG1
   g_animrun[ent] = ANIM_RUN
   //g_reward[ent] = ALIEN_BONUS_KILL
   g_speed[ent] = ALIEN_SPEED_AG1
   g_distance[ent] = ALIEN_ATTACK_DISTANCE
   g_atdelay[ent] = ALIEN_ATTACK_DELAY
   g_lastat[ent] = 0.0
   g_exprew[ent] = exprew
   g_target[ent] = find_closes_enemy(ent)

   set_task(5.0, "update_target", ent)

   return ent;
}

public npc_think(ent)
{
   if(!is_valid_ent(ent))
      return;

   static className[32], animation;
   animation = 0;
   entity_get_string(ent, EV_SZ_classname, className, charsmax(className))

   if(!equali(className, npc_classname))
      return;
   
   if (!g_bAlienLevel)
      if (entity_get_float(ent, EV_FL_health) <= (ALIEN_HEALTH / 2.0))
      {
         g_bAlienLevel = true;
         
         g_speed[ent] = ALIEN_SPEED_AG2;
         g_dmg[ent] = ALIEN_DAMAGE_ATTACK_AG2;
      }
   
   if(g_alive[ent])
   {
      new Float:vecOrigin[3];
      
      entity_get_vector(ent, EV_VEC_origin, vecOrigin);
      
      vecOrigin[2] += SPRITE_Z;
      
      entity_set_origin(g_pSprite, vecOrigin);
      
      if(g_game_start)
      {
         new Float:velocity[3]
         pev(ent,pev_velocity,velocity)
         velocity[0] += velocity[1] + velocity[2]

         if(!is_user_alive(g_target[ent]))
            g_target[ent] = find_closes_enemy(ent)
      
         new Float:angle[3], Float:zmaim[3]
         pev(g_target[ent], pev_origin, zmaim)
         aim_at_origin(ent, zmaim, angle)
         angle[0] = 0.0
         entity_set_vector(ent, EV_VEC_angles, angle)

         if(g_target[ent])
         {
            new Float:origins[3]
            pev(ent, pev_origin, origins)
            new Float:flDistance = get_distance_f(origins, zmaim)
 
            if(flDistance> 170.0)
            {
               if(g_moves[ent])
               {
                  zmaim[0] += random_num(1, -1) * 80.0
                  zmaim[1] += random_num(1, -1) * 80.0
                  g_moves[ent] -= 1
               }
               else if(!g_moves[ent] && random_num(1, 5) == 1)
                  g_moves[ent] = 20
            }
            if(flDistance <= ALIEN_ATTACK_DISTANCE) g_moves[ent] = 0
            if(flDistance <= g_distance[ent] && get_gametime() - g_lastat[ent] > g_atdelay[ent])
            {
               if(!start_swing[ent] && !start_knock[ent])
               {
                  g_lastat[ent] = get_gametime()
      
                  new anim = ANIM_JUSTICESWING

                  Util_PlayAnimation(ent, ANIM_IDLE)
                  Util_PlayAnimation(ent, anim)
                  
                  ExecuteHamB(Ham_TakeDamage, g_target[ent] , 0, 0, g_dmg[ent], DMG_BULLET);
                  
                  set_task(2.0, "reset_swing", ent + ALIEN_TASK3)
                  start_swing[ent] = true
                  g_animattack[ent] = anim
               
                  if(anim == ANIM_JUSTICESWING)
                     emit_sound(ent, CHAN_VOICE, g_AlienSound[2], VOL_NORM, ATTN_NORM, 0, PITCH_NORM)
               
                  if(g_jump_count[ent] < g_iRandomSkills)
                     g_jump_count[ent]++
               }
            }
            else
            {            
               new Float:frames
               if(g_animattack[ent] == ANIM_JUSTICESWING) frames = 1.5
      
               if(get_gametime() - g_lastat[ent] > frames)
               {
                  if(flDistance <= g_distance[ent])
                     Util_PlayAnimation(ent, ANIM_IDLE)
                  else
                  {
                     if(g_jump_count[ent] == g_iRandomSkills && flDistance <= 400.0)
                     {
                        // change skill delay
                        g_iRandomSkills = random_num(2,4);
                        
                        if(!task_exists(ent + ALIEN_TASK2) && !task_exists(ent + ALIEN_TASK1))
                        {
                           new task_args[4]
                           task_args[0] = ent
                           task_args[1] = floatround(zmaim[0]*100000, floatround_floor)
                           task_args[2] = floatround(zmaim[1]*100000, floatround_floor)
                           task_args[3] = floatround(zmaim[2]*100000, floatround_floor)
                        
                           if(!g_ability)
                           {
                              g_ability = true
                              Util_PlayAnimation(ent, ANIM_MAHADASH)
                              emit_sound(ent, CHAN_VOICE, g_AlienSound[1], VOL_NORM, ATTN_NORM, 0, PITCH_NORM)
                        
                              set_task(0.8, "go_jump", ent + ALIEN_TASK1, task_args, 4)
                              
                              animation = 1;
                           }
                           else
                           {
                              if (entity_get_float(ent, EV_FL_health) > (ALIEN_HEALTH / 2))
                              {
                                 server_print("--------- 1");
                                 Util_PlayAnimation(ent, ANIM_SHOCKWAVE)
                                 start_knock[ent] = true
                                 set_task(2.1, "go_knock_agres1", ent + ALIEN_TASK1, task_args, 4)
                              }
                              else if (entity_get_float(ent, EV_FL_health) <= (ALIEN_HEALTH / 2))
                              {
                                 server_print("--------- 2");
                                 Util_PlayAnimation(ent, ANIM_SHOCKWAVE)
                                 start_knock[ent] = true
                                 set_task(2.1, "go_knock_agres2", ent + ALIEN_TASK1, task_args, 4)
                              }
                              
                              animation = 2;
                           }
                        }
                     }
                     else
                     {
                        ent_move_to(ent, zmaim, g_speed[ent])
                        Util_PlayAnimation(ent, g_animrun[ent])
                     }
                  }
               }
            }
         }
         if(!g_target[ent]) Util_PlayAnimation(ent, ANIM_IDLE)
      }
      else if(g_can_jump)
         Util_PlayAnimation(ent, ANIM_IDLE)
      else
         Util_PlayAnimation(ent, ANIM_IDLE)
      if(animation == 1)
         entity_set_float(ent, EV_FL_nextthink, get_gametime() + 0.8);
      else if(animation == 2)
         entity_set_float(ent, EV_FL_nextthink, get_gametime() + 2.1);
      else
         entity_set_float(ent, EV_FL_nextthink, get_gametime() + 0.01);
   }
}

public check_dash_damage(ent, id)
{
   ent = ent - ALIEN_TASK4
   
   for(new i = 0; i < g_maxplayers; i++)
   {
      if(is_user_alive(i))
      {
         new Float:range_distance = entity_range(ent, i)
         new health = get_user_health(i)
         
         if(ALIEN_DASH_DISTANCE < floatround(range_distance) < ALIEN_ATTACK_DISTANCE)
         {         
            if (g_bAlienLevel)
            {
               if(health - ALIEN_DASH_DAMAGE_AG2 > 0)
                  set_user_health(i, health - ALIEN_DASH_DAMAGE_AG2)
               else
               {
                  user_silentkill(i)
                  message_begin(MSG_ALL, get_user_msgid("DeathMsg"))
                  write_byte(ent)
                  write_byte(i)
                  write_byte(0)
                  write_string("Boss Alien")
                  message_end()
               }
            }
            else
            {
               if(health - ALIEN_DASH_DAMAGE_AG1 > 0)
                  set_user_health(i, health - ALIEN_DASH_DAMAGE_AG1)
               else
               {
                  user_silentkill(i)
                  message_begin(MSG_ALL, get_user_msgid("DeathMsg"))
                  write_byte(ent)
                  write_byte(i)
                  write_byte(0)
                  write_string("Boss Alien")
                  message_end()
               }
            }
         }
      }
   }
}

public go_knock_agres1(args[], id)
{
   new ent = args[0]
   new Float:origin[3]
   
   pev(ent,pev_origin,origin)
   message_begin(MSG_BROADCAST, SVC_TEMPENTITY );
   write_byte(TE_BEAMCYLINDER)
   write_coord(floatround(origin[0]))
   write_coord(floatround(origin[1]))
   write_coord(floatround(origin[2])-16)
   write_coord(floatround(origin[0]))
   write_coord(floatround(origin[1]))
   write_coord(floatround(0.0))
   write_short(g_pBeam) // sprite
   write_byte(0) // startframe
   write_byte(0) // framerate
   write_byte(25) // life
   write_byte(60) // width
   write_byte(0) // noise
   write_byte(255) // red
   write_byte(255) // green
   write_byte(0) // blue
   write_byte(200) // brightness
   write_byte(0) // speed
   message_end()
   
        emit_sound(ent, CHAN_VOICE, g_AlienSound[3], VOL_NORM, ATTN_NORM, 0, PITCH_NORM)
   
   set_task(1.0, "reset_knock", ent + ALIEN_TASK2)

   static Float:flOrigin[3] , Float:flDistance , Float:flSpeed
   for(new iVictim=1;iVictim <= 32;iVictim++)
   {
      new health = get_user_health(iVictim)

      if(is_user_connected(iVictim) && is_user_alive(iVictim))
      {
         pev(iVictim, pev_origin, flOrigin)
         flDistance = get_distance_f ( origin, flOrigin ) 

         if(flDistance <= ALIEN_SHOCK_SCREEN_RADIUS_AGRES1)
         {
            ScreenShake(iVictim)

            flSpeed = 1400.0
             
            static Float:flNewSpeed
            flNewSpeed = flSpeed * ( 1.0 - ( flDistance / 1000.0 ) )
            set_user_health(iVictim, health - ALIEN_SHOCK_SCREEN_DAMAGE_AGRES1)
             
            static Float:flVelocity [ 3 ]
            get_speed_vector ( origin, flOrigin, flNewSpeed, flVelocity )
             
            set_pev ( iVictim, pev_velocity,flVelocity )
         }
      }
   }
}

public go_knock_agres2(args[], id)
{
   new ent = args[0]
   new Float:origin[3]
   
   pev(ent,pev_origin,origin)
   message_begin(MSG_BROADCAST, SVC_TEMPENTITY );
   write_byte(TE_BEAMCYLINDER)
   write_coord(floatround(origin[0]))
   write_coord(floatround(origin[1]))
   write_coord(floatround(origin[2])-16)
   write_coord(floatround(origin[0]))
   write_coord(floatround(origin[1]))
   write_coord(floatround(0.0))
   write_short(g_pBeam) // sprite
   write_byte(0) // startframe
   write_byte(0) // framerate
   write_byte(10) // life
   write_byte(60) // width
   write_byte(0) // noise
   write_byte(250) // red
   write_byte(0) // green
   write_byte(0) // blue
   write_byte(200) // brightness
   write_byte(0) // speed
   message_end()
   
        emit_sound(ent, CHAN_VOICE, g_AlienSound[3], VOL_NORM, ATTN_NORM, 0, PITCH_NORM)
   
   set_task(1.0, "reset_knock", ent + ALIEN_TASK2)

   static Float:flOrigin[3] , Float:flDistance , Float:flSpeed
   for(new iVictim=1;iVictim <= 32;iVictim++)
   {
      new health = get_user_health(iVictim)

      if(is_user_connected(iVictim) && is_user_alive(iVictim))
      {
         pev(iVictim, pev_origin, flOrigin)
         flDistance = get_distance_f ( origin, flOrigin ) 

         if(flDistance <= ALIEN_SHOCK_SCREEN_RADIUS_AGRES2)
         {
            ScreenShake(iVictim)

            flSpeed = 1400.0
             
            static Float:flNewSpeed
            flNewSpeed = flSpeed * ( 1.0 - ( flDistance / 1000.0 ) )
            set_user_health(iVictim, health - ALIEN_SHOCK_SCREEN_DAMAGE_AGRES2)
             
            static Float:flVelocity [ 3 ]
            get_speed_vector ( origin, flOrigin, flNewSpeed, flVelocity )
             
            set_pev ( iVictim, pev_velocity,flVelocity )
         }
      }
   }
}

public ScreenShake(id)
{
   if(!is_user_alive(id))
      return;

   message_begin(MSG_ONE_UNRELIABLE, g_screenshake, _, id)
   write_short(UNIT_SECOND*7) // amplitude
   write_short(UNIT_SECOND*5) // duration
   write_short(UNIT_SECOND*15) // frequency
   message_end()
}

public reset_knock(ent)
{
   ent = ent - ALIEN_TASK2
   
   start_knock[ent] = false
   g_ability = false
   g_jump_count[ent] = 0
}

public go_jump(args[])
{
   new ent = args[0]
   new Float:zmaim[3]
   
   zmaim[0]=float(args[1]/100000)
   zmaim[1]=float(args[2]/100000)
   zmaim[2]=float(args[3]/100000)
   
   ent_jump_to(ent, zmaim, 1700)
   
   g_can_jump = true
   
   set_task(0.6, "check_dash_damage", ent + ALIEN_TASK4)
   set_task(1.4, "reset_jump", ent + ALIEN_TASK2)
}

public reset_swing(ent)
{
   ent = ent - ALIEN_TASK3
   start_swing[ent] = false
}

public reset_jump(ent)
{
   ent = ent - ALIEN_TASK2
   g_jump_count[ent] = 0
   set_task(0.5, "reset_time", ent + 55555)
}

public reset_time()
   g_can_jump = false

public zp_user_infected_pre(id, inflector, nemesis){
   zp_disinfect_user(id, 1);
   return ZP_PLUGIN_HANDLED;
}

public zp_user_infect_attempt(id, inflector, nemesis){
   zp_disinfect_user(id, 1);
   return ZP_PLUGIN_HANDLED;
}
   
public npc_takedamage(ent, inflictor, attacker, Float:damage, damage_type)
{
   if(!is_user_alive(attacker) || !is_valid_ent(ent))
      return;

   new className[32];
   entity_get_string(ent, EV_SZ_classname, className, charsmax(className))

   if(!equali(className, npc_classname) || !g_alive[ent])
      return;
   
   g_fUserDamage[attacker] += damage;
   
   //client_print(attacker, print_center, "%f" , g_fUserDamage[attacker]);
   if(g_fUserDamage[attacker] >= 2000){
      g_fUserDamage[attacker] -= 2000;
      
      zp_set_user_ammo_packs(attacker, zp_get_user_ammo_packs(attacker)+1);
   }
   
   entity_set_float(g_pSprite, EV_FL_frame, entity_get_float(ent, EV_FL_health) / (ALIEN_HEALTH / 100.0));
}

public fw_PlayerPreThink(id)
{
   if(cs_get_user_team(id) == CS_TEAM_T)
      cs_set_user_team(id, CS_TEAM_CT)
}

public force_team(id)
{
   engclient_cmd(id, "jointeam", "2", "3")
}

public npc_traceattack(ent, attacker, Float: damage, Float: direction[3], trace, damageBits)
{
   if(!is_valid_ent(ent) || !g_alive[ent])
      return;

   new className[32];
   entity_get_string(ent, EV_SZ_classname, className, charsmax(className))

   if(!equali(className, npc_classname) || !g_alive[ent])
      return;

   new Float: end[3]
   get_tr2(trace, TR_vecEndPos, end);

   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(spr_blood_spray)
   write_short(spr_blood_drop)
   write_byte(247)
   write_byte(random_num(5, 10))
   message_end()
}

public player_killed(ent, attacker)
{   
   for(new id=1;id<g_maxplayers;id++)
   {
      if(is_user_alive(id))
         return;
   }
   
   begin_changelevel();
   client_print(0, print_chat, "Все люди умерли! Смена карты началась!");
}

public npc_killed(ent, attacker)
{
   new className[32];
   entity_get_string(ent, EV_SZ_classname, className, charsmax(className))

   if(!equali(className, npc_classname) || !g_alive[ent])
      return HAM_IGNORED;

   g_alive[ent] = 0
   Util_PlayAnimation(ent, ANIM_DEATH);
   emit_sound(ent, CHAN_VOICE, g_AlienSound[0], VOL_NORM, ATTN_NORM, 0, PITCH_NORM)
   remove_task(ent)
   set_pev(ent, pev_solid, SOLID_NOT)
   set_task(4.5, "npc_remove", ent)

   entity_set_int(ent, EV_INT_iuser4, 1);

   //cs_set_user_money(attacker, cs_get_user_money(attacker) + g_reward[ent])
   
   zp_set_user_ammo_packs(attacker, zp_get_user_ammo_packs(attacker) + random_num(40,60));
   
   entity_set_int(g_pSprite, EV_INT_rendermode, kRenderTransTexture);
   entity_set_float(g_pSprite, EV_FL_renderamt, 0.0);
   
   begin_changelevel();
   
   client_print(0, print_chat, "Босс умер! Смена карты началась!");

   return HAM_SUPERCEDE;
}

public round_end()
{   
   remove_task(ALIEN_TASK)
   remove_task(ALIEN_TASK1)
   remove_task(ALIEN_TASK2)
   remove_task(ALIEN_TASK3)
   remove_task(ALIEN_TASK4)

   g_game_start = false
   
   begin_changelevel();
}

public event_death(id)
{
   static ent = -1;
   
   while ((ent = engfunc(EngFunc_FindEntityByString, ent, "classname", npc_classname)) != 0)
   {
      if(g_target[ent] == id)
         g_target[ent] = find_closes_enemy(ent)
   }
   client_cmd(id, "stopsound")
   
   new iVictim = read_data(2)
   new iKiller = read_data(1)
   new iHS = read_data(3)
   new szWeapon[24]
   read_data(4, szWeapon, 23)
   
   if(!is_user_connected(iVictim))
   {
      do_deathmsg(iKiller, iVictim, iHS, szWeapon)
      return PLUGIN_CONTINUE
   }
   
   if(!is_user_connected(iKiller) && iKiller != ent)
   {
      do_deathmsg(iKiller, iVictim, iHS, szWeapon)
      return PLUGIN_CONTINUE
   }
   
   if(iKiller != iVictim && iKiller == ent)
   {      
      new iNewKiller
      for(new i = 1; i < g_maxplayers; i++){
         if(is_user_connected(i) && i != iVictim && !is_user_admin(id))
         {
            iNewKiller = i;
            break;
         }
      }
      
      if(!iNewKiller || iNewKiller == iKiller)
      {
         do_deathmsg(iVictim, iVictim, iHS, szWeapon)
         return PLUGIN_HANDLED;
      }
      
      new szName[32];

      get_user_name(iNewKiller, szName, 31)
      g_szName[iNewKiller] = szName

      set_msg_block(msgID_sayText, BLOCK_ONCE);
      set_user_info(iNewKiller, "name", "ALIEN BOSS");
      
      new args[4]

      args[0] = iVictim
      args[1] = iNewKiller
      args[2] = iHS
      
      set_task(0.01, "player_diePost", 0, args, 3)
   }
   else
   {
      do_deathmsg(iVictim, iVictim, iHS, szWeapon)
   }
   
   return PLUGIN_CONTINUE;
}

public player_diePost(arg[])
{
   new szWeapon[24] = "allien_boss_attack";
   new iKiller = arg[1]
   
   new CsTeams:tempteam = cs_get_user_team(iKiller);
   cs_set_user_team(iKiller, CS_TEAM_T);
   
   do_deathmsg(iKiller, arg[0], arg[2], szWeapon)
   
   cs_set_user_team(iKiller, tempteam);

   set_msg_block(msgID_sayText, BLOCK_ONCE)
   set_user_info(iKiller, "name", g_szName[iKiller])

   return PLUGIN_CONTINUE
}

public npc_remove(ent)
{   
   remove_task(ALIEN_TASK)
   remove_task(ALIEN_TASK1)
   remove_task(ALIEN_TASK2)
   remove_task(ALIEN_TASK3)
   remove_task(ALIEN_TASK4)
   
   remove_entity(ent)
   remove_task(ent)
   
   g_jump_count[ent] = 0
   g_game_start = false
}

public count_start(ent)
{
   g_timer = g_timer - 1
   
   if(g_timer > 0)
      client_print(0, print_center, "Игра начнётся через %d секунд.", g_timer)
   
   if(g_timer < 11)
      client_cmd(0, "spk zombie_plague/vox/%d", g_timer)
   
   if(g_timer >= 0)
      set_task(1.0, "count_start", ALIEN_TASK)
      
   if(g_timer == 0)
   {
      client_print(0, print_center, "Alien Boss появился убейте его!")
      g_game_start = true
   }
}

public update_target(ent)
{
   if(!is_valid_ent(ent))
      return;

   g_target[ent] = find_closes_enemy(ent)
   set_task(5.0, "update_target", ent)
}

public msg_deathMsg()
   return PLUGIN_HANDLED;

public begin_changelevel(){   
   g_bChangeLevel = true;
   
   new ent;
   if((ent = engfunc(EngFunc_FindEntityByString, ent, "classname", npc_classname)) != 0)
      npc_remove(ent);
   
   for(new id=1; id<g_maxplayers; id++)
   {
      if(is_user_alive(id))
      {
         set_pev(id, pev_velocity, 1.0);
         set_pev(id, pev_maxspeed, 1.0);
      }
   }
   
   server_cmd(g_sVoteCommand);
}

public fwd_UpdateClientData(id, weapons, cd)
{
   if(id < 0 || id > g_maxplayers)
      return FMRES_IGNORED
      
   if(g_bChangeLevel)
   {
      set_cd(cd, CD_flNextAttack, 0.5)
      set_cd(cd, CD_MaxSpeed, 1.0)
      return FMRES_HANDLED
   }
   
   return FMRES_IGNORED
}

stock do_deathmsg(iKiller, iVictim, iHS, const szWeapon[])
{
   message_begin(MSG_ALL, msgID_deathMsg)
   write_byte(iKiller)
   write_byte(iVictim)
   write_byte(iHS)
   write_string(szWeapon)
   message_end()
}

stock find_closes_enemy(ent)
{
   new enemy, Float:dist, Float:distmin, Float:origin[3], Float:originT[3]
   pev(ent, pev_origin, origin)
   origin[2] += 120.0
   
   for(new id=1; id<=32; id++)
   {
      if (!is_user_alive(id)) continue;

      dist = entity_range(ent, id)
      pev(id, pev_origin, originT)
      if ((!distmin || dist <= distmin))
      {
         distmin = dist
         enemy = id
      }
   }   

   return enemy
}

stock ent_move_to(ent, Float:target[3], speed)
{
   static Float:vec[3]
   aim_at_origin(ent, target, vec)
   engfunc(EngFunc_MakeVectors, vec)
   global_get(glb_v_forward, vec)
   vec[0] *= speed
   vec[1] *= speed
   vec[2] *= speed * 0.1
   set_pev(ent, pev_velocity, vec)
      
   new Float:angle[3]
   aim_at_origin(ent, target, angle)
   angle[0] = 0.0
   entity_set_vector(ent, EV_VEC_angles, angle)
}

stock ent_jump_to(ent, Float:target[3], speed)
{
   static Float:vec[3]
   aim_at_origin(ent, target, vec)
   engfunc(EngFunc_MakeVectors, vec)
   global_get(glb_v_forward, vec)
   vec[0] *= speed
   vec[1] *= speed
   vec[2] *= speed * 0.1
   set_pev(ent, pev_velocity, vec)
      
   new Float:angle[3]
   aim_at_origin(ent, target, angle)
   angle[0] = 0.0
   entity_set_vector(ent, EV_VEC_angles, angle)
   
}

stock aim_at_origin(id, Float:target[3], Float:angles[3])
{
   static Float:vec[3]
   pev(id, pev_origin, vec)
   vec[0] = target[0] - vec[0]
   vec[1] = target[1] - vec[1]
   vec[2] = target[2] - vec[2]
   engfunc(EngFunc_VecToAngles, vec, angles)
   angles[0] *= -1.0, angles[2] = 0.0
}

stock get_speed_vector(const Float:origin1[3], const Float:origin2[3], Float:speed, Float:new_velocity[3])
{
   new_velocity[0] = origin2[0] - origin1[0]
   new_velocity[1] = origin2[1] - origin1[1]
   new_velocity[2] = origin2[2] - origin1[2]
   new Float:num = floatsqroot(speed*speed / (new_velocity[0]*new_velocity[0] + new_velocity[1]*new_velocity[1] + new_velocity[2]*new_velocity[2]))
   new_velocity[0] *= num
   new_velocity[1] *= num
   new_velocity[2] *= num
     
   return 1;
}

stock Util_PlayAnimation(index, sequence, Float: framerate = 1.0)
{
   if(entity_get_int(index, EV_INT_sequence) == sequence) return;

   entity_set_float(index, EV_FL_animtime, get_gametime());
   entity_set_float(index, EV_FL_framerate, framerate);
   entity_set_float(index, EV_FL_frame, 0.0);
   entity_set_int(index, EV_INT_sequence, sequence);
}

stock bool:is_hull_vacant(const Float:origin[3], hull,id)
{
   static tr
   engfunc(EngFunc_TraceHull, origin, origin, 0, hull, id, tr)
   if (!get_tr2(tr, TR_StartSolid) || !get_tr2(tr, TR_AllSolid))
   return true

   return false
}

stock fm_set_user_health(id, health)
{
   (health > 0) ? set_pev(id, pev_health, float(health)) : dllfunc(DLLFunc_ClientKill, id);
}

// Босс скачан с сайта Zombie-Mod.ru