[GC] Electric Guitar

Hello, i want to share a interseting plugin is Electric Guitar

Note: This Plugin Is Not Same as GC, it's fan made (Beta) (Not Fully Plugin)

it give random mouse moves effect and screenfade and glow

srry for my bad english

Here is the code


#include < amxmodx >

#include < engine >

#include < fun >

#include < cstrike >

#include < fakemeta >

#include < hamsandwich >

#include < cs_ham_bots_api >

#include < zp50_items >

#include < zp50_core >



#define SetPlayerBit(%1,%2) (%1 |= (1<<(%2&31)))

#define RemovePlayerBit(%1,%2) (%1 &= ~(1 <<(%2&31)))

#define GetPlayerBit(%1,%2) (%1 & (1<<(%2&31)))



enum _:fModelType

{

PLAYER,

VIEW,

WORLD

};



new g_fModels[fModelType][] =

{

"models/zombie_plague/p_electric_guitar.mdl",

"models/zombie_plague/v_electric_guitar.mdl",

"models/zombie_plague/w_electric_guitar.mdl"

};



enum _:Colors

{

RED,

GREEN,

BLUE

}



enum _:eRender

{

RENDERFX,

RENDERCOLORR,

RENDERCOLORG,

RENDERCOLORB,

RENDERMODE,

RENDERAMT,

};



new const ITEM_NAME[] = "[GC] Electric Guitar";

const ITEM_COST = 35;

const MAXPLAYERS = 32;

const TASK_SHOCK = 100;

const TASK_EFFECT = 200;

const TASK_RENDER = 300;

const FFADE_IN = 0x0000

const Float:SHOOTSPEED = 0.10;

const WEAPON_ELECTRIC_GUITAR = 852;



new const szWeapon_Galil[] = "weapon_galil"



const m_pPlayer = 41;

const m_pActiveItem = 373;



new g_fClipAmmo[ MAXPLAYERS+1 ], g_fHasGuitar, g_fiItemID, g_fEvent_Guitar, g_fPrimaryAttack, g_fPcvarDamage, g_fPcvarDelay, g_fPcvarEffectTime, g_sModelIndexLaser, g_fMsgScreenFade;

new Float:fAngles[ MAXPLAYERS+1 ][ 3 ], fColor[ MAXPLAYERS+1 ][ Colors ], fRender[ MAXPLAYERS+1 ][ eRender ];



new const SHOT_SOUND[][] = { "weapons/rguitar.wav" };



new const ELECTGUITAR_SOUNDS[][] = { "weapons/gt_clipin.wav", "weapons/gt_clipon.wav", "weapons/gt_clipout.wav", "weapons/gt_draw.wav" };



new const SOUND_SHOCK[] = "zombie_plague/guitar_shock.wav";



new const GUNSHOT_DECALS[] = {41, 42, 43, 44, 45}



public plugin_init()

{

register_plugin("[ZP50] Electric Guitar", "1.0", "ShaunCraft");



g_fiItemID = zp_items_register(ITEM_NAME, ITEM_COST);



g_fPcvarDamage = register_cvar("zp_electric_guitar_dmg", "1.3");

g_fPcvarDelay = register_cvar("zp_electric_guitar_delay", "7.0");

g_fPcvarEffectTime = register_cvar("zp_electric_guitar_effecttime", "2.0");



g_fMsgScreenFade = get_user_msgid("ScreenFade");



register_event("HLTV", "Event_NewRound", "a", "1=0", "2=0");



register_forward(FM_UpdateClientData, "Fakemeta_UpdateClientData_Post", 1);

register_forward(FM_PrecacheEvent, "Fakemeta_PrecacheEvent_Post", 1);

register_forward(FM_PlaybackEvent, "Fakemeta_PlayBackEvent_Pre");

register_forward(FM_SetModel, "Fakemeta_SetModel_Pre");

register_forward(FM_PlayerPreThink, "Fakemeta_PlayerPreThink");



register_clcmd("say /effectme", "EffectMe")



RegisterHam(Ham_Item_PostFrame, szWeapon_Galil, "cBaseEntity_ItemPostFrame_Pre");

RegisterHam(Ham_TraceAttack, "player", "CBaseEntity_TraceAttack_Post", 1);

RegisterHam(Ham_TraceAttack, "worldspawn", "CBaseEntity_TraceAttack_Post", 1);

RegisterHam(Ham_TraceAttack, "func_wall", "CBaseEntity_TraceAttack_Post", 1);

RegisterHam(Ham_TraceAttack, "func_breakable", "CBaseEntity_TraceAttack_Post", 1);

RegisterHam(Ham_TraceAttack, "func_door", "CBaseEntity_TraceAttack_Post", 1);

RegisterHam(Ham_TraceAttack, "func_door_rotating", "CBaseEntity_TraceAttack_Post", 1);

RegisterHam(Ham_TraceAttack, "worldspawn", "CBaseEntity_BulletHole_Post", 1);

RegisterHam(Ham_Weapon_PrimaryAttack, szWeapon_Galil, "cBaseEntity_PrimaryAttack");

RegisterHam(Ham_Weapon_PrimaryAttack, szWeapon_Galil, "cBaseEntity_PrimaryAttack_Post", 1);

RegisterHam(Ham_Item_Deploy, szWeapon_Galil, "cBaseEntity_ItemDeploy_Post", 1);

RegisterHam(Ham_TakeDamage, "player", "CBasePlayer_TakeDamage_Pre");

RegisterHamBots(Ham_TakeDamage, "CBasePlayer_TakeDamage_Pre");

RegisterHam(Ham_TakeDamage, "player", "CBasePlayer_TakeDamage_Post", 1);

RegisterHamBots(Ham_TakeDamage, "CBasePlayer_TakeDamage_Pre");

RegisterHam(Ham_Killed, "player", "CBasePlayer_Killed_Post", 1);

RegisterHamBots(Ham_Killed, "CBasePlayer_Killed_Post", 1);

RegisterHam(Ham_Item_AddToPlayer, szWeapon_Galil, "CGalil_AddToPlayer_Pre");

}



public plugin_precache()

{

precache_model(g_fModels[PLAYER]);

precache_model(g_fModels[VIEW]);

precache_model(g_fModels[WORLD]);



g_sModelIndexLaser = precache_model("sprites/dot.spr");



precache_sound(SOUND_SHOCK)



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

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

}



public client_disconnect(this)

{

RemovePlayerBit(g_fHasGuitar, this);

CheckTaskes(this)

}



public zp_fw_core_infect_post(this)

{

RemovePlayerBit(g_fHasGuitar, this);

CheckTaskes(this)

}



public zp_fw_core_cure_post(this)

{

RemovePlayerBit(g_fHasGuitar, this);

CheckTaskes(this)

}



public client_putinserver(this)

{

RemovePlayerBit(g_fHasGuitar, this);

CheckTaskes(this)

}



public Event_NewRound()

{

new rgPlayers[MAXPLAYERS], iPlayersCount, pPlayer, pActiveItem;

get_players(rgPlayers, iPlayersCount);



for (new i = 0; i < iPlayersCount; i++)

{

pPlayer = rgPlayers[i];



if (!GetPlayerBit(g_fHasGuitar, pPlayer))

continue;



RemovePlayerBit(g_fHasGuitar, pPlayer);



pActiveItem = get_pdata_cbase(pPlayer, m_pActiveItem);



if (pActiveItem == -1)

continue;



if (cs_get_weapon_id(pActiveItem) != CSW_GALIL)

continue;



entity_set_string(pPlayer, EV_SZ_viewmodel, "models/v_galil.mdl");

entity_set_string(pPlayer, EV_SZ_weaponmodel, "models/p_galil.mdl");

}

}



public zp_fw_items_select_pre(this, fItemID)

{

if(fItemID != g_fiItemID)

return ZP_ITEM_AVAILABLE;



if(zp_core_is_zombie(this))

return ZP_ITEM_DONT_SHOW;



if(GetPlayerBit(g_fHasGuitar, this))

return ZP_ITEM_NOT_AVAILABLE;



return ZP_ITEM_AVAILABLE;

}



public zp_fw_items_select_post(this, fItemID)

{

if(fItemID != g_fiItemID)

return;



cs_drop_user_weapon(this, szWeapon_Galil)



SetPlayerBit(g_fHasGuitar, this);



new fWeaponID = give_item(this, szWeapon_Galil);



cs_set_weapon_ammo(fWeaponID, 40);

cs_set_user_bpammo(this, CSW_GALIL, 200);

}



public Fakemeta_UpdateClientData_Post(this, fSendWeapons, fHandle)

{

if(is_user_alive(this) && get_user_weapon(this) == CSW_GALIL && GetPlayerBit(g_fHasGuitar, this))

set_cd(fHandle, CD_flNextAttack, halflife_time () + 0.001);

}



public Fakemeta_PrecacheEvent_Post(fType, const szName[])

{

if(equal("events/galil.sc", szName))

{

g_fEvent_Guitar = get_orig_retval()

return FMRES_HANDLED;

}



return FMRES_IGNORED;

}



public Fakemeta_PlayBackEvent_Pre(fFlags, fInvoker, fEventID, Float:fDelay, Float:fOrigin[3], Float:dAngles[3], Float:fParam1, Float:fParam2, pParam1, pParam2, aParam1, aParam2)

{

if ((fEventID != g_fEvent_Guitar) || !g_fPrimaryAttack)

return FMRES_IGNORED;



if (!(1 <= fInvoker <= get_maxplayers()))

return FMRES_IGNORED;



playback_event(fFlags | FEV_HOSTONLY, fInvoker, fEventID, fDelay, fOrigin, dAngles, fParam1, fParam2, pParam1, pParam2, aParam1, aParam2);

return FMRES_SUPERCEDE;

}



public Fakemeta_SetModel_Pre(this, const szModel[])

{

if (!is_valid_ent(this))

return FMRES_IGNORED;



if (!equali(szModel[7], "w_gali", 4))

return FMRES_IGNORED;



new pevWeapon = find_ent_by_owner(-1, szWeapon_Galil, this);



if (pevWeapon == 0)

return FMRES_IGNORED;



new pevOwner = entity_get_edict(this, EV_ENT_owner);



if (!GetPlayerBit(g_fHasGuitar, pevOwner))

return FMRES_IGNORED;



entity_set_int(pevWeapon, EV_INT_impulse, WEAPON_ELECTRIC_GUITAR);

entity_set_model(this, g_fModels[WORLD]);



RemovePlayerBit(g_fHasGuitar, pevOwner);

return FMRES_SUPERCEDE;

}



public Fakemeta_PlayerPreThink(this)

{

if(!is_user_alive(this) || !task_exists(this+TASK_SHOCK))

{

entity_set_int(this, EV_INT_fixangle, 0);

return;

}

}



public CGalil_AddToPlayer_Pre(this, pevPlayer)

{

if (entity_get_int(this, EV_INT_impulse) == WEAPON_ELECTRIC_GUITAR)

{

entity_set_int(this, EV_INT_impulse, 0);

SetPlayerBit(g_fHasGuitar, pevPlayer);

}

}



public CheckTaskes(this)

{

if(task_exists(this+TASK_SHOCK))

remove_task(this+TASK_SHOCK)



if(task_exists(this+TASK_RENDER))

remove_task(this+TASK_RENDER)

}



public cBasePlayer_Killed_Post(this)

CheckTaskes(this)



public CBaseEntity_BulletHole_Post(this, pevAttacker, Float:flDamage, Float:vecDir[3], tr)

{

if (this == pevAttacker)

return;



if (!is_user_alive(pevAttacker))

return;



if (get_user_weapon(pevAttacker) != CSW_GALIL)

return;



if (!GetPlayerBit(g_fHasGuitar, pevAttacker))

return;



new Float:vecEndPos[3];



get_tr2(tr, TR_vecEndPos, vecEndPos);



CreateBulletHole(pevAttacker, this, vecEndPos)

}



public CBaseEntity_TraceAttack_Post(this, pevAttacker, Float:flDamage, Float:vecDir[3], tr)

{

if (this == pevAttacker)

return;



if (!is_user_alive(pevAttacker))

return;



if (get_user_weapon(pevAttacker) != CSW_GALIL)

return;



if (!GetPlayerBit(g_fHasGuitar, pevAttacker))

return;



new Float:vecEndPos[3];



get_tr2(tr, TR_vecEndPos, vecEndPos);



CreateTracer(pevAttacker, vecEndPos, 15, 14, 0, 250, 0)

CreateTracer(pevAttacker, vecEndPos, 15, 18, 0, 250, 250)

CreateTracer(pevAttacker, vecEndPos, 15, 22, 0, 0, 250)



}



public CreateBulletHole(fAttacker, this, Float:fOrigin[3])

{

if(this)

{

message_begin(MSG_BROADCAST, SVC_TEMPENTITY)

{

write_byte(TE_DECAL)

engfunc(EngFunc_WriteCoord, fOrigin[0])

engfunc(EngFunc_WriteCoord, fOrigin[1])

engfunc(EngFunc_WriteCoord, fOrigin[2])

write_byte(GUNSHOT_DECALS[random_num (0, sizeof GUNSHOT_DECALS -1)])

write_short(this)

}

message_end()

}

else

{

message_begin(MSG_BROADCAST, SVC_TEMPENTITY)

{

write_byte(TE_WORLDDECAL)

engfunc(EngFunc_WriteCoord, fOrigin[0])

engfunc(EngFunc_WriteCoord, fOrigin[1])

engfunc(EngFunc_WriteCoord, fOrigin[2])

write_byte(GUNSHOT_DECALS[random_num (0, sizeof GUNSHOT_DECALS -1)])

}

message_end()

}



message_begin(MSG_BROADCAST, SVC_TEMPENTITY)

{

write_byte(TE_GUNSHOTDECAL)

engfunc(EngFunc_WriteCoord, fOrigin[0])

engfunc(EngFunc_WriteCoord, fOrigin[1])

engfunc(EngFunc_WriteCoord, fOrigin[2])

write_short(fAttacker)

write_byte(GUNSHOT_DECALS[random_num (0, sizeof GUNSHOT_DECALS -1)])

}

message_end()

}



public CreateTracer(pevAttacker, Float:vecEndPos[3], fSize, fDist, fRed, fGreen, fBlue)

{

message_begin ( MSG_BROADCAST, SVC_TEMPENTITY )

{

write_byte ( TE_BEAMENTPOINT );

write_short ( pevAttacker | 0x1000 );

engfunc ( EngFunc_WriteCoord, vecEndPos[0] );

engfunc ( EngFunc_WriteCoord, vecEndPos[1] );

engfunc ( EngFunc_WriteCoord, vecEndPos[2] );

write_short ( g_sModelIndexLaser );

write_byte ( 0 );

write_byte ( 1 );

write_byte ( 1 );

write_byte ( fSize );

write_byte ( fDist );

write_byte ( fRed ) // Red amount

write_byte ( fGreen ) // Green amount

write_byte ( fBlue) // Blue amount

write_byte ( 200 );

write_byte ( 0 );

}

message_end ( );

}



public CBasePlayer_TakeDamage_Pre(this, pevInflictor, pevAttacker, Float:flDamage)

{

if (this == pevAttacker)

return HAM_IGNORED;



if (!is_user_alive(pevAttacker))

return HAM_IGNORED;



new iWeaponId;



get_user_attacker(this, iWeaponId);



if (iWeaponId != CSW_GALIL)

return HAM_IGNORED;



if (!GetPlayerBit(g_fHasGuitar, pevAttacker))

return HAM_IGNORED;



SetHamParamFloat(4, flDamage * get_pcvar_float(g_fPcvarDamage));

return HAM_IGNORED;

}



public CBasePlayer_TakeDamage_Post(this, pevInflictor, pevAttacker)

{

if (this == pevAttacker)

return;



if (!is_user_alive(this) || !zp_core_is_zombie(this))

return;



if (!is_user_alive(pevAttacker))

return;



new iWeaponId;



get_user_attacker(this, iWeaponId);



if (iWeaponId != CSW_GALIL)

return;



if (!GetPlayerBit(g_fHasGuitar, pevAttacker))

return;



if (task_exists(this+TASK_EFFECT))

return;



if(task_exists(this+TASK_SHOCK))

       return;



set_task(get_pcvar_float(g_fPcvarDelay), "TaskDelay", this+TASK_EFFECT);



emit_sound(this, CHAN_BODY, SOUND_SHOCK, VOL_NORM, ATTN_NORM, 0, PITCH_NORM);



new Float:fDuration = get_pcvar_float(g_fPcvarEffectTime)



new fCount = floatround(fDuration / 0.15)



set_task(0.15, "ShockEffect", this+TASK_SHOCK, _, _, "a", fCount)

}



public TaskBlindRender(iTaskId)

{

new pevPlayer = iTaskId - TASK_RENDER;



if (!is_user_alive(pevPlayer))

return;



set_user_rendering(pevPlayer, fRender[pevPlayer][RENDERFX], fRender[pevPlayer][RENDERCOLORR], fRender[pevPlayer][RENDERCOLORG], fRender[pevPlayer][RENDERCOLORB], fRender[pevPlayer][RENDERMODE], fRender[pevPlayer][RENDERAMT]);

}



public EffectMe(this)

{

emit_sound(this, CHAN_BODY, SOUND_SHOCK, VOL_NORM, ATTN_NORM, 0, PITCH_NORM);



new Float:fDuration = get_pcvar_float(g_fPcvarEffectTime)



new fCount = floatround(fDuration / 0.15)



set_task(0.15, "ShockEffect", this+TASK_SHOCK, _, _, "a", fCount)

}



public TaskDelay(fTaskID) { /* Nothing XD */ }



public ShockEffect(fTaskID)

{

new fPlayer = fTaskID - TASK_SHOCK;



new fRandomNum = random_num(0, 2)



switch(fRandomNum)

{

case 0: fColor[fPlayer][RED] = 0, fColor[fPlayer][GREEN] = 100, fColor[fPlayer][BLUE] = 100;

case 1: fColor[fPlayer][RED] = 0, fColor[fPlayer][GREEN] = 100, fColor[fPlayer][BLUE] = 0;

}



UTIL_ScreenFade(fPlayer, fColor[fPlayer][RED], fColor[fPlayer][GREEN], fColor[fPlayer][BLUE], 125)



new Float:vecColor[3];



entity_get_vector(fPlayer, EV_VEC_rendercolor, vecColor);



fRender[fPlayer]{RENDERFX} = entity_get_int(fPlayer, EV_INT_renderfx);

fRender[fPlayer][RENDERCOLORR] = floatround(vecColor[0]);

fRender[fPlayer][RENDERCOLORG] = floatround(vecColor[1]);

fRender[fPlayer][RENDERCOLORB] = floatround(vecColor[2]);

fRender[fPlayer][RENDERMODE] = entity_get_int(fPlayer, EV_INT_rendermode);

fRender[fPlayer][RENDERAMT] = floatround(entity_get_float(fPlayer, EV_FL_renderamt));



set_user_rendering(fPlayer, kRenderFxGlowShell, fColor[fPlayer][RED], fColor[fPlayer][GREEN], fColor[fPlayer][BLUE], kRenderNormal, 25);

set_task(get_pcvar_float(g_fPcvarEffectTime), "TaskBlindRender", fPlayer+TASK_RENDER);



entity_get_vector(fPlayer, EV_VEC_v_angle, fAngles[fPlayer]);

entity_get_vector(fPlayer, EV_VEC_angles, fAngles[fPlayer]);



switch(random(2))

{

case 0: fAngles[ fPlayer ][ 0 ] += random_float( 60.0, 80.0 ), fAngles[ fPlayer ][ 1 ] = 0.0, fAngles[ fPlayer ][ 2 ] = 0.0;

case 1: fAngles[ fPlayer ][ 0 ] = 0.0, fAngles[ fPlayer ][ 1 ] += random_float( 60.0, 80.0 ), fAngles[ fPlayer ][ 2 ] = 0.0;

case 2: fAngles[ fPlayer ][ 0 ] = 0.0, fAngles[ fPlayer ][ 1 ] = 0.0, fAngles[ fPlayer ][ 2 ] = random_float( 60.0, 80.0 );

}



entity_set_vector(fPlayer, EV_VEC_v_angle, fAngles[fPlayer]);

entity_set_vector(fPlayer, EV_VEC_angles, fAngles[fPlayer]);

entity_set_int(fPlayer, EV_INT_fixangle, 1);



remove_task(fPlayer);

}



public cBaseEntity_ItemPostFrame_Pre(this)

{

new fOwner = pev(this, pev_owner);



if(!GetPlayerBit(g_fHasGuitar, fOwner) || !is_user_connected(fOwner) || !pev_valid(this))

return HAM_IGNORED;



static fExtraClip; fExtraClip = 40;



new Float:fNextAttack = get_pdata_float(fOwner, 83, 5);



new fAmmo = cs_get_user_bpammo(fOwner, CSW_GALIL), fClip = get_pdata_int(this, 51, 4), fInReload = get_pdata_int(this, 54, 4);



if(fInReload && fNextAttack <= 0.0)

{

new fClp = min(fExtraClip - fClip, fAmmo);

set_pdata_int(this, 51, fClip + fClp, 4);

cs_set_user_bpammo(fOwner, CSW_GALIL, fAmmo - fClp);

set_pdata_int(this, 54, 0, 4);

fInReload = 0;



return HAM_SUPERCEDE;

}



return HAM_IGNORED;

}



public cBaseEntity_PrimaryAttack(this)

{

new fOwner = get_pdata_cbase(this, 41, 4);



if(!GetPlayerBit(g_fHasGuitar, fOwner))

return;



g_fClipAmmo[fOwner] = cs_get_weapon_ammo(this);

g_fPrimaryAttack = 1;

}



public cBaseEntity_PrimaryAttack_Post(this)

{

new fOwner = get_pdata_cbase(this, 41, 4);



if(GetPlayerBit(g_fHasGuitar, fOwner) && g_fClipAmmo[fOwner])

{

g_fPrimaryAttack = 0;

set_pdata_float(this, 46, SHOOTSPEED, 4);

emit_sound(fOwner, CHAN_WEAPON, SHOT_SOUND[0], VOL_NORM, ATTN_NORM, 0, PITCH_NORM)

UTIL_PlayWeaponAnimation(fOwner, random_num(3, 5));

}

}



public cBaseEntity_ItemDeploy_Post(this)

{

new pevOwner = get_pdata_cbase(this, 41, 4);



if (!GetPlayerBit(g_fHasGuitar, pevOwner))

return;



entity_set_string(pevOwner, EV_SZ_viewmodel, g_fModels[VIEW]);

entity_set_string(pevOwner, EV_SZ_weaponmodel, g_fModels[PLAYER]);

}



cs_drop_user_weapon( const id, const szWeaponName[]="", const bStrip=0 )

{

new wEnt = -1 , WeaponId = get_weaponid( szWeaponName );  



const NadeBits = ( ( 1 << CSW_HEGRENADE ) | ( 1 << CSW_FLASHBANG ) | ( 1 << CSW_SMOKEGRENADE ) );



if( ( 0 < WeaponId < 30 ) && is_user_alive( id ) && user_has_weapon( id, WeaponId ) )

{

if( bStrip > 0 )

{

while( ( wEnt = engfunc( EngFunc_FindEntityByString , wEnt , "classname" , szWeaponName ) ) && pev( wEnt , pev_owner ) != id ) {}

 

if( !wEnt )

return -1;



ExecuteHamB( Ham_Weapon_RetireWeapon , wEnt);



if( !ExecuteHamB( Ham_RemovePlayerItem , id , wEnt ) )

return -1;



ExecuteHamB( Ham_Item_Kill , wEnt );



if( WeaponId == CSW_C4 )

{

               cs_set_user_plant( id , 0 , 0 );

               cs_set_user_bpammo( id , CSW_C4 , 0 );

}

}

else if ( NadeBits & ( 1 << WeaponId ) )

           cs_set_user_bpammo(id,WeaponId,0);

else

           engclient_cmd( id, "drop", szWeaponName );



user_has_weapon( id, WeaponId, 0 );

}



return wEnt;

}



stock fm_set_rendering(entity, fx = kRenderFxNone, r = 255, g = 255, b = 255, render = kRenderNormal, amount = 16)

{

static Float:color[3]

color[0] = float(r)

color[1] = float(g)

color[2] = float(b)



set_pev(entity, pev_renderfx, fx)

set_pev(entity, pev_rendercolor, color)

set_pev(entity, pev_rendermode, render)

set_pev(entity, pev_renderamt, float(amount))

}



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_ScreenFade(this, fRed, fGreen, fBlue, fAlpha)

{

message_begin ( MSG_ONE_UNRELIABLE, g_fMsgScreenFade, {0,0,0}, this )

{

write_short ( 1<<13 ) // Duration

write_short ( 1<<14 ) // Hold Time

write_short ( FFADE_IN ) // Fade type

write_byte( clamp( fRed, 0, 255 ) )

write_byte( clamp( fGreen, 0, 255 ) )

write_byte( clamp( fBlue, 0, 255 ) )

write_byte( clamp( fAlpha, 0, 255 ) )

}

message_end ( )

}