YGGverse
/
hlsdk-portable
mirror of https://github.com/YGGverse/hlsdk-portable.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Portable Half-Life SDK. GoldSource and Xash3D. Crossplatform.
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
609 Commits
61 Branches
7 Tags
22 MiB
Tree: 5cad247127
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '5cad247127'
${ noResults }
hlsdk-portable/dlls/flybee.cpp

1507 lines
33 KiB
Raw Normal View History Unescape

HL:Invasion Merge SERVER DLL (+vgui attack fix and all previous fixes)
2 years ago
//---------------------------------------------------------
//---------------------------------------------------------
//- ---
//- flybee.cpp ---
//- ---
//---------------------------------------------------------
//---------------------------------------------------------
//- par JujU -----------
//- julien.lecorre@free.fr -----------
//---------------------------------------------------------
//- code du monstre flybee -----------
//---------------------------------------------------------
//---------------------------------------------------------
//---------------------------------------------------------
// inclusions
#include "extdll.h"
#include "util.h"
#include "cbase.h"
#include "monsters.h"
#include "effects.h"
#include "schedule.h"
#include "weapons.h"
#include "flyingmonster.h"
#include "nodes.h"
#include "soundent.h"
extern int gmsgClientDecal;
#define FLYBEE_SPEED 150
#define PROBE_LENGTH 150
#define FEAR_LEVEL 10
#define HATE_LEVEL -10
//=========================================================
// monster-specific tasks and states
//=========================================================
enum
{
TASK_FLYBEE_CIRCLE_ENEMY = LAST_COMMON_TASK + 1,
TASK_FLYBEE_SWIM,
TASK_FLYBEE_STOP_MOVING,
TASK_FLYBEE_RUN_ATTACK,
TASK_FLYBEE_RANGE_ATTACK2,
};
//=========================================================
// Monster's Anim Events Go Here
//=========================================================
#define FLYBEE_AE_HIT 1
#define FLYBEE_AE_ATTACK1 2
#define FLYBEE_AE_ATTACK2 3
//=========================================================
// D
//=========================================================
class CFlybee : public CFlyingMonster
{
public:
void Spawn( void );
void Precache( void );
int Classify( void );
int Save( CSave &save );
int Restore( CRestore &restore );
static TYPEDESCRIPTION m_SaveData[];
CUSTOM_SCHEDULES;
void HandleAnimEvent( MonsterEvent_t *pEvent );
Schedule_t *GetSchedule( void );
Schedule_t *GetScheduleOfType ( int Type );
void StartTask( Task_t *pTask );
void RunTask( Task_t *pTask );
BOOL CheckMeleeAttack1 ( float flDot, float flDist );
BOOL CheckRangeAttack1 ( float flDot, float flDist );
BOOL CheckRangeAttack2 ( float flDot, float flDist );
Activity GetStoppedActivity( void );
void MonsterThink( void );
void Move( float flInterval );
void MoveExecute( CBaseEntity *pTargetEnt, const Vector &vecDir, float flInterval );
void Stop( void );
void Swim( void );
void SetYawSpeed( void );
float ChangeYaw( int speed );
Vector DoProbe(const Vector &Probe);
float VectorToPitch( const Vector &vec);
float FlPitchDiff( void );
float ChangePitch( int speed );
Vector m_SaveVelocity;
float m_idealDist;
float m_flMaxSpeed;
float m_flMinSpeed;
float m_flMaxDist;
Vector m_vecAttack2;
int m_iSpriteTexture;
CBeam *m_pBeam;
int m_iFear;
float m_flNextAlert;
float m_flNextAttack;
static const char *pIdleSounds[];
static const char *pAlertSounds[];
static const char *pAttackSounds[];
static const char *pBiteSounds[];
static const char *pDieSounds[];
static const char *pPainSounds[];
void IdleSound( void );
void AlertSound( void );
void AttackSound( void );
void BiteSound( void );
void DeathSound( void );
void PainSound( void );
};
LINK_ENTITY_TO_CLASS( monster_flybee, CFlybee );
TYPEDESCRIPTION CFlybee::m_SaveData[] =
{
DEFINE_FIELD( CFlybee, m_SaveVelocity, FIELD_VECTOR ),
DEFINE_FIELD( CFlybee, m_idealDist, FIELD_FLOAT ),
DEFINE_FIELD( CFlybee, m_flMaxSpeed, FIELD_FLOAT ),
DEFINE_FIELD( CFlybee, m_flMinSpeed, FIELD_FLOAT ),
DEFINE_FIELD( CFlybee, m_flMaxDist, FIELD_FLOAT ),
DEFINE_FIELD( CFlybee, m_flNextAlert, FIELD_TIME ),
DEFINE_FIELD( CFlybee, m_flNextAttack, FIELD_TIME ),
DEFINE_FIELD( CFlybee, m_iFear, FIELD_INTEGER ),
DEFINE_FIELD( CFlybee, m_vecAttack2, FIELD_VECTOR ),
};
IMPLEMENT_SAVERESTORE( CFlybee, CFlyingMonster );
class CFlyBall : public CBaseMonster
{
public :
void Spawn( void );
void Precache( void );
void EXPORT AnimateThink( void );
void EXPORT ExplodeTouch( CBaseEntity *pOther );
int Classify ( void );
static CFlyBall *CreateFlyBall( Vector vecOrigin, Vector vecAngles, entvars_s *pevOwner );
int m_iSprite;
};
LINK_ENTITY_TO_CLASS( flyball, CFlyBall );
const char *CFlybee::pIdleSounds[] =
{
"ichy/ichy_idle1.wav",
"ichy/ichy_idle2.wav",
"ichy/ichy_idle3.wav",
"ichy/ichy_idle4.wav",
};
const char *CFlybee::pAlertSounds[] =
{
"ichy/ichy_alert2.wav",
"ichy/ichy_alert3.wav",
};
const char *CFlybee::pAttackSounds[] =
{
"ichy/ichy_attack1.wav",
"ichy/ichy_attack2.wav",
};
const char *CFlybee::pBiteSounds[] =
{
"ichy/ichy_bite1.wav",
"ichy/ichy_bite2.wav",
};
const char *CFlybee::pPainSounds[] =
{
"ichy/ichy_pain2.wav",
"ichy/ichy_pain3.wav",
"ichy/ichy_pain5.wav",
};
const char *CFlybee::pDieSounds[] =
{
"ichy/ichy_die2.wav",
"ichy/ichy_die4.wav",
};
#define EMIT_ICKY_SOUND( chan, array ) \
EMIT_SOUND_DYN ( ENT(pev), chan , array [ RANDOM_LONG(0,ARRAYSIZE( array )-1) ], 1.0, 0.6, 0, RANDOM_LONG(95,105) );
void CFlybee :: IdleSound( void )
{
EMIT_ICKY_SOUND( CHAN_VOICE, pIdleSounds );
}
void CFlybee :: AlertSound( void )
{
EMIT_ICKY_SOUND( CHAN_VOICE, pAlertSounds );
}
void CFlybee :: AttackSound( void )
{
EMIT_ICKY_SOUND( CHAN_VOICE, pAttackSounds );
}
void CFlybee :: BiteSound( void )
{
EMIT_ICKY_SOUND( CHAN_WEAPON, pBiteSounds );
}
void CFlybee :: DeathSound( void )
{
EMIT_ICKY_SOUND( CHAN_VOICE, pDieSounds );
}
void CFlybee :: PainSound( void )
{
EMIT_ICKY_SOUND( CHAN_VOICE, pPainSounds );
}
//=========================================================
// Spawn
//=========================================================
void CFlybee :: Spawn()
{
Precache( );
SET_MODEL(ENT(pev), "models/flybee.mdl");
UTIL_SetSize( pev, Vector( -24, -24, 0 ), Vector( 24,24,24 ) );
pev->solid = SOLID_BBOX;
pev->movetype = MOVETYPE_FLY;
m_bloodColor = BLOOD_COLOR_GREEN;
pev->health = gSkillData.ichthyosaurHealth;
pev->view_ofs = Vector ( 0, 0, 16 );
m_flFieldOfView = VIEW_FIELD_WIDE;
m_MonsterState = MONSTERSTATE_NONE;
SetFlyingSpeed( FLYBEE_SPEED );
SetFlyingMomentum( 2.5 ); // Set momentum constant
m_afCapability = bits_CAP_MELEE_ATTACK1 | bits_CAP_RANGE_ATTACK1 | bits_CAP_RANGE_ATTACK2 | bits_CAP_SWIM;
MonsterInit();
m_idealDist = 384;
m_flMinSpeed = 80;
m_flMaxSpeed = 300;
m_flMaxDist = 384;
m_iFear = 0;
m_flNextAttack = 0;
Vector Forward;
UTIL_MakeVectorsPrivate(pev->angles, Forward, 0, 0);
pev->velocity = m_flightSpeed * Forward.Normalize();
m_SaveVelocity = pev->velocity;
}
//=========================================================
// Precache - precaches all resources this monster needs
//=========================================================
void CFlybee :: Precache()
{
PRECACHE_MODEL("models/flybee.mdl");
PRECACHE_SOUND("zombie/claw_miss2.wav");
PRECACHE_SOUND("debris/beamstart4.wav");
PRECACHE_MODEL("sprites/nhth1.spr");
PRECACHE_SOUND_ARRAY( pIdleSounds );
PRECACHE_SOUND_ARRAY( pAlertSounds );
PRECACHE_SOUND_ARRAY( pAttackSounds );
PRECACHE_SOUND_ARRAY( pBiteSounds );
PRECACHE_SOUND_ARRAY( pDieSounds );
PRECACHE_SOUND_ARRAY( pPainSounds );
UTIL_PrecacheOther ( "flyball" );
m_iSpriteTexture = PRECACHE_MODEL("sprites/shockwave.spr");
}
//=========================================================
// Classify - indicates this monster's place in the
// relationship table.
//=========================================================
int CFlybee :: Classify ( void )
{
return CLASS_ALIEN_MONSTER;
}
//=========================================================
// Check Attacks
//=========================================================
BOOL CFlybee :: CheckMeleeAttack1 ( float flDot, float flDist )
{
if ( flDist <= 64 )
{
return TRUE;
}
return FALSE;
}
BOOL CFlybee :: CheckRangeAttack1 ( float flDot, float flDist )
{
if ( !HasConditions( bits_COND_ENEMY_OCCLUDED ) && flDot > -0.7 && m_iFear <= HATE_LEVEL )
{
return TRUE;
}
return FALSE;
}
BOOL CFlybee :: CheckRangeAttack2 ( float flDot, float flDist )
{
if ( !HasConditions( bits_COND_ENEMY_OCCLUDED ) && m_iFear >= FEAR_LEVEL && m_flNextAttack < gpGlobals->time )
{
return TRUE;
}
return FALSE;
}
//=========================================================
// SetYawSpeed - allows each sequence to have a different
// turn rate associated with it.
//=========================================================
void CFlybee :: SetYawSpeed ( void )
{
pev->yaw_speed = 100;
}
//=========================================================
// HandleAnimEvent - catches the monster-specific messages
// that occur when tagged animation frames are played.
//=========================================================
void CFlybee :: HandleAnimEvent( MonsterEvent_t *pEvent )
{
switch( pEvent->event )
{
case FLYBEE_AE_HIT:
{
TraceResult tr;
UTIL_MakeVectors( pev->angles );
Vector vecStart = pev->origin;
vecStart.z += pev->size.z * 0.5;
Vector vecEnd = vecStart + (gpGlobals->v_forward * 70);
UTIL_TraceHull( vecStart, vecEnd, dont_ignore_monsters, head_hull, ENT(pev), &tr );
if ( tr.pHit )
{
CBaseEntity *pEntity = CBaseEntity::Instance( tr.pHit );
pEntity->pev->punchangle.z = 25;
pEntity->TakeDamage( pev, pev,20, DMG_CLUB );
}
break;
}
case FLYBEE_AE_ATTACK2:
{
UTIL_MakeVectors( pev->angles );
TraceResult tr;
Vector vecStart = pev->origin + gpGlobals->v_up * 24 + gpGlobals->v_forward * 32;
UTIL_TraceLine ( vecStart, m_vecAttack2, dont_ignore_monsters, dont_ignore_glass, ENT(pev), &tr );
Vector vecEnd = tr.vecEndPos;
for ( int i = 0; i<4; i ++ )
{
CBeam *pBeam = CBeam::BeamCreate( "sprites/laserbeam.spr", 8 );
if ( RANDOM_LONG(0,1) )
pBeam->SetColor( 206,118, 254 );
else
pBeam->SetColor( 223,224, 255 );
pBeam->SetBrightness( 192 );
pBeam->SetStartPos( vecStart );
pBeam->SetEndPos ( vecEnd );
pBeam->RelinkBeam( );
pBeam->SetNoise ( 30 );
pBeam->LiveForTime ( 0.35 );
}
CSprite *pSprite = CSprite::SpriteCreate ( "sprites/nhth1.spr", vecEnd, TRUE );
pSprite->AnimateAndDie ( 10 );
pSprite->SetScale ( 0.8 );
pSprite->SetTransparency ( kRenderTransAdd, 230, 255, 230, 150, kRenderFxNone );
pSprite->Expand ( pSprite->pev->scale, 120 );
MESSAGE_BEGIN( MSG_PVS, SVC_TEMPENTITY, pev->origin );
WRITE_BYTE( TE_BEAMCYLINDER );
WRITE_COORD( vecEnd.x); WRITE_COORD( vecEnd.y); WRITE_COORD( vecEnd.z);
WRITE_COORD( vecEnd.x); WRITE_COORD( vecEnd.y); WRITE_COORD( vecEnd.z + 1000 );
WRITE_SHORT( m_iSpriteTexture );
WRITE_BYTE( 0 ); // startframe
WRITE_BYTE( 0 ); // framerate
WRITE_BYTE( 2 ); // life
WRITE_BYTE( 16 ); // width
WRITE_BYTE( 0 ); // noise
WRITE_BYTE( 206 ); WRITE_BYTE( 118 ); WRITE_BYTE( 255 ); WRITE_BYTE( 80 ); // rgba
WRITE_BYTE( 0 ); // speed
MESSAGE_END();
RadiusDamage ( vecEnd, pev, pev, 50, CLASS_ALIEN_MONSTER, DMG_SHOCK );
UTIL_EmitAmbientSound( ENT(pev), vecEnd, "debris/beamstart4.wav", 0.9, ATTN_NORM, 0, RANDOM_LONG( 90, 99 ) );
break;
}
case FLYBEE_AE_ATTACK1:
{
UTIL_MakeVectors( pev->angles );
Vector vecSrc = pev->origin + gpGlobals->v_up * 24 + gpGlobals->v_forward * 32;
Vector ang = UTIL_VecToAngles( (m_hEnemy->Center() - vecSrc).Normalize() );
CFlyBall ::CreateFlyBall ( vecSrc + gpGlobals->v_right * 30, ang, pev );
CFlyBall ::CreateFlyBall ( vecSrc + gpGlobals->v_right * 10, ang, pev );
CFlyBall ::CreateFlyBall ( vecSrc - gpGlobals->v_right * 30, ang, pev );
CFlyBall ::CreateFlyBall ( vecSrc - gpGlobals->v_right * 10, ang, pev );
break;
}
default:
CFlyingMonster::HandleAnimEvent( pEvent );
break;
}
}
//=========================================================
// AI Schedules Specific to this monster
//=========================================================
static Task_t tlFlybeeSwimAround[] =
{
{ TASK_SET_ACTIVITY, (float)ACT_WALK },
{ TASK_FLYBEE_SWIM, (float)0 },
};
static Schedule_t slFlybeeSwimAround[] =
{
{
tlFlybeeSwimAround,
ARRAYSIZE(tlFlybeeSwimAround),
bits_COND_LIGHT_DAMAGE |
bits_COND_HEAVY_DAMAGE |
bits_COND_SEE_ENEMY |
bits_COND_NEW_ENEMY |
bits_COND_HEAR_SOUND,
bits_SOUND_PLAYER |
bits_SOUND_COMBAT,
"SwimAround"
},
};
static Task_t tlFlybeeSwimAgitated[] =
{
{ TASK_STOP_MOVING, (float) 0 },
{ TASK_SET_ACTIVITY, (float)ACT_WALK },
{ TASK_WAIT, (float)2.0 },
};
static Schedule_t slFlybeeSwimAgitated[] =
{
{
tlFlybeeSwimAgitated,
ARRAYSIZE(tlFlybeeSwimAgitated),
0,
0,
"SwimAgitated"
},
};
static Task_t tlFlybeeCircleEnemy[] =
{
{ TASK_SET_ACTIVITY, (float)ACT_WALK },
{ TASK_FLYBEE_CIRCLE_ENEMY, 0.0 },
};
static Schedule_t slFlybeeCircleEnemy[] =
{
{
tlFlybeeCircleEnemy,
ARRAYSIZE(tlFlybeeCircleEnemy),
bits_COND_NEW_ENEMY |
bits_COND_LIGHT_DAMAGE |
bits_COND_HEAVY_DAMAGE |
bits_COND_CAN_MELEE_ATTACK1 |
bits_COND_CAN_RANGE_ATTACK1 |
bits_COND_CAN_RANGE_ATTACK2,
0,
"CircleEnemy"
},
};
Task_t tlFlybeeTwitchDie[] =
{
{ TASK_STOP_MOVING, 0 },
{ TASK_SOUND_DIE, (float)0 },
{ TASK_DIE, (float)0 },
};
Schedule_t slFlybeeTwitchDie[] =
{
{
tlFlybeeTwitchDie,
ARRAYSIZE( tlFlybeeTwitchDie ),
0,
0,
"Die"
},
};
Task_t tlFlybeeRangeAttack1[] =
{
{ TASK_FLYBEE_STOP_MOVING, 0 },
{ TASK_FACE_ENEMY, (float)0 },
{ TASK_RANGE_ATTACK1, (float)0 },
};
Schedule_t slFlybeeRangeAttack1[] =
{
{
tlFlybeeRangeAttack1,
ARRAYSIZE( tlFlybeeRangeAttack1 ),
bits_COND_ENEMY_DEAD |
bits_COND_HEAVY_DAMAGE,
0,
"Range attack 1"
},
};
Task_t tlFlybeeRangeAttack2[] =
{
{ TASK_FLYBEE_STOP_MOVING, (float)0 },
{ TASK_FACE_ENEMY, (float)0 },
{ TASK_FLYBEE_RANGE_ATTACK2, (float)0 },
};
Schedule_t slFlybeeRangeAttack2[] =
{
{
tlFlybeeRangeAttack2,
ARRAYSIZE( tlFlybeeRangeAttack2 ),
bits_COND_ENEMY_DEAD |
bits_COND_HEAVY_DAMAGE,
0,
"Range attack 2"
},
};
Task_t tlFlybeeRunAttack[] =
{
{ TASK_SET_FAIL_SCHEDULE, (float)SCHED_RANGE_ATTACK1 },
{ TASK_FLYBEE_STOP_MOVING, (float) 0 },
{ TASK_FLYBEE_RUN_ATTACK, (float) 0 },
};
Schedule_t slFlybeeRunAttack[] =
{
{
tlFlybeeRunAttack,
ARRAYSIZE( tlFlybeeRunAttack ),
bits_COND_ENEMY_DEAD |
bits_COND_CAN_MELEE_ATTACK1 |
bits_COND_HEAVY_DAMAGE,
0,
"Range attack 2"
},
};
Task_t tlFlybeeMeleeAttack[] =
{
{ TASK_FLYBEE_STOP_MOVING, (float)0 },
{ TASK_FACE_ENEMY, (float)0 },
{ TASK_MELEE_ATTACK1, (float)0 },
};
Schedule_t slFlybeeMeleeAttack[] =
{
{
tlFlybeeMeleeAttack,
ARRAYSIZE ( tlFlybeeMeleeAttack ),
bits_COND_NEW_ENEMY |
bits_COND_ENEMY_DEAD,
0,
"Flybee Melee Attack"
},
};
DEFINE_CUSTOM_SCHEDULES(CFlybee)
{
slFlybeeSwimAround,
slFlybeeSwimAgitated,
slFlybeeCircleEnemy,
slFlybeeTwitchDie,
slFlybeeRangeAttack1,
slFlybeeRangeAttack2,
slFlybeeRunAttack,
slFlybeeMeleeAttack,
};
IMPLEMENT_CUSTOM_SCHEDULES(CFlybee, CFlyingMonster);
//=========================================================
// GetSchedule
//=========================================================
Schedule_t* CFlybee::GetSchedule()
{
switch(m_MonsterState)
{
case MONSTERSTATE_IDLE:
m_flightSpeed = 80;
return GetScheduleOfType( SCHED_IDLE_WALK );
case MONSTERSTATE_ALERT:
m_flightSpeed = 150;
return GetScheduleOfType( SCHED_IDLE_WALK );
case MONSTERSTATE_COMBAT:
m_flMaxSpeed = 400;
if ( HasConditions( bits_COND_CAN_MELEE_ATTACK1 ) )
{
// ALERT ( at_console, "MELEE1\n" );
m_iFear = Q_max ( HATE_LEVEL, m_iFear - 5 );
return GetScheduleOfType( SCHED_MELEE_ATTACK1 );
}
if ( HasConditions( bits_COND_CAN_RANGE_ATTACK1 ) )
{
// ALERT ( at_console, "ATTACK1\n" );
m_iFear = Q_min ( FEAR_LEVEL, m_iFear + 5 );
return GetScheduleOfType( SCHED_RANGE_ATTACK1 );
}
if ( HasConditions( bits_COND_CAN_RANGE_ATTACK2 ) )
{
// ALERT ( at_console, "ATTACK2\n" );
m_iFear -= 10;
m_flNextAttack = gpGlobals->time + RANDOM_FLOAT ( 3,5 );
return GetScheduleOfType( SCHED_RANGE_ATTACK2 );
}
if ( HasConditions( bits_COND_HEAVY_DAMAGE ) )
{
m_iFear = Q_min ( FEAR_LEVEL, m_iFear + 3 );
m_flightSpeed = Q_min ( m_flMaxSpeed, m_flightSpeed + 40 );
}
return GetScheduleOfType( SCHED_STANDOFF );
}
return CFlyingMonster :: GetSchedule();
}
//=========================================================
//=========================================================
Schedule_t* CFlybee :: GetScheduleOfType ( int Type )
{
switch ( Type )
{
case SCHED_IDLE_WALK:
return slFlybeeSwimAround;
case SCHED_STANDOFF:
return slFlybeeCircleEnemy;
case SCHED_FAIL:
return slFlybeeSwimAgitated;
case SCHED_DIE:
return slFlybeeTwitchDie;
case SCHED_CHASE_ENEMY:
AttackSound( );
case SCHED_MELEE_ATTACK1:
return slFlybeeMeleeAttack;
case SCHED_RANGE_ATTACK1:
return slFlybeeRangeAttack1;
case SCHED_RANGE_ATTACK2:
if ( m_hEnemy->pev->velocity.Length() <= 100 )
{
if ( (Center()-m_hEnemy->Center()).Length() <= 300 && fabs(pev->origin.z-m_hEnemy->pev->origin.z) <= 128 )
return slFlybeeRunAttack;
else
{
if ( RANDOM_LONG ( 0,2 ) == 0 )
return slFlybeeRangeAttack1;
else
return slFlybeeRangeAttack2;
}
}
else
{
return slFlybeeRangeAttack1;
}
case SCHED_BURNT:
m_flightSpeed = m_flMaxSpeed;
return slFlybeeSwimAround;
}
return CBaseMonster :: GetScheduleOfType( Type );
}
//=========================================================
// Start task - selects the correct activity and performs
// any necessary calculations to start the next task on the
// schedule.
//=========================================================
void CFlybee::StartTask(Task_t *pTask)
{
switch (pTask->iTask)
{
case TASK_FLYBEE_CIRCLE_ENEMY:
break;
case TASK_FLYBEE_SWIM:
break;
case TASK_SMALL_FLINCH:
if (m_idealDist > 128)
{
m_flMaxDist = 512;
m_idealDist = 512;
}
CFlyingMonster::StartTask(pTask);
break;
case TASK_FLYBEE_STOP_MOVING:
m_flightSpeed = 0;
if ( m_IdealActivity == m_movementActivity )
{
m_IdealActivity = GetStoppedActivity();
}
RouteClear();
TaskComplete();
break;
case TASK_FLYBEE_RUN_ATTACK:
m_IdealActivity = ACT_CROUCH;
m_flightSpeed = 128;
RouteClear();
break;
case TASK_DIE:
pev->movetype = MOVETYPE_STEP;
pev->angles.x = 0;
UTIL_SetSize( pev, Vector( -8, -8, 0 ), Vector( 8,8,8 ) );
CFlyingMonster::StartTask(pTask);
break;
case TASK_FLYBEE_RANGE_ATTACK2:
m_vecAttack2 = m_hEnemy->Center();
m_IdealActivity = ACT_RANGE_ATTACK2;
break;
default:
CFlyingMonster::StartTask(pTask);
break;
}
}
void CFlybee :: RunTask ( Task_t *pTask )
{
switch ( pTask->iTask )
{
case TASK_FLYBEE_CIRCLE_ENEMY:
if (m_hEnemy == NULL)
{
TaskComplete( );
}
else if (FVisible( m_hEnemy ))
{
// nouvelle position
Vector vecFrom = m_hEnemy->EyePosition( );
Vector vecDelta = (pev->origin - vecFrom).Normalize( );
Vector vecSwim = CrossProduct( vecDelta, Vector( 0, 0, 1 ) ).Normalize( );
if (DotProduct( vecSwim, m_SaveVelocity ) < 0)
vecSwim = vecSwim * -1.0;
Vector vecPos = vecFrom + vecDelta * m_idealDist + vecSwim * 32;
/* if (!m_pBeam)
{
m_pBeam = CBeam::BeamCreate( "sprites/laserbeam.spr", 80 );
m_pBeam->SetColor( 255, 180, 96 );
m_pBeam->SetBrightness( 192 );
}
m_pBeam->SetStartPos( m_hEnemy->Center() );
m_pBeam->SetEndPos ( vecPos );
m_pBeam->RelinkBeam( );
*/
// test de la position
TraceResult tr;
UTIL_TraceHull( vecFrom, vecPos, ignore_monsters, large_hull, m_hEnemy->edict(), &tr );
if (tr.flFraction > 0.5)
vecPos = tr.vecEndPos;
m_SaveVelocity = m_SaveVelocity * 0.8 + 0.2 * (vecPos - pev->origin).Normalize() * m_flightSpeed;
// console
/* ALERT ( at_console, "%s %c%c%c%c%c%c%c%c%c%c0%c%c%c%c%c%c%c%c%c%c - %i\n",
HasConditions( bits_COND_ENEMY_FACING_ME ) && m_hEnemy->FVisible( this ) ? "FACING " : "facing ",
m_iFear <= -10 ? '|' : '-', m_iFear <= -9 ? '|' : '-', m_iFear <= -8 ? '|' : '-',
m_iFear <= -7 ? '|' : '-', m_iFear <= -6 ? '|' : '-', m_iFear <= -5 ? '|' : '-',
m_iFear <= -4 ? '|' : '-', m_iFear <= -3 ? '|' : '-', m_iFear <= -2 ? '|' : '-',
m_iFear <= -1 ? '|' : '-', m_iFear >= 1 ? '|' : '-', m_iFear >= 2 ? '|' : '-',
m_iFear >= 3 ? '|' : '-', m_iFear >= 4 ? '|' : '-', m_iFear >= 5 ? '|' : '-',
m_iFear >= 6 ? '|' : '-', m_iFear >= 7 ? '|' : '-', m_iFear >= 8 ? '|' : '-',
m_iFear >= 9 ? '|' : '-', m_iFear >= 10 ? '|' : '-',
m_iFear);
*/
// cons
if ( m_hEnemy->MyMonsterPointer()->FInViewCone ( this ) && m_hEnemy->FVisible( this ))
{
m_flNextAlert -= 0.1;
if ( m_iFear < FEAR_LEVEL )
m_iFear ++;
if (m_idealDist < m_flMaxDist)
{
m_idealDist += 4;
}
if (m_flightSpeed < m_flMaxSpeed)
{
m_flightSpeed += 40;
}
else if (m_flightSpeed < m_flMinSpeed)
{
m_flightSpeed += 80;
}
}
else
{
m_flNextAlert += 0.1;
if ( m_iFear > HATE_LEVEL )
m_iFear --;
if (m_idealDist > 128)
{
m_idealDist -= 4;
}
if (m_flightSpeed > m_flMinSpeed)
{
m_flightSpeed -= 3;
}
}
if (m_flightSpeed < m_flMinSpeed)
{
m_flightSpeed = 128;
}
if (m_flightSpeed > m_flMaxSpeed)
{
m_flightSpeed = m_flMaxSpeed;
}
// ALERT( at_console, "%.0f\n", m_idealDist );
}
else
{
m_flNextAlert = gpGlobals->time + 0.2;
}
if (m_flNextAlert < gpGlobals->time)
{
// ALERT( at_console, "AlertSound()\n");
AlertSound( );
m_flNextAlert = gpGlobals->time + RANDOM_FLOAT( 3, 5 );
}
break;
case TASK_FLYBEE_RUN_ATTACK:
{
if (m_fSequenceFinished && m_IdealActivity == ACT_CROUCH )
{
m_IdealActivity = ACT_RUN;
}
else if (m_fSequenceFinished )
TaskComplete( );
TraceResult tr;
UTIL_TraceHull( pev->origin, m_hEnemy->Center(), ignore_monsters, large_hull, m_hEnemy->edict(), &tr );
if (tr.flFraction < 0.9)
{
// ALERT ( at_console, "RUNATTACK fails\n" );
TaskFail ();
break;
}
m_SaveVelocity = (tr.vecEndPos - pev->origin).Normalize() * m_flightSpeed;
m_flightSpeed = Q_min ( m_flMaxSpeed, m_flightSpeed *= 1.2 );
break;
}
case TASK_FLYBEE_RANGE_ATTACK2:
{
if ( m_fSequenceFinished )
{
m_Activity = ACT_RESET;
TaskComplete();
}
break;
}
case TASK_FLYBEE_SWIM:
if (m_fSequenceFinished )
{
TaskComplete( );
}
break;
case TASK_DIE:
if ( m_fSequenceFinished && m_IdealActivity == ACT_DIESIMPLE && FBitSet( pev->flags, FL_ONGROUND) )
{
pev->deadflag = DEAD_DYING;
m_IdealActivity = ACT_LAND;
ResetSequenceInfo ();
}
else if ( m_fSequenceFinished && m_IdealActivity == ACT_DIESIMPLE )
{
pev->deadflag = DEAD_DYING;
}
else if ( m_fSequenceFinished && m_IdealActivity == ACT_LAND )
{
CFlyingMonster :: RunTask ( pTask );
pev->deadflag = DEAD_DEAD;
}
break;
default:
CFlyingMonster :: RunTask ( pTask );
break;
}
}
float CFlybee::VectorToPitch( const Vector &vec )
{
float pitch;
if (vec.z == 0 && vec.x == 0)
pitch = 0;
else
{
pitch = (int) (atan2(vec.z, sqrt(vec.x*vec.x+vec.y*vec.y)) * 180 / M_PI);
if (pitch < 0)
pitch += 360;
}
return pitch;
}
//=========================================================
void CFlybee::Move(float flInterval)
{
CFlyingMonster::Move( flInterval );
}
float CFlybee::FlPitchDiff( void )
{
float flPitchDiff;
float flCurrentPitch;
flCurrentPitch = UTIL_AngleMod( pev->angles.z );
if ( flCurrentPitch == pev->idealpitch )
{
return 0;
}
flPitchDiff = pev->idealpitch - flCurrentPitch;
if ( pev->idealpitch > flCurrentPitch )
{
if (flPitchDiff >= 180)
flPitchDiff = flPitchDiff - 360;
}
else
{
if (flPitchDiff <= -180)
flPitchDiff = flPitchDiff + 360;
}
return flPitchDiff;
}
float CFlybee :: ChangePitch( int speed )
{
if ( pev->movetype == MOVETYPE_FLY )
{
float diff = FlPitchDiff();
float target = 0;
if ( m_IdealActivity != GetStoppedActivity() )
{
if (diff < -20)
target = 45;
else if (diff > 20)
target = -45;
}
pev->angles.x = UTIL_Approach(target, pev->angles.x, 220.0 * 0.1 );
}
return 0;
}
float CFlybee::ChangeYaw( int speed )
{
if ( pev->movetype == MOVETYPE_FLY )
{
float diff = FlYawDiff();
float target = 0;
if ( m_IdealActivity != GetStoppedActivity() )
{
if ( diff < -20 )
target = 20;
else if ( diff > 20 )
target = -20;
}
pev->angles.z = UTIL_Approach( target, pev->angles.z, 220.0 * 0.1 );
}
return CFlyingMonster::ChangeYaw( speed );
}
Activity CFlybee:: GetStoppedActivity( void )
{
if ( pev->movetype != MOVETYPE_FLY ) // UNDONE: Ground idle here, IDLE may be something else
return ACT_IDLE;
return ACT_WALK;
}
void CFlybee::MoveExecute( CBaseEntity *pTargetEnt, const Vector &vecDir, float flInterval )
{
m_SaveVelocity = vecDir * m_flightSpeed;
}
void CFlybee::MonsterThink ( void )
{
CFlyingMonster::MonsterThink( );
if ( pev->deadflag == DEAD_NO && m_MonsterState != MONSTERSTATE_SCRIPT )
{
Swim( );
}
}
void CFlybee :: Stop( void )
{
m_flightSpeed = 80.0;
}
void CFlybee::Swim( )
{
int retValue = 0;
Vector start = pev->origin;
Vector Angles;
Vector Forward, Right, Up;
if (FBitSet( pev->flags, FL_ONGROUND))
{
pev->angles.x = 0;
pev->angles.y += RANDOM_FLOAT( -45, 45 );
ClearBits( pev->flags, FL_ONGROUND );
Angles = Vector( -pev->angles.x, pev->angles.y, pev->angles.z );
UTIL_MakeVectorsPrivate(Angles, Forward, Right, Up);
pev->velocity = Forward * 200 + Up * 200;
return;
}
Angles = UTIL_VecToAngles( m_SaveVelocity );
Angles.x = -Angles.x;
UTIL_MakeVectorsPrivate(Angles, Forward, Right, Up);
Vector f, u, l, r, d;
f = DoProbe(start + PROBE_LENGTH * Forward);
r = DoProbe(start + PROBE_LENGTH/3 * Forward+Right);
l = DoProbe(start + PROBE_LENGTH/3 * Forward-Right);
u = DoProbe(start + PROBE_LENGTH/3 * Forward+Up);
d = DoProbe(start + PROBE_LENGTH/3 * Forward-Up);
Vector SteeringVector = f+r+l+u+d;
m_SaveVelocity = (m_SaveVelocity + SteeringVector/2).Normalize();
Angles = Vector( -pev->angles.x, pev->angles.y, pev->angles.z );
UTIL_MakeVectorsPrivate(Angles, Forward, Right, Up);
// ALERT( at_console, "%f : %f\n", Angles.x, Forward.z );
float flDot = DotProduct( Forward, m_SaveVelocity );
if (flDot > 0.5)
pev->velocity = m_SaveVelocity = m_SaveVelocity * m_flightSpeed;
else if (flDot > 0)
pev->velocity = m_SaveVelocity = m_SaveVelocity * m_flightSpeed * (flDot + 0.5);
else
pev->velocity = m_SaveVelocity = m_SaveVelocity * 80;
// ALERT( at_console, "%.0f %.0f\n", m_flightSpeed, pev->velocity.Length() );
// ALERT( at_console, "Steer %f %f %f\n", SteeringVector.x, SteeringVector.y, SteeringVector.z );
/*
m_pBeam->SetStartPos( pev->origin + pev->velocity );
m_pBeam->RelinkBeam( );
*/
// ALERT( at_console, "speed %f\n", m_flightSpeed );
Angles = UTIL_VecToAngles( m_SaveVelocity );
// Smooth Pitch
//
if (Angles.x > 180)
Angles.x = Angles.x - 360;
pev->angles.x = UTIL_Approach(Angles.x, pev->angles.x, 50 * 0.1 );
if (pev->angles.x < -80) pev->angles.x = -80;
if (pev->angles.x > 80) pev->angles.x = 80;
// Smooth Yaw and generate Roll
//
float turn = 360;
// ALERT( at_console, "Y %.0f %.0f\n", Angles.y, pev->angles.y );
if (fabs(Angles.y - pev->angles.y) < fabs(turn))
{
turn = Angles.y - pev->angles.y;
}
if (fabs(Angles.y - pev->angles.y + 360) < fabs(turn))
{
turn = Angles.y - pev->angles.y + 360;
}
if (fabs(Angles.y - pev->angles.y - 360) < fabs(turn))
{
turn = Angles.y - pev->angles.y - 360;
}
float speed = m_flightSpeed * 0.1;
// ALERT( at_console, "speed %.0f %f\n", turn, speed );
if (fabs(turn) > speed)
{
if (turn < 0.0)
{
turn = -speed;
}
else
{
turn = speed;
}
}
pev->angles.y += turn;
pev->angles.z -= turn;
pev->angles.y = fmod((pev->angles.y + 360.0), 360.0);
static float yaw_adj;
yaw_adj = yaw_adj * 0.8 + turn;
// ALERT( at_console, "yaw %f : %f\n", turn, yaw_adj );
SetBoneController( 0, -yaw_adj / 4.0 );
// Roll Smoothing
//
turn = 360;
if (fabs(Angles.z - pev->angles.z) < fabs(turn))
{
turn = Angles.z - pev->angles.z;
}
if (fabs(Angles.z - pev->angles.z + 360) < fabs(turn))
{
turn = Angles.z - pev->angles.z + 360;
}
if (fabs(Angles.z - pev->angles.z - 360) < fabs(turn))
{
turn = Angles.z - pev->angles.z - 360;
}
speed = m_flightSpeed/2 * 0.1;
if (fabs(turn) < speed)
{
pev->angles.z += turn;
}
else
{
if (turn < 0.0)
{
pev->angles.z -= speed;
}
else
{
pev->angles.z += speed;
}
}
if (pev->angles.z < -20) pev->angles.z = -20;
if (pev->angles.z > 20) pev->angles.z = 20;
UTIL_MakeVectorsPrivate( Vector( -Angles.x, Angles.y, Angles.z ), Forward, Right, Up);
// UTIL_MoveToOrigin ( ENT(pev), pev->origin + Forward * speed, speed, MOVE_STRAFE );
}
Vector CFlybee::DoProbe(const Vector &Probe)
{
Vector WallNormal = Vector(0,0,-1); // WATER normal is Straight Down for fish.
float frac;
BOOL bBumpedSomething = ProbeZ(pev->origin, Probe, &frac);
TraceResult tr;
TRACE_MONSTER_HULL(edict(), pev->origin, Probe, dont_ignore_monsters, edict(), &tr);
if ( tr.fAllSolid || tr.flFraction < 0.99 )
{
if (tr.flFraction < 0.0) tr.flFraction = 0.0;
if (tr.flFraction > 1.0) tr.flFraction = 1.0;
if (tr.flFraction < frac)
{
frac = tr.flFraction;
bBumpedSomething = TRUE;
WallNormal = tr.vecPlaneNormal;
}
}
if (bBumpedSomething && (m_hEnemy == NULL || tr.pHit != m_hEnemy->edict()))
{
Vector ProbeDir = Probe - pev->origin;
Vector NormalToProbeAndWallNormal = CrossProduct(ProbeDir, WallNormal);
Vector SteeringVector = CrossProduct( NormalToProbeAndWallNormal, ProbeDir);
float SteeringForce = m_flightSpeed * (1-frac) * (DotProduct(WallNormal.Normalize(), m_SaveVelocity.Normalize()));
if (SteeringForce < 0.0)
{
SteeringForce = -SteeringForce;
}
SteeringVector = SteeringForce * SteeringVector.Normalize();
return SteeringVector;
}
return Vector(0, 0, 0);
}
//--------------------------------------------------------------------------
CFlyBall *CFlyBall :: CreateFlyBall ( Vector vecOrigin, Vector vecAngles, entvars_s *pevOwner )
{
CFlyBall *pBall = GetClassPtr( (CFlyBall *)NULL );
UTIL_MakeAimVectors ( vecAngles );
float x, y, z;
do
{
x = RANDOM_FLOAT(-0.5,0.5) + RANDOM_FLOAT(-0.5,0.5);
y = RANDOM_FLOAT(-0.5,0.5) + RANDOM_FLOAT(-0.5,0.5);
z = x*x+y*y;
}
while (z > 1);
Vector vecDir = gpGlobals->v_forward +
x * VECTOR_CONE_6DEGREES.x * gpGlobals->v_right +
y * VECTOR_CONE_6DEGREES.y * gpGlobals->v_up;
pBall->pev->angles = UTIL_VecToAngles ( vecDir.Normalize() );
pBall->pev->angles.x = -pBall->pev->angles.x;
UTIL_SetOrigin( pBall->pev, vecOrigin );
pBall->pev->owner = ENT ( pevOwner );
pBall->Spawn();
pBall->SetTouch( &CFlyBall::ExplodeTouch );
return pBall;
}
void CFlyBall :: Spawn( void )
{
Precache( );
pev->movetype = MOVETYPE_FLY;
pev->solid = SOLID_BBOX;
pev->classname = MAKE_STRING("flyball");
SET_MODEL(ENT(pev), "sprites/muz7.spr");
pev->rendermode = kRenderTransAdd;
pev->rendercolor.x = 255;
pev->rendercolor.y = 255;
pev->rendercolor.z = 255;
pev->renderamt = 190;
pev->scale = 0.2;
UTIL_SetSize(pev, Vector( 0, 0, 0), Vector(0, 0, 0));
UTIL_SetOrigin( pev, pev->origin );
SetThink( &CFlyBall::AnimateThink );
SetTouch( &CFlyBall::ExplodeTouch );
pev->dmgtime = gpGlobals->time; // keep track of when ball spawned
pev->nextthink = gpGlobals->time + 0.1;
UTIL_MakeVectors ( pev->angles );
pev->velocity = gpGlobals->v_forward * 1000;
m_flFieldOfView = -1;
m_hEnemy = NULL;
}
int CFlyBall::Classify ( void )
{
return CLASS_ALIEN_BIOWEAPON;
}
void CFlyBall :: Precache( void )
{
PRECACHE_MODEL("sprites/xspark3.spr");
PRECACHE_SOUND("weapons/electro4.wav");
m_iSprite = PRECACHE_MODEL("sprites/muz7.spr");
}
void CFlyBall :: AnimateThink( void )
{
pev->nextthink = gpGlobals->time + 0.05;
// sprite
float delta = gpGlobals->time - pev->dmgtime;
if ( delta > 5 || pev->velocity.Length() < 10)
{
SetTouch( NULL );
UTIL_Remove( this );
}
// train
if ( delta > 0 && delta < 0.9 )
{
CSprite *pTrail = CSprite::SpriteCreate ( "sprites/xspark3.spr", pev->origin, TRUE );
pTrail->AnimateAndDie ( 22 );
pTrail->SetScale ( 0.2 );
pTrail->SetTransparency ( kRenderTransAdd, 230, 255, 230, 150, kRenderFxNone );
pTrail->Expand ( pTrail->pev->scale, 120 );
}
}
void CFlyBall::ExplodeTouch( CBaseEntity *pOther )
{
// truc affreux pour creer une particule a travers ce message pour les decals
TraceResult trace = UTIL_GetGlobalTrace( );
Vector vecNorm = trace.vecPlaneNormal.Normalize();
for ( int i = 0; i<2; i++ )
{
MESSAGE_BEGIN( MSG_ALL, gmsgClientDecal );
WRITE_COORD( trace.vecEndPos.x ); // xyz source
WRITE_COORD( trace.vecEndPos.y );
WRITE_COORD( trace.vecEndPos.z );
WRITE_COORD( vecNorm.x ); // xyz norme
WRITE_COORD( vecNorm.y );
WRITE_COORD( vecNorm.z );
WRITE_CHAR ( 'C' ); // type de texture
WRITE_BYTE ( 1 ); // 4 == electro-rocket
MESSAGE_END();
}
if (pOther->pev->takedamage)
{
if ( pOther->pev != VARS ( pev->owner ) )
{
ClearMultiDamage( );
pOther->TraceAttack(pev, 20, pev->velocity.Normalize(), &trace, DMG_ENERGYBEAM );
ApplyMultiDamage( pev, pev );
}
}
UTIL_EmitAmbientSound( ENT(pev), trace.vecEndPos, "weapons/electro4.wav", 0.3, ATTN_NORM, 0, RANDOM_LONG( 90, 99 ) );
UTIL_Remove( this );
}