Código:

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

#define NAME      "AlienBoss Special For Zombie-Mod.Ru"
#define VERSION      "Public"
#define AUTHOR      "Alexander.3 / Edit: Optimist"

const alien_hp =      25000
const boss_speed =      200
const Float:prepare_time =   15.0
const dmg_attack =      50
const dmg_ms =         50
const dmg_sw =         50

static Float:Origin[3]

static g_Alien
static g_BossTarget
static VictimID
static Float:g_Health

static Ability

new const Resource[][] = {
   "models/npc/alien/alien.mdl",
   "sprites/blood.spr",
   "sprites/bloodspray.spr",
   "sprites/npc/hp.spr",
   "sprites/shockwave.spr",   // 4
   "sprites/npc/alien/fluxing.spr" // 5
}
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"
}

static g_Resource[sizeof Resource]

enum {
   IDLE,
   WALK,
   MS,
   ATTACK,
   SW
}

public plugin_precache()
{
   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]);
   
   for(new i; i <= charsmax(Resource); i++)
      g_Resource[i] = precache_model(Resource[i])
}

public plugin_init() {
   register_plugin(NAME, VERSION, AUTHOR)
   
   register_clcmd("say /create", "create", ADMIN_RCON)
   register_clcmd("say /spawn", "spawn", ADMIN_RCON)
      
   register_think("AlienBossik", "Think_Boss")
   register_think("HP", "Think_HP")
   
   register_touch("AlienBossik", "player", "Touch_Boss")
   
   RegisterHam(Ham_TakeDamage, "info_target", "TakeDamage", ADMIN_RCON)
   RegisterHam(Ham_TraceAttack, "info_target", "TraceAttack", ADMIN_RCON)
}

public RandomAbility(taskid) {
   if (Ability != WALK)
      return
   
   switch(random(2)) {
      case 0: Ability = MS
      case 1: Ability = SW
   }
}

public create(id)
if (get_user_flags(id) & ADMIN_RCON)
{
   pev(id, pev_origin, Origin)
}
   
public spawn(id)
{
   if (get_user_flags(id) & ADMIN_RCON)
   {
      g_Alien = engfunc(EngFunc_CreateNamedEntity, engfunc(EngFunc_AllocString, "info_target"))
      new HPspr = engfunc(EngFunc_CreateNamedEntity, engfunc(EngFunc_AllocString, "info_target"))
   
      engfunc(EngFunc_SetModel, g_Alien, Resource[0])
      engfunc(EngFunc_SetSize, g_Alien, { -32.0, -32.0, -36.0 }, { 32.0, 32.0, 96.0 })
      engfunc(EngFunc_SetOrigin, g_Alien, Origin)
   
      set_pev(g_Alien, pev_classname, "AlienBossik")
      set_pev(g_Alien, pev_solid, SOLID_BBOX)
      set_pev(g_Alien, pev_movetype, MOVETYPE_PUSHSTEP)
      set_pev(g_Alien, pev_takedamage, DAMAGE_NO)
      set_pev(g_Alien, pev_health, float(alien_hp))
      set_pev(g_Alien, pev_deadflag, DEAD_NO)
      set_pev(g_Alien, pev_nextthink, get_gametime() + prepare_time)
   
      Ability = IDLE
      Anim(g_Alien, 2)
   
      static Float:Origin[3]
      pev(g_Alien, pev_origin, Origin)
      Origin[2] += 200.0
      engfunc(EngFunc_SetOrigin, HPspr, Origin)
      engfunc(EngFunc_SetModel, HPspr, Resource[3])
      entity_set_float(HPspr, EV_FL_scale, 0.5)
      set_pev(HPspr, pev_classname, "HP")
      set_pev(HPspr, pev_solid, SOLID_NOT)
      set_pev(HPspr, pev_movetype, MOVETYPE_NOCLIP)
      set_pev(HPspr, pev_frame, 100.0)
      set_pev(HPspr, pev_nextthink, get_gametime() + prepare_time)
   }
}

public Think_Boss(Ent)
{
   if (pev(Ent, pev_deadflag) == DEAD_DYING)
      return
   
   static bool:one
   
   switch ( Ability ) {
      case IDLE: {
         Ability = WALK
         set_task(10.0, "RandomAbility", 1337, _, _, "b")
         set_pev(Ent, pev_nextthink, get_gametime() + 0.1)
         return
      }
      case WALK: {
         static Float:Origin[3], Float:Origin2[3], Float:Vector[3], Float:Angle[3]
         if (!is_user_alive(g_BossTarget)) {
            g_BossTarget = GetRandomAlive(random_num(1, GetAliveCount()))
            set_pev(Ent, pev_nextthink, get_gametime() + 0.1)
            return
         }
         if (one) {
            set_pev(Ent, pev_movetype, MOVETYPE_PUSHSTEP)
            Anim(Ent, 3)
            one = false
         }
         pev(Ent, pev_origin, Origin)
         pev(g_BossTarget, pev_origin, Origin2)
         
         xs_vec_sub(Origin2, Origin, Vector)
         vector_to_angle(Vector, Angle)
         new Float:num = floatsqroot(float(boss_speed)*float(boss_speed) / (Vector[0]*Vector[0] + Vector[1]*Vector[1] + Vector[2]*Vector[2]))
         Vector[0] *= num
         Vector[1] *= num
         Vector[2] ? (Vector[2] = 0.0) : (Vector[2] *= num)
         set_pev(Ent, pev_velocity, Vector)
         Angle[0] = 0.0
         Angle[2] = 0.0
         set_pev(Ent, pev_angles, Angle)
         set_pev(Ent, pev_nextthink, get_gametime() + 0.1)
         return
      }
      case ATTACK: {
         static num         
         switch (num) {
            case 0: {
               Anim(Ent, 6)
               num++
               set_pev(Ent, pev_nextthink, get_gametime() + 1.0)
               return
            }
            case 1: {
               static Float:OriginA[3], Float:OriginA2[3], Float:LenA, Float:Vector[3], Float:Velocity[3]
               
               pev(g_Alien, pev_origin, OriginA)
               pev(VictimID, pev_origin, OriginA2)
               
               xs_vec_sub(OriginA2, OriginA, Velocity)
               xs_vec_sub(OriginA, OriginA2, Vector)
               
               LenA = xs_vec_len(Vector)
               
               if (LenA <= 170) {
                  xs_vec_normalize(Velocity, Velocity)
                  Velocity[2] = 0.5
                  xs_vec_mul_scalar(Velocity, 1000.0, Velocity)
                  ExecuteHamB(Ham_TakeDamage, VictimID, 0, VictimID, float(dmg_attack), DMG_BULLET)
                  ScreenFade(VictimID, 3, {255, 0, 0}, 120)
                  ScreenShake(VictimID)
                  set_pev(VictimID, pev_velocity, Velocity)
                  emit_sound(Ent, CHAN_VOICE, g_AlienSound[2], VOL_NORM, ATTN_NORM, 0, PITCH_NORM)
               }
            }
         }
         num = 0
         one = true
         Ability = WALK
         set_pev(Ent, pev_nextthink, get_gametime() + 0.2)
      }
      case MS: {
         static num, Float:Origin[3], Float:Origin2[3], Float:Vector[3], Float:Angle[3]
         switch ( num ) {
            case 0: {
               new MS_Attack = GetRandomAlive(random_num(1, GetAliveCount()))
               
               pev(MS_Attack, pev_origin, Origin)
               pev(Ent, pev_origin, Origin2)
               
               xs_vec_sub(Origin, Origin2, Vector)
               vector_to_angle(Vector, Angle)
               xs_vec_normalize(Vector, Vector)
               xs_vec_mul_scalar(Vector, 2000.0, Vector)
               Angle[0] = 0.0
               Angle[2] = 0.0
               Vector[2] = 0.0
               set_pev(Ent, pev_angles, Angle)
               set_pev(Ent, pev_movetype, MOVETYPE_NONE)
               Anim(Ent, 7)
               set_pev(Ent, pev_nextthink, get_gametime() + 1.0)
               num++
               return
            }
            case 1: {
               set_pev(Ent, pev_movetype, MOVETYPE_FLY)
               set_pev(Ent, pev_velocity, Vector)
               set_pev(Ent, pev_nextthink, get_gametime() + 1.0)
               num++
               return
            }
         }
         set_pev(Ent, pev_nextthink, get_gametime() + 0.1)
         num = 0
         Ability = WALK
         one = true
         return
      }
      case SW: {
         static num, FluxSpr, Float:Origin[3], sw_random
         switch ( num ) {
            case 0: {
               sw_random = random(3)
               Anim(Ent, 2)
               FluxSpr = engfunc(EngFunc_CreateNamedEntity, engfunc(EngFunc_AllocString, "env_sprite"))
               pev(Ent, pev_origin, Origin)
               Origin[2] += 70
               engfunc(EngFunc_SetOrigin, FluxSpr, Origin)
               engfunc(EngFunc_SetModel, FluxSpr, Resource[5])
               set_pev(FluxSpr, pev_solid, SOLID_NOT)
               set_pev(FluxSpr, pev_movetype, MOVETYPE_NOCLIP)
               switch(sw_random) {
                  case 0: {
                     set_rendering(FluxSpr, kRenderFxFadeSlow, 255, 0, 0, kRenderTransAdd, 255)
                     set_rendering(Ent, kRenderFxGlowShell, 255, 0, 0, kRenderNormal, 30)
                  }
                  case 1: {
                     set_rendering(FluxSpr, kRenderFxFadeSlow, 255, 255, 0, kRenderTransAdd, 255)
                     set_rendering(Ent, kRenderFxGlowShell, 255, 255, 0, kRenderNormal, 30)
                  }
                  case 2: {
                     set_rendering(FluxSpr, kRenderFxFadeSlow, 0, 0, 255, kRenderTransAdd, 255)
                     set_rendering(Ent, kRenderFxGlowShell, 0, 0, 255, kRenderNormal, 30)
                  }
               }
               set_pev(FluxSpr, pev_framerate, 5.0)
               dllfunc(DLLFunc_Spawn, FluxSpr)
               set_pev(Ent, pev_nextthink, get_gametime() + 0.1)
               num++
               return
            }
            case 1..10: {
               for(new id = 1; id <= get_maxplayers(); id++) {
                  if (!is_user_alive(id))
                     continue
                     
                  static Float:OriginSW[3], Float:OriginSW2[3], Float:Vector[3]
                  pev(Ent, pev_origin, OriginSW)
                  pev(id, pev_origin, OriginSW2)
                  
                  xs_vec_sub(OriginSW, OriginSW2, Vector)
                  xs_vec_normalize(Vector, Vector)
                  xs_vec_mul_scalar(Vector, 800.0, Vector)
                  set_pev(id, pev_velocity, Vector)
                  set_pev(Ent, pev_nextthink, get_gametime() + 0.2)
                  num++
                  return
               }
            }
            case 11: {
               engfunc(EngFunc_RemoveEntity, FluxSpr)
               Anim(Ent, 5)
               set_pev(Ent, pev_nextthink, get_gametime() + 2.2)
               num++
               return
            }
            case 12: {
               static Float:Orig[3]
               pev(Ent, pev_origin, Orig)
               set_rendering(Ent)
               
               switch (sw_random) {
                  case 0: ShockWave(Orig, 5, 35, 1000.0, {255, 0, 0}) // 450
                  case 1: ShockWave(Orig, 5, 35, 1000.0, {255, 255, 0})
                  case 2: ShockWave(Orig, 5, 35, 1000.0, {0, 0, 255})
               }
               
               for(new id = 1; id <= get_maxplayers(); id++) {
                  if (!is_user_alive(id))
                     continue
                     
                  if (pev(id, pev_flags) & FL_ONGROUND) {
                     static Float:gOrigin[3], Float:Vec[3], Float:Len
                     pev(id, pev_origin, gOrigin)
                     xs_vec_sub(Orig, gOrigin, Vec)
                     Len = xs_vec_len(Vec)
                     if (Len <= 450.0) {
                        switch (sw_random) {
                           case 0: user_kill(id)
                           case 1: {
                              ScreenFade(id, 5, {255, 0, 0}, 120)
                              ExecuteHamB(Ham_TakeDamage, id, 0, id, float(dmg_sw), DMG_SONIC)
                              ScreenShake(id)
                           }
                           case 2: {
                              client_cmd(id, "drop")
                              ScreenShake(id)
                           }
                        }
                     }
                  }
               }
               Ability = WALK
               one = true
               num = 0
               set_pev(Ent, pev_nextthink, get_gametime() + 0.2)
               return
            }
         }
      }
   }
}

public Think_HP(Ent) {
   static Float:Origin[3], num
   pev(g_Alien, pev_origin, Origin)
   Origin[2] += 200.0
   set_pev(Ent, pev_origin, Origin)
   
   switch ( num ) {
      case 0: {
         Anim(g_Alien, 3)
         set_pev(g_Alien, pev_takedamage, DAMAGE_YES)
         num++
      }
      case 1: {
         static Float:frame
         frame = g_Health * 100.0 / float(alien_hp)
         
         if (frame)
            set_pev(Ent, pev_frame, frame)
         
         if (pev(g_Alien, pev_deadflag) == DEAD_DYING) {
            engfunc(EngFunc_RemoveEntity, Ent)
            return
         }
      }
   }
   set_pev(Ent, pev_nextthink, get_gametime() + 0.1)
}

public TraceAttack(victim, attacker, Float:damage, Float:direction[3], th, dt) {
   static Float:End[3], ClassName[32]
   pev(victim, pev_classname, ClassName, charsmax(ClassName))
   if (equal(ClassName, "AlienBossik")) {
      get_tr2(th, TR_vecEndPos, End)
      Blood(End)
   }
}

public TakeDamage(victim, weapon, attacker, Float:damage, damagetype) {
   static ClassName[32]
   pev(victim, pev_classname, ClassName, charsmax(ClassName))
   if (equal(ClassName, "AlienBossik")) {
      pev(victim, pev_health, g_Health)
      if (g_Health <= damage) {
         Anim(victim, 1)
         set_pev(victim, pev_movetype, MOVETYPE_FLY)
         set_pev(victim, pev_solid, SOLID_NOT)
         set_pev(victim, pev_velocity, {0.0, 0.0, 0.0})
         set_pev(victim, pev_deadflag, DEAD_DYING)
         remove_task(1337)
         return HAM_SUPERCEDE
      }
   }
   return HAM_HANDLED
}

public Touch_Boss(Ent, WorldEnt) {
   if (Ability == MS) {
      static victim = -1, Float:Origin[3]
      pev(Ent, pev_origin, Origin)
      while((victim = engfunc(EngFunc_FindEntityInSphere, victim, Origin, 400.0)) != 0) {
         if (!is_user_alive(victim))
            continue
         
         ExecuteHamB(Ham_TakeDamage, victim, 0, victim, float(dmg_ms), DMG_BULLET)
      }
   }
   
   if (Ability == WALK) {
      Ability = ATTACK
      VictimID = WorldEnt
   }
}

stock Blood(Float:Orig[3]) {   
   message_begin(MSG_BROADCAST, SVC_TEMPENTITY);
   write_byte(TE_BLOODSPRITE);
   engfunc(EngFunc_WriteCoord, Orig[0])
   engfunc(EngFunc_WriteCoord, Orig[1])
   engfunc(EngFunc_WriteCoord, Orig[2])
   write_short(g_Resource[1])
   write_short(g_Resource[2])
   write_byte(218)
   write_byte(random_num(1, 2))
   message_end();
}


stock Anim(ent, sequence) {
   set_pev(ent, pev_sequence, sequence)
   set_pev(ent, pev_animtime, halflife_time())
   set_pev(ent, pev_framerate, 1.0)
}

stock ShockWave(Float:Orig[3], Life, Width, Float:Radius, Color[3]) {
   engfunc(EngFunc_MessageBegin, MSG_PVS, SVC_TEMPENTITY, Orig, 0)
   write_byte(TE_BEAMCYLINDER) // TE id
   engfunc(EngFunc_WriteCoord, Orig[0]) // x
   engfunc(EngFunc_WriteCoord, Orig[1]) // y
   engfunc(EngFunc_WriteCoord, Orig[2]-40.0) // z
   engfunc(EngFunc_WriteCoord, Orig[0]) // x axis
   engfunc(EngFunc_WriteCoord, Orig[1]) // y axis
   engfunc(EngFunc_WriteCoord, Orig[2]+Radius) // z axis
   write_short(g_Resource[4]) // sprite
   write_byte(0) // startframe
   write_byte(0) // framerate
   write_byte(Life) // life (4)
   write_byte(Width) // width (20)
   write_byte(0) // noise
   write_byte(Color[0]) // red
   write_byte(Color[1]) // green
   write_byte(Color[2]) // blue
   write_byte(255) // brightness
   write_byte(0) // speed
   message_end()
}

stock ScreenFade(id, Timer, Colors[3], Alpha) {   
   message_begin(MSG_ONE_UNRELIABLE, get_user_msgid("ScreenFade"), _, id);
   write_short((1<<12) * Timer)
   write_short(1<<12)
   write_short(0)
   write_byte(Colors[0])
   write_byte(Colors[1])
   write_byte(Colors[2])
   write_byte(Alpha)
   message_end()
}

stock ScreenShake(id) {
   message_begin(MSG_ONE_UNRELIABLE, get_user_msgid("ScreenShake"), _, id);
   write_short(1<<14)
   write_short(1<<12)
   write_short(2<<12)
   message_end();
}

GetRandomAlive(target_index) {         // :3
   new iAlive
   for (new id = 1; id <= get_maxplayers(); id++) {
      if (is_user_alive(id)) iAlive++
      if (iAlive == target_index) return id
   }
   return -1
}

GetAliveCount() {            // ^^
   new iAlive
   for (new id = 1; id <= get_maxplayers(); id++) if (is_user_alive(id)) iAlive++
   return iAlive
}
/* AMXX-Studio Notes - DO NOT MODIFY BELOW HERE
*{\\ rtf1\\ ansi\\ deff0{\\ fonttbl{\\ f0\\ fnil Tahoma;}}\n\\ viewkind4\\ uc1\\ pard\\ lang1046\\ f0\\ fs16 \n\\ par }
*/


Código:

#include <amxmodx>
#include <amxmisc>
#include <engine>
#include <fakemeta>
#include <hamsandwich>
#include <zombieplague>

#define PLUGIN "NPC"
#define VERSION "1.0"
#define AUTHOR "Dias"

#define NPC_CLASSNAME "witch"
#define NPC_HEALTH 1000.0

#define TASK_CRY 11111
#define TASK_STARTATTACK 11112
#define TASK_ATTACKING 11113
#define TASK_AURA 11114

#define MAX_WITCH 3

const MAX_NPC = 512
new npc_modelindex, g_hamnpc, Float:g_myorigin[3], g_ena
new const npc_model[] = "models/player/witch_npc/witch_npc.mdl"
new npc_victim[MAX_NPC]
new g_think[MAX_NPC], g_madness[MAX_NPC]
new cache_blood, cache_bloodspray

// spawns & way points
new const SPAWNS_FILE[] = "%s/npc_witch/%s.cfg"
const MAX_SPAWNS = 128
new Float:g_spawns[MAX_SPAWNS][3], g_total_spawns

enum
{
   THINK_DEATH = 1,
   THINK_REMOVE
}

new const witch_cry[][] = {
   "npc_witch/witch_llora_1.wav",
   "npc_witch/witch_llora_2.wav",
   "npc_witch/witch_llora_3.wav"
}

new const witch_madness[][] = {
   "npc_witch/female_ls_d_madscream01.wav",
   "npc_witch/female_ls_d_madscream02.wav",
   "npc_witch/female_ls_d_madscream03.wav"
}

new const witch_startattack[][] = {
   "npc_witch/female_distantscream1.wav",
   "npc_witch/female_distantscream2.wav"
}

new const witch_death[][] = {
   "npc_witch/female_death_1.wav",   
   "npc_witch/headshot_death_1.wav",
   "npc_witch/headshot_death_2.wav",
   "npc_witch/headshot_death_3.wav"
}

new const witch_pain[][] = {
   "npc_witch/witch_pain_1.wav",
   "npc_witch/witch_pain_2.wav",
   "npc_witch/witch_pain_3.wav"
}

new const killed_by_witch[] = "npc_witch/killed_by_witch.wav"

public plugin_init()
{
   register_plugin(PLUGIN, VERSION, AUTHOR)
   
   register_clcmd("say /witch_criar", "event_newround")
   register_clcmd("say /witch_nacer", "get_origin")
}

public plugin_precache()
{
   npc_modelindex = engfunc(EngFunc_PrecacheModel, npc_model)

   cache_blood = engfunc(EngFunc_PrecacheModel, "sprites/blood.spr")
   cache_bloodspray = engfunc(EngFunc_PrecacheModel, "sprites/bloodspray.spr")

   new i
   for(i = 0; i < sizeof(witch_cry); i++)
      engfunc(EngFunc_PrecacheSound, witch_cry[i])   
   for(i = 0; i < sizeof(witch_madness); i++)
      engfunc(EngFunc_PrecacheSound, witch_madness[i])
   for(i = 0; i < sizeof(witch_startattack); i++)
      engfunc(EngFunc_PrecacheSound, witch_startattack[i])
   for(i = 0; i < sizeof(witch_death); i++)
      engfunc(EngFunc_PrecacheSound, witch_death[i])
   for(i = 0; i < sizeof(witch_pain); i++)
      engfunc(EngFunc_PrecacheSound, witch_pain[i])
   engfunc(EngFunc_PrecacheSound, killed_by_witch)
   
   load_spawn_points()
}

public event_newround(id)
{
   create_npc()
      
   client_print(id, print_chat, "Pronto")
}

stock collect_spawn(Float:origin[3])
{
   for (new i=1; i<=g_total_spawns*3; i++)
   {
      origin = g_spawns[random(g_total_spawns)]
      if (check_spawn(origin)) return 1;
   }

   return 0;
}

stock check_spawn(Float:origin[3])
{
   new Float:originE[3], Float:origin1[3], Float:origin2[3]
   new ent = -1
   while ((ent = engfunc(EngFunc_FindEntityByString, ent, "classname", NPC_CLASSNAME)) != 0)
   {
      pev(ent, pev_origin, originE)
      
      // xoy
      origin1 = origin
      origin2 = originE
      origin1[2] = origin2[2] = 0.0
      if (vector_distance(origin1, origin2) <= 2 * 16.0)
      {
         // oz
         origin1 = origin
         origin2 = originE
         origin1[0] = origin2[0] = origin1[1] = origin2[1] = 0.0
         if (vector_distance(origin1, origin2) <= 36.0) return 0;
      }
   }
   return 1;
}

// load spawn points
load_spawn_points()
{
   // Check for spawns points of the current map
   new cfgdir[32], mapname[32], filepath[100], linedata[64]
   get_configsdir(cfgdir, charsmax(cfgdir))
   get_mapname(mapname, charsmax(mapname))
   formatex(filepath, charsmax(filepath), SPAWNS_FILE, cfgdir, mapname)
   
   // Load spawns points
   if (file_exists(filepath))
   {
      new file = fopen(filepath,"rt"), row[4][6]
      
      while (file && !feof(file))
      {
         fgets(file, linedata, charsmax(linedata))
         
         // invalid spawn
         if(!linedata[0] || str_count(linedata,' ') < 2) continue;
         
         // get spawn point data
         parse(linedata,row[0],5,row[1],5,row[2],5,row[3],5)
         
         // origin
         if (g_total_spawns<MAX_SPAWNS)
         {
            g_spawns[g_total_spawns][0] = floatstr(row[1])
            g_spawns[g_total_spawns][1] = floatstr(row[2])
            g_spawns[g_total_spawns][2] = floatstr(row[3])
            g_total_spawns++
         }
      }
      if (file) fclose(file)
   }
}

stock str_count(const str[], searchchar)
{
   new count, i, len = strlen(str)
   
   for (i = 0; i <= len; i++)
   {
      if(str[i] == searchchar)
         count++
   }
   
   return count;
}

public get_origin(id)
{
   g_ena = 1
   pev(id, pev_origin, g_myorigin)
}

public create_npc()
{
   new ent = create_entity("info_target")
   
   dllfunc(DLLFunc_Spawn, ent)
   entity_set_string(ent, EV_SZ_classname, NPC_CLASSNAME)
   
   static Float:Origin[3]
   collect_spawn(Origin)
   
   if(g_ena)
   {
      entity_set_origin(ent, g_myorigin)
   } else {
      entity_set_origin(ent, Origin)
   }
   set_pev(ent, pev_health, NPC_HEALTH)
   
   entity_set_model(ent, npc_model)
   entity_set_int(ent, EV_INT_modelindex, npc_modelindex)   
   entity_set_int(ent, EV_INT_solid, SOLID_SLIDEBOX)
   entity_set_int(ent, EV_INT_movetype, MOVETYPE_FLY)
   
   entity_set_float(ent, EV_FL_animtime, get_gametime())
   entity_set_float(ent, EV_FL_framerate,1.0)
   entity_set_float(ent, EV_FL_gravity, 1.0)
   entity_set_float(ent, EV_FL_takedamage, 1.0)
   entity_set_float(ent, EV_FL_nextthink, halflife_time() + 0.1)

   new Float:maxs[3] = {16.0,16.0,36.0}
   new Float:mins[3] = {-16.0,-16.0,-36.0}
   entity_set_size(ent, mins, maxs)
   
   entity_set_byte(ent, EV_BYTE_controller1, 125)
   entity_set_byte(ent, EV_BYTE_controller2, 125)
   entity_set_byte(ent, EV_BYTE_controller3, 125)
   entity_set_byte(ent, EV_BYTE_controller4, 125)   
   
   set_task(0.1, "make_aura", ent+TASK_AURA, _, _, "b")
   
   g_madness[ent] = 0
   g_think[ent] = 0
   npc_victim[ent] = 0
   
   drop_to_floor(ent)
   
   set_task(5.0, "witch_do_cry", ent+TASK_CRY, _, _, "b")
   
   if (!g_hamnpc)
   {
      RegisterHamFromEntity(Ham_TakeDamage, ent, "fw_TakeDamage")
      RegisterHamFromEntity(Ham_Think, ent, "fw_think")
      RegisterHamFromEntity(Ham_Touch, ent, "fw_touch")

      g_hamnpc = 1
   }   
}

public witch_do_cry(ent)
{
   ent -= TASK_CRY
   
   if(g_think[ent] == THINK_DEATH || g_think[ent] == THINK_REMOVE || g_madness[ent] != 0)
   {
      remove_task(ent+TASK_CRY)
      return
   }
   
   emit_sound(ent, CHAN_AUTO, witch_cry[random_num(0, charsmax(witch_cry))], 1.0, ATTN_NORM, 0, PITCH_NORM)
}

public make_aura(ent)
{
   ent -= TASK_AURA
   
   if(g_think[ent] == THINK_DEATH || g_think[ent] == THINK_REMOVE)
   {
      remove_task(ent+TASK_AURA)
      return
   }
   
   static Float:origin[3]
   pev(ent, pev_origin, origin)
   
   message_begin(MSG_BROADCAST,SVC_TEMPENTITY);
   write_byte(27)
   write_coord(floatround(origin[0]))
   write_coord(floatround(origin[1]))
   write_coord(floatround(origin[2]))
   write_byte(10)
   write_byte(255)
   write_byte(0)
   write_byte(0)
   write_byte(100)
   write_byte(60)
   message_end()
}

public fw_TakeDamage(victim, inflictor, attacker, Float:damage, damage_type)
{   
   if (victim == attacker)
      return HAM_IGNORED
   
   if (!pev_valid(victim) || !pev_valid(attacker))
      return HAM_IGNORED
   
   if (is_user_connected(victim) && is_user_connected(attacker))
      return HAM_SUPERCEDE
   
   if(zp_get_user_zombie(attacker))
      return FMRES_IGNORED
   
   new classname[32]
   pev(victim, pev_classname, classname, charsmax(classname))
   
   if (equal(classname, NPC_CLASSNAME))
   {
      if (g_think[victim] == THINK_DEATH || g_think[victim] == THINK_REMOVE) return HAM_SUPERCEDE
      
      // get aim
      new aimOrigin[3], target, body
      get_user_origin(attacker, aimOrigin, 3)
      get_user_aiming(attacker, target, body)
      
      // fix hit body damage
      if (!(damage_type & DMG_BULLET)) damage = float(get_damage_body(body, damage))
      
      // set new damage
      SetHamParamFloat(4, damage)
      
      // create block sprites
      if (damage_type & DMG_BULLET)
         create_blood(aimOrigin)
      
      emit_sound(victim, CHAN_AUTO, witch_pain[random_num(0, charsmax(witch_pain))], 1.0, ATTN_NORM, 0, PITCH_NORM)
      
      // NPC die
      if (0.0 < pev(victim, pev_health) <= damage)
      {
         set_pev(victim, pev_health, 0.0)
         
         static Float:reset[3]
         entity_set_size(victim, reset, reset)
         entity_set_vector(victim, EV_VEC_velocity, reset)
         set_anim(victim, 128)
         
         emit_sound(victim, CHAN_AUTO, witch_death[random_num(0, charsmax(witch_death))], 1.0, ATTN_NORM, 0, PITCH_NORM)
         
         g_think[victim] = THINK_DEATH
         
         return HAM_SUPERCEDE
      }
      else
      {
         set_anim(victim, 127)
         
         if(!g_madness[victim])
         {
            npc_victim[victim] = attacker
            
            static name[32]
            get_user_name(attacker, name, sizeof(name))
            
            client_print(0, print_chat, "%s Mexeu com a Witch !!", name)   
            
            g_madness[victim] = 2
            
            emit_sound(victim, CHAN_AUTO, witch_startattack[random_num(0, charsmax(witch_startattack))], 1.0, ATTN_NORM, 0, PITCH_NORM)
            
            set_task(3.0, "start_attack", victim+TASK_STARTATTACK)
            set_task(1.5, "witch_do_madness", victim+TASK_ATTACKING, _, _, "b")
         }
      }
      
   }
   
   return HAM_IGNORED
}

public start_attack(ent)
{
   ent -= TASK_STARTATTACK
   
   g_madness[ent] = 1
}

public witch_do_madness(ent)
{
   ent -= TASK_ATTACKING
   
   if(g_think[ent] == THINK_DEATH || g_think[ent] == THINK_REMOVE || g_madness[ent] != 1)
   {
      remove_task(ent+TASK_ATTACKING)
      return
   }
   
   emit_sound(ent, CHAN_AUTO, witch_madness[random_num(0, charsmax(witch_madness))], 1.0, ATTN_NORM, 0, PITCH_NORM)
}

public fw_think(ent)
{
   if(g_think[ent] == THINK_DEATH || g_think[ent] == THINK_REMOVE)
      return HAM_IGNORED
   
   if(g_madness[ent] == 2)
   {
      set_anim(ent, 1)
      } else if(g_madness[ent] == 1) {   
      static victim
      victim = npc_victim[ent]
      
      static Float:Origin[3], Float:VicOrigin[3], Float:distance
      
      pev(ent, pev_origin, Origin)
      pev(victim, pev_origin, VicOrigin)
      
      distance = get_distance_f(Origin, VicOrigin)      
      
      if(is_user_alive(victim))
      {
         if(distance <= 60.0)
         {
            new Float:Ent_Origin[3], Float:Vic_Origin[3]
            
            pev(ent, pev_origin, Ent_Origin)
            pev(victim, pev_origin, Vic_Origin)         
            
            witch_attack(ent, victim)
            } else {
            set_anim(ent, 4)
            
            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)
            
            entity_set_float(ent, EV_FL_nextthink, get_gametime() + 0.5)
         }
      } else {
         g_madness[ent] = 0
         set_task(5.0, "witch_do_cry", ent+TASK_CRY, _, _, "b")
            
         remove_task(ent+TASK_ATTACKING)
      }
      } else if(!g_madness[ent]) {
      set_anim(ent, 0)
   }
   
   entity_set_float(ent, EV_FL_nextthink, halflife_time() + 0.1)
   
   return HAM_HANDLED
}

public fw_touch(witch, id)
{
   if(g_think[witch] == THINK_DEATH || g_think[witch] == THINK_REMOVE)
      return HAM_IGNORED
   
   if(!is_user_alive(id))
      return HAM_IGNORED
   
   if(g_madness[witch] != 1)
      return HAM_IGNORED
   
   set_anim(witch, 85)
   user_kill(id)
   emit_sound(id, CHAN_AUTO, killed_by_witch, 1.0, ATTN_NORM, 0, PITCH_NORM)
   
   static name[32]
   get_user_name(id, name, sizeof(name))
   
   client_print(0, print_chat, "%s Foi assasinado pela Witch !!", name)      
   
   return HAM_HANDLED
}

public witch_attack(ent, victim)
{
   set_anim(ent, 85)
   
   emit_sound(victim, CHAN_AUTO, killed_by_witch, 1.0, ATTN_NORM, 0, PITCH_NORM)
   user_kill(victim)
   
   static name[32]
   get_user_name(victim, name, sizeof(name))
   
   client_print(0, print_chat, "%s Foi assasinado pela Witch !!", name)      
}

stock set_anim(ent, anim)
{
   if (pev(ent, pev_sequence) != anim)
   {
      entity_set_float(ent, EV_FL_animtime, get_gametime())
      entity_set_int(ent, EV_INT_sequence, anim)
   }
}

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

stock get_damage_body(body, Float:damage)
{
   switch (body)
   {
      case HIT_HEAD: damage *= 4.0
         case HIT_STOMACH: damage *= 1.25
         case HIT_LEFTLEG: damage *= 0.75
         case HIT_RIGHTLEG: damage *= 0.75
         default: damage *= 1.0
   }
   
   return floatround(damage);
}

stock 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)
   }
}

stock hook_ent(ent, victim)
{
   static Float:fl_Velocity[3]
   static Float:VicOrigin[3], Float:EntOrigin[3]
   static Float:Speed
   
   pev(ent, pev_origin, EntOrigin)
   pev(victim, pev_origin, VicOrigin)
   Speed = 400.0
   
   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)
}


Código:

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

#define OBERON_CLASSNAME "oberon"

#define FLAG_ACESS                  ADMIN_LEVEL_F

#define OBERON_HEALTH                  500000
#define MONEY_DMG                  1000.0
#define MONEY_REWARD                  1000
#define CLASS_NAME                  "npc_oberon"
#define CLASS_TIP                  "Oberon Boss"
#define OBERON_ATTACK_WAITIME                3.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], g_damagedealt[33] , g_boss_exists[33], g_position_created[33]
new cvar_dmg_ap_allow, cvar_ammodamage, cvar_ammo_quantity

public plugin_init()
{
  register_plugin("[ZP] Addon: Oberon Boss", "1.0", "Dias | [P]erfec[T] [S]cr[@]s[H]")
 
  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")
  register_clcmd("say get_origin", "get_origin")
  register_clcmd("say make", "create_oberon")
  register_clcmd("say .get_origin", "get_origin")
  register_clcmd("say .make", "create_oberon")
 
  cvar_dmg_ap_allow = register_cvar("zp_oberon_dmg_ap_reward_allow", "1")      // Ganhar Ammo Packs Por Dano
  cvar_ammodamage = register_cvar("zp_oberon_dmg_for_reward", "300")      // Dmg Necessario Para Ganhar Ammo Packs
  cvar_ammo_quantity  = register_cvar("zp_oberom_reward_ap_quantity", "1")    // Quantia de Ammo Packs que ira ganhar
}

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)
{
  if(get_user_flags(id) & FLAG_ACESS)
  {
      pev(id, pev_origin, g_cur_origin)
      pev(id, pev_angles, g_cur_angles)
      pev(id, pev_v_angle, g_cur_v_angle)
     
      g_position_created[id]++
     
      client_printcolor(id, "!g[ZP Oberon]!y Posicao do Nascimento do Oberon Salva Com Sucesso. Para Invocar digite !t^"say /criar_oberon^"")
  }
  else
  {
      client_printcolor(id,"!g[ZP Oberon]!y Voce Nao Tem Acesso a esse Comando")
  }
}

public create_oberon(id)
{
  if(get_user_flags(id) & FLAG_ACESS)
  {
 
      if(g_position_created[id] == 0)
      {
        client_printcolor(id, "!g[ZP Oberon]!y Voce Tem que Defenir a Posicao de Nascimento Primeiro !g(Digitando:!t say /salvar_local_do_oberon!g)")
        return;
      }
     
      if(g_boss_exists[id] >= 1)
      {
        client_printcolor(id, "!g[ZP Oberon]!y Ja Existe um Oberon no Jogo Nao Pode Criar Mais")
        return;
      }
     
      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)
      g_boss_exists[id]++
      set_task(15.0, "do_random_skill", ent, _, _, "b")
      set_task(5.0, "creditos", id)
     
      set_hudmessage(255, 0, 0, -1.0, 0.17, 1, 0.0, 5.0, 1.0, 1.0, -1)
      show_hudmessage(id, "O Oberon Foi Solto. Fuja ou Se Esconda !!")
     
      if(!g_reg)
      {
        RegisterHamFromEntity(Ham_TakeDamage, ent, "fw_takedmg", 1)
        RegisterHamFromEntity(Ham_Think, ent, "fw_think")
        g_reg = 1
      } 
     
      g_boss_exists[id]++
      g_boss_exists[id]++
      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)
  }
  else
  {
      client_printcolor(id, "!g[ZP Oberon]!y Voce Nao Tem Acesso a esse Comando")
  }

}

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 *= 5.0
           
        ExecuteHam(Ham_TakeDamage, i, 300, i, Damage, DMG_BLAST)
        hit_screen(i)
      }
  } 
 
  remove_entity(ent)
  remove_entity_name("oberon_bomb")
 
  set_task(1.0, "remove_bomb", ent)
}

public remove_bomb(ent)
{
  remove_entity(ent)
  remove_entity_name("oberon_bomb")
}

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, "Vida do Oberon: %i", floatround(pev(victim, pev_health) - 1000.0))
 
  create_blood(Origin)
 
  if(get_pcvar_num(cvar_dmg_ap_allow))
  {
      // Store damage dealt
      g_damagedealt[attacker] += floatround(damage)
       
      // Reward ammo packs for every [ammo damage] dealt
      while (g_damagedealt[attacker] > get_pcvar_num(cvar_ammodamage))
      {
        g_damagedealt[attacker] -= get_pcvar_num(cvar_ammodamage)
        zp_set_user_ammo_packs(attacker, zp_get_user_ammo_packs(attacker) + get_pcvar_num(cvar_ammo_quantity))
      }
  }
}

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)
}

public creditos(id)
{
  set_hudmessage(0, 255, 255, -1.0, 0.89, 1, 0.0, 5.0, 1.0, 1.0, -1)
  show_hudmessage(id, "Plugin de Boss Editado Por: [P]erfec[T] [S]cr[@]s[H]")
}
 

stock client_printcolor(const id, const input[], any:...)
{
        new count = 1, players[32]
        static msg[191]
        vformat(msg, 190, input, 3)

        replace_all(msg, 190, "!g", "^4")  // Chat Verde
        replace_all(msg, 190, "!y", "^1")  // Chat Normal
        replace_all(msg, 190, "!t", "^3")  // Chat Do Time Tr=Vermelho Ct=Azul Spec=Branco

        if (id) players[0] = id; else get_players(players, count, "ch")
        {
                for (new i = 0; i < count; i++)
                {
                        if (is_user_connected(players[i]))
                        {
                                message_begin(MSG_ONE_UNRELIABLE, get_user_msgid("SayText"), _, players[i])
                                write_byte(players[i]);
                                write_string(msg);
                                message_end();
                        }
                }
        }
}
/* AMXX-Studio Notes - DO NOT MODIFY BELOW HERE
*{\\ rtf1\\ ansi\\ deff0{\\ fonttbl{\\ f0\\ fnil Tahoma;}}\n\\ viewkind4\\ uc1\\ pard\\ lang1046\\ f0\\ fs16 \n\\ par }
*/


Código:

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


// Flag De Acesso (Atualmente ta na flag F)
#define FLAG_ACESS                  ADMIN_LEVEL_A
#define NAME      "AlienBoss Special For Zombie-Mod.Ru"
#define VERSION      "Public"
#define AUTHOR      "Alexander.3 / Edit: Optimist"

#define ALIEN_HEALTH                  250000
#define MONEY_DMG                  1000
#define MONEY_REWARD                  500
#define CLASS_NAME                  "npc_alien"
#define CLASS_TIP                  "AlienBoss"
#define ALIEN_ATTACK_WAITIME                3.0

new cvar_dmg_ap_allow, cvar_ammodamage, cvar_ammo_quantity, g_damagedealt[33]
const alien_hp =      250000
const boss_speed =      200
const Float:prepare_time =   5.0
const dmg_attack =      50
const dmg_ms =         50
const dmg_sw =         50

static Float:Origin[3]

static g_Alien
static g_BossTarget
static VictimID
static Float:g_Health

static Ability

new const Resource[][] = {
   "models/npc/alien/alien.mdl",
   "sprites/blood.spr",
   "sprites/bloodspray.spr",
   "sprites/npc/hp.spr",
   "sprites/shockwave.spr",   // 4
   "sprites/npc/alien/fluxing.spr" // 5
}
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"
}

static g_Resource[sizeof Resource]

enum {
   IDLE,
   WALK,
   MS,
   ATTACK,
   SW
}

public plugin_precache()
{
   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]);
   
   for(new i; i <= charsmax(Resource); i++)
      g_Resource[i] = precache_model(Resource[i])
}

public plugin_init() {
   register_plugin(NAME, VERSION, AUTHOR)
   
   register_clcmd("say /salvar_alien", "create", ADMIN_RCON)
   register_clcmd("say /criar_alien", "spawn", ADMIN_RCON)
      
   register_think("AlienBossik", "Think_Boss")
   register_think("HP", "Think_HP")
   
   register_touch("AlienBossik", "player", "Touch_Boss")
   
   cvar_dmg_ap_allow = register_cvar("zp_alien_dmg_ap_reward_allow", "1")      // Ganhar Ammo Packs Por Dano
   cvar_ammodamage = register_cvar("zp_alien_dmg_for_reward", "1000")       // Dmg Necessario Para Ganhar Ammo Packs
   cvar_ammo_quantity  = register_cvar("zp_alien_reward_ap_quantity", "200")       // Quantia de Ammo Packs que ira ganhar
   
   RegisterHam(Ham_TakeDamage, "info_target", "TakeDamage", ADMIN_RCON)
   RegisterHam(Ham_TraceAttack, "info_target", "TraceAttack", ADMIN_RCON)
}

public RandomAbility(taskid) {
   if (Ability != WALK)
      return
   
   switch(random(2)) {
      case 0: Ability = MS
      case 1: Ability = SW
   }
}

public create(id)
if (get_user_flags(id) & ADMIN_RCON)
{
   pev(id, pev_origin, Origin)
}
   
public spawn(id)
{
   if (get_user_flags(id) & ADMIN_RCON)
   {
      g_Alien = engfunc(EngFunc_CreateNamedEntity, engfunc(EngFunc_AllocString, "info_target"))
      new HPspr = engfunc(EngFunc_CreateNamedEntity, engfunc(EngFunc_AllocString, "info_target"))
   
      engfunc(EngFunc_SetModel, g_Alien, Resource[0])
      engfunc(EngFunc_SetSize, g_Alien, { -32.0, -32.0, -36.0 }, { 32.0, 32.0, 96.0 })
      engfunc(EngFunc_SetOrigin, g_Alien, Origin)
   
      set_pev(g_Alien, pev_classname, "AlienBossik")
      set_pev(g_Alien, pev_solid, SOLID_BBOX)
      set_pev(g_Alien, pev_movetype, MOVETYPE_PUSHSTEP)
      set_pev(g_Alien, pev_takedamage, DAMAGE_NO)
      set_pev(g_Alien, pev_health, float(alien_hp))
      set_pev(g_Alien, pev_deadflag, DEAD_NO)
      set_pev(g_Alien, pev_nextthink, get_gametime() + prepare_time)
   
      Ability = IDLE
      Anim(g_Alien, 2)
   
      static Float:Origin[3]
      pev(g_Alien, pev_origin, Origin)
      Origin[2] += 200.0
      engfunc(EngFunc_SetOrigin, HPspr, Origin)
      engfunc(EngFunc_SetModel, HPspr, Resource[3])
      entity_set_float(HPspr, EV_FL_scale, 0.5)
      set_pev(HPspr, pev_classname, "HP")
      set_pev(HPspr, pev_solid, SOLID_NOT)
      set_pev(HPspr, pev_movetype, MOVETYPE_NOCLIP)
      set_pev(HPspr, pev_frame, 100.0)
      set_pev(HPspr, pev_nextthink, get_gametime() + prepare_time)
   }
}

public Think_Boss(Ent)
{
   if (pev(Ent, pev_deadflag) == DEAD_DYING)
      return
   
   static bool:one
   
   switch ( Ability ) {
      case IDLE: {
         Ability = WALK
         set_task(10.0, "RandomAbility", 1337, _, _, "b")
         set_pev(Ent, pev_nextthink, get_gametime() + 0.1)
         return
      }
      case WALK: {
         static Float:Origin[3], Float:Origin2[3], Float:Vector[3], Float:Angle[3]
         if (!is_user_alive(g_BossTarget)) {
            g_BossTarget = GetRandomAlive(random_num(1, GetAliveCount()))
            set_pev(Ent, pev_nextthink, get_gametime() + 0.1)
            return
         }
         if (one) {
            set_pev(Ent, pev_movetype, MOVETYPE_PUSHSTEP)
            Anim(Ent, 3)
            one = false
         }
         pev(Ent, pev_origin, Origin)
         pev(g_BossTarget, pev_origin, Origin2)
         
         xs_vec_sub(Origin2, Origin, Vector)
         vector_to_angle(Vector, Angle)
         new Float:num = floatsqroot(float(boss_speed)*float(boss_speed) / (Vector[0]*Vector[0] + Vector[1]*Vector[1] + Vector[2]*Vector[2]))
         Vector[0] *= num
         Vector[1] *= num
         Vector[2] ? (Vector[2] = 0.0) : (Vector[2] *= num)
         set_pev(Ent, pev_velocity, Vector)
         Angle[0] = 0.0
         Angle[2] = 0.0
         set_pev(Ent, pev_angles, Angle)
         set_pev(Ent, pev_nextthink, get_gametime() + 0.1)
         return
      }
      case ATTACK: {
         static num         
         switch (num) {
            case 0: {
               Anim(Ent, 6)
               num++
               set_pev(Ent, pev_nextthink, get_gametime() + 1.0)
               return
            }
            case 1: {
               static Float:OriginA[3], Float:OriginA2[3], Float:LenA, Float:Vector[3], Float:Velocity[3]
               
               pev(g_Alien, pev_origin, OriginA)
               pev(VictimID, pev_origin, OriginA2)
               
               xs_vec_sub(OriginA2, OriginA, Velocity)
               xs_vec_sub(OriginA, OriginA2, Vector)
               
               LenA = xs_vec_len(Vector)
               
               if (LenA <= 170) {
                  xs_vec_normalize(Velocity, Velocity)
                  Velocity[2] = 0.5
                  xs_vec_mul_scalar(Velocity, 1000.0, Velocity)
                  ExecuteHamB(Ham_TakeDamage, VictimID, 0, VictimID, float(dmg_attack), DMG_BULLET)
                  ScreenFade(VictimID, 3, {255, 0, 0}, 120)
                  ScreenShake(VictimID)
                  set_pev(VictimID, pev_velocity, Velocity)
                  emit_sound(Ent, CHAN_VOICE, g_AlienSound[2], VOL_NORM, ATTN_NORM, 0, PITCH_NORM)
               }
            }
         }
         num = 0
         one = true
         Ability = WALK
         set_pev(Ent, pev_nextthink, get_gametime() + 0.2)
      }
      case MS: {
         static num, Float:Origin[3], Float:Origin2[3], Float:Vector[3], Float:Angle[3]
         switch ( num ) {
            case 0: {
               new MS_Attack = GetRandomAlive(random_num(1, GetAliveCount()))
               
               pev(MS_Attack, pev_origin, Origin)
               pev(Ent, pev_origin, Origin2)
               
               xs_vec_sub(Origin, Origin2, Vector)
               vector_to_angle(Vector, Angle)
               xs_vec_normalize(Vector, Vector)
               xs_vec_mul_scalar(Vector, 2000.0, Vector)
               Angle[0] = 0.0
               Angle[2] = 0.0
               Vector[2] = 0.0
               set_pev(Ent, pev_angles, Angle)
               set_pev(Ent, pev_movetype, MOVETYPE_NONE)
               Anim(Ent, 7)
               set_pev(Ent, pev_nextthink, get_gametime() + 1.0)
               num++
               return
            }
            case 1: {
               set_pev(Ent, pev_movetype, MOVETYPE_FLY)
               set_pev(Ent, pev_velocity, Vector)
               set_pev(Ent, pev_nextthink, get_gametime() + 1.0)
               num++
               return
            }
         }
         set_pev(Ent, pev_nextthink, get_gametime() + 0.1)
         num = 0
         Ability = WALK
         one = true
         return
      }
      case SW: {
         static num, FluxSpr, Float:Origin[3], sw_random
         switch ( num ) {
            case 0: {
               sw_random = random(3)
               Anim(Ent, 2)
               FluxSpr = engfunc(EngFunc_CreateNamedEntity, engfunc(EngFunc_AllocString, "env_sprite"))
               pev(Ent, pev_origin, Origin)
               Origin[2] += 70
               engfunc(EngFunc_SetOrigin, FluxSpr, Origin)
               engfunc(EngFunc_SetModel, FluxSpr, Resource[5])
               set_pev(FluxSpr, pev_solid, SOLID_NOT)
               set_pev(FluxSpr, pev_movetype, MOVETYPE_NOCLIP)
               switch(sw_random) {
                  case 0: {
                     set_rendering(FluxSpr, kRenderFxFadeSlow, 255, 0, 0, kRenderTransAdd, 255)
                     set_rendering(Ent, kRenderFxGlowShell, 255, 0, 0, kRenderNormal, 30)
                  }
                  case 1: {
                     set_rendering(FluxSpr, kRenderFxFadeSlow, 255, 255, 0, kRenderTransAdd, 255)
                     set_rendering(Ent, kRenderFxGlowShell, 255, 255, 0, kRenderNormal, 30)
                  }
                  case 2: {
                     set_rendering(FluxSpr, kRenderFxFadeSlow, 0, 0, 255, kRenderTransAdd, 255)
                     set_rendering(Ent, kRenderFxGlowShell, 0, 0, 255, kRenderNormal, 30)
                  }
               }
               set_pev(FluxSpr, pev_framerate, 5.0)
               dllfunc(DLLFunc_Spawn, FluxSpr)
               set_pev(Ent, pev_nextthink, get_gametime() + 0.1)
               num++
               return
            }
            case 1..10: {
               for(new id = 1; id <= get_maxplayers(); id++) {
                  if (!is_user_alive(id))
                     continue
                     
                  static Float:OriginSW[3], Float:OriginSW2[3], Float:Vector[3]
                  pev(Ent, pev_origin, OriginSW)
                  pev(id, pev_origin, OriginSW2)
                  
                  xs_vec_sub(OriginSW, OriginSW2, Vector)
                  xs_vec_normalize(Vector, Vector)
                  xs_vec_mul_scalar(Vector, 800.0, Vector)
                  set_pev(id, pev_velocity, Vector)
                  set_pev(Ent, pev_nextthink, get_gametime() + 0.2)
                  num++
                  return
               }
            }
            case 11: {
               engfunc(EngFunc_RemoveEntity, FluxSpr)
               Anim(Ent, 5)
               set_pev(Ent, pev_nextthink, get_gametime() + 2.2)
               num++
               return
            }
            case 12: {
               static Float:Orig[3]
               pev(Ent, pev_origin, Orig)
               set_rendering(Ent)
               
               switch (sw_random) {
                  case 0: ShockWave(Orig, 5, 35, 1000.0, {255, 0, 0}) // 450
                  case 1: ShockWave(Orig, 5, 35, 1000.0, {255, 255, 0})
                  case 2: ShockWave(Orig, 5, 35, 1000.0, {0, 0, 255})
               }
               
               for(new id = 1; id <= get_maxplayers(); id++) {
                  if (!is_user_alive(id))
                     continue
                     
                  if (pev(id, pev_flags) & FL_ONGROUND) {
                     static Float:gOrigin[3], Float:Vec[3], Float:Len
                     pev(id, pev_origin, gOrigin)
                     xs_vec_sub(Orig, gOrigin, Vec)
                     Len = xs_vec_len(Vec)
                     if (Len <= 450.0) {
                        switch (sw_random) {
                           case 0: user_kill(id)
                           case 1: {
                              ScreenFade(id, 5, {255, 0, 0}, 120)
                              ExecuteHamB(Ham_TakeDamage, id, 0, id, float(dmg_sw), DMG_SONIC)
                              ScreenShake(id)
                           }
                           case 2: {
                              client_cmd(id, "drop")
                              ScreenShake(id)
                           }
                        }
                     }
                  }
               }
               Ability = WALK
               one = true
               num = 0
               set_pev(Ent, pev_nextthink, get_gametime() + 0.2)
               return
            }
         }
      }
   }
}

public Think_HP(Ent) {
   static Float:Origin[3], num
   pev(g_Alien, pev_origin, Origin)
   Origin[2] += 200.0
   set_pev(Ent, pev_origin, Origin)
   
   switch ( num ) {
      case 0: {
         Anim(g_Alien, 3)
         set_pev(g_Alien, pev_takedamage, DAMAGE_YES)
         num++
      }
      case 1: {
         static Float:frame
         frame = g_Health * 100.0 / float(alien_hp)
         
         if (frame)
            set_pev(Ent, pev_frame, frame)
         
         if (pev(g_Alien, pev_deadflag) == DEAD_DYING) {
            engfunc(EngFunc_RemoveEntity, Ent)
            return
         }
      }
   }
   set_pev(Ent, pev_nextthink, get_gametime() + 0.1)
}

public TraceAttack(victim, attacker, Float:damage, Float:direction[3], th, dt) {
   static Float:End[3], ClassName[32]
   pev(victim, pev_classname, ClassName, charsmax(ClassName))
   if (equal(ClassName, "AlienBossik")) {
      get_tr2(th, TR_vecEndPos, End)
      Blood(End)
   }
}

public TakeDamage(victim, weapon, attacker, Float:damage, damagetype)
{
   static ClassName[32]
   pev(victim, pev_classname, ClassName, charsmax(ClassName))

   if (equal(ClassName, "AlienBossik"))
   {
      pev(victim, pev_health, g_Health)
      if (g_Health <= damage)
      {
         Anim(victim, 1)
         set_pev(victim, pev_movetype, MOVETYPE_FLY)
         set_pev(victim, pev_solid, SOLID_NOT)
         set_pev(victim, pev_velocity, {0.0, 0.0, 0.0})
         set_pev(victim, pev_deadflag, DEAD_DYING)
         remove_task(1337)
         return HAM_SUPERCEDE
      }
      else if(get_pcvar_num(cvar_dmg_ap_allow))
      {
         // Store damage dealt
         g_damagedealt[attacker] += floatround(damage)
            
         // Reward ammo packs for every [ammo damage] dealt
         while (g_damagedealt[attacker] > get_pcvar_num(cvar_ammodamage))
         {
            g_damagedealt[attacker] -= get_pcvar_num(cvar_ammodamage)
            zp_set_user_ammo_packs(attacker, zp_get_user_ammo_packs(attacker) + get_pcvar_num(cvar_ammo_quantity))
         }
      }
   }

   return HAM_HANDLED
}

public Touch_Boss(Ent, WorldEnt) {
   if (Ability == MS) {
      static victim = -1, Float:Origin[3]
      pev(Ent, pev_origin, Origin)
      while((victim = engfunc(EngFunc_FindEntityInSphere, victim, Origin, 400.0)) != 0) {
         if (!is_user_alive(victim))
            continue
         
         ExecuteHamB(Ham_TakeDamage, victim, 0, victim, float(dmg_ms), DMG_BULLET)
      }
   }
   
   if (Ability == WALK) {
      Ability = ATTACK
      VictimID = WorldEnt
   }
}

stock Blood(Float:Orig[3]) {   
   message_begin(MSG_BROADCAST, SVC_TEMPENTITY);
   write_byte(TE_BLOODSPRITE);
   engfunc(EngFunc_WriteCoord, Orig[0])
   engfunc(EngFunc_WriteCoord, Orig[1])
   engfunc(EngFunc_WriteCoord, Orig[2])
   write_short(g_Resource[1])
   write_short(g_Resource[2])
   write_byte(218)
   write_byte(random_num(1, 2))
   message_end();
}


stock Anim(ent, sequence) {
   set_pev(ent, pev_sequence, sequence)
   set_pev(ent, pev_animtime, halflife_time())
   set_pev(ent, pev_framerate, 1.0)
}

stock ShockWave(Float:Orig[3], Life, Width, Float:Radius, Color[3]) {
   engfunc(EngFunc_MessageBegin, MSG_PVS, SVC_TEMPENTITY, Orig, 0)
   write_byte(TE_BEAMCYLINDER) // TE id
   engfunc(EngFunc_WriteCoord, Orig[0]) // x
   engfunc(EngFunc_WriteCoord, Orig[1]) // y
   engfunc(EngFunc_WriteCoord, Orig[2]-40.0) // z
   engfunc(EngFunc_WriteCoord, Orig[0]) // x axis
   engfunc(EngFunc_WriteCoord, Orig[1]) // y axis
   engfunc(EngFunc_WriteCoord, Orig[2]+Radius) // z axis
   write_short(g_Resource[4]) // sprite
   write_byte(0) // startframe
   write_byte(0) // framerate
   write_byte(Life) // life (4)
   write_byte(Width) // width (20)
   write_byte(0) // noise
   write_byte(Color[0]) // red
   write_byte(Color[1]) // green
   write_byte(Color[2]) // blue
   write_byte(255) // brightness
   write_byte(0) // speed
   message_end()
}

stock ScreenFade(id, Timer, Colors[3], Alpha) {   
   message_begin(MSG_ONE_UNRELIABLE, get_user_msgid("ScreenFade"), _, id);
   write_short((1<<12) * Timer)
   write_short(1<<12)
   write_short(0)
   write_byte(Colors[0])
   write_byte(Colors[1])
   write_byte(Colors[2])
   write_byte(Alpha)
   message_end()
}

stock ScreenShake(id) {
   message_begin(MSG_ONE_UNRELIABLE, get_user_msgid("ScreenShake"), _, id);
   write_short(1<<14)
   write_short(1<<12)
   write_short(2<<12)
   message_end();
}

GetRandomAlive(target_index) {         // :3
   new iAlive
   for (new id = 1; id <= get_maxplayers(); id++) {
      if (is_user_alive(id)) iAlive++
      if (iAlive == target_index) return id
   }
   return -1
}

GetAliveCount() {            // ^^
   new iAlive
   for (new id = 1; id <= get_maxplayers(); id++) if (is_user_alive(id)) iAlive++
   return iAlive
}


ZORO escreveu:

Código:

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


// Flag De Acesso (Atualmente ta na flag F)
#define FLAG_ACESS                   ADMIN_LEVEL_A
#define NAME      "AlienBoss Special For Zombie-Mod.Ru"
#define VERSION      "Public"
#define AUTHOR      "Alexander.3 / Edit: Optimist"

#define ALIEN_HEALTH                  250000
#define MONEY_DMG                  1000
#define MONEY_REWARD                  500
#define CLASS_NAME                  "npc_alien"
#define CLASS_TIP                  "AlienBoss"
#define ALIEN_ATTACK_WAITIME                3.0

new cvar_dmg_ap_allow, cvar_ammodamage, cvar_ammo_quantity, g_damagedealt[33]
const alien_hp =      250000
const boss_speed =      200
const Float:prepare_time =   5.0
const dmg_attack =      50
const dmg_ms =         50
const dmg_sw =         50

static Float:Origin[3]

static g_Alien
static g_BossTarget
static VictimID
static Float:g_Health

static Ability

new const Resource[][] = {
   "models/npc/alien/alien.mdl",
   "sprites/blood.spr",
   "sprites/bloodspray.spr",
   "sprites/npc/hp.spr",
   "sprites/shockwave.spr",   // 4
   "sprites/npc/alien/fluxing.spr" // 5
}
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"
}

static g_Resource[sizeof Resource]

enum {
   IDLE,
   WALK,
   MS,
   ATTACK,
   SW
}

public plugin_precache()
{
   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]);
   
   for(new i; i <= charsmax(Resource); i++)
      g_Resource[i] = precache_model(Resource[i])
}

public plugin_init() {
   register_plugin(NAME, VERSION, AUTHOR)
   
   register_clcmd("say /salvar_alien", "create", ADMIN_RCON)
   register_clcmd("say /criar_alien", "spawn", ADMIN_RCON)
      
   register_think("AlienBossik", "Think_Boss")
   register_think("HP", "Think_HP")
   
   register_touch("AlienBossik", "player", "Touch_Boss")
   
   cvar_dmg_ap_allow = register_cvar("zp_alien_dmg_ap_reward_allow", "1")      // Ganhar Ammo Packs Por Dano
   cvar_ammodamage = register_cvar("zp_alien_dmg_for_reward", "1000")       // Dmg Necessario Para Ganhar Ammo Packs
   cvar_ammo_quantity  = register_cvar("zp_alien_reward_ap_quantity", "200")       // Quantia de Ammo Packs que ira ganhar
   
   RegisterHam(Ham_TakeDamage, "info_target", "TakeDamage", ADMIN_RCON)
   RegisterHam(Ham_TraceAttack, "info_target", "TraceAttack", ADMIN_RCON)
}

public RandomAbility(taskid) {
   if (Ability != WALK)
      return
   
   switch(random(2)) {
      case 0: Ability = MS
      case 1: Ability = SW
   }
}

public create(id)
if (get_user_flags(id) & ADMIN_RCON)
{
   pev(id, pev_origin, Origin)
}
   
public spawn(id)
{
   if (get_user_flags(id) & ADMIN_RCON)
   {
      g_Alien = engfunc(EngFunc_CreateNamedEntity, engfunc(EngFunc_AllocString, "info_target"))
      new HPspr = engfunc(EngFunc_CreateNamedEntity, engfunc(EngFunc_AllocString, "info_target"))
   
      engfunc(EngFunc_SetModel, g_Alien, Resource[0])
      engfunc(EngFunc_SetSize, g_Alien, { -32.0, -32.0, -36.0 }, { 32.0, 32.0, 96.0 })
      engfunc(EngFunc_SetOrigin, g_Alien, Origin)
   
      set_pev(g_Alien, pev_classname, "AlienBossik")
      set_pev(g_Alien, pev_solid, SOLID_BBOX)
      set_pev(g_Alien, pev_movetype, MOVETYPE_PUSHSTEP)
      set_pev(g_Alien, pev_takedamage, DAMAGE_NO)
      set_pev(g_Alien, pev_health, float(alien_hp))
      set_pev(g_Alien, pev_deadflag, DEAD_NO)
      set_pev(g_Alien, pev_nextthink, get_gametime() + prepare_time)
   
      Ability = IDLE
      Anim(g_Alien, 2)
   
      static Float:Origin[3]
      pev(g_Alien, pev_origin, Origin)
      Origin[2] += 200.0
      engfunc(EngFunc_SetOrigin, HPspr, Origin)
      engfunc(EngFunc_SetModel, HPspr, Resource[3])
      entity_set_float(HPspr, EV_FL_scale, 0.5)
      set_pev(HPspr, pev_classname, "HP")
      set_pev(HPspr, pev_solid, SOLID_NOT)
      set_pev(HPspr, pev_movetype, MOVETYPE_NOCLIP)
      set_pev(HPspr, pev_frame, 100.0)
      set_pev(HPspr, pev_nextthink, get_gametime() + prepare_time)
   }
}

public Think_Boss(Ent)
{
   if (pev(Ent, pev_deadflag) == DEAD_DYING)
      return
   
   static bool:one
   
   switch ( Ability ) {
      case IDLE: {
         Ability = WALK
         set_task(10.0, "RandomAbility", 1337, _, _, "b")
         set_pev(Ent, pev_nextthink, get_gametime() + 0.1)
         return
      }
      case WALK: {
         static Float:Origin[3], Float:Origin2[3], Float:Vector[3], Float:Angle[3]
         if (!is_user_alive(g_BossTarget)) {
            g_BossTarget = GetRandomAlive(random_num(1, GetAliveCount()))
            set_pev(Ent, pev_nextthink, get_gametime() + 0.1)
            return
         }
         if (one) {
            set_pev(Ent, pev_movetype, MOVETYPE_PUSHSTEP)
            Anim(Ent, 3)
            one = false
         }
         pev(Ent, pev_origin, Origin)
         pev(g_BossTarget, pev_origin, Origin2)
         
         xs_vec_sub(Origin2, Origin, Vector)
         vector_to_angle(Vector, Angle)
         new Float:num = floatsqroot(float(boss_speed)*float(boss_speed) / (Vector[0]*Vector[0] + Vector[1]*Vector[1] + Vector[2]*Vector[2]))
         Vector[0] *= num
         Vector[1] *= num
         Vector[2] ? (Vector[2] = 0.0) : (Vector[2] *= num)
         set_pev(Ent, pev_velocity, Vector)
         Angle[0] = 0.0
         Angle[2] = 0.0
         set_pev(Ent, pev_angles, Angle)
         set_pev(Ent, pev_nextthink, get_gametime() + 0.1)
         return
      }
      case ATTACK: {
         static num         
         switch (num) {
            case 0: {
               Anim(Ent, 6)
               num++
               set_pev(Ent, pev_nextthink, get_gametime() + 1.0)
               return
            }
            case 1: {
               static Float:OriginA[3], Float:OriginA2[3], Float:LenA, Float:Vector[3], Float:Velocity[3]
               
               pev(g_Alien, pev_origin, OriginA)
               pev(VictimID, pev_origin, OriginA2)
               
               xs_vec_sub(OriginA2, OriginA, Velocity)
               xs_vec_sub(OriginA, OriginA2, Vector)
               
               LenA = xs_vec_len(Vector)
               
               if (LenA <= 170) {
                  xs_vec_normalize(Velocity, Velocity)
                  Velocity[2] = 0.5
                  xs_vec_mul_scalar(Velocity, 1000.0, Velocity)
                  ExecuteHamB(Ham_TakeDamage, VictimID, 0, VictimID, float(dmg_attack), DMG_BULLET)
                  ScreenFade(VictimID, 3, {255, 0, 0}, 120)
                  ScreenShake(VictimID)
                  set_pev(VictimID, pev_velocity, Velocity)
                  emit_sound(Ent, CHAN_VOICE, g_AlienSound[2], VOL_NORM, ATTN_NORM, 0, PITCH_NORM)
               }
            }
         }
         num = 0
         one = true
         Ability = WALK
         set_pev(Ent, pev_nextthink, get_gametime() + 0.2)
      }
      case MS: {
         static num, Float:Origin[3], Float:Origin2[3], Float:Vector[3], Float:Angle[3]
         switch ( num ) {
            case 0: {
               new MS_Attack = GetRandomAlive(random_num(1, GetAliveCount()))
               
               pev(MS_Attack, pev_origin, Origin)
               pev(Ent, pev_origin, Origin2)
               
               xs_vec_sub(Origin, Origin2, Vector)
               vector_to_angle(Vector, Angle)
               xs_vec_normalize(Vector, Vector)
               xs_vec_mul_scalar(Vector, 2000.0, Vector)
               Angle[0] = 0.0
               Angle[2] = 0.0
               Vector[2] = 0.0
               set_pev(Ent, pev_angles, Angle)
               set_pev(Ent, pev_movetype, MOVETYPE_NONE)
               Anim(Ent, 7)
               set_pev(Ent, pev_nextthink, get_gametime() + 1.0)
               num++
               return
            }
            case 1: {
               set_pev(Ent, pev_movetype, MOVETYPE_FLY)
               set_pev(Ent, pev_velocity, Vector)
               set_pev(Ent, pev_nextthink, get_gametime() + 1.0)
               num++
               return
            }
         }
         set_pev(Ent, pev_nextthink, get_gametime() + 0.1)
         num = 0
         Ability = WALK
         one = true
         return
      }
      case SW: {
         static num, FluxSpr, Float:Origin[3], sw_random
         switch ( num ) {
            case 0: {
               sw_random = random(3)
               Anim(Ent, 2)
               FluxSpr = engfunc(EngFunc_CreateNamedEntity, engfunc(EngFunc_AllocString, "env_sprite"))
               pev(Ent, pev_origin, Origin)
               Origin[2] += 70
               engfunc(EngFunc_SetOrigin, FluxSpr, Origin)
               engfunc(EngFunc_SetModel, FluxSpr, Resource[5])
               set_pev(FluxSpr, pev_solid, SOLID_NOT)
               set_pev(FluxSpr, pev_movetype, MOVETYPE_NOCLIP)
               switch(sw_random) {
                  case 0: {
                     set_rendering(FluxSpr, kRenderFxFadeSlow, 255, 0, 0, kRenderTransAdd, 255)
                     set_rendering(Ent, kRenderFxGlowShell, 255, 0, 0, kRenderNormal, 30)
                  }
                  case 1: {
                     set_rendering(FluxSpr, kRenderFxFadeSlow, 255, 255, 0, kRenderTransAdd, 255)
                     set_rendering(Ent, kRenderFxGlowShell, 255, 255, 0, kRenderNormal, 30)
                  }
                  case 2: {
                     set_rendering(FluxSpr, kRenderFxFadeSlow, 0, 0, 255, kRenderTransAdd, 255)
                     set_rendering(Ent, kRenderFxGlowShell, 0, 0, 255, kRenderNormal, 30)
                  }
               }
               set_pev(FluxSpr, pev_framerate, 5.0)
               dllfunc(DLLFunc_Spawn, FluxSpr)
               set_pev(Ent, pev_nextthink, get_gametime() + 0.1)
               num++
               return
            }
            case 1..10: {
               for(new id = 1; id <= get_maxplayers(); id++) {
                  if (!is_user_alive(id))
                     continue
                     
                  static Float:OriginSW[3], Float:OriginSW2[3], Float:Vector[3]
                  pev(Ent, pev_origin, OriginSW)
                  pev(id, pev_origin, OriginSW2)
                  
                  xs_vec_sub(OriginSW, OriginSW2, Vector)
                  xs_vec_normalize(Vector, Vector)
                  xs_vec_mul_scalar(Vector, 800.0, Vector)
                  set_pev(id, pev_velocity, Vector)
                  set_pev(Ent, pev_nextthink, get_gametime() + 0.2)
                  num++
                  return
               }
            }
            case 11: {
               engfunc(EngFunc_RemoveEntity, FluxSpr)
               Anim(Ent, 5)
               set_pev(Ent, pev_nextthink, get_gametime() + 2.2)
               num++
               return
            }
            case 12: {
               static Float:Orig[3]
               pev(Ent, pev_origin, Orig)
               set_rendering(Ent)
               
               switch (sw_random) {
                  case 0: ShockWave(Orig, 5, 35, 1000.0, {255, 0, 0}) // 450
                  case 1: ShockWave(Orig, 5, 35, 1000.0, {255, 255, 0})
                  case 2: ShockWave(Orig, 5, 35, 1000.0, {0, 0, 255})
               }
               
               for(new id = 1; id <= get_maxplayers(); id++) {
                  if (!is_user_alive(id))
                     continue
                     
                  if (pev(id, pev_flags) & FL_ONGROUND) {
                     static Float:gOrigin[3], Float:Vec[3], Float:Len
                     pev(id, pev_origin, gOrigin)
                     xs_vec_sub(Orig, gOrigin, Vec)
                     Len = xs_vec_len(Vec)
                     if (Len <= 450.0) {
                        switch (sw_random) {
                           case 0: user_kill(id)
                           case 1: {
                              ScreenFade(id, 5, {255, 0, 0}, 120)
                              ExecuteHamB(Ham_TakeDamage, id, 0, id, float(dmg_sw), DMG_SONIC)
                              ScreenShake(id)
                           }
                           case 2: {
                              client_cmd(id, "drop")
                              ScreenShake(id)
                           }
                        }
                     }
                  }
               }
               Ability = WALK
               one = true
               num = 0
               set_pev(Ent, pev_nextthink, get_gametime() + 0.2)
               return
            }
         }
      }
   }
}

public Think_HP(Ent) {
   static Float:Origin[3], num
   pev(g_Alien, pev_origin, Origin)
   Origin[2] += 200.0
   set_pev(Ent, pev_origin, Origin)
   
   switch ( num ) {
      case 0: {
         Anim(g_Alien, 3)
         set_pev(g_Alien, pev_takedamage, DAMAGE_YES)
         num++
      }
      case 1: {
         static Float:frame
         frame = g_Health * 100.0 / float(alien_hp)
         
         if (frame)
            set_pev(Ent, pev_frame, frame)
         
         if (pev(g_Alien, pev_deadflag) == DEAD_DYING) {
            engfunc(EngFunc_RemoveEntity, Ent)
            return
         }
      }
   }
   set_pev(Ent, pev_nextthink, get_gametime() + 0.1)
}

public TraceAttack(victim, attacker, Float:damage, Float:direction[3], th, dt) {
   static Float:End[3], ClassName[32]
   pev(victim, pev_classname, ClassName, charsmax(ClassName))
   if (equal(ClassName, "AlienBossik")) {
      get_tr2(th, TR_vecEndPos, End)
      Blood(End)
   }
}

public TakeDamage(victim, weapon, attacker, Float:damage, damagetype)
{
   static ClassName[32]
   pev(victim, pev_classname, ClassName, charsmax(ClassName))

   if (equal(ClassName, "AlienBossik"))
   {
      pev(victim, pev_health, g_Health)
      if (g_Health <= damage)
      {
         Anim(victim, 1)
         set_pev(victim, pev_movetype, MOVETYPE_FLY)
         set_pev(victim, pev_solid, SOLID_NOT)
         set_pev(victim, pev_velocity, {0.0, 0.0, 0.0})
         set_pev(victim, pev_deadflag, DEAD_DYING)
         remove_task(1337)
         return HAM_SUPERCEDE
      }
      else if(get_pcvar_num(cvar_dmg_ap_allow))
      {
         // Store damage dealt
         g_damagedealt[attacker] += floatround(damage)
            
         // Reward ammo packs for every [ammo damage] dealt
         while (g_damagedealt[attacker] > get_pcvar_num(cvar_ammodamage))
         {
            g_damagedealt[attacker] -= get_pcvar_num(cvar_ammodamage)
            zp_set_user_ammo_packs(attacker, zp_get_user_ammo_packs(attacker) + get_pcvar_num(cvar_ammo_quantity))
         }
      }
   }

   return HAM_HANDLED
}

public Touch_Boss(Ent, WorldEnt) {
   if (Ability == MS) {
      static victim = -1, Float:Origin[3]
      pev(Ent, pev_origin, Origin)
      while((victim = engfunc(EngFunc_FindEntityInSphere, victim, Origin, 400.0)) != 0) {
         if (!is_user_alive(victim))
            continue
         
         ExecuteHamB(Ham_TakeDamage, victim, 0, victim, float(dmg_ms), DMG_BULLET)
      }
   }
   
   if (Ability == WALK) {
      Ability = ATTACK
      VictimID = WorldEnt
   }
}

stock Blood(Float:Orig[3]) {   
   message_begin(MSG_BROADCAST, SVC_TEMPENTITY);
   write_byte(TE_BLOODSPRITE);
   engfunc(EngFunc_WriteCoord, Orig[0])
   engfunc(EngFunc_WriteCoord, Orig[1])
   engfunc(EngFunc_WriteCoord, Orig[2])
   write_short(g_Resource[1])
   write_short(g_Resource[2])
   write_byte(218)
   write_byte(random_num(1, 2))
   message_end();
}


stock Anim(ent, sequence) {
   set_pev(ent, pev_sequence, sequence)
   set_pev(ent, pev_animtime, halflife_time())
   set_pev(ent, pev_framerate, 1.0)
}

stock ShockWave(Float:Orig[3], Life, Width, Float:Radius, Color[3]) {
   engfunc(EngFunc_MessageBegin, MSG_PVS, SVC_TEMPENTITY, Orig, 0)
   write_byte(TE_BEAMCYLINDER) // TE id
   engfunc(EngFunc_WriteCoord, Orig[0]) // x
   engfunc(EngFunc_WriteCoord, Orig[1]) // y
   engfunc(EngFunc_WriteCoord, Orig[2]-40.0) // z
   engfunc(EngFunc_WriteCoord, Orig[0]) // x axis
   engfunc(EngFunc_WriteCoord, Orig[1]) // y axis
   engfunc(EngFunc_WriteCoord, Orig[2]+Radius) // z axis
   write_short(g_Resource[4]) // sprite
   write_byte(0) // startframe
   write_byte(0) // framerate
   write_byte(Life) // life (4)
   write_byte(Width) // width (20)
   write_byte(0) // noise
   write_byte(Color[0]) // red
   write_byte(Color[1]) // green
   write_byte(Color[2]) // blue
   write_byte(255) // brightness
   write_byte(0) // speed
   message_end()
}

stock ScreenFade(id, Timer, Colors[3], Alpha) {   
   message_begin(MSG_ONE_UNRELIABLE, get_user_msgid("ScreenFade"), _, id);
   write_short((1<<12) * Timer)
   write_short(1<<12)
   write_short(0)
   write_byte(Colors[0])
   write_byte(Colors[1])
   write_byte(Colors[2])
   write_byte(Alpha)
   message_end()
}

stock ScreenShake(id) {
   message_begin(MSG_ONE_UNRELIABLE, get_user_msgid("ScreenShake"), _, id);
   write_short(1<<14)
   write_short(1<<12)
   write_short(2<<12)
   message_end();
}

GetRandomAlive(target_index) {         // :3
   new iAlive
   for (new id = 1; id <= get_maxplayers(); id++) {
      if (is_user_alive(id)) iAlive++
      if (iAlive == target_index) return id
   }
   return -1
}

GetAliveCount() {            // ^^
   new iAlive
   for (new id = 1; id <= get_maxplayers(); id++) if (is_user_alive(id)) iAlive++
   return iAlive
}


Aqui NPC Alien configurado para dar packs
Creditos: [P]erfec[T] [S]cr[@]s[H]