void CNPC_SO_BaseZombie::ForceMove( const Vector &targetPos, const Vector &traceDir, bool bRun )
{
// Make sure our zombie gets the message (sometimes it is stubborn)
// This bit should force our zombie to listen to us
SetEnemy( NULL );
SetSchedule( SCHED_ZOMBIE_AMBUSH_MODE );
Vector chasePosition = targetPos;
Vector vUpBit = chasePosition;
vUpBit.z += 1;
trace_t tr;
AI_TraceHull( chasePosition, vUpBit, GetHullMins(), GetHullMaxs(), MASK_NPCSOLID, this, COLLISION_GROUP_NONE, &tr );
m_vecLastPosition = chasePosition;
if ( m_hCine != NULL )
ExitScriptedSequence();
SetCondition( COND_RECEIVED_ORDERS );
if ( bRun )
SetSchedule( SCHED_FORCED_GO_RUN );
else
SetSchedule( SCHED_FORCED_GO );
m_flMoveWaitFinished = gpGlobals->curtime;
}
void
ScheduleAccount::DeleteSchedule(pid_t pid,const string & tape,bool share)
{
boost::lock_guard<boost::mutex> lock(mutex_);
string schedule;
SetSchedule(schedule,tape,share);
ScheduleMap::iterator i = scheduleMap_.find(pid);
if ( scheduleMap_.end() == i ) {
LogError(pid << " : " << schedule);
return;
}
vector<string>::iterator iter = find(
i->second.begin(),
i->second.end(),
schedule );
if ( i->second.end() == iter ) {
LogError(pid << " : " << schedule);
return;
} else {
i->second.erase(iter);
return;
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CNPC_Ichthyosaur::EnsnareVictim( CBaseEntity *pVictim )
{
CBaseCombatCharacter* pBCC = (CBaseCombatCharacter *) pVictim;
if ( pBCC && pBCC->DispatchInteraction( g_interactionBarnacleVictimGrab, NULL, this ) )
{
if ( pVictim->IsPlayer() )
{
CBasePlayer *pPlayer = dynamic_cast< CBasePlayer * >((CBaseEntity *) pVictim);
if ( pPlayer )
{
m_flHoldTime = MAX( gpGlobals->curtime+3.0f, pPlayer->PlayerDrownTime() - 2.0f );
}
}
else
{
m_flHoldTime = gpGlobals->curtime + 4.0f;
}
m_pVictim = pVictim;
m_pVictim->AddSolidFlags( FSOLID_NOT_SOLID );
SetSchedule( SCHED_ICH_DROWN_VICTIM );
}
}
void SquadronClass::ShiftSchedule (void)
{
int i;
for (i=0; i<VEHICLES_PER_UNIT; i++)
{
if (!GetNumVehicles(i))
SetSchedule(i, 0xFFFFFFFF); // Nothing here, set as used.
else
ShiftSchedule(i); // [i] = sq->schedule[i] >> 1;
}
}
void
ScheduleAccount::InsertSchedule(pid_t pid,const string & tape,bool share)
{
boost::lock_guard<boost::mutex> lock(mutex_);
string schedule;
SetSchedule(schedule,tape,share);
ScheduleMap::iterator i = scheduleMap_.insert(
ScheduleMap::value_type(pid,vector<string>()) ).first;
i->second.push_back(schedule);
}
// make this alien jump off the head of the ent he's standing on
bool CASW_Alien_Jumper::DoJumpOffHead()
{
//Too soon to try to jump
if ( m_flJumpTime > gpGlobals->curtime )
return false;
if (!(GetGroundEntity()) || GetNavType() == NAV_JUMP )
return false;
// force this drone to have jumping capabilities
m_bDisableJump = false;
CapabilitiesAdd( bits_CAP_MOVE_JUMP );
//Vector vecDest = RandomVector(-1, 1);
//vecDest.z = 0;
//vecDest *= random->RandomFloat(30, 100);
Vector vecDest;
AngleVectors(GetAbsAngles(), &vecDest);
vecDest *= 200.0f;
vecDest += GetAbsOrigin();
// Try the jump
AIMoveTrace_t moveTrace;
GetMoveProbe()->MoveLimit( NAV_JUMP, GetAbsOrigin(), vecDest, MASK_NPCSOLID, NULL, &moveTrace );
//See if it succeeded
if ( IsMoveBlocked( moveTrace.fStatus ) )
{
if ( asw_debug_aliens.GetInt() == 2 )
{
NDebugOverlay::Box( vecDest, GetHullMins(), GetHullMaxs(), 255, 0, 0, 0, 5 );
NDebugOverlay::Line( GetAbsOrigin(), vecDest, 255, 0, 0, 0, 5 );
}
m_flJumpTime = gpGlobals->curtime + random->RandomFloat( 1.0f, 2.0f );
return false;
}
if ( asw_debug_aliens.GetInt() == 2 )
{
NDebugOverlay::Box( vecDest, GetHullMins(), GetHullMaxs(), 0, 255, 0, 0, 5 );
NDebugOverlay::Line( GetAbsOrigin(), vecDest, 0, 255, 0, 0, 5 );
}
//Save this jump in case the next time fails
m_vecSavedJump = moveTrace.vJumpVelocity;
m_vecLastJumpAttempt = vecDest;
SetSchedule(SCHED_ASW_ALIEN_JUMP);
m_bForcedStuckJump = true;
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pevInflictor -
// *pAttacker -
// flDamage -
// bitsDamageType -
//-----------------------------------------------------------------------------
int CNPC_Ichthyosaur::OnTakeDamage_Alive( const CTakeDamageInfo &info )
{
//Release the player if he's struck us while being held
if ( m_flHoldTime > gpGlobals->curtime )
{
ReleaseVictim();
//Don't give them as much time to flee
m_flNextBiteTime = gpGlobals->curtime + 2.0f;
SetSchedule( SCHED_ICH_THRASH );
}
return BaseClass::OnTakeDamage_Alive( info );
}
bool CASW_Alien_Jumper::DoJumpTo(Vector &vecDest)
{
//Too soon to try to jump
if ( m_flJumpTime > gpGlobals->curtime )
return false;
// only jump if you're on the ground
if (!(GetFlags() & FL_ONGROUND) || GetNavType() == NAV_JUMP )
return false;
// Don't jump if I'm not allowed
if ( ( CapabilitiesGet() & bits_CAP_MOVE_JUMP ) == false )
return false;
// Try the jump
AIMoveTrace_t moveTrace;
GetMoveProbe()->MoveLimit( NAV_JUMP, GetAbsOrigin(), vecDest, MASK_NPCSOLID, NULL, &moveTrace );
//See if it succeeded
if ( IsMoveBlocked( moveTrace.fStatus ) )
{
if ( asw_debug_aliens.GetInt() == 2 )
{
NDebugOverlay::Box( vecDest, GetHullMins(), GetHullMaxs(), 255, 0, 0, 0, 5 );
NDebugOverlay::Line( GetAbsOrigin(), vecDest, 255, 0, 0, 0, 5 );
}
m_flJumpTime = gpGlobals->curtime + random->RandomFloat( 1.0f, 2.0f );
return false;
}
if ( asw_debug_aliens.GetInt() == 2 )
{
NDebugOverlay::Box( vecDest, GetHullMins(), GetHullMaxs(), 0, 255, 0, 0, 5 );
NDebugOverlay::Line( GetAbsOrigin(), vecDest, 0, 255, 0, 0, 5 );
}
//Save this jump in case the next time fails
m_vecSavedJump = moveTrace.vJumpVelocity;
m_vecLastJumpAttempt = vecDest;
SetSchedule(SCHED_ASW_ALIEN_JUMP);
m_bForcedStuckJump = true;
//Msg("Drone saving jump vec %f %f %f\n", m_vecSavedJump.x, m_vecSavedJump.y, m_vecSavedJump.z);
return true;
}
bool CASW_Alien_Jumper::DoForcedJump( Vector &vecVelocity )
{
//Too soon to try to jump
if ( m_flJumpTime > gpGlobals->curtime )
return false;
// only jump if you're on the ground
if (!(GetFlags() & FL_ONGROUND) || GetNavType() == NAV_JUMP )
return false;
// Don't jump if I'm not allowed
if ( ( CapabilitiesGet() & bits_CAP_MOVE_JUMP ) == false )
return false;
m_vecSavedJump = vecVelocity;
m_vecLastJumpAttempt = GetAbsOrigin() + vecVelocity * 100;
SetSchedule(SCHED_ASW_ALIEN_JUMP);
m_bForcedStuckJump = true;
return true;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
bool CAI_BaseNPC::ScheduledFollowPath( int scheduleType, CBaseEntity *pPathStart, Activity movementActivity )
{
// If a behavior is active, we need to stop running it
SetPrimaryBehavior( NULL );
if ( m_NPCState == NPC_STATE_NONE )
{
// More than likely being grabbed before first think. Set ideal state to prevent schedule stomp
m_NPCState = m_IdealNPCState;
}
SetSchedule( scheduleType );
SetGoalEnt( pPathStart );
// HACKHACK: Call through TranslateNavGoal to fixup this goal position
AI_NavGoal_t goal(GOALTYPE_PATHCORNER, pPathStart->GetLocalOrigin(), movementActivity, AIN_DEF_TOLERANCE, AIN_YAW_TO_DEST);
TranslateNavGoal( pPathStart, goal.dest );
return GetNavigator()->SetGoal( goal );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
bool CAI_BaseNPC::ScheduledMoveToGoalEntity( int scheduleType, CBaseEntity *pGoalEntity, Activity movementActivity )
{
// If a behavior is active, we need to stop running it
SetPrimaryBehavior( NULL );
if ( m_NPCState == NPC_STATE_NONE )
{
// More than likely being grabbed before first think. Set ideal state to prevent schedule stomp
m_NPCState = m_IdealNPCState;
}
SetSchedule( scheduleType );
SetGoalEnt( pGoalEntity );
// HACKHACK: Call through TranslateNavGoal to fixup this goal position
// UNDONE: Remove this and have NPCs that need this functionality fix up paths in the
// movement system instead of when they are specified.
AI_NavGoal_t goal(pGoalEntity->GetAbsOrigin(), movementActivity, AIN_DEF_TOLERANCE, AIN_YAW_TO_DEST);
TranslateNavGoal( pGoalEntity, goal.dest );
return GetNavigator()->SetGoal( goal );
}
//------------------------------------------------------------------------------
// Purpose :
// Input :
// Output :
//------------------------------------------------------------------------------
void CNPC_CombineDropship::Spawn( void )
{
Precache( );
SetModel( "models/combine_dropship.mdl" );
BaseClass::Spawn();
ExtractBbox( SelectHeaviestSequence( ACT_DROPSHIP_DEPLOY_IDLE ), m_cullBoxMins, m_cullBoxMaxs );
BaseClass::Spawn();
InitPathingData( DROPSHIP_LEAD_DISTANCE, DROPSHIP_MIN_CHASE_DIST_DIFF, DROPSHIP_AVOID_DIST );
// create the correct bin for the ship to carry
switch ( m_iCrateType )
{
case CRATE_ROLLER_HOPPER:
break;
case CRATE_SOLDIER:
m_hContainer = CreateEntityByName( "prop_dynamic" );
if ( m_hContainer )
{
m_hContainer->SetModel( "models/props_junk/trashdumpster02.mdl" );
m_hContainer->SetLocalOrigin( GetAbsOrigin() );
m_hContainer->SetLocalAngles( GetLocalAngles() );
m_hContainer->SetAbsAngles( GetAbsAngles() );
m_hContainer->SetParent(this, 0);
m_hContainer->SetOwnerEntity(this);
m_hContainer->SetSolid( SOLID_VPHYSICS );
m_hContainer->Spawn();
}
break;
case CRATE_NONE:
default:
break;
}
m_iHealth = 100;
m_flFieldOfView = 0.5; // 60 degrees
m_iContainerMoveType = MOVETYPE_NONE;
//InitBoneControllers();
InitCustomSchedules();
if ( m_hContainer )
{
SetIdealActivity( (Activity)ACT_DROPSHIP_FLY_IDLE_CARGO );
}
else
{
SetIdealActivity( (Activity)ACT_DROPSHIP_FLY_IDLE_EXAGG );
}
m_flMaxSpeed = DROPSHIP_MAX_SPEED;
m_flMaxSpeedFiring = BASECHOPPER_MAX_FIRING_SPEED;
m_hPickupTarget = NULL;
//!!!HACKHACK
// This tricks the AI code that constantly complains that the vehicle has no schedule.
SetSchedule( SCHED_IDLE_STAND );
m_iLandState = LANDING_NO;
}
//-----------------------------------------------------------------------------
// Purpose: Handles all flight movement because we don't ever build paths when
// when we are flying.
// Input : flInterval - Seconds to simulate.
//-----------------------------------------------------------------------------
bool CNPC_Crow::OverrideMove( float flInterval )
{
if ( GetNavigator()->GetPath()->CurWaypointNavType() == NAV_FLY && GetNavigator()->GetNavType() != NAV_FLY )
{
SetNavType( NAV_FLY );
}
if ( IsFlying() )
{
if ( GetNavigator()->GetPath()->GetCurWaypoint() )
{
if ( m_flLastStuckCheck <= gpGlobals->curtime )
{
if ( m_vLastStoredOrigin == GetAbsOrigin() )
{
if ( GetAbsVelocity() == vec3_origin )
{
float flDamage = m_iHealth;
CTakeDamageInfo dmgInfo( this, this, flDamage, DMG_GENERIC );
GuessDamageForce( &dmgInfo, vec3_origin - Vector( 0, 0, 0.1 ), GetAbsOrigin() );
TakeDamage( dmgInfo );
return false;
}
else
{
m_vLastStoredOrigin = GetAbsOrigin();
}
}
else
{
m_vLastStoredOrigin = GetAbsOrigin();
}
m_flLastStuckCheck = gpGlobals->curtime + 1.0f;
}
if (m_bReachedMoveGoal )
{
SetIdealActivity( (Activity)ACT_CROW_LAND );
SetFlyingState( FlyState_Landing );
TaskMovementComplete();
}
else
{
SetIdealActivity ( ACT_FLY );
MoveCrowFly( flInterval );
}
}
else
{
SetSchedule( SCHED_CROW_IDLE_FLY );
SetFlyingState( FlyState_Flying );
SetIdealActivity ( ACT_FLY );
}
return true;
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CNPC_Ichthyosaur::PrescheduleThink( void )
{
BaseClass::PrescheduleThink();
//Ambient sounds
/*
if ( random->RandomInt( 0, 20 ) == 10 )
{
if ( random->RandomInt( 0, 1 ) )
{
ENVELOPE_CONTROLLER.SoundChangeVolume( m_pSwimSound, random->RandomFloat( 0.0f, 0.5f ), 1.0f );
}
else
{
ENVELOPE_CONTROLLER.SoundChangeVolume( m_pVoiceSound, random->RandomFloat( 0.0f, 0.5f ), 1.0f );
}
}
*/
//Pings
if ( m_flNextPingTime < gpGlobals->curtime )
{
m_flNextPingTime = gpGlobals->curtime + random->RandomFloat( 3.0f, 8.0f );
}
//Growls
if ( ( m_NPCState == NPC_STATE_COMBAT || m_NPCState == NPC_STATE_ALERT ) && ( m_flNextGrowlTime < gpGlobals->curtime ) )
{
m_flNextGrowlTime = gpGlobals->curtime + random->RandomFloat( 2.0f, 6.0f );
}
//Randomly emit bubbles
if ( random->RandomInt( 0, 10 ) == 0 )
{
UTIL_Bubbles( GetAbsOrigin()+(GetHullMins()*0.5f), GetAbsOrigin()+(GetHullMaxs()*0.5f), 1 );
}
//Check our water level
if ( GetWaterLevel() != 3 )
{
if ( GetWaterLevel() < 2 )
{
DevMsg( 2, "Came out of water\n" );
if ( Beached() )
{
SetSchedule( SCHED_ICH_THRASH );
Vector vecNewVelocity = GetAbsVelocity();
vecNewVelocity[2] = 8.0f;
SetAbsVelocity( vecNewVelocity );
}
}
else
{
//TODO: Wake effects
}
}
//If we have a victim, update them
if ( m_pVictim != NULL )
{
//See if it's time to release the victim
if ( m_flHoldTime < gpGlobals->curtime )
{
ReleaseVictim();
return;
}
Bite();
}
}
void web::ProcessWebClients()
{
// listen for incoming clients
EthernetClient client = m_server->available();
if (client)
{
bool bReset = false;
#ifdef ARDUINO
FILE stream_file;
FILE * pFile = &stream_file;
setup_sendbuf();
fdev_setup_stream(pFile, stream_putchar, NULL, _FDEV_SETUP_WRITE);
stream_file.udata = &client;
#else
FILE * pFile = fdopen(client.GetSocket(), "w");
#endif
freeMemory();
trace(F("Got a client\n"));
//ShowSockStatus();
KVPairs key_value_pairs;
char sPage[35];
if (!ParseHTTPHeader(client, &key_value_pairs, sPage, sizeof(sPage)))
{
trace(F("ERROR!\n"));
ServeError(pFile);
}
else
{
trace(F("Page:%s\n"), sPage);
//ShowSockStatus();
if (strcmp(sPage, "bin/setSched") == 0)
{
if (SetSchedule(key_value_pairs))
{
if (GetRunSchedules())
ReloadEvents();
ServeHeader(pFile, 200, "OK", false);
}
else
ServeError(pFile);
}
else if (strcmp(sPage, "bin/setZones") == 0)
{
if (SetZones(key_value_pairs))
{
ReloadEvents();
ServeHeader(pFile, 200, "OK", false);
}
else
ServeError(pFile);
}
else if (strcmp(sPage, "bin/delSched") == 0)
{
if (DeleteSchedule(key_value_pairs))
{
if (GetRunSchedules())
ReloadEvents();
ServeHeader(pFile, 200, "OK", false);
}
else
ServeError(pFile);
}
else if (strcmp(sPage, "bin/setQSched") == 0)
{
if (SetQSched(key_value_pairs))
{
ServeHeader(pFile, 200, "OK", false);
}
else
ServeError(pFile);
}
else if (strcmp(sPage, "bin/settings") == 0)
{
if (SetSettings(key_value_pairs))
{
ReloadEvents();
ServeHeader(pFile, 200, "OK", false);
}
else
ServeError(pFile);
}
else if (strcmp(sPage, "bin/manual") == 0)
{
if (ManualZone(key_value_pairs))
{
ServeHeader(pFile, 200, "OK", false);
}
else
ServeError(pFile);
}
else if (strcmp(sPage, "bin/run") == 0)
{
if (RunSchedules(key_value_pairs))
{
ReloadEvents();
ServeHeader(pFile, 200, "OK", false);
}
else
ServeError(pFile);
}
else if (strcmp(sPage, "bin/factory") == 0)
{
ResetEEPROM();
ReloadEvents();
ServeHeader(pFile, 200, "OK", false);
}
else if (strcmp(sPage, "bin/reset") == 0)
{
ServeHeader(pFile, 200, "OK", false);
bReset = true;
}
else if (strcmp(sPage, "json/schedules") == 0)
{
JSONSchedules(key_value_pairs, pFile);
}
else if (strcmp(sPage, "json/zones") == 0)
{
JSONZones(key_value_pairs, pFile);
}
else if (strcmp(sPage, "json/settings") == 0)
{
JSONSettings(key_value_pairs, pFile);
}
else if (strcmp(sPage, "json/state") == 0)
{
JSONState(key_value_pairs, pFile);
}
else if (strcmp(sPage, "json/schedule") == 0)
{
JSONSchedule(key_value_pairs, pFile);
}
else if (strcmp(sPage, "json/wcheck") == 0)
{
JSONwCheck(key_value_pairs, pFile);
}
#ifdef LOGGING
else if (strcmp(sPage, "json/logs") == 0)
{
JSONLogs(key_value_pairs, pFile);
}
else if (strcmp(sPage, "json/tlogs") == 0)
{
JSONtLogs(key_value_pairs, pFile);
}
#endif
else if (strcmp(sPage, "ShowSched") == 0)
{
freeMemory();
ServeSchedPage(pFile);
}
else if (strcmp(sPage, "ShowZones") == 0)
{
freeMemory();
ServeZonesPage(pFile);
}
else if (strcmp(sPage, "ShowEvent") == 0)
{
ServeEventPage(pFile);
}
else if (strcmp(sPage, "ReloadEvent") == 0)
{
ReloadEvents(true);
ServeEventPage(pFile);
}
else
{
if (strlen(sPage) == 0)
strcpy(sPage, "index.htm");
// prepend path
memmove(sPage + 5, sPage, sizeof(sPage) - 5);
memcpy(sPage, "/web/", 5);
sPage[sizeof(sPage)-1] = 0;
trace(F("Serving Page: %s\n"), sPage);
SdFile theFile;
if (!theFile.open(sPage, O_READ))
Serve404(pFile);
else
{
if (theFile.isFile())
ServeFile(pFile, sPage, theFile, client);
else
Serve404(pFile);
theFile.close();
}
}
}
#ifdef ARDUINO
flush_sendbuf(client);
// give the web browser time to receive the data
delay(1);
#else
fflush(pFile);
fclose(pFile);
#endif
// close the connection:
client.stop();
if (bReset)
sysreset();
}
}
void CASW_Alien_Jumper::WaitAndRetryJump(Vector &vecDest)
{
m_vecLastJumpAttempt = vecDest;
SetSchedule(SCHED_ASW_WAIT_AND_RETRY_JUMP);
}
// Sets schedule usage for the passed period and slot numbers
void SquadronClass::ScheduleAircraft (Flight fl, MissionRequest mis)
{
int i,j,sn,nv,nr,role,got=0;
//TJL 10/30/03
int want_alert = 0;
VehicleClassDataType *vc;
role = MissionData[mis->mission].skill;
if (MissionData[mis->mission].flags & AMIS_DONT_USE_AC)
{
// Just fill up our slots sequentially
for (i=0; i<VEHICLES_PER_UNIT; i++)
{
if (mis->aircraft < 12)
nv = 2;
else
nv = 3;
if (nv + got > mis->aircraft)
nv = mis->aircraft-got;
fl->SetNumVehicles(i,nv);
got += nv;
}
memset(fl->slots,255,PILOTS_PER_FLIGHT);
// Fake got for pilot assignments
if (got > 4)
got = 4;
}
else
{
// schedule the aircraft
for (sn=0; sn<PILOTS_PER_FLIGHT; sn++)
{
if (mis->slots[sn] < VEHICLES_PER_UNIT)
{
// KCK: Add turn-around time to final block to determine when
// aircraft will be available next
int finalBlock = mis->final_block + (AIRCRAFT_TURNAROUND_TIME_MINUTES / MIN_PLAN_AIR);
if (finalBlock >= ATM_MAX_CYCLES)
finalBlock = ATM_MAX_CYCLES;
for (j=mis->start_block; j<=mis->final_block; j++)
SetSchedule(mis->slots[sn], (1 << j));
}
}
fl->SetRoster(0);
for (i=0; i<PILOTS_PER_FLIGHT; i++)
{
if (mis->slots[i] < VEHICLES_PER_UNIT)
{
nv = GetNumVehicles(mis->slots[i]);
if (nv+got > mis->aircraft)
nv = mis->aircraft-got;
got += nv;
fl->slots[i] = mis->slots[i];
// KCK NOTE: doing this is safe, since flight isn't inserted yet.
fl->SetNumVehicles(fl->slots[i], nv);
SetAssigned (GetAssigned() + nv);
// Lower score for this role, to prevent repicks of same mission
// KCK NOTE: this is local only - other machines will not get this data
nr = FloatToInt32(0.75F * GetRating(role)) + 1;
if (nr < 1)
nr = 1;
SetRating(role, nr);
}
}
}
// Set aircraft availablity bits
for (i=0; i<PILOTS_PER_FLIGHT; i++)
{
if (i<got)
fl->plane_stats[i] = AIRCRAFT_AVAILABLE;
else
fl->plane_stats[i] = AIRCRAFT_NOT_ASSIGNED;
fl->MakeFlightDirty (DIRTY_PLANE_STATS, DDP[120].priority);
// fl->MakeFlightDirty (DIRTY_PLANE_STATS, SEND_RELIABLE);
fl->pilots[i] = NO_PILOT;
}
fl->last_player_slot = PILOTS_PER_FLIGHT;
// Large flights (i.e.: transport 'copters) only use 4 pilots
if (got > PILOTS_PER_FLIGHT)
got = PILOTS_PER_FLIGHT;
// Find and fill an empty takeoff slot at this airbase
fl->SetUnitAirbase(GetUnitAirbaseID());
// Name this flight
vc = GetVehicleClassData(fl->GetVehicleID(0));
fl->callsign_id = vc->CallsignIndex;
GetCallsignID(&fl->callsign_id,&fl->callsign_num,vc->CallsignSlots);
if (fl->callsign_num)
SetCallsignID(fl->callsign_id,fl->callsign_num);
}
void CASW_Parasite::LeapTouch( CBaseEntity *pOther )
{
m_bMidJump = false;
if ( IRelationType( pOther ) == D_HT )
{
if (m_bDefanged)
{
if ( pOther->m_takedamage != DAMAGE_NO )
{
BiteSound();
TouchDamage( pOther );
//ClearSchedule( "About to gib self" );
// gib us
CTakeDamageInfo info(NULL, NULL, Vector(0,0,0), GetAbsOrigin(), GetHealth() * 2,
DMG_ACID);
TakeDamage(info);
SetSchedule( SCHED_DIE );
return;
}
else
{
//ImpactSound();
}
}
// Don't hit if back on ground
//if ( !( GetFlags() & FL_ONGROUND ) && m_bDefanged) // if we're defanged, don't infest, just do some combat damage
//{
//}
//else
//{
//ImpactSound();
//}
}
else if( !(GetFlags() & FL_ONGROUND) )
{
// Still in the air...
if( gpGlobals->curtime < m_flIgnoreWorldCollisionTime )
{
// Headcrabs try to ignore the world, static props, and friends for a
// fraction of a second after they jump. This is because they often brush
// doorframes or props as they leap, and touching those objects turns off
// this touch function, which can cause them to hit the player and not bite.
// A timer probably isn't the best way to fix this, but it's one of our
// safer options at this point (sjb).
return;
}
if( !pOther->IsSolid() )
{
// Touching a trigger or something.
return;
}
}
// make sure we're solid
RemoveSolidFlags( FSOLID_NOT_SOLID );
// Shut off the touch function.
SetTouch( &CASW_Parasite::NormalTouch );
SetThink ( &CASW_Parasite::CallNPCThink );
SetCollisionGroup( ASW_COLLISION_GROUP_PARASITE );
// if we hit a marine, infest him and go away
NormalTouch( pOther );
}
// Prepare this talking NPC to answer question
void CAI_PlayerAlly::SetAnswerQuestion( CAI_PlayerAlly *pSpeaker )
{
if ( !m_hCine )
SetSchedule( SCHED_TALKER_IDLE_RESPONSE );
SetSpeechTarget( (CAI_BaseNPC *)pSpeaker );
}
