Half-Life и Adrenaline Gamer форум

/* AMX Mod X
*   Lasermines for HLDM
*
* http://aghl.ru/forum/ - Russian Half-Life and Adrenaline Gamer Community
*
* This file is provided as is (no warranties)
*/

#pragma semicolon 1
#pragma ctrlchar '\'

#include <amxmodx>
#include <fakemeta_util>
#include <hamsandwich>
#include <xs>

#define PLUGIN "Lasermine"
#define VERSION "1.2"
#define AUTHOR "KORD_12.7//Gauss"

#define TRIPMINE_LASER      pev_iuser4
#define TRIPMINE_OWNER      pev_iuser3
#define TRIPMINE_BEAM      pev_iuser2
#define TRIPMINE_SPARKS_DELAY   pev_fuser4
#define TRIPMINE_BLOOD_DELAY   pev_fuser3
#define TRIPMINE_FRACTION_OLD   pev_fuser2

#define MAX_PLAYERS      32

#define IsPlayer(%1) (1 <= %1 <= g_MaxPlayers)
new frozen;
#define IsFrozen(%1)     (frozen & (1<<(%1&31)))
new frz[33];


enum TRIPMINE
{
   TRIPMINE_MODE,
   Float: TRIPMINE_DELAY,
   
   TRIPMINE_END
};
 
new const 
m_flPowerUp = 166,
m_vecEnd_x = 170,
m_vecEnd_y = 171,
m_vecEnd_z = 172,
m_pBeam = 176,
extraoffset_linux = 5,


SPRITE_BLOOD[] = "sprites/blood.spr",
SPRITE_BLOOD2[] = "sprites/bloodspray.spr";

new 
g_SpawnsId[64],
m_iBlood[2],
g_MaxPlayers,
g_Tripmines[MAX_PLAYERS + 1][TRIPMINE_END],
delaytime[33],
delaytime2[33],
delaytime3[33],

pcvar_lasermine_enable,
pcvar_lasermine_laser_damage,
pcvar_lasermine_laser_color,
pcvar_lasermine_laser_color2,
pcvar_lasermine_laser_color3,
pcvar_lasermine_laser_color4,
pcvar_lasermine_laser_color5,
pcvar_lasermine_laser_width,
pcvar_lasermine_laser_noise,
GLOW,
HOT_GLOW,
pcvar_lasermine_laser_bright;

public plugin_init() 
{
   register_plugin(PLUGIN, VERSION, AUTHOR);
   register_cvar("lasermines_version", VERSION, FCVAR_SPONLY | FCVAR_SERVER | FCVAR_UNLOGGED);

   register_forward(FM_CmdStart, "fw_CmdStart");
   register_forward(FM_TraceLine, "fw_TraceLine", 1);
   
   RegisterHam(Ham_Spawn, "monster_tripmine", "Tripmine_Spawn_Post", 1);
   RegisterHam(Ham_Think, "monster_tripmine", "Tripmine_Think_Post", 1);
   RegisterHam(Ham_Killed, "player", "fw_Player_Death");
   RegisterHam(Ham_TakeDamage, "player", "fw_TakeDamage");
   
   pcvar_lasermine_enable = register_cvar("lasermine_enable", "1");
   pcvar_lasermine_laser_damage = register_cvar("lasermine_laser_damage", "40.0");
   pcvar_lasermine_laser_color = register_cvar("lasermine_laser_color", "255000000");
   pcvar_lasermine_laser_color2= register_cvar("lasermine_laser_color2", "000255000");
   pcvar_lasermine_laser_color3= register_cvar("lasermine_laser_color3", "255255255");
   pcvar_lasermine_laser_color4= register_cvar("lasermine_laser_color4", "050050255");
   pcvar_lasermine_laser_color5= register_cvar("lasermine_laser_color5", "255128000");
   
   pcvar_lasermine_laser_width = register_cvar("lasermine_laser_width", "20");
   pcvar_lasermine_laser_noise = register_cvar("lasermine_laser_noise", "0");
   pcvar_lasermine_laser_bright = register_cvar("lasermine_laser_brightness", "150");
   
   g_MaxPlayers = get_maxplayers();
   start_map();
}

public start_map()
{
   new ent;
   new i;
   
   while((ent = engfunc(EngFunc_FindEntityByString, ent, "classname", "info_player_deathmatch")))
   {
      g_SpawnsId[i++] = ent;
      if(i == sizeof g_SpawnsId)
         break;
   }
}

public plugin_precache()
{
   m_iBlood[0] = precache_model(SPRITE_BLOOD);
   m_iBlood[1] = precache_model(SPRITE_BLOOD2);

   precache_sound("debris/beamstart4.wav");
   precache_sound("debris/beamstart7.wav");
   precache_sound("debris/beamstart9.wav");
   precache_model("sprites/b-tele1.spr");
   GLOW = precache_model("sprites/glow02.spr");
   HOT_GLOW = precache_model("sprites/hotglow.spr");
}

public fw_TraceLine(Float:start[3], Float:dest[3], ignore_monsters, ent, ptr)
{
   if (!pev_valid(ent))
      return FMRES_IGNORED;

   static classname[32];
   pev(ent, pev_classname, classname, charsmax(classname));
   
   if (equali(classname, "monster_tripmine") && pev(ent, TRIPMINE_LASER))
   {   
      if (get_pdata_float(ent, m_flPowerUp, extraoffset_linux) < get_gametime())
      {
         set_tr2(ptr, TR_flFraction, 0.0001);
         return FMRES_HANDLED;
      }
   }
   
   return FMRES_IGNORED;
}

public fw_CmdStart(id, UC_Handle, seed)
{
   if (!is_user_alive(id) || !get_pcvar_num(pcvar_lasermine_enable) || get_user_weapon(id) != HLW_TRIPMINE)
      return FMRES_IGNORED;
      
   static buttons; buttons = get_uc(UC_Handle, UC_Buttons);   
   static Float:gametime; gametime = get_gametime();
      
   if (buttons & IN_ATTACK && g_Tripmines[id][TRIPMINE_DELAY] < gametime)
   {
      if(!((buttons & IN_USE)||(buttons & IN_RELOAD)))
      {
         g_Tripmines[id][TRIPMINE_MODE] = 0;
         g_Tripmines[id][TRIPMINE_DELAY] = _:(gametime + 0.2);
      }
      else if(buttons & IN_USE)
      {
         new ptr = create_tr2();
         
         new Float: vecSrc[3];
         new Float: vecAiming[3];
         new Float: fraction;
   
         GetGunPosition(id, vecSrc);
         velocity_by_aim(id, 128, vecAiming);
         xs_vec_add(vecAiming, vecSrc, vecAiming);
         
         engfunc(EngFunc_TraceLine, vecSrc, vecAiming, DONT_IGNORE_MONSTERS, id, ptr);
         
         get_tr2(ptr, TR_flFraction, fraction); 
         free_tr2(ptr);
   
         if (fraction < 1.0)
         {
            UTIL_PlayWeaponAnimation(id, 6);
            
            g_Tripmines[id][TRIPMINE_MODE] = 4;
            g_Tripmines[id][TRIPMINE_DELAY] = _:(gametime + 0.3);
            
            ExecuteHamB(Ham_Weapon_PrimaryAttack, fm_get_user_weapon_entity(id, HLW_TRIPMINE));
         }
      }
      else if (buttons & IN_RELOAD)
      {   
         new ptr = create_tr2();
         
         new Float: vecSrc[3];
         new Float: vecAiming[3];
         new Float: fraction;
      
         GetGunPosition(id, vecSrc);
         velocity_by_aim(id, 128, vecAiming);
         xs_vec_add(vecAiming, vecSrc, vecAiming);
         
         engfunc(EngFunc_TraceLine, vecSrc, vecAiming, DONT_IGNORE_MONSTERS, id, ptr);
         
         get_tr2(ptr, TR_flFraction, fraction); 
         free_tr2(ptr);
      
         if (fraction < 1.0)
         {
            UTIL_PlayWeaponAnimation(id, 6);
            
            g_Tripmines[id][TRIPMINE_MODE] = 2;
            g_Tripmines[id][TRIPMINE_DELAY] = _:(gametime + 0.3);
            
            ExecuteHamB(Ham_Weapon_PrimaryAttack, fm_get_user_weapon_entity(id, HLW_TRIPMINE));
         }
      }   
   }
   else if (buttons & IN_ATTACK2  && g_Tripmines[id][TRIPMINE_DELAY] < gametime)
   {   
      if(!((buttons & IN_USE)||(buttons & IN_RELOAD)))
      {
         new ptr = create_tr2();
         
         new Float: vecSrc[3];
         new Float: vecAiming[3];
         new Float: fraction;
   
         GetGunPosition(id, vecSrc);
         velocity_by_aim(id, 128, vecAiming);
         xs_vec_add(vecAiming, vecSrc, vecAiming);
         
         engfunc(EngFunc_TraceLine, vecSrc, vecAiming, DONT_IGNORE_MONSTERS, id, ptr);
         
         get_tr2(ptr, TR_flFraction, fraction); 
         free_tr2(ptr);
   
         if (fraction < 1.0)
         {
            UTIL_PlayWeaponAnimation(id, 6);
            
            g_Tripmines[id][TRIPMINE_MODE] = 1;
            g_Tripmines[id][TRIPMINE_DELAY] = _:(gametime + 0.3);
            
            ExecuteHamB(Ham_Weapon_PrimaryAttack, fm_get_user_weapon_entity(id, HLW_TRIPMINE));
         }
      }
      else if(buttons & IN_USE)
      {
         new ptr = create_tr2();
         
         new Float: vecSrc[3];
         new Float: vecAiming[3];
         new Float: fraction;
   
         GetGunPosition(id, vecSrc);
         velocity_by_aim(id, 128, vecAiming);
         xs_vec_add(vecAiming, vecSrc, vecAiming);
         
         engfunc(EngFunc_TraceLine, vecSrc, vecAiming, DONT_IGNORE_MONSTERS, id, ptr);
         
         get_tr2(ptr, TR_flFraction, fraction); 
         free_tr2(ptr);
   
         if (fraction < 1.0)
         {
            UTIL_PlayWeaponAnimation(id, 6);
            
            g_Tripmines[id][TRIPMINE_MODE] = 3;
            g_Tripmines[id][TRIPMINE_DELAY] = _:(gametime + 0.3);
            
            ExecuteHamB(Ham_Weapon_PrimaryAttack, fm_get_user_weapon_entity(id, HLW_TRIPMINE));
         }
      }
      else if (buttons & IN_RELOAD)
      {   
         new ptr = create_tr2();
         
         new Float: vecSrc[3];
         new Float: vecAiming[3];
         new Float: fraction;
      
         GetGunPosition(id, vecSrc);
         velocity_by_aim(id, 128, vecAiming);
         xs_vec_add(vecAiming, vecSrc, vecAiming);
         
         engfunc(EngFunc_TraceLine, vecSrc, vecAiming, DONT_IGNORE_MONSTERS, id, ptr);
         
         get_tr2(ptr, TR_flFraction, fraction); 
         free_tr2(ptr);
      
         if (fraction < 1.0)
         {
            UTIL_PlayWeaponAnimation(id, 6);
            
            g_Tripmines[id][TRIPMINE_MODE] = 5;
            g_Tripmines[id][TRIPMINE_DELAY] = _:(gametime + 0.3);
            
            ExecuteHamB(Ham_Weapon_PrimaryAttack, fm_get_user_weapon_entity(id, HLW_TRIPMINE));
         }
      }
      
   }   
   /*else if (buttons & IN_RELOAD && g_Tripmines[id][TRIPMINE_DELAY] < gametime)
   {   
      new ptr = create_tr2();
      
      new Float: vecSrc[3];
      new Float: vecAiming[3];
      new Float: fraction;

      GetGunPosition(id, vecSrc);
      velocity_by_aim(id, 128, vecAiming);
      xs_vec_add(vecAiming, vecSrc, vecAiming);
      
      engfunc(EngFunc_TraceLine, vecSrc, vecAiming, DONT_IGNORE_MONSTERS, id, ptr);
      
      get_tr2(ptr, TR_flFraction, fraction); 
      free_tr2(ptr);

      if (fraction < 1.0)
      {
         UTIL_PlayWeaponAnimation(id, 6);
         
         g_Tripmines[id][TRIPMINE_MODE] = 2;
         g_Tripmines[id][TRIPMINE_DELAY] = _:(gametime + 0.3);
         
         ExecuteHamB(Ham_Weapon_PrimaryAttack, fm_get_user_weapon_entity(id, HLW_TRIPMINE));
      }
   }*/   
   
   return FMRES_IGNORED;   
}

public Tripmine_Spawn_Post(ent)
{
   if (pev_valid(ent))
   {
      new id = pev(ent, pev_owner);

      set_pev(ent, TRIPMINE_LASER, g_Tripmines[id][TRIPMINE_MODE]);
      set_pev(ent, TRIPMINE_OWNER, id);
            
      if(pev(ent, TRIPMINE_LASER)==0)
      {
         set_pev(ent, pev_dmg, 150.0);
      }
      else if(pev(ent, TRIPMINE_LASER)==3)
      {
         set_pev(ent, pev_dmg, 200.0);
      }
      else
      {
         set_pev(ent, pev_dmg, get_pcvar_float(pcvar_lasermine_laser_damage));
      }
   }
   
   return HAM_IGNORED;
}

public Tripmine_Think_Post(ent)
{
   static Float: flTime;
   if (!pev_valid(ent) || !pev(ent, TRIPMINE_LASER) || get_pdata_float(ent, m_flPowerUp, extraoffset_linux) > (flTime = get_gametime()))
      return HAM_IGNORED;
   
   set_pev(ent, pev_nextthink, flTime + 0.05);
   
   static beam; beam = get_pdata_cbase(ent, m_pBeam, extraoffset_linux);
   if (!pev_valid(beam)) return HAM_IGNORED;
         
   if (!pev(ent, TRIPMINE_BEAM))
   {
      new Float: rgb[3];
      if(pev(ent, TRIPMINE_LASER)==1)
         GetBeamColor(rgb,1);
      if(pev(ent, TRIPMINE_LASER)==2)
         GetBeamColor(rgb,2);
      if(pev(ent, TRIPMINE_LASER)==3)
         GetBeamColor(rgb,3);
      if(pev(ent, TRIPMINE_LASER)==4)
         GetBeamColor(rgb,4);
      if(pev(ent, TRIPMINE_LASER)==5)
         GetBeamColor(rgb,5);
      
      set_pev(beam, pev_rendercolor, rgb);
      set_pev(beam, pev_scale, get_pcvar_float(pcvar_lasermine_laser_width));
      set_pev(beam, pev_body, get_pcvar_num(pcvar_lasermine_laser_noise));
      set_pev(beam, pev_renderamt, get_pcvar_float(pcvar_lasermine_laser_bright));
      if(pev(ent, TRIPMINE_LASER)>=3)////////////////
      {
         set_pev(beam, pev_scale, 27.0);
         set_pev(beam, pev_renderamt, 230.0);
      }
      set_pev(ent, TRIPMINE_BEAM, 1);
   }
         
   static Float: vecEnd[3];
   static Float: origin[3];
   static Float: fraction;
   static Float: damage;
   
   static ptr, pHit;
      
   pev(ent, pev_origin, origin);
   pev(ent, pev_dmg, damage);
      
   vecEnd[0] = get_pdata_float(ent, m_vecEnd_x, extraoffset_linux);
   vecEnd[1] = get_pdata_float(ent, m_vecEnd_y, extraoffset_linux);
   vecEnd[2] = get_pdata_float(ent, m_vecEnd_z, extraoffset_linux);
   
   ptr = create_tr2();
   
   engfunc(EngFunc_TraceLine, origin, vecEnd, DONT_IGNORE_MONSTERS, ent, ptr);
   
   get_tr2(ptr, TR_vecEndPos, vecEnd);
   get_tr2(ptr, TR_flFraction, fraction);
   
   pHit = get_tr2(ptr, TR_pHit);
   
   //çàنهâàèيه ëَ÷à
   if (fraction < 1.0)
   {
      get_tr2(ptr, TR_vecEndPos, vecEnd);
      
      if (pev_valid(pHit))
      {
         if(pev(ent, TRIPMINE_LASER)==1)
         {
            static Float: BloodDelay; 
            pev(ent, TRIPMINE_BLOOD_DELAY, BloodDelay);
            
            if (BloodDelay  < flTime) // Say no to "Overflow 500 temporary ents" :D
            {
               set_pev(ent, TRIPMINE_BLOOD_DELAY, flTime + 0.1);
               UTIL_MakeBlood(vecEnd, damage, pHit);
            }
            
            //ExecuteHamB(Ham_TakeDamage, pHit, ent, pev(ent, TRIPMINE_OWNER), damage, DMG_ENERGYBEAM | DMG_ALWAYSGIB);
            ExecuteHamB(Ham_TakeDamage, pHit, ent,0, damage, DMG_ENERGYBEAM | DMG_ALWAYSGIB);
         }
         if(pev(ent, TRIPMINE_LASER)==2)
         {
            if(IsPlayer(pHit))
               teleport(pHit);
         }
         if(pev(ent, TRIPMINE_LASER)==3)
         {
                        
            if(IsPlayer(pHit))
            {
               new origin[3];
               get_user_origin(pHit,origin);
               flash(pHit,origin);
            }
         }
         if(pev(ent, TRIPMINE_LASER)==4)
         {            
            if(IsPlayer(pHit))
            {
               new origin[3];
               get_user_origin(pHit,origin);
               freeze(pHit,origin);
            }
         }
         if(pev(ent, TRIPMINE_LASER)==5)
         {            
            if(IsPlayer(pHit))
            {
               new origin[3];
               get_user_origin(pHit,origin);
               Reverse(pHit,origin);
            }
         }
      }
   }
   
   free_tr2(ptr);
   
   static Float: fractionOld; 
   pev(ent, TRIPMINE_FRACTION_OLD, fractionOld);
   
   if (fractionOld != fraction)
   {
      RelinkBeam(beam, vecEnd, vecEnd, origin);
      set_pev(ent, TRIPMINE_FRACTION_OLD, fraction);
   }
   /*
   static Float: SparksDelay; 
   pev(ent, TRIPMINE_SPARKS_DELAY, SparksDelay);
   
   if (SparksDelay  < flTime && !IsPlayer(pHit))
   {
      set_pev(ent, TRIPMINE_SPARKS_DELAY, flTime + 0.1);
      
      message_begin(MSG_BROADCAST, SVC_TEMPENTITY);
      write_byte(TE_SPARKS);
      engfunc(EngFunc_WriteCoord, vecEnd[0]);
      engfunc(EngFunc_WriteCoord, vecEnd[1]);
      engfunc(EngFunc_WriteCoord, vecEnd[2]);
      message_end();
   }
   */
   return HAM_IGNORED;   
}
public teleport(player)
{
   new spawnId;
   new Float:origin[3];
   new Float:angles[3];
   //new player = pev(id, pev_owner)
   
   new ent = engfunc(EngFunc_CreateNamedEntity, engfunc(EngFunc_AllocString, "cycler_sprite"));

   set_pev(ent, pev_rendermode, kRenderTransAdd);
   engfunc(EngFunc_SetModel, ent, "sprites/b-tele1.spr");

   set_pev(ent, pev_renderamt, 255.0);
   set_pev(ent, pev_animtime, 1.0);
   set_pev(ent, pev_framerate, 50.0);
   set_pev(ent, pev_frame, 10);
   
   pev(player, pev_origin, origin);
   
   set_pev(ent,  pev_origin, origin);
   dllfunc(DLLFunc_Spawn, ent);
   set_pev(ent, pev_solid, SOLID_NOT);
   
   emit_sound(ent, CHAN_AUTO, "debris/beamstart4.wav", 0.8, ATTN_NORM, 0, PITCH_NORM);

   message_begin(MSG_BROADCAST,SVC_TEMPENTITY);
   write_byte(TE_DLIGHT);
   write_coord(floatround(origin[0]));
   write_coord(floatround(origin[1]));
   write_coord(floatround(origin[2]));
   write_byte(35);
   write_byte(0);
   write_byte(255);
   write_byte(0);
   write_byte(80);
   write_byte(60);
   message_end();
   
   spawnId = g_SpawnsId[random_num(0, strlen(g_SpawnsId) - 1)];
   
   pev(spawnId, pev_origin, origin);
   pev(spawnId, pev_angles, angles);
   
   set_pev(player, pev_origin, origin);
   set_pev(player, pev_angles, angles);
   set_pev(player, pev_fixangle, 1);
   set_pev(player, pev_velocity, {0.0, 0.0, 0.0});
   
   emit_sound(player, CHAN_AUTO, "debris/beamstart4.wav", 0.5, ATTN_NORM, 0, PITCH_NORM);
   
   message_begin(MSG_ONE, get_user_msgid("ScreenFade"), {0,0,0}, player);
   write_short(1<<10);
   write_short(1<<3);
   write_short(0);
   write_byte(100);
   write_byte(255);
   write_byte(100);
   write_byte(150);
   message_end();

   set_task(0.5, "remove_telesprite_task", ent + 31453);
}
public flash(player,origin[3])
{
   if(get_systime()>(delaytime[player]+5))
   {
      delaytime[player] = get_systime();
      
      //êîن
      message_begin(MSG_ONE, get_user_msgid("ScreenFade"), {0,0,0}, player);
      write_short(12000);
      write_short(12000);
      write_short(0);
      write_byte(255);
      write_byte(255);
      write_byte(255);
      write_byte(250);
      message_end();
      
      emit_sound(player, CHAN_AUTO, "debris/beamstart9.wav", 0.5, ATTN_NORM, 0, PITCH_NORM);      
      
      message_begin(MSG_BROADCAST,SVC_TEMPENTITY);
      write_byte(TE_SPRITETRAIL);
      write_coord(origin[0]);
      write_coord(origin[1]);
      write_coord(origin[2]);
      write_coord(origin[0]);
      write_coord(origin[1]);
      write_coord(origin[2]);
      write_short(GLOW);
      write_byte(70);
      write_byte(10);
      write_byte(4);
      write_byte(80);
      write_byte(30);
      message_end();
   }
}

public remove_telesprite_task(ent)
{
   ent -= 31453;
   if(pev_valid(ent))
      engfunc(EngFunc_RemoveEntity, ent);
}

public freeze(player,origin[3])
{
   if(get_systime()>(delaytime2[player]+10))
   {
      delaytime2[player] = get_systime();
      
      //êîن
      message_begin(MSG_ONE, get_user_msgid("ScreenFade"), {0,0,0}, player);
      write_short(18000);
      write_short(18000);
      write_short(0);
      write_byte(050);
      write_byte(050);
      write_byte(255);
      write_byte(100);
      message_end();
      
      emit_sound(player, CHAN_AUTO, "debris/beamstart7.wav", 0.5, ATTN_NORM, 0, PITCH_NORM);      
            
      message_begin(MSG_BROADCAST,SVC_TEMPENTITY);
      write_byte(TE_DLIGHT);
      write_coord(origin[0]);
      write_coord(origin[1]);
      write_coord(origin[2]);
      write_byte(100);//R
      write_byte(0);//r
      write_byte(0);//g
      write_byte(255);//b
      write_byte(150);//t
      write_byte(60);//decay *0.1s
      message_end();
      set_user_freeze(player,1);
      
      set_task(6.0, "unfreeze", player + 14457);
      
   }
}

public unfreeze(ent)
{
   ent -= 14457;
   if(pev_valid(ent))
   {
      if(IsPlayer(ent))
      {
         set_user_freeze(ent,0);
      }
   }
}

public Reverse(player,origin[3])
{
   if(get_systime()>(delaytime3[player]+5))
   {
      delaytime3[player] = get_systime();
      
      //êîن
      message_begin(MSG_ONE, get_user_msgid("ScreenFade"), {0,0,0}, player);
      write_short(5000);
      write_short(5000);
      write_short(0);
      write_byte(255);
      write_byte(128);
      write_byte(0);
      write_byte(50);
      message_end();
      
      emit_sound(player, CHAN_AUTO, "debris/beamstart7.wav", 0.5, ATTN_NORM, 0, PITCH_NORM);      
            
      message_begin(MSG_BROADCAST,SVC_TEMPENTITY);
      write_byte(TE_DLIGHT);
      write_coord(origin[0]);
      write_coord(origin[1]);
      write_coord(origin[2]);
      write_byte(50);//R
      write_byte(255);//r
      write_byte(218);//g
      write_byte(0);//b
      write_byte(150);//t
      write_byte(60);//decay *0.1s
      message_end();
      
      message_begin(MSG_BROADCAST,SVC_TEMPENTITY);
      write_byte(TE_SPRITETRAIL);
      write_coord(origin[0]);
      write_coord(origin[1]);
      write_coord(origin[2]);
      write_coord(origin[0]);
      write_coord(origin[1]);
      write_coord(origin[2]);
      write_short(HOT_GLOW);
      write_byte(40);
      write_byte(10);
      write_byte(4);
      write_byte(40);
      write_byte(30);
      message_end();
      
      set_migraine(player,1);
      
      //set_task(6.0, "Unrevesre", player + 17457);
      
   }
}



set_migraine(id,num)
{
   new Float:vecPunchAngle[3];
   new Float:idPunchAngle[3];
   pev(id,pev_punchangle,idPunchAngle);
   vecPunchAngle[0] = idPunchAngle[0];
   vecPunchAngle[1] = idPunchAngle[1];
   if(num==1)
      vecPunchAngle[2] = idPunchAngle[2]+360;
   //if(num==0)
      //vecPunchAngle[2] = idPunchAngle[2]-180;

   set_pev(id, pev_punchangle, vecPunchAngle);

}

public fw_TakeDamage(victim, inflictor, attacker, Float:damage, damage_type)
{
   if(!(1 <= inflictor <= 32))
      return HAM_IGNORED;

   if(frz[victim]==1)
      SetHamParamInteger(5, DMG_ALWAYSGIB);
      
   return HAM_IGNORED;
}

public fw_Player_Death(victim) 
{
   if (IsFrozen(victim))
   {
      set_user_freeze(victim,0);
   }
}
stock set_user_freeze(client,freez)
{
    new iFlag = pev(client,pev_flags);
    set_pev(client,pev_flags,freez ? iFlag | FL_FROZEN:iFlag & ~FL_FROZEN);
    frz[client] = freez;
    if(freez==1)
   fm_set_rendering(client,kRenderFxGlowShell,50,50,250,kRenderNormal,50);
    else
   fm_set_rendering(client, kRenderFxNone, 255, 255, 255, kRenderNormal,16);
}


RelinkBeam(const beam, const Float: Origin[3], const Float: startPos[3], const Float: endPos[3])
{
   static Float: mins[3], Float: maxs[3];
   
   mins[0] = floatmin(startPos[0], endPos[0]);
   mins[1] = floatmin(startPos[1], endPos[1]);
   mins[2] = floatmin(startPos[2], endPos[2]);
   
   maxs[0] = floatmax(startPos[0], endPos[0]);
   maxs[1] = floatmax(startPos[1], endPos[1]);
   maxs[2] = floatmax(startPos[2], endPos[2]);
   
   xs_vec_sub(mins, Origin, mins);
   xs_vec_sub(maxs, Origin, maxs);
   
   set_pev(beam, pev_mins, mins);
   set_pev(beam, pev_maxs, maxs);
   
   engfunc(EngFunc_SetSize, beam, mins, maxs);
   engfunc(EngFunc_SetOrigin, beam, Origin);
}

GetBeamColor(Float: rgb[3],type)
{
   new color_str[10], color, red, green, blue;
   if(type==1)
   {
      get_pcvar_string(pcvar_lasermine_laser_color, color_str, charsmax(color_str));
   }
   if(type==2)
   {
      get_pcvar_string(pcvar_lasermine_laser_color2, color_str, charsmax(color_str));
   }
   if(type==3)
   {
      get_pcvar_string(pcvar_lasermine_laser_color3, color_str, charsmax(color_str));
   }
   if(type==4)
   {
      get_pcvar_string(pcvar_lasermine_laser_color4, color_str, charsmax(color_str));
   }
   if(type==5)
   {
      get_pcvar_string(pcvar_lasermine_laser_color5, color_str, charsmax(color_str));
   }
   color = str_to_num(color_str);
   red = color / 1000000;
   color %= 1000000;
   green = color / 1000;
   blue = color % 1000;
      
   rgb[0] = float(red);
   rgb[1] = float(green);
   rgb[2] = float(blue);
}

stock GetGunPosition(const player, Float:origin[3] )
{
   new Float:viewOfs[3];
   
   pev(player, pev_origin, origin);
   pev(player, pev_view_ofs, viewOfs);
    
   xs_vec_add( origin, viewOfs, origin);
}

stock UTIL_PlayWeaponAnimation(const Player, const Sequence)
{
   set_pev(Player, pev_weaponanim, Sequence);
   
   message_begin(MSG_ONE_UNRELIABLE, SVC_WEAPONANIM, .player = Player);
   write_byte(Sequence);
   write_byte(pev(Player, pev_body));
   message_end();
}

stock UTIL_MakeBlood(const Float:vTraceEnd[3], const Float:Damage, const hitEnt) 
{
   new bloodColor = ExecuteHam(Ham_BloodColor, hitEnt);
   if (bloodColor == -1) return;

   new amount = floatround(Damage); amount *= 2;
   
   message_begin(MSG_BROADCAST, SVC_TEMPENTITY);
   write_byte(TE_BLOODSPRITE);
   engfunc(EngFunc_WriteCoord, vTraceEnd[0]);
   engfunc(EngFunc_WriteCoord, vTraceEnd[1]);
   engfunc(EngFunc_WriteCoord, vTraceEnd[2]);
   write_short(m_iBlood[1]);
   write_short(m_iBlood[0]);
   write_byte(bloodColor);
   write_byte(min(max(3, amount/10), 16));
   message_end();
}