news
 current
 submit

tutorials
 database
  -mp
  -client
 submit
 search

forum
 main

contact
 email

HalfLife's Code is BLUE
Axe-=HL CODER=-'s Code is RED
Axe-=HL CODER=-'s Commentary is GREEN

First Ceate An New File Called "firegrenade.cpp"
And put this in this files


#include "extdll.h" // Including The Header File "Extdll.h"
#include "util.h" // Including The Header File "Util.h"
#include "cbase.h" // Including The Header File "Cbase.h"
#include "monsters.h" // Including The Header File "Monsters.h"
#include "weapons.h" // Including The Header File "Weapons.h"
#include "nodes.h" // Including The Header File "Nodes.h"
#include "player.h" // Including The Header File "Player.h"
#include "gamerules.h" // Including The Header File "Gamerules.h"
#include "soundent.h" // Including The Header File "Soundent.h"
#include "shake.h" // Including The Header File "Shake.h"
#include "basemonster.h" // Including The Header File "Basemonster.h"

#define FIRETIME 15 // Fire Time
#define FIRE_SLOTNUMBER 7 // Slot Number
#define FIRE_POSITION 0 // Slot Position
#define WEAPON_NUMBER 31 // *Change Some Things */// Weapon Number Look at weapons.h!!!
#define WEAPON_WEIGHT 20 // Hmmmmmm?
#define WEAPON_DEFAULT_AMMO 2 // The Ammo When You Pick It Up
#define WEAPON_MAX_AMMO 10 // The Max Ammo
#define WEAPON_MAX_AMMO2 "-1" // Max Ammo 2 No Ammo In Here!
#define AMMO_NAME "Smoke Grenade" // Ammo Name For In Maps
#define THE_WORLD_MODEL "models/w_grenade.mdl" // What we see
#define THE_PLAYER_MODEL "models/v_grenade.mdl" // What they see
#define THE_PRECACHE_MODEL "models/p_grenade.mdl" // The World Model On Ground
#define THE_FAKE_MODEL "models/invis.mdl" // The Invisible Model
#define THE_FLY_SOUND "weapons/xbow_fly.wav" // The Fly Sound
#define THE_EMPTY_SOUND "weapons/electro5.wav" // Empty?
#define THE_SHOOTER_SOUND "weapons/electro4.wav" // Shooting!
#define THE_EXPLODE_SPRITE "sprites/fexplo.spr" // The Explode Sprite

enum handgrenade_e {

HANDGRENADE_IDLE = 0,
HANDGRENADE_FIDGET,
HANDGRENADE_PINPULL,
HANDGRENADE_THROW1,
HANDGRENADE_THROW2,
HANDGRENADE_THROW3,
HANDGRENADE_HOLSTER,
HANDGRENADE_DRAW
};



class CFireGrenade : public CBasePlayerWeapon
{
public:
void Spawn( void );
void Precache( void );
int iItemSlot( void ) { return 5; }
int GetItemInfo(ItemInfo *p);
void PrimaryAttack( void );
BOOL Deploy( void );
BOOL CanHolster( void );
void Holster( void );
void TakeDamageBurn( void );
void WeaponIdle( void );
void FireThink( void );
float m_flStartThrow;
float m_flReleaseThrow;
int m_iExplode;
};
LINK_ENTITY_TO_CLASS( weapon_firebomber, CFireGrenade );



void CFireGrenade::Spawn( )
{
Precache( );
m_iId = WEAPON_NUMBER;
SET_MODEL(ENT(pev), "models/w_grenade.mdl");

pev->dmg = gSkillData.plrDmgHandGrenade;
m_iDefaultAmmo = WEAPON_DEFAULT_AMMO;
FallInit();

UTIL_SetOrigin( pev, pev->origin );
}





void CFireGrenade::Precache( void )
{
PRECACHE_MODEL ( THE_WORLD_MODEL );
PRECACHE_MODEL ( THE_PLAYER_MODEL );
PRECACHE_MODEL ( THE_PRECACHE_MODEL );
PRECACHE_MODEL ( THE_FAKE_MODEL );
PRECACHE_SOUND ( THE_FLY_SOUND );
PRECACHE_SOUND ( THE_EMPTY_SOUND );
PRECACHE_SOUND ( THE_SHOOTER_SOUND );
m_iExplode = PRECACHE_MODEL( THE_EXPLODE_SPRITE );
}



int CFireGrenade::GetItemInfo(ItemInfo *p)
{
p->pszName = STRING(pev->classname);
p->pszAmmo1 = "AMMO_NAME";
p->iMaxAmmo1 = WEAPON_MAX_AMMO;
p->pszAmmo2 = WEAPON_MAX_AMMO2;
p->iMaxAmmo2 = -1;
p->iMaxClip = WEAPON_NOCLIP;
p->iSlot = FIRE_SLOTNUMBER;
p->iPosition = FIRE_POSITION;
p->iId = m_iId = WEAPON_NUMBER;
p->iWeight = WEAPON_WEIGHT;
p->iFlags = ITEM_FLAG_LIMITINWORLD | ITEM_FLAG_EXHAUSTIBLE;

return 1;
}





BOOL CFireGrenade::Deploy( )
{
m_flReleaseThrow = -1;
return DefaultDeploy( "models/v_grenade.mdl", "models/p_grenade.mdl", HANDGRENADE_DRAW, "crowbar" );
}



BOOL CFireGrenade::CanHolster( void )
{
return ( m_flStartThrow == 0 );
}



void CFireGrenade::Holster( )
{
m_pPlayer->m_flNextAttack = gpGlobals->time + 0.5;
if (m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType])
{
SendWeaponAnim( HANDGRENADE_HOLSTER );
}
else
{
m_pPlayer->pev->weapons &= ~(1<
SetThink( DestroyItem );
pev->nextthink = gpGlobals->time + 0.1;
}

EMIT_SOUND(ENT(m_pPlayer->pev), CHAN_WEAPON, "common/null.wav", 1.0, ATTN_NORM);
}







void CFireGrenade::PrimaryAttack()
{
if (!m_flStartThrow && m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType] > 0)
{
m_flStartThrow = gpGlobals->time;
m_flReleaseThrow = 0;

SendWeaponAnim( HANDGRENADE_PINPULL );
m_flTimeWeaponIdle = gpGlobals->time + 0.5;
}
}



void CFireGrenade::FireThink( void )
{
pev->velocity = pev->velocity * 0.4;
pev->sequence = RANDOM_LONG( 1, 1 );

if (pev->dmgtime < gpGlobals->time){
EMIT_SOUND(ENT(pev), CHAN_WEAPON, "common/null.wav", 1 , ATTN_NORM);
pev->velocity = Vector( 0, 0, 0 );
UTIL_Remove( this );
return;
}
else
{
EMIT_SOUND(ENT(pev), CHAN_WEAPON, "weapons/xbow_fly1.wav", .3 , ATTN_NORM);
}

Vector vecSpot = pev->origin + (pev->mins + pev->maxs) * 0.5;

MESSAGE_BEGIN( MSG_PVS, SVC_TEMPENTITY, vecSpot );
WRITE_BYTE( TE_SPRITE );
WRITE_COORD( vecSpot.x );
WRITE_COORD( vecSpot.y );
WRITE_COORD( vecSpot.z + 0 );
WRITE_SHORT( g_sModelIndexFireball );
WRITE_BYTE( 15 );
WRITE_BYTE( 255 );
MESSAGE_END();

CGrenade::ShootTimedFireBomber( pev, pev->origin, Vector(RANDOM_LONG( -2, 2), RANDOM_LONG( -2, 2), RANDOM_LONG( -2, 2))*RANDOM_LONG( 0.1, 0.1), RANDOM_FLOAT( 0.1, 0.1));

TakeDamageBurn();

m_flTimeWeaponIdle = gpGlobals->time + RANDOM_FLOAT ( 10, 15 );
m_flReleaseThrow = -1;
pev->nextthink = gpGlobals->time + 0.3;
}

void CFireGrenade::TakeDamageBurn( void )
{
// Add Code For Extra Damage Here
}
void CFireGrenade::WeaponIdle( void )
{

if (m_flReleaseThrow == 0)
m_flReleaseThrow = gpGlobals->time;

if (m_flTimeWeaponIdle > gpGlobals->time)
return;

if (m_flStartThrow)
{
Vector angThrow = m_pPlayer->pev->v_angle + m_pPlayer->pev->punchangle;

if (angThrow.x < 0)
angThrow.x = -10 + angThrow.x * ((90 - 10) / 90.0);
else
angThrow.x = -10 + angThrow.x * ((90 + 10) / 90.0);

float flVel = (90 - angThrow.x) * 4;
if (flVel > 500)
flVel = 500;

UTIL_MakeVectors( angThrow );

Vector vecSrc = m_pPlayer->pev->origin + m_pPlayer->pev->view_ofs + gpGlobals->v_forward * 16;

Vector vecThrow = gpGlobals->v_forward * flVel + m_pPlayer->pev->velocity;

float time = m_flStartThrow - gpGlobals->time + 10.0;
if (time < 0)
time = 0;

CGrenade *pGrenade = GetClassPtr( (CGrenade *)NULL );

pGrenade->Spawn();

UTIL_SetOrigin( pGrenade->pev, vecSrc );

pGrenade->pev->velocity = vecThrow;

pGrenade->pev->angles = UTIL_VecToAngles(pGrenade->pev->velocity);

pGrenade->pev->owner = ENT(m_pPlayer->pev);

pGrenade->pev->dmgtime = gpGlobals->time + FIRETIME;

pGrenade->SetThink( FireThink );

pGrenade->pev->nextthink = gpGlobals->time + 2.1;

SET_MODEL(ENT(pGrenade->pev), "models/w_grenade.mdl");

if (flVel < 500)
{
SendWeaponAnim( HANDGRENADE_THROW1 );
}
else if (flVel < 1000)
{
SendWeaponAnim( HANDGRENADE_THROW2 );
}
else
{
SendWeaponAnim( HANDGRENADE_THROW3 );
}

m_pPlayer->SetAnimation( PLAYER_ATTACK1 );

m_flStartThrow = 0;
m_flNextPrimaryAttack = gpGlobals->time + 0.5;
m_flTimeWeaponIdle = gpGlobals->time + 0.5;

m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType]--;

if ( !m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType] )
{
m_flTimeWeaponIdle = m_flNextSecondaryAttack = m_flNextPrimaryAttack = gpGlobals->time + 0.5;
}
return;
}
else if (m_flReleaseThrow > 0)
{
m_flStartThrow = 0;

if (m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType])
{
SendWeaponAnim( HANDGRENADE_DRAW );
}
else
{
RetireWeapon();
return;
}

m_flTimeWeaponIdle = gpGlobals->time + RANDOM_FLOAT ( 10, 15 );
m_flReleaseThrow = -1;
return;
}

if (m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType])
{
int iAnim;
float flRand = RANDOM_FLOAT(0, 1);
if (flRand <= 0.75)
{
iAnim = HANDGRENADE_IDLE;
m_flTimeWeaponIdle = gpGlobals->time + RANDOM_FLOAT ( 10, 15 );
}
else
{
iAnim = HANDGRENADE_FIDGET;
m_flTimeWeaponIdle = gpGlobals->time + 75.0 / 30.0;
}

SendWeaponAnim( iAnim );
}
}

Then Open "Weapons.h" And Create After static CGrenade *ShootTimed( entvars_t *pevOwner, Vector vecStart, Vector vecVelocity, float time );

This

static CGrenade *ShootTimedFireBomber( entvars_t *pevOwner, Vector vecStart, Vector vecVelocity, float time );
And This void EXPORT FireBomberBounce( CBaseEntity *pOther );

And This void EXPORT FireBomberExplode( void );

And This void EXPORT FireBomberFly( void );


And This void EXPORT FireBomberFire( void );
The open up ggrenade.cpp And Add This Anywhere



void CGrenade::FireBomberExplode( void )
{
TraceResult tr;
Vector vecSpot;// trace starts here!

vecSpot = pev->origin + Vector ( 0 , 0 , 8 );
UTIL_TraceLine ( vecSpot, vecSpot + Vector ( 0, 0, -40 ), ignore_monsters, ENT(pev), & tr);
}

void CGrenade::FireBomberBounce( CBaseEntity *pOther )
{
if ( pOther->edict() == pev->owner )
return;

if (m_flNextAttack < gpGlobals->time && pev->velocity.Length() > 100)
{
entvars_t *pevOwner = VARS( pev->owner );
if (pevOwner)
{
TraceResult tr = UTIL_GetGlobalTrace( );
ClearMultiDamage( );
pOther->TraceAttack(pevOwner, 1, gpGlobals->v_forward, &tr, DMG_CLUB );
ApplyMultiDamage( pev, pevOwner);
}
m_flNextAttack = gpGlobals->time + 1.0;
}

Vector vecTestVelocity;

vecTestVelocity = pev->velocity;
vecTestVelocity.z *= 0.45;

if ( !m_fRegisteredSound && vecTestVelocity.Length() <= 60 )
{
CSoundEnt::InsertSound ( bits_SOUND_DANGER, pev->origin, pev->dmg / 0.4, 0.3 );
m_fRegisteredSound = TRUE;
}

if (pev->flags & FL_ONGROUND)
{
pev->velocity = pev->velocity * 0.8;

pev->sequence = RANDOM_LONG( 1, 1 );
}
else
{
FireBomberBounceSound();
}
pev->framerate = pev->velocity.Length() / 200.0;
if (pev->framerate > 1.0)
pev->framerate = 1;
else if (pev->framerate < 0.5)
pev->framerate = 0;

}


void CGrenade :: FireBomberBounceSound( void )
{
switch ( RANDOM_LONG( 0, 2 ) )
{
case 0: EMIT_SOUND(ENT(pev), CHAN_VOICE, "weapons/glauncher.wav", 0.25, ATTN_NORM); break;
case 1: EMIT_SOUND(ENT(pev), CHAN_VOICE, "weapons/glauncher.wav", 0.25, ATTN_NORM); break;
case 2: EMIT_SOUND(ENT(pev), CHAN_VOICE, "weapons/glauncher.wav", 0.25, ATTN_NORM); break;
}
}

void CGrenade :: FireBomberFly( void )
{
if (!IsInWorld())
{
UTIL_Remove( this );
return;
}

StudioFrameAdvance( );
pev->nextthink = gpGlobals->time + 0.1;

if (pev->dmgtime - 1 < gpGlobals->time)
{
CSoundEnt::InsertSound ( bits_SOUND_DANGER, pev->origin + pev->velocity * (pev->dmgtime - gpGlobals->time), 400, 0.1 );
}

if (pev->dmgtime <= gpGlobals->time)
{
SetThink( FireBomberExplode );
}
if (pev->waterlevel != 0)
{
pev->velocity = pev->velocity * 0.5;
pev->framerate = 0.2;
}
Vector vecSpot = pev->origin + (pev->mins + pev->maxs) * 0.5;

MESSAGE_BEGIN( MSG_PVS, SVC_TEMPENTITY, vecSpot );
WRITE_BYTE( TE_SPRITE );
WRITE_COORD( vecSpot.x );
WRITE_COORD( vecSpot.y );
WRITE_COORD( vecSpot.z + 75 );
WRITE_SHORT( g_sModelIndexFireball );
WRITE_BYTE( 15 );
WRITE_BYTE( 255 );
MESSAGE_END();

FireBomberFire();
}


void CGrenade :: FireBomberFire( void )
{
Vector vecSpot = pev->origin + (pev->mins + pev->maxs) * 0.5;

MESSAGE_BEGIN( MSG_PVS, SVC_TEMPENTITY, vecSpot );
WRITE_BYTE( TE_SPRITE );
WRITE_COORD( vecSpot.x );
WRITE_COORD( vecSpot.y ); WRITE_COORD( vecSpot.z + 75 );
WRITE_SHORT( g_sModelIndexFireball );
WRITE_BYTE( 15 );
WRITE_BYTE( 255 ); MESSAGE_END();
}


CGrenade * CGrenade:: ShootTimedFireBomber( entvars_t *pevOwner, Vector vecStart, Vector vecVelocity, float time )
{
CGrenade *pGrenade = GetClassPtr( (CGrenade *)NULL );


pGrenade->Spawn();


UTIL_SetOrigin( pGrenade->pev, vecStart );


pGrenade->pev->velocity = vecVelocity;

pGrenade->pev->angles = UTIL_VecToAngles(pGrenade->pev->velocity);

pGrenade->pev->owner = ENT(pevOwner);

pGrenade->SetTouch( FireBomberBounce );

pGrenade->pev->dmgtime = gpGlobals->time + time;

pGrenade->SetThink( FireBomberFly );

pGrenade->pev->nextthink = gpGlobals->time + 0.1;


if (time < 0.1)
{
pGrenade->pev->nextthink = gpGlobals->time;

pGrenade->pev->velocity = Vector( 0, 0, 0 );
}

pGrenade->pev->sequence = RANDOM_LONG( 3, 6 );

pGrenade->pev->framerate = 1.0;

pGrenade->pev->gravity = 0.5;

pGrenade->pev->friction = 0.8;

SET_MODEL(ENT(pGrenade->pev), "models/invis.mdl");


pGrenade->pev->dmg = 100;

return pGrenade;
}
I''ve you Want The Model File You need to email me [HTML]Email Me[/HTML]