//=========================================================
// BarneyFirePistol - shoots one round from the pistol at
// the enemy barney is facing.
//=========================================================
void CBarney :: BarneyFirePistol ( void )
{
Vector vecShootOrigin;
UTIL_MakeVectors(pev->angles);
vecShootOrigin = pev->origin + Vector( 0, 0, 55 );
Vector vecShootDir = ShootAtEnemy( vecShootOrigin );
Vector angDir = UTIL_VecToAngles( vecShootDir );
SetBlending( 0, angDir.x );
pev->effects = EF_MUZZLEFLASH;
FireBullets(1, vecShootOrigin, vecShootDir, VECTOR_CONE_2DEGREES, 1024, BULLET_MONSTER_9MM );
int pitchShift = RANDOM_LONG( 0, 20 );
// Only shift about half the time
if ( pitchShift > 10 )
pitchShift = 0;
else
pitchShift -= 5;
EMIT_SOUND_DYN( ENT(pev), CHAN_WEAPON, "barney/ba_attack2.wav", 1, ATTN_NORM, 0, 100 + pitchShift );
CSoundEnt::InsertSound ( bits_SOUND_COMBAT, pev->origin, 384, 0.3 );
// UNDONE: Reload?
m_cAmmoLoaded--;// take away a bullet!
}
// Sticky gib puts blood on the wall and stays put.
void CGib::StickyGibTouch(CBaseEntity *pOther)
{
Vector vecSpot;
TraceResult tr;
SetThink(&CBaseEntity::SUB_Remove);
pev->nextthink = gpGlobals->time + 10;
if (!FClassnameIs(pOther->pev, "worldspawn"))
{
pev->nextthink = gpGlobals->time;
return;
}
vecSpot = pev->origin + pev->velocity * 32;
UTIL_TraceLine(pev->origin, vecSpot, ignore_monsters, ENT(pev), &tr);
UTIL_BloodDecalTrace(&tr, m_bloodColor);
pev->velocity = tr.vecPlaneNormal * -1;
pev->angles = UTIL_VecToAngles(pev->velocity);
pev->velocity = g_vecZero;
pev->avelocity = g_vecZero;
pev->movetype = MOVETYPE_NONE;
}
//=========================================================
CQuakeRocket *CQuakeRocket::CreateRocket( Vector vecOrigin, Vector vecAngles, CBaseEntity *pOwner )
{
CQuakeRocket *pRocket = GetClassPtr( (CQuakeRocket *)NULL );
UTIL_SetOrigin( pRocket->pev, vecOrigin );
SET_MODEL(ENT(pRocket->pev), "models/rocket.mdl");
pRocket->Spawn();
pRocket->pev->classname = MAKE_STRING("missile");
pRocket->pev->owner = pOwner->edict();
// Setup
pRocket->pev->movetype = MOVETYPE_FLYMISSILE;
pRocket->pev->solid = SOLID_BBOX;
// Velocity
pRocket->pev->velocity = vecAngles * 1000;
pRocket->pev->angles = UTIL_VecToAngles( vecAngles );
// Touch
pRocket->SetTouch( CQuakeRocket::RocketTouch );
// Safety Remove
pRocket->pev->nextthink = gpGlobals->time + 5;
pRocket->SetThink( SUB_Remove );
// Effects
// pRocket->pev->effects |= EF_LIGHT;
PLAYBACK_EVENT_FULL (FEV_GLOBAL, pRocket->edict(), g_sTrail, 0.0,
(float *)&pRocket->pev->origin, (float *)&pRocket->pev->angles, 0.7, 0.0, pRocket->entindex(), ROCKET_TRAIL, 0, 0);
return pRocket;
}
CGrenade *CGrenade::ShootContact( entvars_t *pevOwner, Vector vecStart, Vector vecVelocity )
{
CGrenade *pGrenade = GetClassPtr( (CGrenade *)NULL );
pGrenade->Spawn();
// contact grenades arc lower
pGrenade->pev->gravity = 0.5;// lower gravity since grenade is aerodynamic and engine doesn't know it.
UTIL_SetOrigin( pGrenade->pev, vecStart );
pGrenade->pev->velocity = vecVelocity;
pGrenade->pev->angles = UTIL_VecToAngles (pGrenade->pev->velocity);
pGrenade->pev->owner = ENT(pevOwner);
// make monsters afaid of it while in the air
pGrenade->SetThink( &CGrenade::DangerSoundThink );
pGrenade->pev->nextthink = gpGlobals->time;
// Tumble in air
pGrenade->pev->avelocity.x = RANDOM_FLOAT ( -100, -500 );
// Explode on contact
pGrenade->SetTouch( &CGrenade::ExplodeTouch );
pGrenade->pev->dmg = gSkillData.plrDmgM203Grenade;
return pGrenade;
}
bool AvHMine::GetDropLocation(Vector& outLocation, Vector* outAngles) const
{
bool theSuccess = false;
UTIL_MakeVectors( m_pPlayer->pev->v_angle + m_pPlayer->pev->punchangle );
Vector vecSrc = m_pPlayer->GetGunPosition( );
Vector vecAiming = gpGlobals->v_forward;
TraceResult tr;
UTIL_TraceLine( vecSrc, vecSrc + vecAiming*this->mRange, dont_ignore_monsters, ENT( m_pPlayer->pev ), &tr );
if (tr.flFraction < 1.0)
{
CBaseEntity* theEntity = CBaseEntity::Instance( tr.pHit );
// puzl: 981
// Mines can't be planted on players or buildings
if (!dynamic_cast<AvHDeployedMine*>(theEntity) && !dynamic_cast<AvHPlayer *>(theEntity) && !dynamic_cast<AvHBaseBuildable *>(theEntity))
{
int kOffset = 8;
Vector thePotentialOrigin = tr.vecEndPos + tr.vecPlaneNormal * kOffset;
BaseEntityListType theEntityList;
theEntityList.push_back(theEntity);
// Make sure there isn't an entity nearby that this would block
theEntity = NULL;
const int kMineSearchRadius = 15;
while((theEntity = UTIL_FindEntityInSphere(theEntity, thePotentialOrigin, kMineSearchRadius)) != NULL)
{
theEntityList.push_back(theEntity);
}
// For the mine placement to be valid, the entity it hit, and all the entities nearby must be valid and non-blocking
theSuccess = true;
for(BaseEntityListType::iterator theIter = theEntityList.begin(); theIter != theEntityList.end(); theIter++)
{
// puzl: 225 make sure there are no mines within kMineSearchRadius of each other ( 15 units )
CBaseEntity* theCurrentEntity = *theIter;
if(!theCurrentEntity || (theCurrentEntity->pev->flags & FL_CONVEYOR) || AvHSUGetIsExternalClassName(STRING(theCurrentEntity->pev->classname)) || dynamic_cast<CBaseDoor*>(theCurrentEntity) || dynamic_cast<CRotDoor*>(theCurrentEntity)
|| dynamic_cast<AvHDeployedMine*>(theCurrentEntity) )
{
theSuccess = false;
break;
}
}
if(theSuccess)
{
VectorCopy(thePotentialOrigin, outLocation);
if(outAngles)
{
VectorCopy(UTIL_VecToAngles( tr.vecPlaneNormal ), *outAngles)
}
}
}
void CCSBot::UpdateLookAt()
{
Vector to = m_lookAtSpot - EyePosition();
Vector idealAngle = UTIL_VecToAngles(to);
idealAngle.x = 360.0f - idealAngle.x;
SetLookAngles(idealAngle.y, idealAngle.x);
}
//=========================================================
// BarneyFirePistol - shoots one round from the pistol at
// the enemy barney is facing.
//=========================================================
void CFriend :: BarneyFirePistol ( void )
{
Vector vecShootOrigin;
UTIL_MakeVectors(pev->angles);
vecShootOrigin = pev->origin + Vector( 0, 0, 55 );
Vector vecShootDir = ShootAtEnemy( vecShootOrigin );
Vector angDir = UTIL_VecToAngles( vecShootDir );
SetBlending( 0, angDir.x );
pev->effects = EF_MUZZLEFLASH;
if (pev->frags)
{
FireBullets(8, vecShootOrigin, vecShootDir, VECTOR_CONE_10DEGREES, 1024, BULLET_PLAYER_BUCKSHOT);//357
EMIT_SOUND( ENT(pev), CHAN_WEAPON, "weapons/shotgun/sbarrel1.wav", 1, ATTN_NORM );
}
else
{
FireBullets(1, vecShootOrigin, vecShootDir, VECTOR_CONE_2DEGREES, 1024, BULLET_MONSTER_9MM );
int pitchShift = RANDOM_LONG( 0, 20 );
// Only shift about half the time
if ( pitchShift > 10 )
pitchShift = 0;
else
pitchShift -= 5;
EMIT_SOUND( ENT(pev), CHAN_WEAPON, "weapons/m16/m16_fire-1.wav", 1, ATTN_NORM );
}
CSoundEnt::InsertSound ( bits_SOUND_COMBAT, pev->origin, 384, 0.3 );
// UNDONE: Reload?
m_cAmmoLoaded--;// take away a bullet!
// Teh_Freak: World Lighting!
MESSAGE_BEGIN( MSG_BROADCAST, SVC_TEMPENTITY );
WRITE_BYTE( TE_DLIGHT );
WRITE_COORD( vecShootOrigin.x ); // origin
WRITE_COORD( vecShootOrigin.y );
WRITE_COORD( vecShootOrigin.z );
WRITE_BYTE( 16 ); // radius
WRITE_BYTE( 255 ); // R
WRITE_BYTE( 255 ); // G
WRITE_BYTE( 128 ); // B
WRITE_BYTE( 0 ); // life * 10
WRITE_BYTE( 0 ); // decay
MESSAGE_END();
// Teh_Freak: World Lighting!
CBaseEntity *pPlayer = UTIL_PlayerByIndex( 1 );
if (pPlayer->m_fSlowMotionOn)
CBullet::Shoot( pev, vecShootOrigin, vecShootDir * 500 );
}
void CTripmine::PrimaryAttack( void )
{
if (m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType] <= 0)
return;
UTIL_MakeVectors( m_pPlayer->pev->v_angle + m_pPlayer->pev->punchangle );
Vector vecSrc = m_pPlayer->GetGunPosition( );
Vector vecAiming = gpGlobals->v_forward;
TraceResult tr;
UTIL_TraceLine( vecSrc, vecSrc + vecAiming * 128, dont_ignore_monsters, ENT( m_pPlayer->pev ), &tr );
int flags;
#ifdef CLIENT_WEAPONS
flags = FEV_NOTHOST;
#else
flags = 0;
#endif
PLAYBACK_EVENT_FULL( flags, m_pPlayer->edict(), m_usTripFire, 0.0, (float *)&g_vecZero, (float *)&g_vecZero, 0.0, 0.0, 0, 0, 0, 0 );
if (tr.flFraction < 1.0)
{
CBaseEntity *pEntity = CBaseEntity::Instance( tr.pHit );
if ( pEntity && !(pEntity->pev->flags & FL_CONVEYOR) )
{
Vector angles = UTIL_VecToAngles( tr.vecPlaneNormal );
CBaseEntity *pEnt = CBaseEntity::Create( "monster_tripmine", tr.vecEndPos + tr.vecPlaneNormal * 8, angles, m_pPlayer->edict() );
m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType]--;
// player "shoot" animation
m_pPlayer->SetAnimation( PLAYER_ATTACK1 );
if ( m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType] <= 0 )
{
// no more mines!
RetireWeapon();
return;
}
}
else
{
// ALERT( at_console, "no deploy\n" );
}
}
else
{
}
m_flNextPrimaryAttack = UTIL_WeaponTimeBase() + 0.3;
m_flTimeWeaponIdle = UTIL_WeaponTimeBase() + UTIL_SharedRandomFloat( m_pPlayer->random_seed, 10, 15 );
}
void CHostage::MoveToward(Vector &vecLoc)
{
int nFwdMove;
Vector vecFwd;
Vector vecbigDest;
Vector vecMove;
CBaseEntity *pFollowing;
Vector vecAng;
float flDist;
pFollowing = GetClassPtr((CBaseEntity *)m_hTargetEnt->pev);
vecMove = vecLoc - pev->origin;
vecAng = UTIL_VecToAngles(vecMove);
vecAng = Vector(0, vecAng.y, 0);
UTIL_MakeVectorsPrivate(vecAng, vecFwd, NULL, NULL);
if ((vecFwd * m_LocalNav->s_flStepSize).Length2D() <= (vecLoc - pev->origin).Length2D())
flDist = (vecFwd * m_LocalNav->s_flStepSize).Length2D();
else
flDist = (vecLoc - pev->origin).Length2D();
vecbigDest = pev->origin + (vecFwd * flDist);
nFwdMove = m_LocalNav->PathTraversable(pev->origin, vecbigDest, FALSE);
if (nFwdMove != TRAVERSABLE_NO)
{
vecbigDest = pFollowing->pev->origin;
vecbigDest.z += pFollowing->pev->mins.z;
if (FBitSet(pev->flags, FL_ONGROUND))
{
flDist = (vecbigDest - pev->origin).Length();
if (flDist >= 110)
{
if (flDist >= 250)
flDist = 400;
else
flDist = 300;
}
}
else
flDist = 250;
pev->velocity.x = vecFwd.x * flDist;
pev->velocity.y = vecFwd.y * flDist;
UTIL_DrawBeamPoints(pev->origin, pev->origin + (pev->velocity.Normalize() * 500), 10, 255, 0, 0);
if (nFwdMove != TRAVERSABLE_STEP && nFwdMove == TRAVERSABLE_STEPJUMPABLE)
{
if (FBitSet(pev->flags, FL_ONGROUND))
pev->velocity.z = 270;
}
}
}
void CTripmine::PrimaryAttack( void )
{
if (m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType] <= 0)
return;
UTIL_MakeVectors( m_pPlayer->pev->v_angle + m_pPlayer->pev->punchangle );
Vector vecSrc = m_pPlayer->GetGunPosition( );
Vector vecAiming = gpGlobals->v_forward;
TraceResult tr;
UTIL_TraceLine( vecSrc, vecSrc + vecAiming * 128, dont_ignore_monsters, ENT( m_pPlayer->pev ), &tr );
if (tr.flFraction < 1.0)
{
// ALERT( at_console, "hit %f\n", tr.flFraction );
CBaseEntity *pEntity = CBaseEntity::Instance( tr.pHit );
if (pEntity && !(pEntity->pev->flags & FL_CONVEYOR))
{
Vector angles = UTIL_VecToAngles( tr.vecPlaneNormal );
CBaseEntity *pEnt = CBaseEntity::Create( "monster_tripmine", tr.vecEndPos + tr.vecPlaneNormal * 8, angles, m_pPlayer->edict() );
CTripmineGrenade *pMine = (CTripmineGrenade *)pEnt;
m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType]--;
// player "shoot" animation
m_pPlayer->SetAnimation( PLAYER_ATTACK1 );
if (m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType] > 0)
{
SendWeaponAnim( TRIPMINE_DRAW );
}
else
{
// no more mines!
RetireWeapon();
return;
}
}
else
{
// ALERT( at_console, "no deploy\n" );
}
}
else
{
}
m_flNextPrimaryAttack = gpGlobals->time + 0.3;
m_flTimeWeaponIdle = gpGlobals->time + RANDOM_FLOAT ( 10, 15 );
}
// =========================================================
// TORCH SUPPORT
// =========================================================
void CGenericMonster :: Torch ( void )
{
Vector vecGunPos;
Vector vecGunAngles;
Vector vecShootDir;
GetAttachment( 4, vecGunPos, vecGunAngles );
pev->effects |= EF_MUZZLEFLASH;
Vector angDir = UTIL_VecToAngles( vecShootDir );
SetBlending( 0, angDir.x );
}
CGrenade * CGrenade :: ShootFrag( entvars_t *pevOwner, Vector vecStart, Vector vecVelocity, int mode )
{
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->pev->solid = SOLID_BBOX;
if ( mode == 1 )
{
SET_MODEL(ENT(pGrenade->pev), "models/w_fgrenade.mdl");
pGrenade->SetTouch( FragTouch );
pGrenade->SetThink( FragThink );
pGrenade->pev->nextthink = gpGlobals->time + 0.1;
}
else
{
SET_MODEL(ENT(pGrenade->pev), "models/w_frag.mdl");
pGrenade->SetThink( Detonate );
pGrenade->pev->nextthink = gpGlobals->time + RANDOM_FLOAT( 2,3 );
pGrenade->pev->solid = SOLID_NOT;
}
MESSAGE_BEGIN( MSG_BROADCAST, SVC_TEMPENTITY );
WRITE_BYTE( TE_BEAMFOLLOW );
WRITE_SHORT(pGrenade->entindex()); // entity
WRITE_SHORT(iFgTrail ); // model
WRITE_BYTE( 10 ); // life
WRITE_BYTE( 1.5 ); // width
WRITE_BYTE( 240 ); // r, g, b
WRITE_BYTE( 215 ); // r, g, b
WRITE_BYTE( 80 ); // r, g, b
WRITE_BYTE( 200 ); // brightness
MESSAGE_END();
pGrenade->pev->sequence = 4;
pGrenade->pev->framerate = 6;
pGrenade->pev->gravity = 0.35;
pGrenade->pev->friction = 0.9;
pGrenade->pev->dmg = 100;
return pGrenade;
}
CTankProj *CTankProj::ShootTankProj(entvars_t *pevOwner, Vector vecStart, Vector vecVelocity)
{
CTankProj *pTankProj = GetClassPtr( (CTankProj *)NULL );
pTankProj->Spawn();
UTIL_SetOrigin(pTankProj->pev, vecStart);
pTankProj->pev->velocity = vecVelocity;
pTankProj->pev->angles = UTIL_VecToAngles (pTankProj->pev->velocity);
pTankProj->pev->owner = ENT(pevOwner);
pTankProj->SetTouch( ExplodeTouch );
pTankProj->pev->dmg = dmg_tank_cannon.value * (mp_wpn_power.value/100);
return pTankProj;
}
//=========================================================
// RunTask
//=========================================================
void CMGargantua::RunTask( Task_t *pTask )
{
switch ( pTask->iTask )
{
case TASK_FLAME_SWEEP:
if ( gpGlobals->time > m_flWaitFinished )
{
FlameDestroy();
TaskComplete();
FlameControls( 0, 0 );
SetBoneController( 0, 0 );
SetBoneController( 1, 0 );
}
else
{
BOOL cancel = FALSE;
Vector angles = g_vecZero;
FlameUpdate();
edict_t *pEnemy = m_hEnemy;
if ( pEnemy )
{
Vector org = pev->origin;
org.z += 64;
Vector dir = UTIL_BodyTarget(pEnemy,org) - org;
angles = UTIL_VecToAngles( dir );
angles.x = -angles.x;
angles.y -= pev->angles.y;
if ( dir.Length() > 400 )
cancel = TRUE;
}
if ( fabs(angles.y) > 60 )
cancel = TRUE;
if ( cancel )
{
m_flWaitFinished -= 0.5;
m_flameTime -= 0.5;
}
// FlameControls( angles.x + 2 * sin(gpGlobals->time*8), angles.y + 28 * sin(gpGlobals->time*8.5) );
FlameControls( angles.x, angles.y );
}
break;
default:
CMBaseMonster::RunTask( pTask );
break;
}
}
void CTank :: UpdateCamAngle ( Vector vecNewPosition, float flTime )
{
Vector vecNewAngle;
GetAttachment( 2, vecCamTarget, Vector ( 0, 0, 0 ) );
vecNewAngle = UTIL_VecToAngles( vecCamTarget - vecNewPosition );
vecNewAngle.x = -vecNewAngle.x;
float distX = UTIL_AngleDistance( m_pCam->pev->angles.x, vecNewAngle.x );
m_pCam->pev->avelocity.x = -distX / flTime;
float distY = UTIL_AngleDistance( m_pCam->pev->angles.y, vecNewAngle.y );
m_pCam->pev->avelocity.y = -distY / flTime;
}
Vector CCalcVelocityPolar::CalcVelocity( CBaseEntity *pLocus )
{
Vector vecBasis = CalcLocus_Velocity( this, pLocus, STRING(pev->netname) );
Vector vecAngles = UTIL_VecToAngles( vecBasis ) + pev->angles;
Vector vecOffset = CalcLocus_Velocity( this, pLocus, STRING(pev->message) );
float fFactor = CalcLocus_Ratio( pLocus, STRING(pev->noise) );
if (!(pev->spawnflags & SF_CALCVELOCITY_NORMALIZE))
fFactor = fFactor * vecBasis.Length();
UTIL_MakeVectors( vecAngles );
return (gpGlobals->v_forward * fFactor) + vecOffset;
}
Vector CTank :: TourelleAngle ( void )
{
UTIL_MakeVectors(pev->angles );
Vector angle = UTIL_VecToAngles( gpGlobals->v_forward );
angle.x += pev->v_angle.x;
angle.y += pev->v_angle.y;
angle.y = UTIL_AngleMod( angle.y );
angle.x = -angle.x;
return angle;
}
CMmissile *CMmissile::ShootMmissile( entvars_t *pevOwner, Vector vecStart, Vector vecVelocity )
{
CMmissile *pMmissile = GetClassPtr( (CMmissile *)NULL );
pMmissile->Spawn();
UTIL_SetOrigin( pMmissile->pev, vecStart );
pMmissile->pev->velocity = vecVelocity;
pMmissile->pev->angles = UTIL_VecToAngles (pMmissile->pev->velocity);
pMmissile->pev->owner = ENT(pevOwner);
pMmissile->SetTouch( ExplodeTouch );
pMmissile->pev->dmg = dmg_devastator.value * (mp_wpn_power.value/100);
FX_Trail(pMmissile->pev->origin, pMmissile->entindex(), PROJ_MMISSILE );
return pMmissile;
}
void CBreakable::TraceAttack( entvars_t *pevAttacker, float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType )
{
// random spark if this is a 'computer' object
if (RANDOM_LONG(0,1) )
{
switch( m_Material )
{
case matComputer:
{
UTIL_Sparks( ptr->vecEndPos );
float flVolume = RANDOM_FLOAT ( 0.7 , 1.0 );//random volume range
switch ( RANDOM_LONG(0,1) )
{
case 0: EMIT_SOUND(ENT(pev), CHAN_VOICE, "buttons/spark5.wav", flVolume, ATTN_NORM); break;
case 1: EMIT_SOUND(ENT(pev), CHAN_VOICE, "buttons/spark6.wav", flVolume, ATTN_NORM); break;
}
}
break;
case matUnbreakableGlass:
UTIL_Ricochet( ptr->vecEndPos, RANDOM_FLOAT(0.5,1.5) );
break;
}
}
//LRC
if (m_iszWhenHit)
{
if(m_pHitProxy==NULL){ //AJH may need to reset this as it's null after save/load
m_pHitProxy = GetClassPtr( (CPointEntity*)NULL );
}
m_pHitProxy->pev->origin = ptr->vecEndPos;
if (pev->spawnflags&SF_BREAKABLE_INVERT){ //AJH
vecDir.y=-vecDir.y;
//vecDir.z=-vecDir.z;
vecDir.x=-vecDir.x;
//ALERT(at_debug,"INVERTING Breakables 'hit' vector (x&y components only) \n");
}
m_pHitProxy->pev->velocity = vecDir;
m_pHitProxy->pev->angles = UTIL_VecToAngles(vecDir); //AJH
//ALERT(at_debug,"Func_breakable fires %s \n",STRING(m_iszWhenHit));
FireTargets( STRING(m_iszWhenHit), m_pHitProxy, this, USE_TOGGLE, 0 );
}
CBaseDelay::TraceAttack( pevAttacker, flDamage, vecDir, ptr, bitsDamageType );
}
void CHellKnight :: ShootSpike( float flOffset )
{
Vector ang = UTIL_VecToAngles( m_hEnemy->pev->origin - pev->origin );
ang.y += flOffset * 6;
UTIL_MakeVectors( ang );
Vector org = pev->origin + pev->mins + pev->size * 0.5f + gpGlobals->v_forward * 20;
// set missile speed
Vector vec = gpGlobals->v_forward.Normalize();
vec.z = -vec.z + RANDOM_FLOAT( -0.05f, 0.05f );
EMIT_SOUND( edict(), CHAN_WEAPON, "hknight/attack1.wav", 1.0, ATTN_NORM );
CNail::CreateKnightSpike( org, vec, this );
}
CSunOfGod *CSunOfGod::ShootSunOfGod( entvars_t *pevOwner, Vector vecStart)
{
CSunOfGod *pSunOfGod = GetClassPtr( (CSunOfGod *)NULL );
pSunOfGod->Spawn();
UTIL_SetOrigin( pSunOfGod->pev, vecStart );
pSunOfGod->pev->velocity = gpGlobals->v_forward * 0;
pSunOfGod->pev->angles = UTIL_VecToAngles (pSunOfGod->pev->velocity);
pSunOfGod->pev->owner = ENT(pevOwner);
pSunOfGod->SetThink ( Animate );
pSunOfGod->pev->nextthink = gpGlobals->time + 0.1;
pSunOfGod->SetTouch( ExplodeTouch );
pSunOfGod->pev->dmg = dmg_sunofgod.value * (mp_wpn_power.value/100);
FX_Trail(pSunOfGod->pev->origin, pSunOfGod->entindex(), PROJ_SUNOFGOD);
return pSunOfGod;
}
CFlame *CFlame::ShootFlame( entvars_t *pevOwner, Vector vecStart, Vector vecVelocity )
{
CFlame *pFlame = GetClassPtr( (CFlame *)NULL );
pFlame->Spawn();
UTIL_SetOrigin( pFlame->pev, vecStart );
pFlame->pev->velocity = vecVelocity + gpGlobals->v_right * RANDOM_FLOAT(-40,40) + gpGlobals->v_up * RANDOM_FLOAT(-40,40);
pFlame->pev->angles = UTIL_VecToAngles(pFlame->pev->velocity);
pFlame->pev->owner = ENT(pevOwner);
pFlame->SetTouch( ExplodeTouch );
pFlame->pev->dmg = dmg_flamethrower.value * (mp_wpn_power.value/100);
pFlame->SetThink ( Fly );
pFlame->pev->nextthink = 0.1;
FX_Trail(pFlame->pev->origin, pFlame->entindex(), PROJ_FLAME );
return pFlame;
}
CGrenade * CGrenade:: ShootTimed( 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( &CGrenade::BounceTouch ); // Bounce if touched
#ifdef DEBUG
if(ns_cvar_float(&avh_bulletcam))
{
SET_VIEW(ENT(pevOwner), ENT(pGrenade->pev));
}
#endif
// Take one second off of the desired detonation time and set the think to PreDetonate. PreDetonate
// will insert a DANGER sound into the world sound list and delay detonation for one second so that
// the grenade explodes after the exact amount of time specified in the call to ShootTimed().
pGrenade->pev->dmgtime = gpGlobals->time + time;
pGrenade->SetThink( &CGrenade::TumbleThink );
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 = 0;//RANDOM_LONG( 3, 6 );
pGrenade->pev->framerate = 1.0;
// Tumble through the air
pGrenade->pev->avelocity.x = RANDOM_LONG(-800, -300);
// Also explode on contact
//pGrenade->SetTouch( ExplodeTouch );
pGrenade->pev->gravity = 0.5;
pGrenade->pev->friction = 0.8;
SET_MODEL(ENT(pGrenade->pev), "models/w_grenade.mdl");
return pGrenade;
}
//=========================================================
// Shoot
//=========================================================
void CHAssassin :: Shoot ( void )
{
if (m_hEnemy == NULL)
{
return;
}
Vector vecShootOrigin = GetGunPosition();
Vector vecShootDir = ShootAtEnemy( vecShootOrigin );
if (m_flLastShot + 2 < gpGlobals->time)
{
m_flDiviation = 0.10;
}
else
{
m_flDiviation -= 0.01;
if (m_flDiviation < 0.02)
m_flDiviation = 0.02;
}
m_flLastShot = gpGlobals->time;
UTIL_MakeVectors ( pev->angles );
Vector vecShellVelocity = gpGlobals->v_right * RANDOM_FLOAT(40,90) + gpGlobals->v_up * RANDOM_FLOAT(75,200) + gpGlobals->v_forward * RANDOM_FLOAT(-40, 40);
EjectBrass ( pev->origin + gpGlobals->v_up * 32 + gpGlobals->v_forward * 12, vecShellVelocity, pev->angles.y, m_iShell, TE_BOUNCE_SHELL);
FireBullets(1, vecShootOrigin, vecShootDir, Vector( m_flDiviation, m_flDiviation, m_flDiviation ), 2048, BULLET_MONSTER_9MM ); // shoot +-8 degrees
switch(RANDOM_LONG(0,1))
{
case 0:
EMIT_SOUND(ENT(pev), CHAN_WEAPON, "weapons/pl_gun1.wav", RANDOM_FLOAT(0.6, 0.8), ATTN_NORM);
break;
case 1:
EMIT_SOUND(ENT(pev), CHAN_WEAPON, "weapons/pl_gun2.wav", RANDOM_FLOAT(0.6, 0.8), ATTN_NORM);
break;
}
pev->effects |= EF_MUZZLEFLASH;
Vector angDir = UTIL_VecToAngles( vecShootDir );
SetBlending( 0, angDir.x );
m_cAmmoLoaded--;
}
bool UpdateSounds(edict_t *pEdict, edict_t *pPlayer)
{
float distance;
static bool check_footstep_sounds = TRUE;
static float footstep_sounds_on;
float sensitivity = 1.0;
float volume;
// update sounds made by this player, alert bots if they are nearby...
if (check_footstep_sounds)
{
check_footstep_sounds = FALSE;
footstep_sounds_on = CVAR_GET_FLOAT("mp_footsteps");
}
if (footstep_sounds_on > 0.0)
{
CBasePlayer* thePlayer = (CBasePlayer*)CBaseEntity::Instance(pPlayer);
// check if this player is moving fast enough to make sounds...
if (pPlayer->v.velocity.Length2D() > thePlayer->GetMaxWalkSpeed())
{
volume = 500.0; // volume of sound being made (just pick something)
Vector v_sound = pPlayer->v.origin - pEdict->v.origin;
distance = v_sound.Length();
// is the bot close enough to hear this sound?
if (distance < (volume * sensitivity))
{
Vector bot_angles = UTIL_VecToAngles( v_sound );
pEdict->v.ideal_yaw = bot_angles.y;
BotFixIdealYaw(pEdict);
return TRUE;
}
}
}
return FALSE;
}
CDumbfire *CDumbfire::ShootDumbfire( entvars_t *pevOwner, Vector vecStart, Vector vecVelocity )
{
CDumbfire *pDumbfire = GetClassPtr( (CDumbfire *)NULL );
pDumbfire->Spawn();
UTIL_SetOrigin( pDumbfire->pev, vecStart );
pDumbfire->pev->velocity = vecVelocity;
pDumbfire->pev->angles = UTIL_VecToAngles (pDumbfire->pev->velocity);
pDumbfire->pev->owner = ENT(pevOwner);
pDumbfire->SetThink ( Follow );
pDumbfire->pev->nextthink = 0.1;
pDumbfire->SetTouch( ExplodeTouch );
pDumbfire->pev->dmg = dmg_dumbfire_missile.value * (mp_wpn_power.value/100);
pDumbfire->pev->avelocity.z = -300;
FX_Trail(pDumbfire->pev->origin, pDumbfire->entindex(), PROJ_DUMBFIRE );
return pDumbfire;
}
CMGrenade * CMGrenade:: ShootTimed( entvars_t *pevOwner, Vector vecStart, Vector vecVelocity, float time )
{
CMGrenade *pGrenade = CreateClassPtr( (CMGrenade *)NULL );
if (pGrenade == NULL) // no free monster edicts left?
return 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( BounceTouch ); // Bounce if touched
// Take one second off of the desired detonation time and set the think to PreDetonate. PreDetonate
// will insert a DANGER sound into the world sound list and delay detonation for one second so that
// the grenade explodes after the exact amount of time specified in the call to ShootTimed().
pGrenade->pev->dmgtime = gpGlobals->time + time;
pGrenade->SetThink( TumbleThink );
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;
// Tumble through the air
// pGrenade->pev->avelocity.x = -400;
pGrenade->pev->gravity = 0.5;
pGrenade->pev->friction = 0.8;
SET_MODEL(ENT(pGrenade->pev), "models/w_grenade.mdl");
pGrenade->pev->dmg = 100;
return pGrenade;
}
CGrenade *CGrenade::ShootContact(entvars_t *pevOwner, Vector vecStart, Vector vecVelocity)
{
CGrenade *pGrenade = GetClassPtr((CGrenade *)NULL);
pGrenade->Spawn();
pGrenade->pev->gravity = 0.5;
UTIL_SetOrigin(pGrenade->pev, vecStart);
pGrenade->pev->velocity = vecVelocity;
pGrenade->pev->angles = UTIL_VecToAngles(pGrenade->pev->velocity);
pGrenade->pev->owner = ENT(pevOwner);
pGrenade->SetThink(&CGrenade::DangerSoundThink);
pGrenade->pev->nextthink = gpGlobals->time;
pGrenade->pev->avelocity.x = RANDOM_FLOAT(-100, -500);
pGrenade->SetTouch(&CGrenade::ExplodeTouch);
pGrenade->pev->dmg = gSkillData.plrDmgM203Grenade;
pGrenade->m_bJustBlew = true;
return pGrenade;
}
//=========================================================
CQuakeRocket *CQuakeRocket::CreateGrenade( Vector vecOrigin, Vector vecVelocity, CBaseEntity *pOwner )
{
CQuakeRocket *pRocket = GetClassPtr( (CQuakeRocket *)NULL );
UTIL_SetOrigin( pRocket->pev, vecOrigin );
SET_MODEL(ENT(pRocket->pev), "models/grenade.mdl");
pRocket->Spawn();
pRocket->pev->classname = MAKE_STRING("grenade");
pRocket->pev->owner = pOwner->edict();
// Setup
pRocket->pev->movetype = MOVETYPE_BOUNCE;
pRocket->pev->solid = SOLID_BBOX;
pRocket->pev->avelocity = Vector(300,300,300);
// Velocity
pRocket->pev->velocity = vecVelocity;
pRocket->pev->angles = UTIL_VecToAngles(vecVelocity);
pRocket->pev->friction = 0.5;
// Touch
pRocket->SetTouch( CQuakeRocket::GrenadeTouch );
// set newmis duration
if ( gpGlobals->deathmatch == 4 )
{
pRocket->m_flAttackFinished = gpGlobals->time + 1.1; // What's this used for?
if (pOwner)
pOwner->TakeDamage( pOwner->pev, pOwner->pev, 10, DMG_GENERIC );
}
pRocket->pev->nextthink = gpGlobals->time + 2.5;
pRocket->SetThink( CQuakeRocket::GrenadeExplode );
PLAYBACK_EVENT_FULL (FEV_GLOBAL, pRocket->edict(), g_sTrail, 0.0,
(float *)&g_vecZero, (float *)&g_vecZero, 0.7, 0.0, pRocket->entindex(), GRENADE_TRAIL, 0, 0);
return pRocket;
}
void CApacheHVR :: AccelerateThink( void )
{
// check world boundaries
if (pev->origin.x < -4096 || pev->origin.x > 4096 || pev->origin.y < -4096 || pev->origin.y > 4096 || pev->origin.z < -4096 || pev->origin.z > 4096)
{
UTIL_Remove( this );
return;
}
// accelerate
float flSpeed = pev->velocity.Length();
if (flSpeed < 1800)
{
pev->velocity = pev->velocity + m_vecForward * 200;
}
// re-aim
pev->angles = UTIL_VecToAngles( pev->velocity );
SetNextThink( 0.1 );
}
