CBaseMonster *COsprey :: MakeGrunt( Vector vecSrc )
{
CBaseEntity *pEntity;
CBaseMonster *pGrunt;
TraceResult tr;
UTIL_TraceLine( vecSrc, vecSrc + Vector( 0, 0, -4096.0), dont_ignore_monsters, ENT(pev), &tr);
if ( tr.pHit && Instance( tr.pHit )->pev->solid != SOLID_BSP)
return NULL;
for (int i = 0; i < m_iUnits; i++)
{
if (m_hGrunt[i] == NULL || !m_hGrunt[i]->IsAlive())
{
if (m_hGrunt[i] != NULL && m_hGrunt[i]->pev->rendermode == kRenderNormal)
{
m_hGrunt[i]->SUB_StartFadeOut( );
}
pEntity = Create( "monster_human_grunt", vecSrc, GetAbsAngles() );
pGrunt = pEntity->MyMonsterPointer( );
pGrunt->pev->movetype = MOVETYPE_FLY;
pGrunt->SetAbsVelocity( Vector( 0, 0, RANDOM_FLOAT( -196, -128 ) ));
pGrunt->SetActivity( ACT_GLIDE );
CBeam *pBeam = CBeam::BeamCreate( "sprites/rope.spr", 10 );
pBeam->PointEntInit( vecSrc + Vector(0,0,112), pGrunt->entindex() );
pBeam->SetFlags( BEAM_FSOLID );
pBeam->SetColor( 255, 255, 255 );
pBeam->SetThink( SUB_Remove );
pBeam->pev->nextthink = gpGlobals->time + -4096.0 * tr.flFraction / pGrunt->GetAbsVelocity().z + 0.5;
// ALERT( at_console, "%d at %.0f %.0f %.0f\n", i, m_vecOrigin[i].x, m_vecOrigin[i].y, m_vecOrigin[i].z );
pGrunt->m_vecLastPosition = m_vecOrigin[i];
m_hGrunt[i] = pGrunt;
return pGrunt;
}
}
// ALERT( at_console, "none dead\n");
return NULL;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CAI_RappelBehavior::CreateZipline()
{
#if 1
if( !m_hLine )
{
int attachment = GetOuter()->LookupAttachment( "zipline" );
if( attachment != -1 )
{
CBeam *pBeam;
pBeam = CBeam::BeamCreate( "cable/cable.vmt", 1 );
pBeam->SetColor( 150, 150, 150 );
pBeam->SetWidth( 0.3 );
pBeam->SetEndWidth( 0.3 );
CAI_BaseNPC *pNPC = GetOuter();
pBeam->PointEntInit( pNPC->GetAbsOrigin() + Vector( 0, 0, 80 ), pNPC );
pBeam->SetEndAttachment( attachment );
m_hLine.Set( pBeam );
}
}
#endif
}
void CTripmineGrenade :: MakeBeam( void )
{
TraceResult tr;
// ALERT( at_console, "serverflags %f\n", gpGlobals->serverflags );
UTIL_TraceLine( pev->origin, m_vecEnd, dont_ignore_monsters, ENT( pev ), &tr );
m_flBeamLength = tr.flFraction;
// set to follow laser spot
SetThink( BeamBreakThink );
pev->nextthink = gpGlobals->time + 0.1;
Vector vecTmpEnd = pev->origin + m_vecDir * 2048 * m_flBeamLength;
m_pBeam = CBeam::BeamCreate( g_pModelNameLaser, 10 );
m_pBeam->PointEntInit( vecTmpEnd, entindex() );
m_pBeam->SetColor( 0, 214, 198 );
m_pBeam->SetScrollRate( 255 );
m_pBeam->SetBrightness( 64 );
}
// Purpose:
// Input : isbeingremoved -
// *predicted -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CBeam::OnPredictedEntityRemove( bool isbeingremoved, C_BaseEntity *predicted )
{
BaseClass::OnPredictedEntityRemove( isbeingremoved, predicted );
CBeam *beam = dynamic_cast< CBeam * >( predicted );
if ( !beam )
{
// Hrm, we didn't link up to correct type!!!
Assert( 0 );
// Delete right away since it's f****d up
return true;
}
if ( beam->IsEFlagSet( EFL_KILLME ) )
{
// Don't delete right away
AddEFlags( EFL_KILLME );
return false;
}
// Go ahead and delete if it's not short-lived
return true;
}
void CGenericMonster::MakeGas( void )
{
Vector posGun, angleGun;
TraceResult tr;
UTIL_MakeVectors( pev->angles );
{
KillGas();
m_pBeam = CBeam::BeamCreate( "sprites/laserbeam.spr", 7 );
if ( m_pBeam )
{
GetAttachment( 4, posGun, angleGun );
GetAttachment( 3, posGun, angleGun );
Vector vecEnd = (gpGlobals->v_forward * 5) + posGun;
UTIL_TraceLine( posGun, vecEnd, dont_ignore_monsters, edict(), &tr );
m_pBeam->EntsInit( edict(), edict() );
m_pBeam->SetColor( 24, 121, 239 );
m_pBeam->SetBrightness( 190 );
m_pBeam->SetScrollRate( 20 );
m_pBeam->SetStartAttachment( 4 );
m_pBeam->SetEndAttachment( 3 );
m_pBeam->DamageDecal( 28 );
m_pBeam->DoSparks( tr.vecEndPos, posGun );
m_pBeam->SetFlags( FBEAM_SHADEIN );
m_pBeam->RelinkBeam();
UTIL_Sparks( tr.vecEndPos );
UTIL_DecalTrace(&tr, 28 + RANDOM_LONG(0,4));
}
}
// m_flNextAttack = gpGlobals->time + RANDOM_FLOAT( 0.5, 4.0 );
if ( int gas = 1 )
{
pev->nextthink = gpGlobals->time;
}
}
//---------------------------------------------------------
//---------------------------------------------------------
void CNPC_GroundTurret::MakeTracer( const Vector &vecTracerSrc, const trace_t &tr, int iTracerType )
{
#if 1
//BaseClass::MakeTracer( vecTracerSrc, tr, iTracerType );
UTIL_Tracer( vecTracerSrc, tr.endpos, 0, TRACER_DONT_USE_ATTACHMENT, 5000, true, "AR2Tracer" );
#else
CBeam *pBeam;
int width = 2;
pBeam = CBeam::BeamCreate( GROUNDTURRET_BEAM_SPRITE, width );
if ( !pBeam )
return;
pBeam->SetStartPos( vecTracerSrc );
pBeam->SetEndPos( tr.endpos );
pBeam->SetWidth( width );
pBeam->SetEndWidth( width / 4.0f );
pBeam->SetBrightness( 100 );
pBeam->SetColor( 0, 145+random->RandomInt( -16, 16 ), 255 );
pBeam->RelinkBeam();
pBeam->LiveForTime( random->RandomFloat( 0.2f, 0.5f ) );
#endif
}
void CEgon::UpdateEffect( const Vector &startPoint, const Vector &endPoint, float timeBlend )
{
if ( !m_pBeam )
{
CreateEffect();
}
m_pBeam->SetStartPos( endPoint );
m_pBeam->SetBrightness( 255 - (timeBlend*180) );
m_pBeam->SetWidth( 40 - (timeBlend*20) );
if ( m_fireMode == FIRE_WIDE )
m_pBeam->SetColor( 30 + (25*timeBlend), 30 + (30*timeBlend), 64 + 80*fabs(sin(gpGlobals->time*10)) );
else
m_pBeam->SetColor( 60 + (25*timeBlend), 120 + (30*timeBlend), 64 + 80*fabs(sin(gpGlobals->time*10)) );
UTIL_SetOrigin( m_pSprite->pev, endPoint );
m_pSprite->pev->frame += 8 * gpGlobals->frametime;
if ( m_pSprite->pev->frame > m_pSprite->Frames() )
m_pSprite->pev->frame = 0;
m_pNoise->SetStartPos( endPoint );
}
void CLeech::UpdateMotion( void )
{
float flapspeed = (pev->speed - m_flAccelerate) / LEECH_ACCELERATE;
m_flAccelerate = m_flAccelerate * 0.8 + pev->speed * 0.2;
if (flapspeed < 0)
flapspeed = -flapspeed;
flapspeed += 1.0;
if (flapspeed < 0.5)
flapspeed = 0.5;
if (flapspeed > 1.9)
flapspeed = 1.9;
pev->framerate = flapspeed;
if ( !m_fPathBlocked )
pev->avelocity.y = pev->ideal_yaw;
else
pev->avelocity.y = pev->ideal_yaw * m_obstacle;
if ( pev->avelocity.y > 150 )
m_IdealActivity = ACT_TURN_LEFT;
else if ( pev->avelocity.y < -150 )
m_IdealActivity = ACT_TURN_RIGHT;
else
m_IdealActivity = ACT_SWIM;
// lean
float targetPitch, delta;
delta = m_height - pev->origin.z;
if ( delta < -10 )
targetPitch = -30;
else if ( delta > 10 )
targetPitch = 30;
else
targetPitch = 0;
pev->angles.x = UTIL_Approach( targetPitch, pev->angles.x, 60 * LEECH_FRAMETIME );
// bank
pev->avelocity.z = - (pev->angles.z + (pev->avelocity.y * 0.25));
if ( m_MonsterState == MONSTERSTATE_COMBAT && HasConditions( bits_COND_CAN_MELEE_ATTACK1 ) )
m_IdealActivity = ACT_MELEE_ATTACK1;
// Out of water check
if ( !pev->waterlevel )
{
pev->movetype = MOVETYPE_TOSS;
m_IdealActivity = ACT_TWITCH;
pev->velocity = g_vecZero;
// Animation will intersect the floor if either of these is non-zero
pev->angles.z = 0;
pev->angles.x = 0;
if ( pev->framerate < 1.0 )
pev->framerate = 1.0;
}
else if ( pev->movetype == MOVETYPE_TOSS )
{
pev->movetype = MOVETYPE_FLY;
pev->flags &= ~FL_ONGROUND;
RecalculateWaterlevel();
m_waterTime = gpGlobals->time + 2; // Recalc again soon, water may be rising
}
if ( m_Activity != m_IdealActivity )
{
SetActivity ( m_IdealActivity );
}
float flInterval = StudioFrameAdvance();
DispatchAnimEvents ( flInterval );
#if DEBUG_BEAMS
if ( !m_pb )
m_pb = CBeam::BeamCreate( "sprites/laserbeam.spr", 5 );
if ( !m_pt )
m_pt = CBeam::BeamCreate( "sprites/laserbeam.spr", 5 );
m_pb->PointsInit( pev->origin, pev->origin + gpGlobals->v_forward * LEECH_CHECK_DIST );
m_pt->PointsInit( pev->origin, pev->origin - gpGlobals->v_right * (pev->avelocity.y*0.25) );
if ( m_fPathBlocked )
{
float color = m_obstacle * 30;
if ( m_obstacle == 1.0 )
color = 0;
if ( color > 255 )
color = 255;
m_pb->SetColor( 255, (int)color, (int)color );
}
else
m_pb->SetColor( 255, 255, 0 );
m_pt->SetColor( 0, 0, 255 );
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : &startPos -
// &endPos -
// width -
// useMuzzle -
//-----------------------------------------------------------------------------
void CASW_PropJeep::DrawBeam( const Vector &startPos, const Vector &endPos, float width )
{
//Tracer down the middle
UTIL_Tracer( startPos, endPos, 0, TRACER_DONT_USE_ATTACHMENT, 6500, false, "GaussTracer" );
//Draw the main beam shaft
CBeam *pBeam = CBeam::BeamCreate( GAUSS_BEAM_SPRITE, 0.5 );
pBeam->SetStartPos( startPos );
pBeam->PointEntInit( endPos, this );
pBeam->SetEndAttachment( LookupAttachment("Muzzle") );
pBeam->SetWidth( width );
pBeam->SetEndWidth( 0.05f );
pBeam->SetBrightness( 255 );
pBeam->SetColor( 255, 185+random->RandomInt( -16, 16 ), 40 );
pBeam->RelinkBeam();
pBeam->LiveForTime( 0.1f );
//Draw electric bolts along shaft
pBeam = CBeam::BeamCreate( GAUSS_BEAM_SPRITE, 3.0f );
pBeam->SetStartPos( startPos );
pBeam->PointEntInit( endPos, this );
pBeam->SetEndAttachment( LookupAttachment("Muzzle") );
pBeam->SetBrightness( random->RandomInt( 64, 255 ) );
pBeam->SetColor( 255, 255, 150+random->RandomInt( 0, 64 ) );
pBeam->RelinkBeam();
pBeam->LiveForTime( 0.1f );
pBeam->SetNoise( 1.6f );
pBeam->SetEndWidth( 0.1f );
}
void CLocusBeam::Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
{
CBaseEntity *pStartEnt;
CBaseEntity *pEndEnt;
Vector vecStartPos;
Vector vecEndPos;
CBeam *pBeam;
switch(pev->impulse)
{
case 0: // ents
pStartEnt = UTIL_FindEntityByTargetname(NULL, STRING(m_iszStart), pActivator);
pEndEnt = UTIL_FindEntityByTargetname(NULL, STRING(m_iszEnd), pActivator);
if (pStartEnt == NULL || pEndEnt == NULL)
return;
pBeam = CBeam::BeamCreate( STRING(m_iszSprite), m_iWidth );
pBeam->EntsInit( pStartEnt->entindex(), pEndEnt->entindex() );
break;
case 1: // pointent
vecStartPos = CalcLocus_Position( this, pActivator, STRING(m_iszStart) );
pEndEnt = UTIL_FindEntityByTargetname(NULL, STRING(m_iszEnd), pActivator);
if (pEndEnt == NULL)
return;
pBeam = CBeam::BeamCreate( STRING(m_iszSprite), m_iWidth );
pBeam->PointEntInit( vecStartPos, pEndEnt->entindex() );
break;
case 2: // points
vecStartPos = CalcLocus_Position( this, pActivator, STRING(m_iszStart) );
vecEndPos = CalcLocus_Position( this, pActivator, STRING(m_iszEnd) );
pBeam = CBeam::BeamCreate( STRING(m_iszSprite), m_iWidth );
pBeam->PointsInit( vecStartPos, vecEndPos );
break;
case 3: // point & offset
vecStartPos = CalcLocus_Position( this, pActivator, STRING(m_iszStart) );
vecEndPos = CalcLocus_Velocity( this, pActivator, STRING(m_iszEnd) );
pBeam = CBeam::BeamCreate( STRING(m_iszSprite), m_iWidth );
pBeam->PointsInit( vecStartPos, vecStartPos + vecEndPos );
break;
}
pBeam->SetColor( pev->rendercolor.x, pev->rendercolor.y, pev->rendercolor.z );
pBeam->SetBrightness( pev->renderamt );
pBeam->SetNoise( m_iDistortion );
pBeam->SetFrame( m_fFrame );
pBeam->SetScrollRate( m_iScrollRate );
pBeam->SetFlags( m_iFlags );
pBeam->pev->dmg = m_fDamage;
pBeam->pev->frags = m_iDamageType;
pBeam->pev->spawnflags |= pev->spawnflags & (SF_BEAM_RING |
SF_BEAM_SPARKSTART | SF_BEAM_SPARKEND | SF_BEAM_DECALS);
if (m_fDuration)
{
pBeam->SetThink(&CBeam:: SUB_Remove );
pBeam->SetNextThink( m_fDuration );
}
pBeam->pev->targetname = m_iszTargetName;
if (pev->target)
{
FireTargets( STRING(pev->target), pBeam, this, USE_TOGGLE, 0 );
}
}
void CGrappleHook::Move( void )
{
// Fograin92: If owner (player) is dead
if( !myowner->IsAlive() )
{
Killed(pev, 0); // Remove tongue instantly
return;
}
// Fograin92: Player isn't holding attack buttons
if( !(myowner->pev->button & (IN_ATTACK|IN_ATTACK2)) )
{
bPullBack = true; // Fograin92: We should pull the tongue back
}
// Fograin92: Animate pull-back tongue animation ONLY if we didn't hit a monster
if(bPullBack)
{
UTIL_MakeVectors( myowner->pev->v_angle + myowner->pev->punchangle );
Vector GunPosition = myowner->GetGunPosition();
GunPosition = GunPosition + gpGlobals->v_up * -4 + gpGlobals->v_right * 3 + gpGlobals->v_forward * 6;
pev->velocity = (GunPosition - pev->origin) * 10; // Pull back the tongue tip
float fDistance = (GunPosition - pev->origin).Length2D(); // Calculate distance between tongue tip and player
//ALERT( at_console, "^2HLU -> ^3weapon_grapple ^2-> %f\n", fDistance );
if (fDistance < 40)
{
Killed(pev, 0);
return;
}
}
else
{
// Fograin92: We did hit a monster
if(m_iHitMonster > 0)
{
// Fograin92: Let's "stick" grapple tongue XYZ to target's center XYZ
pev->origin = myHitMonster->Center();
// Fograin92: We did hit tiny monster, let's pull it
if(m_iHitMonster == 2)
{
myHitMonster->pev->movetype = MOVETYPE_FLY; // Remove gravity effect on our pulled monster
myHitMonster->pev->velocity = (myowner->pev->origin - myHitMonster->pev->origin) * 4; // Pull our monster
}
// Fograin92: Check distance (player <-> monster)
float fDistance = (myowner->pev->origin - myHitMonster->pev->origin).Length2D();
// Fograin92: The monster is very close to player, let's OWN IT!
if (fDistance < 40)
{
ALERT( at_console, "^2HLU -> ^3weapon_grapple ^2-> OWNED -> ^3%s\n", STRING(myHitMonster->pev->classname) );
// Fograin92: Did we pull the gib?
if( myHitMonster->Classify() == CLASS_GIBS )
myHitMonster->SUB_Remove();
else
myHitMonster->TakeDamage(myHitMonster->pev, myowner->pev, 10000, DMG_GENERIC);
Killed(pev, 0); // Fograin92: Target died, kill tongue
}
}
}
// Fograin92: If tongue (beam) exists
if( m_pTongue )
{
UTIL_MakeVectors( myowner->pev->v_angle + myowner->pev->punchangle );
Vector GunPosition = myowner->GetGunPosition();
GunPosition = GunPosition + gpGlobals->v_up * -4 + gpGlobals->v_right * 3 + gpGlobals->v_forward * 6;
m_pTongue->PointEntInit( GunPosition, this->entindex() );
}
else
{
// Fograin92: Create tongue (beam)
m_pTongue = CBeam::BeamCreate( "sprites/_tongue.spr", 8 );
m_pTongue->SetFlags( 0x20 ); // Solid beam
m_pTongue->SetColor( 100, 100, 100 );
m_pTongue->SetScrollRate( 20 );
}
pev->nextthink = gpGlobals->time + 0.01;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CWeaponGaussGun::DrawBeam( const Vector &startPos, const Vector &endPos, float width, bool useMuzzle )
{
CBasePlayer *pOwner = ToBasePlayer(GetOwner());
if (!pOwner)
return;
//Check to store off our view model index
if (m_hViewModel == NULL)
{
CBaseViewModel *vm = pOwner->GetViewModel();
if (vm)
m_hViewModel.Set(vm);
}
//Draw the main beam shaft
CBeam *pBeam = CBeam::BeamCreate( GAUSS_BEAM_SPRITE, width );
if ( useMuzzle )
{
pBeam->PointEntInit( endPos, m_hViewModel );
pBeam->SetEndAttachment( 1 );
pBeam->SetWidth( width / 4.0f );
pBeam->SetEndWidth( width );
}
else
{
pBeam->SetStartPos( startPos );
pBeam->SetEndPos( endPos );
pBeam->SetWidth( width );
pBeam->SetEndWidth( width / 4.0f );
}
pBeam->SetBrightness( 255 );
pBeam->SetColor( 255, 145+random->RandomInt( -16, 16 ), 0 );
pBeam->RelinkBeam();
pBeam->LiveForTime( 0.1f );
//Draw electric bolts along shaft
for ( int i = 0; i < 3; i++ )
{
pBeam = CBeam::BeamCreate( GAUSS_BEAM_SPRITE, (width/2.0f) + i );
if ( useMuzzle )
{
pBeam->PointEntInit( endPos, m_hViewModel );
pBeam->SetEndAttachment( 1 );
}
else
{
pBeam->SetStartPos( startPos );
pBeam->SetEndPos( endPos );
}
pBeam->SetBrightness( random->RandomInt( 64, 255 ) );
pBeam->SetColor( 255, 255, 150+random->RandomInt( 0, 64 ) );
pBeam->RelinkBeam();
pBeam->LiveForTime( 0.1f );
pBeam->SetNoise( 1.6f * i );
pBeam->SetEndWidth( 0.1f );
}
}
void CBaseHumanRepel::RepelUse ( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
{
TraceResult tr;
UTIL_TraceLine( pev->origin, pev->origin + Vector( 0, 0, -4096.0), dont_ignore_monsters, ENT(pev), &tr);
/*
if ( tr.pHit && Instance( tr.pHit )->pev->solid != SOLID_BSP)
return NULL;
*/
edict_t *pent;
CBaseEntity *pEntity;
pent = CREATE_NAMED_ENTITY( MAKE_STRING( EntityName() ));
if ( FNullEnt( pent ) )
{
ALERT ( at_console, "NULL Ent in HumanRepel Create!\n" );
return;
}
pEntity = Instance( pent );
pEntity->pev->owner = NULL;
//
pEntity->pev->origin = pev->origin;
pEntity->pev->angles = pev->angles;
pEntity->pev->spawnflags = pev->spawnflags;
pEntity->pev->weapons = pev->weapons;
pEntity->pev->scale = pev->scale;
pEntity->pev->health = pev->health;
pEntity->pev->skin = pev->skin;
pEntity->pev->frags = pev->frags;//HL2 model compatibility (not used anymore)
pEntity->pev->dmg = pev->dmg;//for monster breakpoint
pEntity->pev->message = pev->message;//when a surrender terrorist fires a trigger
pEntity->pev->target = pev->noise;
//LRC - custom monster behaviour
// CBaseEntity *pEntity = CBaseEntity::Instance( pEntity );
CBaseMonster *pMonst = NULL;
if (pEntity && (pMonst = pEntity->MyMonsterPointer()) != NULL)
{
pMonst->m_iClass = this->m_iClass;
pMonst->m_iPlayerReact = this->m_iPlayerReact;
pMonst->m_iTriggerCondition = this->m_iTriggerCondition; //AJH
pMonst->m_iszTriggerTarget = this->m_iszTriggerTarget; //AJH
}
//
/*
pEntity->pev->origin = pev->origin;
pEntity->pev->angles = pev->angles;
pEntity->pev->spawnflags = pev->spawnflags;
pEntity->pev->body = pev->body;
pEntity->pev->weapons = pev->weapons;
pEntity->pev->netname = pev->netname;
*/
DispatchSpawn( pEntity->edict() );
pEntity->pev->movetype = MOVETYPE_FLY;
pEntity->pev->velocity = Vector( 0, 0, RANDOM_FLOAT( -196, -128 ) );
CBaseMonster *pHuman = pEntity->MyMonsterPointer( );
pHuman->SetActivity( ACT_GLIDE );
pHuman->m_vecLastPosition = tr.vecEndPos;
CBeam *pBeam = CBeam::BeamCreate( "sprites/rope.spr", 10 );
pBeam->PointEntInit( pev->origin/* + Vector(0,0,112)*/, pEntity->entindex() );
pBeam->SetFlags( BEAM_FSOLID );
pBeam->SetColor( 255, 255, 255 );
pBeam->SetThink( SUB_Remove );
pBeam->pev->nextthink = gpGlobals->time + -4096.0 * tr.flFraction / pEntity->pev->velocity.z + 0.5;
UTIL_Remove( this );
}
void CWeaponGravityGun::SecondaryAttack( void )
{
m_flNextSecondaryAttack = gpGlobals->curtime + 0.1;
if ( m_active )
{
EffectDestroy();
SoundDestroy();
return;
}
CBasePlayer *pOwner = ToBasePlayer( GetOwner() );
Assert( pOwner );
if ( pOwner->GetAmmoCount(m_iSecondaryAmmoType) <= 0 )
return;
m_viewModelIndex = pOwner->entindex();
// Make sure I've got a view model
CBaseViewModel *vm = pOwner->GetViewModel();
if ( vm )
{
m_viewModelIndex = vm->entindex();
}
Vector forward;
pOwner->EyeVectors( &forward );
Vector start = pOwner->Weapon_ShootPosition();
Vector end = start + forward * 4096;
trace_t tr;
UTIL_TraceLine( start, end, MASK_SHOT, pOwner, COLLISION_GROUP_NONE, &tr );
if ( tr.fraction == 1.0 || (tr.surface.flags & SURF_SKY) )
return;
CBaseEntity *pHit = tr.m_pEnt;
if ( pHit->entindex() == 0 )
{
pHit = NULL;
}
else
{
// if the object has no physics object, or isn't a physprop or brush entity, then don't glue
if ( !pHit->VPhysicsGetObject() || pHit->GetMoveType() != MOVETYPE_VPHYSICS )
return;
}
QAngle angles;
WeaponSound( SINGLE );
pOwner->RemoveAmmo( 1, m_iSecondaryAmmoType );
VectorAngles( tr.plane.normal, angles );
Vector endPoint = tr.endpos + tr.plane.normal;
CGravityPellet *pPellet = (CGravityPellet *)CBaseEntity::Create( "gravity_pellet", endPoint, angles, this );
if ( pHit )
{
pPellet->SetParent( pHit );
}
AddPellet( pPellet, pHit, tr.plane.normal );
// UNDONE: Probably should just do this client side
CBaseEntity *pEnt = GetBeamEntity();
CBeam *pBeam = CBeam::BeamCreate( PHYSGUN_BEAM_SPRITE, 1.5 );
pBeam->PointEntInit( endPoint, pEnt );
pBeam->SetEndAttachment( 1 );
pBeam->SetBrightness( 255 );
pBeam->SetColor( 255, 0, 0 );
pBeam->RelinkBeam();
pBeam->LiveForTime( 0.1 );
}
//=========================================================
// RunTask
//=========================================================
void CLuciole :: RunTask ( Task_t *pTask )
{
// petite loupiote
MESSAGE_BEGIN( MSG_PVS, SVC_TEMPENTITY, Center() );
WRITE_BYTE(TE_DLIGHT);
WRITE_COORD(Center().x); // X
WRITE_COORD(Center().y); // Y
WRITE_COORD(Center().z); // Z
WRITE_BYTE( 7 ); // radius * 0.1
WRITE_BYTE( 150 ); // r
WRITE_BYTE( 71 ); // g
WRITE_BYTE( 245 ); // b
WRITE_BYTE( 3 ); // time * 10
WRITE_BYTE( 0 ); // decay * 0.1
MESSAGE_END( );
// position de tir
if ( m_hEnemy != NULL && (Center()-m_hEnemy->Center()).Length() < ATTACK_DIST && gpGlobals->time - m_flLastAttack > ATTACK_DELAY )
{
m_flLastAttack = gpGlobals->time;
EMIT_SOUND ( edict(), CHAN_ITEM, "debris/beamstart14.wav", 1.0, ATTN_NORM );
for ( int i=0; i<3; i++ )
{
CBeam *pBeam = CBeam::BeamCreate( "sprites/laserbeam.spr", 2 );
if ( RANDOM_LONG(0,1) )
pBeam->SetColor( 206,118, 254 );
else
pBeam->SetColor( 223,224, 255 );
pBeam->SetBrightness( 192 );
pBeam->PointEntInit( m_hEnemy->Center(), entindex( ) );
pBeam->SetEndAttachment( 0 );
pBeam->RelinkBeam( );
pBeam->SetNoise ( 30 );
pBeam->LiveForTime ( 0.4 );
m_hEnemy->TakeDamage ( pev, pev, gSkillData.LucioleDamage, DMG_SHOCK );
}
return;
}
MakeIdealYaw( m_vecEnemyLKP );
ChangeYaw( pev->yaw_speed );
// run task classique
switch ( pTask->iTask )
{
case TASK_FLYBEE_WAIT_FOR_MOVEMENT:
{
if (MovementIsComplete())
{
TaskComplete();
RouteClear(); // Stop moving
}
break;
}
case TASK_LUCIOLE_GET_PATH:
{
// considère l'objectif atteint à 10 units de distance
BOOL bFinDeRoute = FALSE;
if ( (pev->origin-m_vecRoute).Length() < 10 )
{
bFinDeRoute = TRUE;
}
// actualise la position ennemie
if ( m_hEnemy == NULL )
{
TaskComplete ();
break;
}
Vector vecEnemy = m_hEnemy->Center();
// vérifie la visibilité du joueur
TraceResult tr;
UTIL_TraceLine ( pev->origin, vecEnemy, dont_ignore_monsters, dont_ignore_glass, edict(), &tr );
if ( tr.flFraction == 1.0 || FClassnameIs(tr.pHit, "player") )
{
// champ libre jusqu'au joueur
m_vecRoute = vecEnemy;
m_iMouchard = MOUCHARD_OFF;
}
// joueur invisible
else
{
// trajectoire non finie - on continue
if ( bFinDeRoute == FALSE )
{
// active le mouchard
if ( m_iMouchard == MOUCHARD_OFF )
{
m_iMouchard = MOUCHARD_LANCEMENT;
m_vecMouchard1 = m_vecRoute;
}
}
// pas de trajectoire définie
else
{
// tente d'utiliser le mouchard
TraceResult trMouchard;
UTIL_TraceLine ( pev->origin, m_vecMouchard2, dont_ignore_monsters, dont_ignore_glass, edict(), &trMouchard );
if ( m_iMouchard == MOUCHARD_ON && ( trMouchard.flFraction == 1.0 || FClassnameIs(trMouchard.pHit, "player") ) )
{
// c parti
m_vecRoute = m_vecMouchard2;
// mouchard obsolète, on en relance un nouveau
m_iMouchard = MOUCHARD_LANCEMENT;
}
else
{
TraceResult trTete;
UTIL_TraceLine ( pev->origin, m_hEnemy->pev->view_ofs, dont_ignore_monsters, dont_ignore_glass, edict(), &trTete );
TraceResult trPieds;
UTIL_TraceLine ( pev->origin, m_hEnemy->pev->origin, dont_ignore_monsters, dont_ignore_glass, edict(), &trPieds );
if ( trTete.flFraction == 1.0 || FClassnameIs(trTete.pHit, "player") )
{
// champ libre jusqu'au joueur
m_vecRoute = m_hEnemy->pev->view_ofs;
}
else if ( trPieds.flFraction == 1.0 || FClassnameIs(trPieds.pHit, "player") )
{
// champ libre jusqu'au joueur
m_vecRoute = m_hEnemy->pev->origin;
}
// ennemi totalement invisible
else
{
// bloqué par de petits obstacles - on tente de monter ou descendre un peu
TraceResult trEvite [2];
UTIL_MakeVectors ( pev->angles );
int ordre [4];
switch ( RANDOM_LONG(0,3) )
{
case 0: ordre[0] = 0; ordre[1] = 1; ordre[2] = 2; ordre[3] = 3; break;
case 1: ordre[0] = 0; ordre[1] = 3; ordre[2] = 2; ordre[3] = 1; break;
case 2: ordre[0] = 2; ordre[1] = 3; ordre[2] = 0; ordre[3] = 1; break;
case 3: ordre[0] = 3; ordre[1] = 1; ordre[2] = 0; ordre[3] = 2; break;
}
UTIL_TraceLine ( pev->origin, pev->origin + Vector (0,0,RANDOM_FLOAT(40,60)), dont_ignore_monsters, dont_ignore_glass, edict(), &trEvite[ordre[0]] );
UTIL_TraceLine ( pev->origin, pev->origin - Vector (0,0,RANDOM_FLOAT(40,60)), dont_ignore_monsters, dont_ignore_glass, edict(), &trEvite[ordre[1]] );
UTIL_TraceLine ( pev->origin, pev->origin + gpGlobals->v_right * RANDOM_FLOAT(40,60), dont_ignore_monsters, dont_ignore_glass, edict(), &trEvite[ordre[2]] );
UTIL_TraceLine ( pev->origin, pev->origin - gpGlobals->v_right * RANDOM_FLOAT(40,60), dont_ignore_monsters, dont_ignore_glass, edict(), &trEvite[ordre[3]] );
for ( int i=0; i<4; i++ )
{
if ( trEvite[i].flFraction >= 0.5 )
m_vecRoute = trEvite[i].vecEndPos - (trEvite[i].vecEndPos-pev->origin).Normalize() * 5;
break;
}
}
}
}
}
// actualise le mouchard
if ( m_iMouchard != MOUCHARD_OFF )
{
if ( m_iMouchard == MOUCHARD_LANCEMENT )
{
m_vecMouchard2 = m_vecMouchard1;
}
// vérifie si le joueur est visible depuis sa dernière position connue
TraceResult trMouchard;
UTIL_TraceLine ( m_vecMouchard1, vecEnemy, dont_ignore_monsters, dont_ignore_glass, edict(), &trMouchard );
if ( trMouchard.flFraction == 1.0 || FClassnameIs(trMouchard.pHit, "player") )
{
m_vecMouchard2 = vecEnemy;
m_iMouchard = MOUCHARD_ON;
}
}
// trajectoire établie - application des vitesses
float flDot = DotProduct ( pev->velocity.Normalize(), (m_vecRoute-pev->origin).Normalize() );
float flRatio = 0.6 + (flDot+1)*0.6;
float speed = pev->velocity.Length() * flRatio;
speed = max ( 100, speed );
speed = min ( speed, 250 );
pev->velocity = (m_vecRoute - pev->origin).Normalize() * speed;
break;
}
default:
CBaseMonster :: RunTask ( pTask );
break;
}
}
void CTestEffect::TestThink( void )
{
int i;
float t = (gpGlobals->time - m_flStartTime);
if (m_iBeam < 24)
{
CBeam *pbeam = CBeam::BeamCreate( "sprites/lgtning.spr", 100 );
TraceResult tr;
Vector vecSrc = pev->origin;
Vector vecDir = Vector( RANDOM_FLOAT( -1.0, 1.0 ), RANDOM_FLOAT( -1.0, 1.0 ),RANDOM_FLOAT( -1.0, 1.0 ) );
vecDir = vecDir.Normalize();
UTIL_TraceLine( vecSrc, vecSrc + vecDir * 128, ignore_monsters, ENT(pev), &tr);
pbeam->PointsInit( vecSrc, tr.vecEndPos );
// pbeam->SetColor( 80, 100, 255 );
pbeam->SetColor( 255, 180, 100 );
pbeam->SetWidth( 100 );
pbeam->SetScrollRate( 12 );
m_flBeamTime[m_iBeam] = gpGlobals->time;
m_pBeam[m_iBeam] = pbeam;
m_iBeam++;
#if 0
Vector vecMid = (vecSrc + tr.vecEndPos) * 0.5;
MESSAGE_BEGIN( MSG_BROADCAST, SVC_TEMPENTITY );
WRITE_BYTE(TE_DLIGHT);
WRITE_COORD(vecMid.x); // X
WRITE_COORD(vecMid.y); // Y
WRITE_COORD(vecMid.z); // Z
WRITE_BYTE( 20 ); // radius * 0.1
WRITE_BYTE( 255 ); // r
WRITE_BYTE( 180 ); // g
WRITE_BYTE( 100 ); // b
WRITE_BYTE( 20 ); // time * 10
WRITE_BYTE( 0 ); // decay * 0.1
MESSAGE_END( );
#endif
}
if (t < 3.0)
{
for (i = 0; i < m_iBeam; i++)
{
t = (gpGlobals->time - m_flBeamTime[i]) / ( 3 + m_flStartTime - m_flBeamTime[i]);
m_pBeam[i]->SetBrightness( 255 * t );
// m_pBeam[i]->SetScrollRate( 20 * t );
}
pev->nextthink = gpGlobals->time + 0.1;
}
else
{
for (i = 0; i < m_iBeam; i++)
{
UTIL_Remove( m_pBeam[i] );
}
m_flStartTime = gpGlobals->time;
m_iBeam = 0;
// pev->nextthink = gpGlobals->time;
SetThink( NULL );
}
}
void CEgon::CreateEffect( void )
{
DestroyEffect();
m_pBeam = CBeam::BeamCreate( EGON_BEAM_SPRITE, 40 );
m_pBeam->PointEntInit( pev->origin, m_pPlayer->edict() );
m_pBeam->SetFlags( FBEAM_SINENOISE );
m_pBeam->SetEndAttachment( 1 );
m_pBeam->pev->spawnflags |= SF_BEAM_TEMPORARY; // Flag these to be destroyed on save/restore or level transition
m_pNoise = CBeam::BeamCreate( EGON_BEAM_SPRITE, 55 );
m_pNoise->PointEntInit( pev->origin, m_pPlayer->edict() );
m_pNoise->SetScrollRate( 25 );
m_pNoise->SetBrightness( 100 );
m_pNoise->SetEndAttachment( 1 );
m_pNoise->pev->spawnflags |= SF_BEAM_TEMPORARY;
m_pSprite = CSprite::SpriteCreate( EGON_FLARE_SPRITE, pev->origin, FALSE );
m_pSprite->pev->scale = 1.0;
m_pSprite->SetTransparency( kRenderGlow, 255, 255, 255, 255, kRenderFxNoDissipation );
m_pSprite->pev->spawnflags |= SF_SPRITE_TEMPORARY;
if ( m_fireMode == FIRE_WIDE )
{
m_pBeam->SetScrollRate( 50 );
m_pBeam->SetNoise( 20 );
m_pNoise->SetColor( 50, 50, 255 );
m_pNoise->SetNoise( 8 );
}
else
{
m_pBeam->SetScrollRate( 110 );
m_pBeam->SetNoise( 5 );
m_pNoise->SetColor( 80, 120, 255 );
m_pNoise->SetNoise( 2 );
}
}
BOOL CApache :: FireGun( )
{
UTIL_MakeAimVectors( pev->angles );
Vector posGun, angGun;
GetAttachment( 1, posGun, angGun );
Vector vecTarget = (m_posTarget - posGun).Normalize( );
Vector vecOut;
vecOut.x = DotProduct( gpGlobals->v_forward, vecTarget );
vecOut.y = -DotProduct( gpGlobals->v_right, vecTarget );
vecOut.z = DotProduct( gpGlobals->v_up, vecTarget );
Vector angles = UTIL_VecToAngles (vecOut);
angles.x = -angles.x;
if (angles.y > 180)
angles.y = angles.y - 360;
if (angles.y < -180)
angles.y = angles.y + 360;
if (angles.x > 180)
angles.x = angles.x - 360;
if (angles.x < -180)
angles.x = angles.x + 360;
if (angles.x > m_angGun.x)
m_angGun.x = min( angles.x, m_angGun.x + 12 );
if (angles.x < m_angGun.x)
m_angGun.x = max( angles.x, m_angGun.x - 12 );
if (angles.y > m_angGun.y)
m_angGun.y = min( angles.y, m_angGun.y + 12 );
if (angles.y < m_angGun.y)
m_angGun.y = max( angles.y, m_angGun.y - 12 );
m_angGun.y = SetBoneController( 0, m_angGun.y );
m_angGun.x = SetBoneController( 1, m_angGun.x );
Vector posBarrel, angBarrel;
GetAttachment( 0, posBarrel, angBarrel );
Vector vecGun = (posBarrel - posGun).Normalize( );
if (DotProduct( vecGun, vecTarget ) > 0.98)
{
#if 1
FireBullets( 1, posGun, vecGun, VECTOR_CONE_4DEGREES, 8192, BULLET_MONSTER_12MM, 1 );
EMIT_SOUND(ENT(pev), CHAN_WEAPON, "turret/tu_fire1.wav", 1, 0.3);
#else
static float flNext;
TraceResult tr;
UTIL_TraceLine( posGun, posGun + vecGun * 8192, dont_ignore_monsters, ENT( pev ), &tr );
if (!m_pBeam)
{
m_pBeam = CBeam::BeamCreate( "sprites/lgtning.spr", 80 );
m_pBeam->PointEntInit( pev->origin, entindex( ) );
m_pBeam->SetEndAttachment( 1 );
m_pBeam->SetColor( 255, 180, 96 );
m_pBeam->SetBrightness( 192 );
}
if (flNext < gpGlobals->time)
{
flNext = gpGlobals->time + 0.5;
m_pBeam->SetStartPos( tr.vecEndPos );
}
#endif
return TRUE;
}
else
{
if (m_pBeam)
{
UTIL_Remove( m_pBeam );
m_pBeam = NULL;
}
}
return FALSE;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGrenadeEmpProjectile::Detonate()
{
if ( ShouldNotDetonate() )
{
RemoveGrenade();
return;
}
// Explosion effect on client
// SendDispatchEffect();
float flRadius = 180;
float flDamage = 1;
if ( tf_grenade_show_radius.GetBool() )
{
DrawRadius( flRadius );
}
// Apply some amount of EMP damage to every entity in the radius. They will calculate
// their own damage based on how much ammo they have or some other wacky calculation.
CTakeDamageInfo info( this, GetThrower(), vec3_origin, GetAbsOrigin(), flDamage, /* DMG_EMP |*/ DMG_PREVENT_PHYSICS_FORCE );
CBaseEntity *pEntityList[100];
int nEntityCount = UTIL_EntitiesInSphere( pEntityList, 100, GetAbsOrigin(), flRadius, 0 );
int iEntity;
for ( iEntity = 0; iEntity < nEntityCount; ++iEntity )
{
CBaseEntity *pEntity = pEntityList[iEntity];
if ( pEntity == this )
continue;
if ( pEntity && pEntity->IsPlayer() )
continue;
if ( pEntity && ( pEntity->m_takedamage == DAMAGE_YES || pEntity->m_takedamage == DAMAGE_EVENTS_ONLY ) )
{
pEntity->TakeDamage( info );
//if ( pEntity->IsPlayer() /* || is ammo box || is enemy object */ )
{
CBeam *pBeam = CBeam::BeamCreate( "sprites/physcannon_bluelight1b.vmt", 3.0 );
if ( !pBeam )
return;
pBeam->PointsInit( GetAbsOrigin(), pEntity->WorldSpaceCenter() );
pBeam->SetColor( 255, 255, 255 );
pBeam->SetBrightness( 128 );
pBeam->SetNoise( 12.0f );
pBeam->SetEndWidth( 3.0f );
pBeam->SetWidth( 3.0f );
pBeam->LiveForTime( 0.5f ); // Fail-safe
pBeam->SetFrameRate( 25.0f );
pBeam->SetFrame( random->RandomInt( 0, 2 ) );
}
}
}
DispatchParticleEffect( "emp_shockwave", GetAbsOrigin(), vec3_angle );
UTIL_Remove( this );
#if 0
// Tell the bots an HE grenade has exploded
CTFPlayer *pPlayer = ToTFPlayer( GetThrower() );
if ( pPlayer )
{
KeyValues *pEvent = new KeyValues( "tf_weapon_grenade_detonate" );
pEvent->SetInt( "userid", pPlayer->GetUserID() );
gameeventmanager->FireEventServerOnly( pEvent );
}
#endif
}
void CNPC_Dog::ThrowObject( const char *pAttachmentName )
{
if ( m_hPhysicsEnt )
{
m_bHasObject = false;
IPhysicsObject *pPhysObj = m_hPhysicsEnt->VPhysicsGetObject();
if ( pPhysObj )
{
Vector vGunPos;
QAngle angGunAngles;
AngularImpulse angVelocity = RandomAngularImpulse( -250 , -250 ) / pPhysObj->GetMass();
InvalidateBoneCache();
int iAttachment = LookupAttachment( pAttachmentName );
if ( iAttachment == 0 )
iAttachment = m_iPhysGunAttachment;
GetAttachment( iAttachment, vGunPos, angGunAngles );
pPhysObj->Wake();
if ( pPhysObj->GetShadowController() )
{
m_hPhysicsEnt->SetParent( NULL );
m_hPhysicsEnt->SetMoveType( (MoveType_t)m_iContainerMoveType );
m_hPhysicsEnt->SetOwnerEntity( this );
pPhysObj->RemoveShadowController();
pPhysObj->SetPosition( m_hPhysicsEnt->GetLocalOrigin(), m_hPhysicsEnt->GetLocalAngles(), true );
pPhysObj->RecheckCollisionFilter();
pPhysObj->RecheckContactPoints();
}
if ( m_hThrowTarget == NULL )
#ifdef SecobMod__Enable_Fixed_Multiplayer_AI
m_hThrowTarget = UTIL_GetNearestVisiblePlayer(this);
#else
m_hThrowTarget = AI_GetSinglePlayer();
#endif //SecobMod__Enable_Fixed_Multiplayer_AI
Vector vThrowDirection;
if ( m_hThrowTarget )
{
Vector vThrowOrigin = m_hThrowTarget->GetAbsOrigin();
if ( m_hThrowTarget->IsPlayer() )
vThrowOrigin = vThrowOrigin + Vector( random->RandomFloat( -128, 128 ), random->RandomFloat( -128, 128 ), 0 );
Vector vecToss = VecCheckToss( this, vGunPos, vThrowOrigin, m_flThrowArcModifier, 1.0f, true );
if( vecToss == vec3_origin )
{
// Fix up an impossible throw so dog will at least toss the box in the target's general direction instead of dropping it.
// Also toss it up in the air so it will fall down and break. (Just throw the box up at a 45 degree angle)
Vector forward, up;
GetVectors( &forward, NULL, &up );
vecToss = forward + up;
VectorNormalize( vecToss );
vecToss *= pPhysObj->GetMass() * 30.0f;
}
vThrowDirection = vecToss + ( m_hThrowTarget->GetSmoothedVelocity() / 2 );
Vector vLinearDrag;
Vector unitVel = vThrowDirection;
VectorNormalize( unitVel );
float flTest = 1000 / vThrowDirection.Length();
float flDrag = pPhysObj->CalculateLinearDrag( vThrowDirection );
vThrowDirection = vThrowDirection + ( unitVel * ( flDrag * flDrag ) ) / flTest;
pPhysObj->SetVelocity( &vThrowDirection, &angVelocity );
m_flTimeToCatch = gpGlobals->curtime + dog_max_wait_time.GetFloat();
//Don't start pulling until the object is away from me.
//We base the time on the throw velocity.
m_flTimeToPull = gpGlobals->curtime + ( 1000 / vThrowDirection.Length() );
}
//Fire Output!
m_OnThrow.FireOutput( this, this );
ClearBeams();
if ( m_bBeamEffects == true )
{
EmitSound( "Weapon_PhysCannon.Launch" );
CBeam *pBeam = CBeam::BeamCreate( "sprites/orangelight1.vmt", 1.8 );
if ( pBeam != NULL )
{
pBeam->PointEntInit( m_hPhysicsEnt->WorldSpaceCenter(), this );
pBeam->SetEndAttachment( m_iPhysGunAttachment );
pBeam->SetWidth( 6.4 );
pBeam->SetEndWidth( 12.8 );
pBeam->SetBrightness( 255 );
pBeam->SetColor( 255, 255, 255 );
pBeam->LiveForTime( 0.2f );
pBeam->RelinkBeam();
pBeam->SetNoise( 2 );
}
Vector shotDir = ( m_hPhysicsEnt->WorldSpaceCenter() - vGunPos );
VectorNormalize( shotDir );
CPVSFilter filter( m_hPhysicsEnt->WorldSpaceCenter() );
te->GaussExplosion( filter, 0.0f, m_hPhysicsEnt->WorldSpaceCenter() - ( shotDir * 4.0f ), RandomVector(-1.0f, 1.0f), 0 );
}
}
}
}
