//-----------------------------------------------------------------------------
// Purpose:
// Input : state -
//-----------------------------------------------------------------------------
void CWeaponCrossbow::SetChargerState( ChargerState_t state )
{
// Make sure we're setup
CreateChargerEffects();
// Don't do this twice
if ( state == m_nChargeState )
return;
m_nChargeState = state;
switch( m_nChargeState )
{
case CHARGER_STATE_START_LOAD:
WeaponSound( SPECIAL1 );
// Shoot some sparks and draw a beam between the two outer points
DoLoadEffect();
break;
#ifndef CLIENT_DLL
case CHARGER_STATE_START_CHARGE:
{
if ( m_hChargerSprite == NULL )
break;
m_hChargerSprite->SetBrightness( 32, 0.5f );
m_hChargerSprite->SetScale( 0.025f, 0.5f );
m_hChargerSprite->TurnOn();
}
break;
case CHARGER_STATE_READY:
{
// Get fully charged
if ( m_hChargerSprite == NULL )
break;
m_hChargerSprite->SetBrightness( 80, 1.0f );
m_hChargerSprite->SetScale( 0.1f, 0.5f );
m_hChargerSprite->TurnOn();
}
break;
case CHARGER_STATE_DISCHARGE:
{
SetSkin( BOLT_SKIN_NORMAL );
if ( m_hChargerSprite == NULL )
break;
m_hChargerSprite->SetBrightness( 0 );
m_hChargerSprite->TurnOff();
}
break;
#endif
case CHARGER_STATE_OFF:
{
SetSkin( BOLT_SKIN_NORMAL );
#ifndef CLIENT_DLL
if ( m_hChargerSprite == NULL )
break;
m_hChargerSprite->SetBrightness( 0 );
m_hChargerSprite->TurnOff();
#endif
}
break;
default:
break;
}
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CCrossbowBolt::BoltTouch( CBaseEntity *pOther )
{
if ( pOther->IsSolidFlagSet(FSOLID_VOLUME_CONTENTS | FSOLID_TRIGGER) )
{
// Some NPCs are triggers that can take damage (like antlion grubs). We should hit them.
if ( ( pOther->m_takedamage == DAMAGE_NO ) || ( pOther->m_takedamage == DAMAGE_EVENTS_ONLY ) )
return;
}
if ( pOther->m_takedamage != DAMAGE_NO )
{
trace_t tr, tr2;
tr = BaseClass::GetTouchTrace();
Vector vecNormalizedVel = GetAbsVelocity();
ClearMultiDamage();
VectorNormalize( vecNormalizedVel );
#if defined(HL2_EPISODIC)
//!!!HACKHACK - specific hack for ep2_outland_10 to allow crossbow bolts to pass through her bounding box when she's crouched in front of the player
// (the player thinks they have clear line of sight because Alyx is crouching, but her BBOx is still full-height and blocks crossbow bolts.
if( GetOwnerEntity() && GetOwnerEntity()->IsPlayer() && pOther->Classify() == CLASS_PLAYER_ALLY_VITAL && FStrEq(STRING(gpGlobals->mapname), "ep2_outland_10") )
{
// Change the owner to stop further collisions with Alyx. We do this by making her the owner.
// The player won't get credit for this kill but at least the bolt won't magically disappear!
SetOwnerEntity( pOther );
return;
}
#endif//HL2_EPISODIC
if( GetOwnerEntity() && GetOwnerEntity()->IsPlayer() && pOther->IsNPC() )
{
CTakeDamageInfo dmgInfo( this, GetOwnerEntity(), sk_plr_dmg_crossbow.GetFloat(), DMG_NEVERGIB );
dmgInfo.AdjustPlayerDamageInflictedForSkillLevel();
CalculateMeleeDamageForce( &dmgInfo, vecNormalizedVel, tr.endpos, 0.7f );
dmgInfo.SetDamagePosition( tr.endpos );
pOther->DispatchTraceAttack( dmgInfo, vecNormalizedVel, &tr );
CBasePlayer *pPlayer = ToBasePlayer( GetOwnerEntity() );
if ( pPlayer )
{
gamestats->Event_WeaponHit( pPlayer, true, "weapon_crossbow", dmgInfo );
}
}
else
{
CTakeDamageInfo dmgInfo( this, GetOwnerEntity(), sk_plr_dmg_crossbow.GetFloat(), DMG_BULLET | DMG_NEVERGIB );
CalculateMeleeDamageForce( &dmgInfo, vecNormalizedVel, tr.endpos, 0.7f );
dmgInfo.SetDamagePosition( tr.endpos );
pOther->DispatchTraceAttack( dmgInfo, vecNormalizedVel, &tr );
}
ApplyMultiDamage();
//Adrian: keep going through the glass.
if ( pOther->GetCollisionGroup() == COLLISION_GROUP_BREAKABLE_GLASS )
return;
/*if ( !pOther->IsAlive() )
{
// We killed it!
const surfacedata_t *pdata = physprops->GetSurfaceData( tr.surface.surfaceProps );
if ( pdata->game.material == CHAR_TEX_GLASS )
{
return;
}
}*/
SetAbsVelocity( Vector( 0, 0, 0 ) );
// play body "thwack" sound
EmitSound( "Weapon_Crossbow.BoltHitBody" );
Vector vForward;
AngleVectors( GetAbsAngles(), &vForward );
VectorNormalize ( vForward );
UTIL_TraceLine( GetAbsOrigin(), GetAbsOrigin() + vForward * 128, MASK_BLOCKLOS, pOther, COLLISION_GROUP_NONE, &tr2 );
if ( tr2.fraction != 1.0f )
{
// NDebugOverlay::Box( tr2.endpos, Vector( -16, -16, -16 ), Vector( 16, 16, 16 ), 0, 255, 0, 0, 10 );
// NDebugOverlay::Box( GetAbsOrigin(), Vector( -16, -16, -16 ), Vector( 16, 16, 16 ), 0, 0, 255, 0, 10 );
if ( tr2.m_pEnt == NULL || ( tr2.m_pEnt && tr2.m_pEnt->GetMoveType() == MOVETYPE_NONE ) )
{
CEffectData data;
data.m_vOrigin = tr2.endpos;
data.m_vNormal = vForward;
data.m_nEntIndex = tr2.fraction != 1.0f;
DispatchEffect( "BoltImpact", data );
}
}
SetTouch( NULL );
SetThink( NULL );
if ( !g_pGameRules->IsMultiplayer() )
{
UTIL_Remove( this );
}
}
else
{
trace_t tr;
tr = BaseClass::GetTouchTrace();
// See if we struck the world
if ( pOther->GetMoveType() == MOVETYPE_NONE && !( tr.surface.flags & SURF_SKY ) )
{
EmitSound( "Weapon_Crossbow.BoltHitWorld" );
// if what we hit is static architecture, can stay around for a while.
Vector vecDir = GetAbsVelocity();
float speed = VectorNormalize( vecDir );
// See if we should reflect off this surface
float hitDot = DotProduct( tr.plane.normal, -vecDir );
if ( ( hitDot < 0.5f ) && ( speed > 100 ) )
{
Vector vReflection = 2.0f * tr.plane.normal * hitDot + vecDir;
QAngle reflectAngles;
VectorAngles( vReflection, reflectAngles );
SetLocalAngles( reflectAngles );
SetAbsVelocity( vReflection * speed * 0.75f );
// Start to sink faster
SetGravity( 1.0f );
}
else
{
SetThink( &CCrossbowBolt::SUB_Remove );
SetNextThink( gpGlobals->curtime + 2.0f );
//FIXME: We actually want to stick (with hierarchy) to what we've hit
SetMoveType( MOVETYPE_NONE );
Vector vForward;
AngleVectors( GetAbsAngles(), &vForward );
VectorNormalize ( vForward );
CEffectData data;
data.m_vOrigin = tr.endpos;
data.m_vNormal = vForward;
data.m_nEntIndex = 0;
DispatchEffect( "BoltImpact", data );
UTIL_ImpactTrace( &tr, DMG_BULLET );
AddEffects( EF_NODRAW );
SetTouch( NULL );
SetThink( &CCrossbowBolt::SUB_Remove );
SetNextThink( gpGlobals->curtime + 2.0f );
if ( m_pGlowSprite != NULL )
{
m_pGlowSprite->TurnOn();
m_pGlowSprite->FadeAndDie( 3.0f );
}
}
// Shoot some sparks
if ( UTIL_PointContents( GetAbsOrigin() ) != CONTENTS_WATER)
{
g_pEffects->Sparks( GetAbsOrigin() );
}
}
else
{
// Put a mark unless we've hit the sky
if ( ( tr.surface.flags & SURF_SKY ) == false )
{
UTIL_ImpactTrace( &tr, DMG_BULLET );
}
UTIL_Remove( this );
}
}
if ( g_pGameRules->IsMultiplayer() )
{
// SetThink( &CCrossbowBolt::ExplodeThink );
// SetNextThink( gpGlobals->curtime + 0.1f );
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pOther -
//-----------------------------------------------------------------------------
void CCrossbowBolt::BoltTouch( CBaseEntity *pOther )
{
if ( !pOther->IsSolid() || pOther->IsSolidFlagSet(FSOLID_VOLUME_CONTENTS) )
return;
if ( pOther->m_takedamage != DAMAGE_NO )
{
trace_t tr, tr2;
tr = BaseClass::GetTouchTrace();
Vector vecNormalizedVel = GetAbsVelocity();
ClearMultiDamage();
VectorNormalize( vecNormalizedVel );
if( GetOwnerEntity() && GetOwnerEntity()->IsPlayer() && pOther->IsNPC() )
{
CTakeDamageInfo dmgInfo( this, GetOwnerEntity(), m_iDamage, DMG_NEVERGIB );
dmgInfo.AdjustPlayerDamageInflictedForSkillLevel();
CalculateMeleeDamageForce( &dmgInfo, vecNormalizedVel, tr.endpos, 0.7f );
dmgInfo.SetDamagePosition( tr.endpos );
pOther->DispatchTraceAttack( dmgInfo, vecNormalizedVel, &tr );
}
else
{
CTakeDamageInfo dmgInfo( this, GetOwnerEntity(), m_iDamage, DMG_BULLET | DMG_NEVERGIB );
CalculateMeleeDamageForce( &dmgInfo, vecNormalizedVel, tr.endpos, 0.7f );
dmgInfo.SetDamagePosition( tr.endpos );
pOther->DispatchTraceAttack( dmgInfo, vecNormalizedVel, &tr );
}
ApplyMultiDamage();
//Adrian: keep going through the glass.
if ( pOther->GetCollisionGroup() == COLLISION_GROUP_BREAKABLE_GLASS )
return;
SetAbsVelocity( Vector( 0, 0, 0 ) );
// play body "thwack" sound
EmitSound( "Weapon_Crossbow.BoltHitBody" );
Vector vForward;
AngleVectors( GetAbsAngles(), &vForward );
VectorNormalize ( vForward );
UTIL_TraceLine( GetAbsOrigin(), GetAbsOrigin() + vForward * 128, MASK_OPAQUE, pOther, COLLISION_GROUP_NONE, &tr2 );
if ( tr2.fraction != 1.0f )
{
// NDebugOverlay::Box( tr2.endpos, Vector( -16, -16, -16 ), Vector( 16, 16, 16 ), 0, 255, 0, 0, 10 );
// NDebugOverlay::Box( GetAbsOrigin(), Vector( -16, -16, -16 ), Vector( 16, 16, 16 ), 0, 0, 255, 0, 10 );
if ( tr2.m_pEnt == NULL || ( tr2.m_pEnt && tr2.m_pEnt->GetMoveType() == MOVETYPE_NONE ) )
{
CEffectData data;
data.m_vOrigin = tr2.endpos;
data.m_vNormal = vForward;
data.m_nEntIndex = tr2.fraction != 1.0f;
DispatchEffect( "BoltImpact", data );
}
}
SetTouch( NULL );
SetThink( NULL );
UTIL_Remove( this );
}
else
{
trace_t tr;
tr = BaseClass::GetTouchTrace();
// See if we struck the world
if ( pOther->GetMoveType() == MOVETYPE_NONE && !( tr.surface.flags & SURF_SKY ) )
{
EmitSound( "Weapon_Crossbow.BoltHitWorld" );
// if what we hit is static architecture, can stay around for a while.
Vector vecDir = GetAbsVelocity();
float speed = VectorNormalize( vecDir );
// See if we should reflect off this surface
float hitDot = DotProduct( tr.plane.normal, -vecDir );
if ( ( hitDot < 0.5f ) && ( speed > 100 ) )
{
Vector vReflection = 2.0f * tr.plane.normal * hitDot + vecDir;
QAngle reflectAngles;
VectorAngles( vReflection, reflectAngles );
SetLocalAngles( reflectAngles );
SetAbsVelocity( vReflection * speed * 0.75f );
// Start to sink faster
SetGravity( 1.0f );
}
else
{
SetThink( &CCrossbowBolt::SUB_Remove );
SetNextThink( gpGlobals->curtime + 2.0f );
//FIXME: We actually want to stick (with hierarchy) to what we've hit
SetMoveType( MOVETYPE_NONE );
Vector vForward;
AngleVectors( GetAbsAngles(), &vForward );
VectorNormalize ( vForward );
CEffectData data;
data.m_vOrigin = tr.endpos;
data.m_vNormal = vForward;
data.m_nEntIndex = 0;
DispatchEffect( "BoltImpact", data );
UTIL_ImpactTrace( &tr, DMG_BULLET );
AddEffects( EF_NODRAW );
SetTouch( NULL );
SetThink( &CCrossbowBolt::SUB_Remove );
SetNextThink( gpGlobals->curtime + 2.0f );
if ( m_pGlowSprite != NULL )
{
m_pGlowSprite->TurnOn();
m_pGlowSprite->FadeAndDie( 3.0f );
}
}
// Shoot some sparks
if ( UTIL_PointContents( GetAbsOrigin() ) != CONTENTS_WATER)
{
g_pEffects->Sparks( GetAbsOrigin() );
}
}
else
{
// Put a mark unless we've hit the sky
if ( ( tr.surface.flags & SURF_SKY ) == false )
{
UTIL_ImpactTrace( &tr, DMG_BULLET );
}
UTIL_Remove( this );
}
}
if ( g_pGameRules->IsMultiplayer() )
{
// SetThink( &CCrossbowBolt::ExplodeThink );
// SetNextThink( gpGlobals->curtime + 0.1f );
}
}
//-----------------------------------------------------------------------------
// Purpose: Either become the master of a group of screens, or become a slave to another
//-----------------------------------------------------------------------------
void CMovieDisplayScreen::SetupMovie( void )
{
// Only bother if we haven't been setup yet
if ( m_bInitialized )
return;
const char *szGroupName = m_hScreenEntity->GetGroupName();
CMovieDisplayScreen *pMasterScreen = NULL;
for ( int i = 0; i < g_MovieDisplays.Count(); i++ )
{
// Must be valid and not us
if ( g_MovieDisplays[i] == NULL || g_MovieDisplays[i] == this )
continue;
// Must have an associated movie entity
if ( g_MovieDisplays[i]->m_hScreenEntity == NULL )
continue;
// Must have a group name to care
if ( szGroupName[0] == NULL )
continue;
// Group names must match!
// FIXME: Use an ID instead?
const char *szTestGroupName = g_MovieDisplays[i]->m_hScreenEntity->GetGroupName();
if ( Q_strnicmp( szTestGroupName, szGroupName, 128 ) )
continue;
// See if we've found a master display
if ( g_MovieDisplays[i]->m_bInitialized && g_MovieDisplays[i]->m_bSlaved == false )
{
m_bSlaved = true;
// Share the info from the master
m_playbackInfo = g_MovieDisplays[i]->m_playbackInfo;
// We need to calculate our own playback dimensions as we may be a different size than our parent
CalculatePlaybackDimensions( m_playbackInfo.m_nSourceWidth, m_playbackInfo.m_nSourceHeight );
// Bind our texture
m_nTextureId = surface()->CreateNewTextureID( true );
g_pMatSystemSurface->DrawSetTextureMaterial( m_nTextureId, m_playbackInfo.m_pMaterial );
// Hold this as the master screen
pMasterScreen = g_MovieDisplays[i];
break;
}
}
// We need to try again, we have no screen entity!
if ( m_hScreenEntity == NULL )
return;
// No master found, become one
if ( pMasterScreen == NULL )
{
const char *szFilename = m_hScreenEntity->GetMovieFilename();
BeginPlayback( szFilename );
m_bSlaved = false;
}
// Done
m_bInitialized = true;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CNPC_CraneDriver::SelectSchedule( void )
{
if ( HasSpawnFlags(SF_VEHICLEDRIVER_INACTIVE) )
return BaseClass::SelectSchedule();
// If we've got an object to pickup, so go get it
if ( m_hPickupTarget )
{
// Only clear the pickup target if we managed to pick something up
if ( m_hCrane->GetTotalMassOnCrane() > 0 )
{
if ( m_bForcedPickup )
{
m_OnPickedUpObject.FireOutput( m_hPickupTarget, this );
}
// Remember what we dropped so we go try something else if we can.
m_PreviouslyPickedUpObjects.AddToTail( m_hPickupTarget );
m_hPickupTarget = NULL;
}
else
{
if ( m_NPCState == NPC_STATE_IDLE )
{
m_IdealNPCState = NPC_STATE_ALERT;
}
return SCHED_CRANE_PICKUP_OBJECT;
}
}
// If we're currently being forced to pickup something, do only that
if ( m_bForcedPickup )
{
if ( m_hPickupTarget )
return SCHED_CRANE_PICKUP_OBJECT;
// We've picked up our target, we're waiting to be told where to put it
return SCHED_IDLE_STAND;
}
// If we've been told to drop something off, do that
if ( m_bForcedDropoff )
return SCHED_CRANE_FORCED_DROP;
switch ( m_NPCState )
{
case NPC_STATE_IDLE:
break;
case NPC_STATE_ALERT:
break;
case NPC_STATE_COMBAT:
if ( HasCondition( COND_CAN_RANGE_ATTACK1 ) )
{
// Do we have anything on the crane? If not, look for something
if ( m_hCrane->GetTotalMassOnCrane() == 0 )
return SCHED_CRANE_FIND_LARGE_OBJECT;
// We've got something on the crane, so try and drop it on the enemy
return SCHED_CRANE_RANGE_ATTACK1;
}
// We can't attack him, so if we don't have anything on the crane, grab something
if ( m_hCrane->GetTotalMassOnCrane() == 0 )
return SCHED_CRANE_FIND_LARGE_OBJECT;
}
return BaseClass::SelectSchedule();
}
//------------------------------------------------------------------------------
// Purpose :
// Input :
// Output :
//------------------------------------------------------------------------------
void CPointSpotlight::SpotlightCreate(void)
{
if ( m_hSpotlightTarget.Get() != NULL )
return;
AngleVectors( GetAbsAngles(), &m_vSpotlightDir );
trace_t tr;
UTIL_TraceLine( GetAbsOrigin(), GetAbsOrigin() + m_vSpotlightDir * m_flSpotlightMaxLength, MASK_NPCSOLID_BRUSHONLY, this, COLLISION_GROUP_NONE, &tr);
m_hSpotlightTarget = (CSpotlightEnd*)CreateEntityByName( "spotlight_end" );
m_hSpotlightTarget->Spawn();
m_hSpotlightTarget->SetAbsOrigin( tr.endpos );
m_hSpotlightTarget->SetOwnerEntity( this );
m_hSpotlightTarget->m_clrRender = m_clrRender;
m_hSpotlightTarget->m_Radius = m_flSpotlightMaxLength;
if ( FBitSet (m_spawnflags, SF_SPOTLIGHT_NO_DYNAMIC_LIGHT) )
{
m_hSpotlightTarget->m_flLightScale = 0.0;
}
//m_hSpotlight = CBeam::BeamCreate( "sprites/spotlight.vmt", m_flSpotlightGoalWidth );
m_hSpotlight = CBeam::BeamCreate( "sprites/glow_test02.vmt", m_flSpotlightGoalWidth );
// Set the temporary spawnflag on the beam so it doesn't save (we'll recreate it on restore)
m_hSpotlight->SetHDRColorScale( m_flHDRColorScale );
m_hSpotlight->AddSpawnFlags( SF_BEAM_TEMPORARY );
m_hSpotlight->SetColor( m_clrRender->r, m_clrRender->g, m_clrRender->b );
m_hSpotlight->SetHaloTexture(m_nHaloSprite);
m_hSpotlight->SetHaloScale(60);
m_hSpotlight->SetEndWidth(m_flSpotlightGoalWidth);
m_hSpotlight->SetBeamFlags( (FBEAM_SHADEOUT|FBEAM_NOTILE) );
m_hSpotlight->SetBrightness( 64 );
m_hSpotlight->SetNoise( 0 );
m_hSpotlight->EntsInit( this, m_hSpotlightTarget );
}
int wmain(int argc, wchar_t* argv[])
{
// Initialize COM and deinitialize when we go out of scope
HRESULT hrCoInit = ::CoInitializeEx(nullptr, COINIT_APARTMENTTHREADED | COINIT_DISABLE_OLE1DDE);
shared_ptr<HRESULT> spCoInit(&hrCoInit, [](const HRESULT* hrCom) -> void { if (SUCCEEDED(*hrCom)) { ::CoUninitialize(); } });
{
// Set a close handler to shutdown the chrome instance we launch
::SetConsoleCtrlHandler(OnClose, TRUE);
// Launch chrome
{
CString chromePath;
// Find the chrome install location via the registry
CString keyPath = L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\App Paths\\chrome.exe";
CRegKey regKey;
// First see if we can find where Chrome is installed from the registry. This will only succeed if Chrome is installed for all users
if (regKey.Open(HKEY_LOCAL_MACHINE, keyPath, KEY_READ) == ERROR_SUCCESS)
{
ULONG bufferSize = MAX_PATH;
CString path;
LRESULT result = regKey.QueryStringValue(nullptr, path.GetBufferSetLength(bufferSize), &bufferSize);
path.ReleaseBufferSetLength(bufferSize);
if (result == ERROR_SUCCESS)
{
chromePath = path;
}
}
if (chromePath.GetLength() == 0)
{
// If Chrome is only installed for the current user, look in \AppData\Local\Google\Chrome\Application\ for Chrome.exe
CString appPath;
::SHGetFolderPath(NULL, CSIDL_LOCAL_APPDATA, NULL, SHGFP_TYPE_CURRENT, appPath.GetBuffer(MAX_PATH + 1));
appPath.ReleaseBuffer();
chromePath = appPath + L"\\Google\\Chrome\\Application\\chrome.exe";
}
// Get a temp location
CString temp;
Helpers::ExpandEnvironmentString(L"%Temp%", temp);
// Set arguments for the chrome that we launch
CString arguments;
arguments.Format(L"about:blank --remote-debugging-port=9223 --window-size=0,0 --silent-launch --no-first-run --no-default-browser-check --user-data-dir=\"%s\"", temp);
// Launch the process
STARTUPINFO si = { 0 };
PROCESS_INFORMATION pi = { 0 };
si.cb = sizeof(si);
si.wShowWindow = SW_MINIMIZE;
BOOL result = ::CreateProcess(
chromePath,
arguments.GetBuffer(),
nullptr,
nullptr,
FALSE,
0,
nullptr,
temp,
&si,
&pi);
arguments.ReleaseBuffer();
if (result)
{
// Store the handles
CHandle hThread(pi.hThread);
hChromeProcess.Attach(pi.hProcess);
DWORD waitResult = ::WaitForInputIdle(hChromeProcess, 30000);
}
else
{
std::cerr << "Could not open Chrome. Please ensure that Chrome is installed." << std::endl;
system("pause");
return -1;
}
}
// Get the current path that we are running from
CString fullPath;
DWORD count = ::GetModuleFileName(nullptr, fullPath.GetBuffer(MAX_PATH), MAX_PATH);
fullPath.ReleaseBufferSetLength(count);
LPWSTR buffer = fullPath.GetBuffer();
LPWSTR newPath = ::PathFindFileName(buffer);
if (newPath && newPath != buffer)
{
fullPath.ReleaseBufferSetLength((newPath - buffer));
}
else
{
fullPath.ReleaseBuffer();
}
// Load the proxy server
IEDiagnosticsAdapter proxy(fullPath);
// Create a message pump
MSG msg;
::PeekMessage(&msg, NULL, WM_USER, WM_USER, PM_NOREMOVE);
// Thread message loop
BOOL getMessageRet;
while ((getMessageRet = ::GetMessage(&msg, NULL, 0, 0)) != 0)
{
if (getMessageRet != -1)
{
::TranslateMessage(&msg);
::DispatchMessage(&msg);
}
}
// Leave the window open so we can read the log file
wcout << endl << L"Press [ENTER] to exit." << endl;
cin.ignore();
}
return 0;
}
void usbdrv_thread(USB_DRV_INFO drv_info)
{
CHandle helper;
CHandle req_hnd;
USBGenericRequest request;
bool requested = false;
unsigned int sig=0;
ALLOCATE_SIGNAL(USB_DRIVER_SIG);
helper.tsk_safe_open(drv_info->info.drv_index, 0);
helper.tsk_start_command(NULL, 0);
req_hnd.tsk_safe_open(drv_info->info.drv_index, USB_DRV_MODE(EPT_0, EPT_0));
while(1)
{
sig |= tsk_get_signal(SIGNAL_ANY);
// 2) get waiting clients
if(sig & helper.signal)
{
HANDLE client;
sig ^= helper.signal;
helper.res &= ~FLG_SIGNALED;
client = (HANDLE)helper.dst.as_voidptr;
if(client)
{
RES_CODE res;
res = ((USB_API_FUNC)client->src.as_voidptr)(drv_info, client);
if(res & FLG_SIGNALED)
{
tsk_HND_SET_STATUS(client, res);
}
}
helper.tsk_start_command(NULL, 0);
}
if(sig & req_hnd.signal)
{
sig ^= req_hnd.signal;
req_hnd.res &= ~FLG_SIGNALED;
#if USB_ENABLE_DEVICE
TRACE1_USB(" | req:");
if(req_hnd.res == RES_OK)
{
drv_info->drv_data->device.RequestHandler(drv_info, &request, &req_hnd);
} else
#endif
{
TRACE_USB(" res %x", req_hnd.res);
tsk_sleep(5);
}
requested = false;
}
if(!requested)
{
#if USB_ENABLE_HOST
if(sig == USB_DRIVER_SIG)
{
if(drv_info->drv_data->otg_h_sig & OTG_H_SIG_CON)
{
do
{
sig = atomic_fetch((volatile int*)&drv_info->drv_data->otg_h_sig);
sig &= ~OTG_H_SIG_CON;
} while(atomic_store((volatile int*)&drv_info->drv_data->otg_h_sig, sig));
//wait 1s for connect
for(int retries =0; retries <10; ++retries)
{
if(drv_info->drv_data->otg_flags & USB_OTG_FLG_HOST_RST)
break;
sig = tsk_wait_signal(USB_DRIVER_SIG, 100);
if (sig)
break;
}
if( !(drv_info->drv_data->otg_h_sig & OTG_H_SIG_RST))
{
usb_api_otg_off(drv_info, NULL);
}
}
if(drv_info->drv_data->otg_h_sig & OTG_H_SIG_RST)
{
do
{
sig = atomic_fetch((volatile int*)&drv_info->drv_data->otg_h_sig);
sig &= ~OTG_H_SIG_RST;
} while(atomic_store((volatile int*)&drv_info->drv_data->otg_h_sig, sig));
if(drv_info->drv_data->otg_flags & USB_OTG_FLG_HOST_RST)
{
RES_CODE res;
// Reset requested
for(int retries =0; retries <3; ++retries)
{
tsk_sleep(100);
res = usb_host_reset_bus(drv_info, &req_hnd);
if( res == RES_OK)
break;
}
// if(res != RES_OK)
// usb_api_otg_off(drv_info, NULL);
}
}
if(drv_info->drv_data->otg_h_sig & OTG_H_SIG_RESUME)
{
do
{
sig = atomic_fetch((volatile int*)&drv_info->drv_data->otg_h_sig);
sig &= ~OTG_H_SIG_RESUME;
} while(atomic_store((volatile int*)&drv_info->drv_data->otg_h_sig, sig));
usb_hal_host_resume(drv_info);
}
sig = 0;
}
if(drv_info->drv_data->otg_flags & USB_OTG_FLG_DEV_OK)
{
req_hnd.mode.as_ushort[1] = drv_info->drv_data->drv_state_cnt;
#endif
req_hnd.tsk_start_read(&request, 8);
TRACE_USB_NAME(drv_info);
TRACE1_USB(" st req:");
requested = true;
#if USB_ENABLE_HOST
}
#endif
}
}
}
void CWeaponEgon::Fire( const Vector &vecOrigSrc, const Vector &vecDir )
{
CBasePlayer *pPlayer = ToBasePlayer( GetOwner() );
if ( !pPlayer )
{
return;
}
//CSoundEnt::InsertSound( SOUND_COMBAT, GetAbsOrigin(), 450, 0.1 );
WeaponSound( SINGLE );
Vector vecDest = vecOrigSrc + (vecDir * MAX_TRACE_LENGTH);
trace_t tr;
UTIL_TraceLine( vecOrigSrc, vecDest, MASK_SHOT, pPlayer, COLLISION_GROUP_NONE, &tr );
if ( tr.allsolid )
return;
CBaseEntity *pEntity = tr.m_pEnt;
if ( pEntity == NULL )
return;
if ( g_pGameRules->IsMultiplayer() )
{
if ( m_hSprite )
{
if ( pEntity->m_takedamage != DAMAGE_NO )
{
m_hSprite->TurnOn();
}
else
{
m_hSprite->TurnOff();
}
}
}
if ( m_flDmgTime < gpGlobals->curtime )
{
// wide mode does damage to the ent, and radius damage
if ( pEntity->m_takedamage != DAMAGE_NO )
{
ClearMultiDamage();
CTakeDamageInfo info(this, pPlayer, sk_plr_dmg_egon_wide.GetFloat() * g_pGameRules->GetDamageMultiplier(), DMG_ENERGYBEAM | DMG_ALWAYSGIB | DMG_CRUSH);
CalculateMeleeDamageForce( &info, vecDir, tr.endpos );
pEntity->DispatchTraceAttack( info, vecDir, &tr );
ApplyMultiDamage();
}
if ( g_pGameRules->IsMultiplayer() )
{
// radius damage a little more potent in multiplayer.
#ifndef CLIENT_DLL
RadiusDamage(CTakeDamageInfo(this, pPlayer, sk_plr_dmg_egon_wide.GetFloat() * g_pGameRules->GetDamageMultiplier() / 4, DMG_ENERGYBEAM | DMG_BLAST | DMG_ALWAYSGIB | DMG_CRUSH), tr.endpos, 128, CLASS_NONE, NULL);
#endif
}
if ( !pPlayer->IsAlive() )
return;
if ( g_pGameRules->IsMultiplayer() )
{
//multiplayer uses 5 ammo/second
if ( gpGlobals->curtime >= m_flAmmoUseTime )
{
UseAmmo( 1 );
m_flAmmoUseTime = gpGlobals->curtime + 0.2;
}
}
else
{
// Wide mode uses 10 charges per second in single player
if ( gpGlobals->curtime >= m_flAmmoUseTime )
{
UseAmmo( 1 );
m_flAmmoUseTime = gpGlobals->curtime + 0.1;
}
}
m_flDmgTime = gpGlobals->curtime + EGON_DISCHARGE_INTERVAL;
if ( m_flShakeTime < gpGlobals->curtime )
{
#ifndef CLIENT_DLL
UTIL_ScreenShake( tr.endpos, 5.0, 150.0, 0.75, 250.0, SHAKE_START );
#endif
m_flShakeTime = gpGlobals->curtime + 1.5;
}
}
Vector vecUp, vecRight;
QAngle angDir;
VectorAngles( vecDir, angDir );
AngleVectors( angDir, NULL, &vecRight, &vecUp );
Vector tmpSrc = vecOrigSrc + (vecUp * -8) + (vecRight * 3);
UpdateEffect( tmpSrc, tr.endpos );
}
bool CObjectTunnelTrigger::KeepTunneling( TunnelPlayer *tunnel )
{
if ( !tunnel || ( tunnel->player == NULL ) )
{
return false;
}
float remaining = tunnel->teleporttime - gpGlobals->curtime + 0.5f;
remaining = max( 0.0f, remaining );
tunnel->iremaining = (int)( remaining );
if ( !tunnel->exitstarted )
{
if ( gpGlobals->curtime > tunnel->fadeintime )
{
tunnel->exitstarted = true;
// Fade user screen to black
color32 black = {0,0,0,255};
UTIL_ScreenFade( tunnel->player, black, tunnel->fadetime, 0.0, FFADE_IN | FFADE_PURGE );
// Move to tunnel exit spot now that we're half-way through teleport
if ( m_hTunnelExit != NULL )
{
tunnel->player->EnableControl( true );
tunnel->player->RemoveEffects( EF_NODRAW );
// Change the player to non-solid before the teleport, so the physics system doesn't think he
// actually moved this distance:
int OriginalSolidFlags = tunnel->player->GetSolidFlags();
tunnel->player->AddSolidFlags( FSOLID_NOT_SOLID);
// Do a placement test to prevent the player from teleporting inside another player, the ground, or just to help
// prevent badly placed tunnels from causing stuck situations.
Vector vTarget = m_hTunnelExit->GetAbsOrigin();
Vector vOriginal = vTarget;
if ( !EntityPlacementTest( tunnel->player, vOriginal, vTarget, true ) )
{
Warning("Couldn't place entity after tunnel teleport.\n");
}
tunnel->player->Teleport( &vTarget /*m_hTunnelExit->GetAbsOrigin()*/, &m_hTunnelExit->GetAbsAngles(), NULL );
tunnel->player->SnapEyeAngles( m_hTunnelExit->GetAbsAngles() );
tunnel->player->SetAbsVelocity( vec3_origin );
// Restore the player's solid flags.
tunnel->player->SetSolidFlags(OriginalSolidFlags);
}
}
// Can't quite do this because the player's weapons are still visible flying across the map even if
// he is hidden
#if 0
else if ( gpGlobals->curtime > tunnel->tunnelstarted + tunnel->fadetime )
{
float travel_time = tunnel->duration - 2 * tunnel->fadetime;
if ( travel_time > 0.0f )
{
float f = ( gpGlobals->curtime - tunnel->tunnelstarted - tunnel->fadetime ) / travel_time;
f = clamp( f, 0.0f, 1.0f );
if ( m_hTunnelExit != NULL )
{
Vector delta = m_hTunnelExit->GetAbsOrigin() - tunnel->startpos;
Vector currentPos;
VectorMA( tunnel->startpos, f, delta, currentPos );
tunnel->player->Teleport( ¤tPos, NULL, NULL );
}
}
}
#endif
}
if ( tunnel->ilastremaining != tunnel->iremaining &&
tunnel->needremainigcounter &&
tunnel->iremaining >= 1 &&
tunnel->player != NULL )
{
// Counter
ClientPrint( tunnel->player, HUD_PRINTCENTER, UTIL_VarArgs("\nExiting tunnel in %d %s\n", tunnel->iremaining, tunnel->iremaining > 1 ? "seconds" : "second" ) );
}
tunnel->ilastremaining = tunnel->iremaining;
// TODO: Play footstep or some other teleport sounds occasionaly to this player?
bool done = ( gpGlobals->curtime > tunnel->teleporttime ) ? true : false;
if ( done )
{
color32 black = {0,0,0,255};
UTIL_ScreenFade( tunnel->player, black, 0.0f, 0.0f, FFADE_IN | FFADE_PURGE );
tunnel->player->SetMoveType( MOVETYPE_WALK );
tunnel->player->EnableControl( true );
tunnel->player->RemoveEffects( EF_NODRAW );
tunnel->player->RemoveSolidFlags( FSOLID_NOT_SOLID );
// TODO: Play an exit sound??
OnTunnelTriggerEnd.FireOutput( tunnel->player, this );
}
return !done;
}
void CGameServer::LoadLevel(const CHandle<CLevel>& pLevel)
{
// Create and name the entities first and add them to this array. This way we avoid a problem where
// one entity needs to connect to another entity which has not yet been created.
tmap<size_t, CBaseEntity*> apEntities;
// Do a quick precache now to load default models and such. Another precache will come later.
const auto& aEntities = pLevel->GetEntityData();
for (size_t i = 0; i < aEntities.size(); i++)
AddToPrecacheList("C" + aEntities[i].GetClass());
PrecacheList();
m_bAllowPrecaches = true;
for (size_t i = 0; i < aEntities.size(); i++)
{
const CLevelEntity* pLevelEntity = &aEntities[i];
tstring sClass = "C" + pLevelEntity->GetClass();
auto it = CBaseEntity::GetEntityRegistration().find(sClass);
TAssert(it != CBaseEntity::GetEntityRegistration().end());
if (it == CBaseEntity::GetEntityRegistration().end())
{
TError("Unregistered entity '" + sClass + "'\n");
continue;
}
AddToPrecacheList("C" + aEntities[i].GetClass());
CBaseEntity* pEntity = Create<CBaseEntity>(sClass.c_str());
apEntities[i] = pEntity;
pEntity->SetName(pLevelEntity->GetName());
// Process outputs here so that they exist when handle callbacks run.
for (size_t k = 0; k < pLevelEntity->GetOutputs().size(); k++)
{
auto pOutput = &pLevelEntity->GetOutputs()[k];
tstring sValue = pOutput->m_sOutput;
CSaveData* pSaveData = CBaseEntity::FindOutput(pEntity->GetClassName(), sValue);
TAssert(pSaveData);
if (!pSaveData)
{
TError("Unknown output '" + sValue + "'\n");
continue;
}
tstring sTarget = pOutput->m_sTargetName;
tstring sInput = pOutput->m_sInput;
tstring sArgs = pOutput->m_sArgs;
bool bKill = pOutput->m_bKill;
if (!sTarget.length())
{
TUnimplemented();
TError("Output '" + sValue + "' of entity '" + pEntity->GetName() + "' (" + pEntity->GetClassName() + ") is missing a target.\n");
continue;
}
if (!sInput.length())
{
TUnimplemented();
TError("Output '" + sValue + "' of entity '" + pEntity->GetName() + "' (" + pEntity->GetClassName() + ") is missing an input.\n");
continue;
}
pEntity->AddOutputTarget(sValue, sTarget, sInput, sArgs, bKill);
}
}
for (auto it = apEntities.begin(); it != apEntities.end(); it++)
{
auto pLevelEntity = &aEntities[it->first];
CBaseEntity* pEntity = it->second;
// Force physics related stuff first so it's available if there's a physics model.
auto itScale = pLevelEntity->GetParameters().find("Scale");
if (itScale != pLevelEntity->GetParameters().end())
UnserializeParameter("Scale", itScale->second, pEntity);
auto itOrigin = pLevelEntity->GetParameters().find("Origin");
if (itOrigin != pLevelEntity->GetParameters().end())
UnserializeParameter("Origin", itOrigin->second, pEntity);
for (auto it = pLevelEntity->GetParameters().begin(); it != pLevelEntity->GetParameters().end(); it++)
{
tstring sHandle = it->first;
tstring sValue = it->second;
if (sHandle == "MoveParent")
continue;
if (sHandle == "Scale")
continue;
if (sHandle == "Origin")
continue;
UnserializeParameter(sHandle, sValue, pEntity);
}
}
for (auto it = apEntities.begin(); it != apEntities.end(); it++)
{
auto pLevelEntity = &aEntities[it->first];
CBaseEntity* pEntity = it->second;
// Force MoveParent last so that global -> local conversion is performed.
auto itMoveParent = pLevelEntity->GetParameters().find("MoveParent");
if (itMoveParent != pLevelEntity->GetParameters().end())
UnserializeParameter("MoveParent", itMoveParent->second, pEntity);
}
for (size_t i = 0; i < apEntities.size(); i++)
apEntities[i]->PostLoad();
if (CWorkbench::IsActive())
CWorkbench::LoadLevel(pLevel);
}
int wmain(int argc, wchar_t* argv[])
{
//::MessageBox(NULL, L"Stop here", L"STOP!", MB_ICONWARNING | MB_CANCELTRYCONTINUE | MB_DEFBUTTON3);
std:cout << "Edge Diagnostics Adapter" << std::endl;
po::options_description desc("Allowed options");
desc.add_options()
("help,h", "Prints this help text.")
("launch,l", po::value<string>(), "Launches Edge. Optionally at the URL specified in the value")
("killall,k", "Kills all running Edge processes.")
("chrome,c", "Launches Crhome in the background to serve the Chrome Developer Tools frontend.")
("port,p", po::value<string>(), "The port number to listen on. Default is 9222.");
po::variables_map vm;
try
{
po::store(po::parse_command_line(argc, argv, desc), vm);
}
catch (po::error& e)
{
std::cerr << "ERROR: " << e.what() << std::endl << std::endl;
std::cerr << desc << std::endl;
return E_FAIL;
}
if (vm.count("help"))
{
std::cout << desc << std::endl;
return S_OK;
}
// Initialize COM and deinitialize when we go out of scope
HRESULT hrCoInit = ::CoInitializeEx(nullptr, COINIT_APARTMENTTHREADED | COINIT_DISABLE_OLE1DDE);
shared_ptr<HRESULT> spCoInit(&hrCoInit, [](const HRESULT* hrCom) -> void { if (SUCCEEDED(*hrCom)) { ::CoUninitialize(); } });
{
// Set a close handler to shutdown the chrome instance we launch
::SetConsoleCtrlHandler(OnClose, TRUE);
// Launch chrome
if (vm.count("chrome"))
{
CString chromePath;
// Find the chrome install location via the registry
CString keyPath = L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\App Paths\\chrome.exe";
CRegKey regKey;
// First see if we can find where Chrome is installed from the registry. This will only succeed if Chrome is installed for all users
if (regKey.Open(HKEY_LOCAL_MACHINE, keyPath, KEY_READ) == ERROR_SUCCESS)
{
ULONG bufferSize = MAX_PATH;
CString path;
LRESULT result = regKey.QueryStringValue(nullptr, path.GetBufferSetLength(bufferSize), &bufferSize);
path.ReleaseBufferSetLength(bufferSize);
if (result == ERROR_SUCCESS)
{
chromePath = path;
}
}
if (chromePath.GetLength() == 0)
{
// If Chrome is only installed for the current user, look in \AppData\Local\Google\Chrome\Application\ for Chrome.exe
CString appPath;
::SHGetFolderPath(NULL, CSIDL_LOCAL_APPDATA, NULL, SHGFP_TYPE_CURRENT, appPath.GetBuffer(MAX_PATH + 1));
appPath.ReleaseBuffer();
chromePath = appPath + L"\\Google\\Chrome\\Application\\chrome.exe";
}
// Get a temp location
CString temp;
Helpers::ExpandEnvironmentString(L"%Temp%", temp);
// Set arguments for the chrome that we launch
CString arguments;
arguments.Format(L"about:blank --remote-debugging-port=9223 --window-size=0,0 --silent-launch --no-first-run --no-default-browser-check --user-data-dir=\"%s\"", temp);
// Launch the process
STARTUPINFO si = { 0 };
PROCESS_INFORMATION pi = { 0 };
si.cb = sizeof(si);
si.wShowWindow = SW_MINIMIZE;
BOOL result = ::CreateProcess(
chromePath,
arguments.GetBuffer(),
nullptr,
nullptr,
FALSE,
0,
nullptr,
temp,
&si,
&pi);
arguments.ReleaseBuffer();
if (result)
{
// Store the handles
CHandle hThread(pi.hThread);
hChromeProcess.Attach(pi.hProcess);
DWORD waitResult = ::WaitForInputIdle(hChromeProcess, 30000);
}
else
{
std::cerr << "Could not open Chrome. Please ensure that Chrome is installed." << std::endl;
system("pause");
return -1;
}
}
// Kill all Edge instances if their is an aegument /killall
if (vm.count("killall"))
{
//killAllProcessByExe(L"MicrosoftEdgeCP.exe");
Helpers::KillAllProcessByExe(L"MicrosoftEdge.exe");
}
// Launch Edge if their is an argument set /launch:<url>
if (vm.count("launch"))
{
CString url(vm["launch"].as<string>().c_str());
if (url.GetLength() == 0)
{
url = L"https://www.bing.com";
}
HRESULT hr = Helpers::OpenUrlInMicrosoftEdge(url);
if (FAILED(hr))
{
std::cout << L"Failed to launch Microsoft Edge";
}
}
string port = EdgeDiagnosticsAdapter::s_Default_Port;
if (vm.count("port"))
{
port = vm["port"].as<string>();
}
// We don't care if this fails as the developer can set it manually.
setSecurityACLs();
// We don't care if this fails or not as maybe the developer wants to do something that won't hit the PLM. In case errors went to the console.
setEdgeForDebugging(true);
// Load the proxy server
EdgeDiagnosticsAdapter proxy(getPathToCurrentExeContainer(), port);
if (proxy.IsServerRunning)
{
// Create a message pump
MSG msg;
::PeekMessage(&msg, NULL, WM_USER, WM_USER, PM_NOREMOVE);
// Thread message loop
BOOL getMessageRet;
while ((getMessageRet = ::GetMessage(&msg, NULL, 0, 0)) != 0)
{
if (getMessageRet != -1)
{
::TranslateMessage(&msg);
::DispatchMessage(&msg);
}
}
// Leave the window open so we can read the log file
wcout << endl << L"Press [ENTER] to exit." << endl;
cin.ignore();
}
else
{
wcout << L"Error starting. Quiting.";
return E_FAIL;
}
}
return S_OK;
}
//-----------------------------------------------------------------------------
// Purpose: This takes the current place the NPC's trying to get to, figures out
// what keys to press to get the vehicle to go there, and then sends
// them to the vehicle.
//-----------------------------------------------------------------------------
void CNPC_CraneDriver::DriveVehicle( void )
{
// No targets?
if ( !GetEnemy() && m_vecDesiredPosition == vec3_origin )
return;
Vector vecTarget = m_vecDesiredPosition;
// Track our targets
if ( m_hPickupTarget )
{
vecTarget = m_hPickupTarget->GetAbsOrigin();
}
else if ( !m_bForcedPickup && !m_bForcedDropoff && GetEnemy() )
{
vecTarget = GetEnemy()->GetAbsOrigin();
}
// Move the crane over the target
// Use the crane type as a targeting point
Vector vecCraneTip = m_hCrane->GetCraneTipPosition();
Vector2D vecCraneTip2D( vecCraneTip.x, vecCraneTip.y );
Vector2D vecTarget2D( vecTarget.x, vecTarget.y );
Vector2D vecOrigin2D( m_hCrane->GetAbsOrigin().x, m_hCrane->GetAbsOrigin().y );
if ( g_debug_vehicledriver.GetInt() )
{
NDebugOverlay::Box( vecTarget, -Vector(50,50,50), Vector(50,50,50), 0,255,0, true, 0.1 );
NDebugOverlay::Box( vecCraneTip, -Vector(2,2,5000), Vector(2,2,5), 0,255,0, true, 0.1 );
NDebugOverlay::Box( vecTarget, -Vector(2,2,5), Vector(2,2,5000), 0,255,0, true, 0.1 );
}
// Store off the distance to our target
m_flDistanceToTarget = (vecTarget2D - vecCraneTip2D).Length();
// First determine whether we need to extend / retract the arm
float flDistToTarget = (vecOrigin2D - vecTarget2D).LengthSqr();
float flDistToCurrent = (vecOrigin2D - vecCraneTip2D).LengthSqr();
float flDelta = fabs(flDistToTarget - flDistToCurrent);
// Slow down as we get closer, but do it based upon our current extension rate
float flMinDelta = 50 + (50 * fabs(m_hCrane->GetExtensionRate() / CRANE_EXTENSION_RATE_MAX));
flMinDelta *= flMinDelta;
if ( flDelta > flMinDelta )
{
if ( flDistToCurrent > flDistToTarget )
{
// Retract
m_pVehicleInterface->NPC_ThrottleReverse();
}
else if ( flDistToCurrent < flDistToTarget )
{
// Extend
m_pVehicleInterface->NPC_ThrottleForward();
}
}
else
{
m_pVehicleInterface->NPC_ThrottleCenter();
}
// Then figure out if we need to rotate. Do it all in 2D space.
Vector vecRight, vecForward;
m_hCrane->GetVectors( &vecForward, &vecRight, NULL );
vecRight.z = 0;
vecForward.z = 0;
VectorNormalize( vecRight );
VectorNormalize( vecForward );
Vector vecToTarget = ( vecTarget - m_hCrane->GetAbsOrigin() );
vecToTarget.z = 0;
VectorNormalize( vecToTarget );
float flDotRight = DotProduct( vecRight, vecToTarget );
float flDotForward = DotProduct( vecForward, vecToTarget );
// Start slowing if we're going to hit the point soon
float flTurnInDeg = RAD2DEG( acos(flDotForward) );
float flSpeed = m_hCrane->GetMaxTurnRate() * (flTurnInDeg / 15.0);
flSpeed = min( m_hCrane->GetMaxTurnRate(), flSpeed );
if ( fabs(flSpeed) < 0.05 )
{
// We're approaching the target, so stop turning
m_pVehicleInterface->NPC_TurnCenter();
}
else
{
if ( flDotRight < 0 )
{
// Turn right
m_pVehicleInterface->NPC_TurnRight( flSpeed );
}
else if ( flDotRight > 0 )
{
// Turn left
m_pVehicleInterface->NPC_TurnLeft( flSpeed );
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pTask -
//-----------------------------------------------------------------------------
void CNPC_CraneDriver::StartTask( const Task_t *pTask )
{
switch( pTask->iTask )
{
case TASK_WAIT_FOR_MOVEMENT:
break;
case TASK_CRANE_GET_POSITION_OVER_ENEMY:
{
if ( !GetEnemy() )
{
TaskFail(FAIL_NO_ROUTE);
return;
}
SetDesiredPosition( GetEnemy()->GetAbsOrigin() );
TaskComplete();
}
break;
case TASK_CRANE_GET_POSITION_OVER_OBJECT:
{
if ( !m_hPickupTarget )
{
TaskFail("No object to pickup!");
return;
}
SetDesiredPosition( m_hPickupTarget->GetAbsOrigin() );
TaskComplete();
}
break;
case TASK_CRANE_GET_POSITION_OVER_LASTPOSITION:
{
SetDesiredPosition( m_vecLastPosition );
TaskComplete();
}
break;
case TASK_CRANE_TURN_MAGNET_OFF:
{
// If we picked up something, and we were being forced to pick something up, fire our output
if ( m_hCrane->GetTotalMassOnCrane() > 0 && m_bForcedDropoff )
{
// Are we supposed to pause first?
if ( m_flReleasePause )
{
m_flReleaseAt = gpGlobals->curtime + m_flReleasePause;
m_OnPausingBeforeDrop.FireOutput( this, this );
return;
}
m_OnDroppedObject.FireOutput( this, this );
}
m_hCrane->TurnMagnetOff();
TaskComplete();
}
break;
case TASK_END_FORCED_DROP:
{
m_bForcedDropoff = false;
TaskComplete();
}
break;
case TASK_CRANE_FIND_OBJECT_TO_PICKUP:
{
Vector2D vecOrigin2D( m_hCrane->GetAbsOrigin().x, m_hCrane->GetAbsOrigin().y );
// Find a large physics object within our reach to pickup
float flLargestMass = 0;
CBaseEntity *pLargestEntity = NULL;
CBaseEntity *pList[1024];
Vector delta( m_flDistTooFar, m_flDistTooFar, m_flDistTooFar*2 );
int count = UTIL_EntitiesInBox( pList, 1024, m_hCrane->GetAbsOrigin() - delta, m_hCrane->GetAbsOrigin() + delta, 0 );
for ( int i = 0; i < count; i++ )
{
if ( !pList[i] )
continue;
// Ignore the crane & the magnet
if ( pList[i] == m_hCrane || pList[i] == m_hCrane->GetMagnet() )
continue;
if ( m_PreviouslyPickedUpObjects.Find( pList[i] ) != m_PreviouslyPickedUpObjects.InvalidIndex() )
continue;
// Get the VPhysics object
IPhysicsObject *pPhysics = pList[i]->VPhysicsGetObject();
if ( pPhysics && pList[i]->GetMoveType() == MOVETYPE_VPHYSICS )
{
float flMass = pPhysics->GetMass();
if ( flMass > flLargestMass && (flMass < MAXIMUM_CRANE_PICKUP_MASS) && (flMass > MINIMUM_CRANE_PICKUP_MASS) )
{
// Biggest one we've found so far
// Now make sure it's within our reach
// Do our distance check in 2D
Vector2D vecOrigin2D( m_hCrane->GetAbsOrigin().x, m_hCrane->GetAbsOrigin().y );
Vector2D vecEnemy2D( pList[i]->GetAbsOrigin().x, pList[i]->GetAbsOrigin().y );
float flDist = (vecOrigin2D - vecEnemy2D).Length();
// Maximum & Minimum size of the crane's reach
if ( flDist > MAX_CRANE_FLAT_REACH )
continue;
if ( flDist < MIN_CRANE_FLAT_REACH )
continue;
flLargestMass = flMass;
pLargestEntity = pList[i];
}
}
}
// If we didn't find anything new, clear our list of targets
if ( !pLargestEntity )
{
m_PreviouslyPickedUpObjects.Purge();
}
if ( !pLargestEntity )
{
TaskFail("Couldn't find anything to pick up!");
return;
}
m_hPickupTarget = pLargestEntity;
TaskComplete();
}
break;
case TASK_CRANE_DROP_MAGNET:
{
// Drop the magnet, but only end the task once the magnet's back up
m_pVehicleInterface->NPC_SecondaryFire();
// Don't check to see if drop's finished until this time is up.
// This is necessary because the crane won't start dropping this
// frame, and our cranedriver will think it's finished immediately.
m_flDropWait = gpGlobals->curtime + 0.5;
}
break;
default:
BaseClass::StartTask( pTask );
break;
}
}
//-----------------------------------------------------------------------------
// Purpose: Play beeping sounds until the charge explode
//-----------------------------------------------------------------------------
void CShieldGrenade::CreateShield( void )
{
/*
// Set the orientation of the shield based on
// the closest teammate's relative position...
float mindist = FLT_MAX;
Vector dir;
for ( int i = 1; i <= gpGlobals->maxClients; i++ )
{
CBaseTFPlayer *pPlayer = ToBaseTFPlayer( UTIL_PlayerByIndex(i) );
if ( pPlayer )
{
if (pPlayer->GetTeamNumber() == GetTeamNumber())
{
Vector tempdir;
VectorSubtract( pPlayer->Center(), Center(), tempdir );
float dist = VectorNormalize( tempdir );
if (dist < mindist)
{
mindist = dist;
VectorCopy( tempdir, dir );
}
}
}
}
if( mindist == FLT_MAX )
{
AngleVectors( GetAngles(), &dir );
}
// Never pitch the shield
dir.z = 0.0f;
VectorNormalize(dir);
QAngle relAngles;
VMatrix parentMatrix;
VMatrix worldShieldMatrix;
VMatrix relativeMatrix;
VMatrix parentInvMatrix;
// Construct a transform from shield to grenade (parent)
MatrixFromAngles( GetAngles(), parentMatrix );
#ifdef _DEBUG
bool ok =
#endif
MatrixInverseGeneral( parentMatrix, parentInvMatrix );
Assert( ok );
Vector up( 0, 0, 1 );
Vector left;
CrossProduct( up, dir, left );
MatrixSetIdentity( worldShieldMatrix );
worldShieldMatrix.SetUp( up );
worldShieldMatrix.SetLeft( left );
worldShieldMatrix.SetForward( dir );
MatrixMultiply( parentInvMatrix, worldShieldMatrix, relativeMatrix );
MatrixToAngles( relativeMatrix, relAngles );
*/
Vector offset( 0, 0, SHIELD_GRENADE_HEIGHT * 0.5f );
m_hDeployedShield = CreateFlatShield( this, SHIELD_GRENADE_WIDTH,
SHIELD_GRENADE_HEIGHT, offset, vec3_angle );
// Notify it about EMP state
if (m_IsEMPed)
m_hDeployedShield->SetEMPed(true);
// Play a sound
// WeaponSound( SPECIAL1 );
}
void CWeaponEgon::CreateEffect( void )
{
#ifndef CLIENT_DLL
CBasePlayer *pPlayer = ToBasePlayer( GetOwner() );
if ( !pPlayer )
{
return;
}
DestroyEffect();
m_hBeam = CBeam::BeamCreate( EGON_BEAM_SPRITE, 3.5 );
m_hBeam->PointEntInit( GetAbsOrigin(), this );
m_hBeam->SetBeamFlags( FBEAM_SINENOISE );
m_hBeam->SetEndAttachment( 1 );
m_hBeam->AddSpawnFlags( SF_BEAM_TEMPORARY ); // Flag these to be destroyed on save/restore or level transition
m_hBeam->SetOwnerEntity( pPlayer );
m_hBeam->SetScrollRate( 10 );
m_hBeam->SetBrightness( 200 );
m_hBeam->SetColor( 50, 50, 255 );
m_hBeam->SetNoise( 0.2 );
m_hNoise = CBeam::BeamCreate( EGON_BEAM_SPRITE, 5.0 );
m_hNoise->PointEntInit( GetAbsOrigin(), this );
m_hNoise->SetEndAttachment( 1 );
m_hNoise->AddSpawnFlags( SF_BEAM_TEMPORARY );
m_hNoise->SetOwnerEntity( pPlayer );
m_hNoise->SetScrollRate( 25 );
m_hNoise->SetBrightness( 200 );
m_hNoise->SetColor( 50, 50, 255 );
m_hNoise->SetNoise( 0.8 );
m_hSprite = CSprite::SpriteCreate( EGON_FLARE_SPRITE, GetAbsOrigin(), false );
m_hSprite->SetScale( 1.0 );
m_hSprite->SetTransparency( kRenderGlow, 255, 255, 255, 255, kRenderFxNoDissipation );
m_hSprite->AddSpawnFlags( SF_SPRITE_TEMPORARY );
m_hSprite->SetOwnerEntity( pPlayer );
#endif
}
//------------------------------------------------------------------------------
// Purpose :
//------------------------------------------------------------------------------
void CGameUI::InputActivate( inputdata_t &inputdata )
{
CBasePlayer *pPlayer;
// Determine if we're specifying this as an override parameter
if ( inputdata.value.StringID() != NULL_STRING )
{
CBaseEntity *pEntity = gEntList.FindEntityByName( NULL, inputdata.value.String(), this, inputdata.pActivator, inputdata.pCaller );
if ( pEntity == NULL || pEntity->IsPlayer() == false )
{
Warning( "%s InputActivate: entity %s not found or is not a player!\n", STRING(GetEntityName()), inputdata.value.String() );
return;
}
pPlayer = ToBasePlayer( pEntity );
}
else
{
// Otherwise try to use the activator
if ( inputdata.pActivator == NULL || inputdata.pActivator->IsPlayer() == false )
{
Warning( "%s InputActivate: invalid or missing !activator!\n", STRING(GetEntityName()), inputdata.value.String() );
return;
}
pPlayer = ToBasePlayer( inputdata.pActivator );
}
// If another player is already using these controls3, ignore this activation
if ( m_player.Get() != NULL && pPlayer != m_player.Get() )
{
// TODO: We could allow this by calling Deactivate() at this point and continuing on -- jdw
return;
}
// Setup our internal data
m_player = pPlayer;
m_playerOn.FireOutput( pPlayer, this, 0 );
// Turn the hud off
SetNextThink( gpGlobals->curtime );
// Disable player's motion
if ( FBitSet( m_spawnflags, SF_GAMEUI_FREEZE_PLAYER ) )
{
m_player->AddFlag( FL_ATCONTROLS );
}
// Store off and hide the currently held weapon
if ( FBitSet( m_spawnflags, SF_GAMEUI_HIDE_WEAPON ) )
{
m_player->m_Local.m_iHideHUD |= HIDEHUD_WEAPONSELECTION;
if ( m_player->GetActiveWeapon() )
{
m_hSaveWeapon = m_player->GetActiveWeapon();
m_player->GetActiveWeapon()->Holster();
m_player->ClearActiveWeapon();
m_player->HideViewModels();
}
}
// We must update our state
m_bForceUpdate = true;
}
bool CScriptedIconLesson::Mod_ProcessElementAction( int iAction, bool bNot, const char *pchVarName, EHANDLE &hVar, const CGameInstructorSymbol *pchParamName, float fParam, C_BaseEntity *pParam, const char *pchParam, bool &bModHandled )
{
// Assume we're going to handle the action
bModHandled = true;
C_BaseEntity *pVar = hVar.Get();
switch ( iAction )
{
case LESSON_ACTION_IS_ALLOWED_ITEM:
{
C_ASW_Marine *pMarine = NULL;
C_ASW_Player *pPlayer = dynamic_cast< C_ASW_Player* >( pVar );
if ( pPlayer )
{
pMarine = dynamic_cast< C_ASW_Marine* >( pPlayer->GetMarine() );
}
if ( !pMarine )
{
if ( gameinstructor_verbose.GetInt() > 0 && ShouldShowSpew() )
{
ConColorMsg( CBaseLesson::m_rgbaVerbosePlain, "\t[%s]->AllowedToPickup( [%s] )", pchParamName->String(), pchVarName );
ConColorMsg( CBaseLesson::m_rgbaVerboseName, "... " );
ConColorMsg( CBaseLesson::m_rgbaVerbosePlain, ( bNot ) ? ( "== false\n" ) : ( "== true\n" ) );
ConColorMsg( CBaseLesson::m_rgbaVerboseClose, "\tVar handle as ASW_Marine returned NULL!\n" );
}
return false;
}
bool bIsAllowed = false;
C_ASW_Pickup *pPickup = dynamic_cast< C_ASW_Pickup * >( pParam );
if ( !pPickup )
{
C_ASW_Weapon *pWeapon = dynamic_cast< C_ASW_Weapon * >( pParam );
if ( !pWeapon )
{
if ( gameinstructor_verbose.GetInt() > 0 && ShouldShowSpew() )
{
ConColorMsg( CBaseLesson::m_rgbaVerbosePlain, "\t[%s]->AllowedToPickup( [%s] )", pchParamName->String(), pchVarName );
ConColorMsg( CBaseLesson::m_rgbaVerboseName, "... " );
ConColorMsg( CBaseLesson::m_rgbaVerbosePlain, ( bNot ) ? ( "== false\n" ) : ( "== true\n" ) );
ConColorMsg( CBaseLesson::m_rgbaVerboseClose, "\tParam handle as ASW_Weapon and ASW_Pickup returned NULL!\n" );
}
return false;
}
else
{
bIsAllowed = pWeapon->AllowedToPickup( pMarine );
}
}
else
{
bIsAllowed = pPickup->AllowedToPickup( pMarine );
}
if ( gameinstructor_verbose.GetInt() > 0 && ShouldShowSpew() )
{
ConColorMsg( CBaseLesson::m_rgbaVerbosePlain, "\t[%s]->AllowedToPickup( [%s] )", pchParamName->String(), pchVarName );
ConColorMsg( CBaseLesson::m_rgbaVerboseName, "%s ", ( bIsAllowed ? "true" : "false" ) );
ConColorMsg( CBaseLesson::m_rgbaVerbosePlain, ( bNot ) ? ( "== false\n" ) : ( "== true\n" ) );
}
return ( bNot ) ? ( !bIsAllowed ) : ( bIsAllowed );
}
case LESSON_ACTION_ITEM_WILL_SWAP:
{
C_ASW_Marine *pMarine = NULL;
C_ASW_Player *pPlayer = dynamic_cast< C_ASW_Player* >( pVar );
if ( pPlayer )
{
pMarine = dynamic_cast< C_ASW_Marine* >( pPlayer->GetMarine() );
}
if ( !pMarine )
{
if ( gameinstructor_verbose.GetInt() > 0 && ShouldShowSpew() )
{
ConColorMsg( CBaseLesson::m_rgbaVerbosePlain, "\t[%s]->WillSwap( [%s] )", pchParamName->String(), pchVarName );
ConColorMsg( CBaseLesson::m_rgbaVerboseName, "... " );
ConColorMsg( CBaseLesson::m_rgbaVerbosePlain, ( bNot ) ? ( "== false\n" ) : ( "== true\n" ) );
ConColorMsg( CBaseLesson::m_rgbaVerboseClose, "\tVar handle as ASW_Marine returned NULL!\n" );
}
return false;
}
bool bWillSwap = false;
C_ASW_Pickup_Weapon *pPickup = dynamic_cast< C_ASW_Pickup_Weapon * >( pParam );
if ( !pPickup )
{
C_ASW_Weapon *pWeapon = dynamic_cast< C_ASW_Weapon * >( pParam );
if ( !pWeapon )
{
if ( gameinstructor_verbose.GetInt() > 0 && ShouldShowSpew() )
{
ConColorMsg( CBaseLesson::m_rgbaVerbosePlain, "\t[%s]->WillSwap( [%s] )", pchParamName->String(), pchVarName );
ConColorMsg( CBaseLesson::m_rgbaVerboseName, "... " );
ConColorMsg( CBaseLesson::m_rgbaVerbosePlain, ( bNot ) ? ( "== false\n" ) : ( "== true\n" ) );
ConColorMsg( CBaseLesson::m_rgbaVerboseClose, "\tParam handle as ASW_Weapon and ASW_Pickup returned NULL!\n" );
}
return false;
}
else
{
int nSlot = pMarine->GetWeaponPositionForPickup( pWeapon->GetClassname() );
bWillSwap = ( pMarine->GetASWWeapon( nSlot ) != NULL );
}
}
else
{
int nSlot = pMarine->GetWeaponPositionForPickup( pPickup->GetWeaponClass() );
bWillSwap = ( pMarine->GetASWWeapon( nSlot ) != NULL );
}
if ( gameinstructor_verbose.GetInt() > 0 && ShouldShowSpew() )
{
ConColorMsg( CBaseLesson::m_rgbaVerbosePlain, "\t[%s]->WillSwap( [%s] )", pchParamName->String(), pchVarName );
ConColorMsg( CBaseLesson::m_rgbaVerboseName, "%s ", ( bWillSwap ? "true" : "false" ) );
ConColorMsg( CBaseLesson::m_rgbaVerbosePlain, ( bNot ) ? ( "== false\n" ) : ( "== true\n" ) );
}
return ( bNot ) ? ( !bWillSwap ) : ( bWillSwap );
}
case LESSON_ACTION_CAN_HACK:
{
C_ASW_Marine *pMarine = NULL;
C_ASW_Player *pPlayer = dynamic_cast< C_ASW_Player* >( pVar );
if ( pPlayer )
{
pMarine = dynamic_cast< C_ASW_Marine* >( pPlayer->GetMarine() );
}
if ( !pMarine )
{
if ( gameinstructor_verbose.GetInt() > 0 && ShouldShowSpew() )
{
ConColorMsg( CBaseLesson::m_rgbaVerbosePlain, "\t[%s]->CanHack()", pchVarName );
ConColorMsg( CBaseLesson::m_rgbaVerboseName, "... " );
ConColorMsg( CBaseLesson::m_rgbaVerbosePlain, ( bNot ) ? ( "== false\n" ) : ( "== true\n" ) );
ConColorMsg( CBaseLesson::m_rgbaVerboseClose, "\tVar handle as ASW_Marine returned NULL!\n" );
}
return false;
}
bool bCanHack = pMarine->GetMarineProfile()->CanHack();
if ( gameinstructor_verbose.GetInt() > 0 && ShouldShowSpew() )
{
ConColorMsg( CBaseLesson::m_rgbaVerbosePlain, "\t[%s]->AllowedToPickup()", pchVarName );
ConColorMsg( CBaseLesson::m_rgbaVerboseName, "%s ", ( bCanHack ? "true" : "false" ) );
ConColorMsg( CBaseLesson::m_rgbaVerbosePlain, ( bNot ) ? ( "== false\n" ) : ( "== true\n" ) );
}
return ( bNot ) ? ( !bCanHack ) : ( bCanHack );
}
case LESSON_ACTION_CAN_OFFHAND:
{
C_ASW_Weapon *pWeapon = dynamic_cast< C_ASW_Weapon* >( pVar );
if ( !pWeapon )
{
if ( gameinstructor_verbose.GetInt() > 0 && ShouldShowSpew() )
{
ConColorMsg( CBaseLesson::m_rgbaVerbosePlain, "\t[%s]->CanOffhand()", pchVarName );
ConColorMsg( CBaseLesson::m_rgbaVerboseName, "... " );
ConColorMsg( CBaseLesson::m_rgbaVerbosePlain, ( bNot ) ? ( "== false\n" ) : ( "== true\n" ) );
ConColorMsg( CBaseLesson::m_rgbaVerboseClose, "\tVar handle as ASW_Weapon returned NULL!\n" );
}
return false;
}
bool bCanOffhand = pWeapon->GetWeaponInfo()->m_bOffhandActivate;
if ( gameinstructor_verbose.GetInt() > 0 && ShouldShowSpew() )
{
ConColorMsg( CBaseLesson::m_rgbaVerbosePlain, "\t[%s]->CanOffhand()", pchVarName );
ConColorMsg( CBaseLesson::m_rgbaVerboseName, "%s ", ( bCanOffhand ? "true" : "false" ) );
ConColorMsg( CBaseLesson::m_rgbaVerbosePlain, ( bNot ) ? ( "== false\n" ) : ( "== true\n" ) );
}
return ( bNot ) ? ( !bCanOffhand ) : ( bCanOffhand );
}
case LESSON_ACTION_HAS_SECONDARY:
{
C_ASW_Weapon *pWeapon = dynamic_cast< C_ASW_Weapon* >( pVar );
if ( !pWeapon )
{
if ( gameinstructor_verbose.GetInt() > 0 && ShouldShowSpew() )
{
ConColorMsg( CBaseLesson::m_rgbaVerbosePlain, "\t[%s]->HasSecondary()", pchVarName );
ConColorMsg( CBaseLesson::m_rgbaVerboseName, "... " );
ConColorMsg( CBaseLesson::m_rgbaVerbosePlain, ( bNot ) ? ( "== false\n" ) : ( "== true\n" ) );
ConColorMsg( CBaseLesson::m_rgbaVerboseClose, "\tVar handle as ASW_Weapon returned NULL!\n" );
}
return false;
}
bool bHasSecondary = pWeapon->UsesSecondaryAmmo();
if ( bHasSecondary )
{
bHasSecondary = !( ( pWeapon->UsesClipsForAmmo2() && pWeapon->m_iClip2 <= 0 ) ||
( !pWeapon->UsesClipsForAmmo2() && pWeapon->GetOwner() && pWeapon->GetOwner()->GetAmmoCount( pWeapon->m_iSecondaryAmmoType ) <= 0 ) );
}
if ( gameinstructor_verbose.GetInt() > 0 && ShouldShowSpew() )
{
ConColorMsg( CBaseLesson::m_rgbaVerbosePlain, "\t[%s]->HasSecondary()", pchVarName );
ConColorMsg( CBaseLesson::m_rgbaVerboseName, "%s ", ( bHasSecondary ? "true" : "false" ) );
ConColorMsg( CBaseLesson::m_rgbaVerbosePlain, ( bNot ) ? ( "== false\n" ) : ( "== true\n" ) );
}
return ( bNot ) ? ( !bHasSecondary ) : ( bHasSecondary );
}
case LESSON_ACTION_HAS_SECONDARY_EXPLOSIVES:
{
C_ASW_Marine *pMarine = NULL;
C_ASW_Player *pPlayer = dynamic_cast< C_ASW_Player* >( pVar );
if ( pPlayer )
{
pMarine = dynamic_cast< C_ASW_Marine* >( pPlayer->GetMarine() );
}
if ( !pMarine )
{
if ( gameinstructor_verbose.GetInt() > 0 && ShouldShowSpew() )
{
ConColorMsg( CBaseLesson::m_rgbaVerbosePlain, "\t[%s]->HasAnySecondary()", pchVarName );
ConColorMsg( CBaseLesson::m_rgbaVerboseName, "... " );
ConColorMsg( CBaseLesson::m_rgbaVerbosePlain, ( bNot ) ? ( "== false\n" ) : ( "== true\n" ) );
ConColorMsg( CBaseLesson::m_rgbaVerboseClose, "\tVar handle as ASW_Marine returned NULL!\n" );
}
return false;
}
bool bHasAnySecondary = false;
for ( int i = 0; i < ASW_MAX_EQUIP_SLOTS; ++i )
{
C_ASW_Weapon *pWeapon = static_cast< C_ASW_Weapon* >( pMarine->GetWeapon( i ) );
if ( pWeapon && pWeapon->HasSecondaryExplosive() )
{
if ( !( ( pWeapon->UsesClipsForAmmo2() && pWeapon->m_iClip2 <= 0 ) ||
( !pWeapon->UsesClipsForAmmo2() && pWeapon->GetOwner() && pWeapon->GetOwner()->GetAmmoCount( pWeapon->m_iSecondaryAmmoType ) <= 0 ) ) )
{
bHasAnySecondary = true;
break;
}
}
}
if ( gameinstructor_verbose.GetInt() > 0 && ShouldShowSpew() )
{
ConColorMsg( CBaseLesson::m_rgbaVerbosePlain, "\t[%s]->HasAnySecondary()", pchVarName );
ConColorMsg( CBaseLesson::m_rgbaVerboseName, "%s ", ( bHasAnySecondary ? "true" : "false" ) );
ConColorMsg( CBaseLesson::m_rgbaVerbosePlain, ( bNot ) ? ( "== false\n" ) : ( "== true\n" ) );
}
return ( bNot ) ? ( !bHasAnySecondary ) : ( bHasAnySecondary );
}
case LESSON_ACTION_GET_MARINE:
{
int iTemp = static_cast<int>( fParam );
if ( iTemp <= 0 || iTemp > 2 )
{
if ( gameinstructor_verbose.GetInt() > 0 && ShouldShowSpew() )
{
ConColorMsg( CBaseLesson::m_rgbaVerbosePlain, "\t[entityINVALID] = [%s]->GetMarine()\n", pchVarName );
ConColorMsg( CBaseLesson::m_rgbaVerboseClose, "\tParam selecting string is out of range!\n" );
}
return false;
}
CHandle<C_BaseEntity> *pHandle;
char const *pchParamNameTemp = NULL;
if ( iTemp == 2 )
{
pHandle = &m_hEntity2;
pchParamNameTemp = "entity2";
}
else
{
pHandle = &m_hEntity1;
pchParamNameTemp = "entity1";
}
C_ASW_Player *pPlayer = dynamic_cast< C_ASW_Player* >( pVar );
if ( !pPlayer )
{
if ( gameinstructor_verbose.GetInt() > 0 && ShouldShowSpew() )
{
ConColorMsg( CBaseLesson::m_rgbaVerbosePlain, "\t[%s] = [%s]->GetMarine()", pchParamNameTemp, pchVarName );
ConColorMsg( CBaseLesson::m_rgbaVerboseName, "...\n" );
ConColorMsg( CBaseLesson::m_rgbaVerboseClose, "\tVar handle as ASW_Player returned NULL!\n" );
}
return false;
}
C_ASW_Marine *pMarine = dynamic_cast< C_ASW_Marine* >( pPlayer->GetMarine() );
pHandle->Set( pMarine );
if ( gameinstructor_verbose.GetInt() > 0 && ShouldShowSpew() )
{
ConColorMsg( CBaseLesson::m_rgbaVerbosePlain, "\t[%s] = [%s]->GetMarine()\n", pchParamNameTemp, pchVarName );
}
return true;
}
case LESSON_ACTION_IS_BOT:
{
C_ASW_Marine *pMarine = dynamic_cast< C_ASW_Marine* >( pVar );
if ( !pMarine )
{
if ( gameinstructor_verbose.GetInt() > 0 && ShouldShowSpew() )
{
ConColorMsg( CBaseLesson::m_rgbaVerbosePlain, "\t![%s]->IsInhabited()", pchVarName );
ConColorMsg( CBaseLesson::m_rgbaVerboseName, "... " );
ConColorMsg( CBaseLesson::m_rgbaVerbosePlain, ( bNot ) ? ( "== false\n" ) : ( "== true\n" ) );
ConColorMsg( CBaseLesson::m_rgbaVerboseClose, "\tVar handle as ASW_Marine returned NULL!\n" );
}
return false;
}
bool bIsBot = !pMarine->IsInhabited();
if ( gameinstructor_verbose.GetInt() > 0 && ShouldShowSpew() )
{
ConColorMsg( CBaseLesson::m_rgbaVerbosePlain, "\t![%s]->IsInhabited()", pchVarName );
ConColorMsg( CBaseLesson::m_rgbaVerboseName, "%s ", ( bIsBot ? "true" : "false" ) );
ConColorMsg( CBaseLesson::m_rgbaVerbosePlain, ( bNot ) ? ( "== false\n" ) : ( "== true\n" ) );
}
return ( bNot ) ? ( !bIsBot ) : ( bIsBot );
}
case LESSON_ACTION_WEAPON_HAS_SPARE:
{
C_ASW_Marine *pMarine = NULL;
C_ASW_Player *pPlayer = dynamic_cast< C_ASW_Player* >( pVar );
if ( pPlayer )
{
pMarine = dynamic_cast< C_ASW_Marine* >( pPlayer->GetMarine() );
}
if ( !pMarine )
{
if ( gameinstructor_verbose.GetInt() > 0 && ShouldShowSpew() )
{
ConColorMsg( CBaseLesson::m_rgbaVerbosePlain, "\t[%s]->HasSpareWeapon()", pchVarName );
ConColorMsg( CBaseLesson::m_rgbaVerboseName, "... " );
ConColorMsg( CBaseLesson::m_rgbaVerbosePlain, ( bNot ) ? ( "== false\n" ) : ( "== true\n" ) );
ConColorMsg( CBaseLesson::m_rgbaVerboseClose, "\tVar handle as ASW_Marine returned NULL!\n" );
}
return false;
}
int nOffensiveWeaponCount = 0;
for ( int i = 0; i < ASW_MAX_EQUIP_SLOTS; ++i )
{
C_ASW_Weapon *pWeapon = static_cast< C_ASW_Weapon* >( pMarine->GetWeapon( i ) );
if ( pWeapon && pWeapon->IsOffensiveWeapon() )
{
if ( !( ( pWeapon->UsesClipsForAmmo1() && pWeapon->m_iClip1 <= 0 ) ||
( !pWeapon->UsesClipsForAmmo1() && pWeapon->GetOwner() && pWeapon->GetOwner()->GetAmmoCount( pWeapon->m_iPrimaryAmmoType ) <= 0 ) ) )
{
nOffensiveWeaponCount++;
}
}
}
bool bHasSpare = ( nOffensiveWeaponCount > 1 );
if ( gameinstructor_verbose.GetInt() > 0 && ShouldShowSpew() )
{
ConColorMsg( CBaseLesson::m_rgbaVerbosePlain, "\t[%s]->HasSpareWeapon()", pchVarName );
ConColorMsg( CBaseLesson::m_rgbaVerboseName, "%s ", ( bHasSpare ? "true" : "false" ) );
ConColorMsg( CBaseLesson::m_rgbaVerbosePlain, ( bNot ) ? ( "== false\n" ) : ( "== true\n" ) );
}
return ( bNot ) ? ( !bHasSpare ) : ( bHasSpare );
}
case LESSON_ACTION_WEAPON_IS_OFFENSIVE:
{
C_ASW_Marine *pMarine = NULL;
C_ASW_Player *pPlayer = dynamic_cast< C_ASW_Player* >( pVar );
if ( pPlayer )
{
pMarine = dynamic_cast< C_ASW_Marine* >( pPlayer->GetMarine() );
}
if ( !pMarine )
{
if ( gameinstructor_verbose.GetInt() > 0 && ShouldShowSpew() )
{
ConColorMsg( CBaseLesson::m_rgbaVerbosePlain, "\t[%s]->WeaponIsOffensive()", pchVarName );
ConColorMsg( CBaseLesson::m_rgbaVerboseName, "... " );
ConColorMsg( CBaseLesson::m_rgbaVerbosePlain, ( bNot ) ? ( "== false\n" ) : ( "== true\n" ) );
ConColorMsg( CBaseLesson::m_rgbaVerboseClose, "\tVar handle as ASW_Marine returned NULL!\n" );
}
return false;
}
bool bIsOffensive = false;
C_ASW_Weapon *pWeapon = pMarine->GetActiveASWWeapon();
if ( pWeapon && pWeapon->IsOffensiveWeapon() )
{
if ( !( ( pWeapon->UsesClipsForAmmo1() && pWeapon->m_iClip1 <= 0 ) ||
( !pWeapon->UsesClipsForAmmo1() && pWeapon->GetOwner() && pWeapon->GetOwner()->GetAmmoCount( pWeapon->m_iPrimaryAmmoType ) <= 0 ) ) )
{
bIsOffensive = true;
}
}
if ( gameinstructor_verbose.GetInt() > 0 && ShouldShowSpew() )
{
ConColorMsg( CBaseLesson::m_rgbaVerbosePlain, "\t[%s]->WeaponIsOffensive()", pchVarName );
ConColorMsg( CBaseLesson::m_rgbaVerboseName, "%s ", ( bIsOffensive ? "true" : "false" ) );
ConColorMsg( CBaseLesson::m_rgbaVerbosePlain, ( bNot ) ? ( "== false\n" ) : ( "== true\n" ) );
}
return ( bNot ) ? ( !bIsOffensive ) : ( bIsOffensive );
}
case LESSON_ACTION_WEAPON_LOCAL_HOTBAR_SLOT:
{
CASW_Hud_Master *pHUDMaster = GET_HUDELEMENT( CASW_Hud_Master );
if ( pHUDMaster )
{
m_fOutput = pHUDMaster->GetHotBarSlot( pchParam );
if ( gameinstructor_verbose.GetInt() > 0 && ShouldShowSpew() )
{
ConColorMsg( CBaseLesson::m_rgbaVerbosePlain, "\tm_fOutput = GET_HUDELEMENT( CASW_Hud_Squad_Hotbar )->GetHotBarSlot( [%s] ", pchParamName->String() );
ConColorMsg( CBaseLesson::m_rgbaVerboseName, "\"%s\"", pchParam );
ConColorMsg( CBaseLesson::m_rgbaVerbosePlain, ")\n" );
}
}
return true;
}
case LESSON_ACTION_OWNS_HOTBAR_SLOT:
{
int iTemp = static_cast<int>( fParam );
C_ASW_Player *pPlayer = dynamic_cast< C_ASW_Player* >( pVar );
if ( !pPlayer )
{
if ( gameinstructor_verbose.GetInt() > 0 && ShouldShowSpew() )
{
ConColorMsg( CBaseLesson::m_rgbaVerbosePlain, "\tGET_HUDELEMENT( CASW_Hud_Squad_Hotbar )->OwnsHotBarSlot( [%s] ", pchVarName );
ConColorMsg( CBaseLesson::m_rgbaVerboseName, "..." );
ConColorMsg( CBaseLesson::m_rgbaVerbosePlain, ", [%s] ", pchParamName->String() );
ConColorMsg( CBaseLesson::m_rgbaVerboseName, "\"%i\" ", iTemp );
ConColorMsg( CBaseLesson::m_rgbaVerbosePlain, ") " );
ConColorMsg( CBaseLesson::m_rgbaVerboseName, "... " );
ConColorMsg( CBaseLesson::m_rgbaVerbosePlain, ( bNot ) ? ( "== false\n" ) : ( "== true\n" ) );
ConColorMsg( CBaseLesson::m_rgbaVerboseClose, "\tVar handle as ASW_Player returned NULL!\n" );
}
return false;
}
bool bOwnsHotBarSlot = false;
CASW_Hud_Master *pHUDMaster = GET_HUDELEMENT( CASW_Hud_Master );
if ( pHUDMaster )
{
bOwnsHotBarSlot = pHUDMaster->OwnsHotBarSlot( pPlayer, iTemp );
if ( gameinstructor_verbose.GetInt() > 0 && ShouldShowSpew() )
{
ConColorMsg( CBaseLesson::m_rgbaVerbosePlain, "\tGET_HUDELEMENT( CASW_Hud_Squad_Hotbar )->OwnsHotBarSlot( [%s], [%s] ", pchVarName, pchParamName->String() );
ConColorMsg( CBaseLesson::m_rgbaVerboseName, "\"%i\" ", iTemp );
ConColorMsg( CBaseLesson::m_rgbaVerbosePlain, ") " );
ConColorMsg( CBaseLesson::m_rgbaVerboseName, "%s ", ( bOwnsHotBarSlot ? "true" : "false" ) );
ConColorMsg( CBaseLesson::m_rgbaVerbosePlain, ( bNot ) ? ( "== false\n" ) : ( "== true\n" ) );
}
}
return ( bNot ) ? ( !bOwnsHotBarSlot ) : ( bOwnsHotBarSlot );
}
case LESSON_ACTION_SENTRY_WANTS_DISMANTLE:
{
C_ASW_Sentry_Base *pSentry = dynamic_cast< C_ASW_Sentry_Base* >( pVar );
if ( !pSentry )
{
if ( gameinstructor_verbose.GetInt() > 0 && ShouldShowSpew() )
{
ConColorMsg( CBaseLesson::m_rgbaVerbosePlain, "\t[%s]->WantsDismantle()", pchVarName );
ConColorMsg( CBaseLesson::m_rgbaVerboseName, "... " );
ConColorMsg( CBaseLesson::m_rgbaVerbosePlain, ( bNot ) ? ( "== false\n" ) : ( "== true\n" ) );
ConColorMsg( CBaseLesson::m_rgbaVerboseClose, "\tVar handle as ASW_Sentry_Base returned NULL!\n" );
}
return false;
}
bool bWantsDismantle = pSentry->WantsDismantle();
if ( gameinstructor_verbose.GetInt() > 0 && ShouldShowSpew() )
{
ConColorMsg( CBaseLesson::m_rgbaVerbosePlain, "\t[%s]->WantsDismantle()", pchVarName );
ConColorMsg( CBaseLesson::m_rgbaVerboseName, "%s ", ( bWantsDismantle ? "true" : "false" ) );
ConColorMsg( CBaseLesson::m_rgbaVerbosePlain, ( bNot ) ? ( "== false\n" ) : ( "== true\n" ) );
}
return ( bNot ) ? ( !bWantsDismantle ) : ( bWantsDismantle );
}
case LESSON_ACTION_IS_TUTORIAL:
{
bool bIsTutorial = ASWGameRules()->IsTutorialMap();
if ( gameinstructor_verbose.GetInt() > 0 && ShouldShowSpew() )
{
ConColorMsg( CBaseLesson::m_rgbaVerbosePlain, "\tASWGameRules()->IsTutorialMap()" );
ConColorMsg( CBaseLesson::m_rgbaVerboseName, "%s ", ( bIsTutorial ? "true" : "false" ) );
ConColorMsg( CBaseLesson::m_rgbaVerbosePlain, ( bNot ) ? ( "== false\n" ) : ( "== true\n" ) );
}
return ( bNot ) ? ( !bIsTutorial ) : ( bIsTutorial );
}
case LESSON_ACTION_IS_SINGLEPLAYER:
{
bool bIsSingleplayer = ASWGameRules()->IsOfflineGame();
if ( gameinstructor_verbose.GetInt() > 0 && ShouldShowSpew() )
{
ConColorMsg( CBaseLesson::m_rgbaVerbosePlain, "\tASWGameRules()->IsOfflineGame()" );
ConColorMsg( CBaseLesson::m_rgbaVerboseName, "%s ", ( bIsSingleplayer ? "true" : "false" ) );
ConColorMsg( CBaseLesson::m_rgbaVerbosePlain, ( bNot ) ? ( "== false\n" ) : ( "== true\n" ) );
}
return ( bNot ) ? ( !bIsSingleplayer ) : ( bIsSingleplayer );
}
default:
// Didn't handle this action
bModHandled = false;
break;
}
return false;
}
//------------------------------------------------------------------------------
// Purpose : Update the direction and position of my spotlight
// Input :
// Output :
//------------------------------------------------------------------------------
void CPointSpotlight::SpotlightUpdate(void)
{
// ---------------------------------------------------
// If I don't have a spotlight attempt to create one
// ---------------------------------------------------
if ( !m_hSpotlight )
{
if ( m_bSpotlightOn )
{
// Make the spotlight
SpotlightCreate();
}
else
{
return;
}
}
else if ( !m_bSpotlightOn )
{
SpotlightDestroy();
return;
}
if ( !m_hSpotlightTarget )
{
DevWarning( "**Attempting to update point_spotlight but target ent is NULL\n" );
SpotlightDestroy();
SpotlightCreate();
if ( !m_hSpotlightTarget )
return;
}
m_vSpotlightCurrentPos = SpotlightCurrentPos();
// Update spotlight target velocity
Vector vTargetDir;
VectorSubtract( m_vSpotlightCurrentPos, m_hSpotlightTarget->GetAbsOrigin(), vTargetDir );
float vTargetDist = vTargetDir.Length();
// If we haven't moved at all, don't recompute
if ( vTargetDist < 1 )
{
m_hSpotlightTarget->SetAbsVelocity( vec3_origin );
return;
}
Vector vecNewVelocity = vTargetDir;
VectorNormalize(vecNewVelocity);
vecNewVelocity *= (10 * vTargetDist);
// If a large move is requested, just jump to final spot as we probably hit a discontinuity
if (vecNewVelocity.Length() > 200)
{
VectorNormalize(vecNewVelocity);
vecNewVelocity *= 200;
VectorNormalize(vTargetDir);
m_hSpotlightTarget->SetAbsOrigin( m_vSpotlightCurrentPos );
}
m_hSpotlightTarget->SetAbsVelocity( vecNewVelocity );
m_hSpotlightTarget->m_vSpotlightOrg = GetAbsOrigin();
// Avoid sudden change in where beam fades out when cross disconinuities
VectorSubtract( m_hSpotlightTarget->GetAbsOrigin(), m_hSpotlightTarget->m_vSpotlightOrg, m_hSpotlightTarget->m_vSpotlightDir );
float flBeamLength = VectorNormalize( m_hSpotlightTarget->m_vSpotlightDir );
m_flSpotlightCurLength = (0.60*m_flSpotlightCurLength) + (0.4*flBeamLength);
ComputeRenderInfo();
//NDebugOverlay::Cross3D(GetAbsOrigin(),Vector(-5,-5,-5),Vector(5,5,5),0,255,0,true,0.1);
//NDebugOverlay::Cross3D(m_vSpotlightCurrentPos,Vector(-5,-5,-5),Vector(5,5,5),0,255,0,true,0.1);
//NDebugOverlay::Cross3D(m_vSpotlightTargetPos,Vector(-5,-5,-5),Vector(5,5,5),255,0,0,true,0.1);
}
//-----------------------------------------------------------------------------
void C_BeamSpotLight::ClientThink( void )
{
float dt = gpGlobals->curtime - m_lastTime;
if ( !m_lastTime )
{
dt = 0.0f;
}
m_lastTime = gpGlobals->curtime;
// ---------------------------------------------------
// If I don't have a spotlight attempt to create one
// ---------------------------------------------------
if ( !m_hSpotlight )
{
if ( m_bSpotlightOn )
{
// Make the spotlight
SpotlightCreate();
}
else
{
SetNextClientThink( CLIENT_THINK_NEVER );
return;
}
}
else if ( !m_bSpotlightOn )
{
SpotlightDestroy();
SetNextClientThink( CLIENT_THINK_NEVER );
return;
}
// update rotation
if ( m_flRotationSpeed != 0.0f )
{
QAngle angles = GetAbsAngles();
angles[m_nRotationAxis] += m_flRotationSpeed * dt;
angles[m_nRotationAxis] = anglemod(angles[m_nRotationAxis]);
if ( !m_pCache )
{
m_pCache = new CSpotlightTraceCacheEntry[NUM_CACHE_ENTRIES];
}
SetAbsAngles( angles );
}
m_vSpotlightCurrentPos = SpotlightCurrentPos();
Assert( m_hSpotlight );
m_hSpotlight->SetStartPos( GetAbsOrigin() );
m_hSpotlight->SetEndPos( m_vSpotlightCurrentPos );
// Avoid sudden change in where beam fades out when cross disconinuities
Vector dir = m_vSpotlightCurrentPos - GetAbsOrigin();
float flBeamLength = VectorNormalize( dir );
m_flSpotlightCurLength = (0.60*m_flSpotlightCurLength) + (0.4*flBeamLength);
ComputeRenderInfo();
m_hSpotlight->RelinkBeam();
//NDebugOverlay::Cross3D(GetAbsOrigin(),Vector(-5,-5,-5),Vector(5,5,5),0,255,0,true,0.1);
//NDebugOverlay::Cross3D(m_vSpotlightCurrentPos,Vector(-5,-5,-5),Vector(5,5,5),0,255,0,true,0.1);
//NDebugOverlay::Cross3D(m_vSpotlightTargetPos,Vector(-5,-5,-5),Vector(5,5,5),255,0,0,true,0.1);
// Do we need to keep updating?
if ( !GetMoveParent() && m_flRotationSpeed == 0 )
{
// No reason to think again, we're not going to move unless there's a data change
SetNextClientThink( CLIENT_THINK_NEVER );
}
}
//-----------------------------------------------------------------------------
// Purpose: Stick to an entity (using hierarchy if we can)
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CWeaponStriderBuster::StickToEntity( CBaseEntity *pOther )
{
// Make sure the object is travelling fast enough to stick
if ( m_flCollisionSpeedSqr > 50 && !m_bNoseDiving )
{
// See if this is a valid strider bit
if ( ShouldStickToEntity( pOther ) )
{
// Attempt to constraint to it
if ( CreateConstraintToObject( pOther ) )
{
// Only works for striders, at the moment
CBaseEntity *pFollowParent = pOther->GetOwnerEntity();
if ( pFollowParent == NULL )
return false;
// Allows us to identify our constrained object later
SetOwnerEntity( pFollowParent );
// Make a sound
EmitSound( "Weapon_StriderBuster.StickToEntity" );
DispatchParticleEffect( "striderbuster_attach", GetAbsOrigin(), GetAbsAngles(), NULL );
if( striderbuster_use_particle_flare.GetBool() )
{
// We don't have to save any pointers or handles to this because it's parented to the buster.
// So it will die when the buster dies. Yay.
CParticleSystem *pFlare = (CParticleSystem *) CreateEntityByName( "info_particle_system" );
if ( pFlare != NULL )
{
pFlare->KeyValue( "start_active", "1" );
pFlare->KeyValue( "effect_name", "striderbuster_attached_pulse" );
pFlare->SetParent( this );
pFlare->SetLocalOrigin( vec3_origin );
DispatchSpawn( pFlare );
pFlare->Activate();
}
}
else
{
// Create a glow sprite
m_hGlowSprite = CSprite::SpriteCreate( "sprites/orangeflare1.vmt", GetLocalOrigin(), false );
Assert( m_hGlowSprite );
if ( m_hGlowSprite != NULL )
{
m_hGlowSprite->TurnOn();
m_hGlowSprite->SetTransparency( kRenderWorldGlow, 255, 255, 255, 255, kRenderFxNoDissipation );
m_hGlowSprite->SetAbsOrigin( GetAbsOrigin() );
m_hGlowSprite->SetScale( 5.0f );
m_hGlowSprite->m_nRenderFX = kRenderFxStrobeFaster;
m_hGlowSprite->SetGlowProxySize( 16.0f );
m_hGlowSprite->SetParent( this );
}
}
// Stop touching things
SetTouch( NULL );
// Must be a strider
CNPC_Strider *pStrider = dynamic_cast<CNPC_Strider *>(pFollowParent);
if ( pStrider == NULL )
return false;
// Notify the strider we're attaching to him
pStrider->StriderBusterAttached( this );
m_OnAttachToStrider.FireOutput( this, this );
// Start the ping sound.
SetContextThink( &CWeaponStriderBuster::BusterPingThink, gpGlobals->curtime + BUSTER_PING_SOUND_FREQ, s_pBusterPingThinkContext );
// Don't autodelete this one!
WeaponManager_RemoveManaged( this );
return true;
}
return false;
}
}
return false;
}
C_BaseCombatCharacter* C_QUA_Strider::GetPassenger( int nRole )
{
if (nRole == VEHICLE_ROLE_DRIVER)
return m_hPlayer.Get();
return NULL;
}
//-----------------------------------------------------------------------------
// Purpose: Update the fire and its children
//-----------------------------------------------------------------------------
void CFire::Update( float simTime )
{
VPROF_FIRE( "CFire::Update" );
if ( m_flFuel != 0 )
{
m_flFuel -= simTime;
if ( m_flFuel <= 0 )
{
GoOutInSeconds( 1 );
return;
}
}
float strength = m_flHeatLevel / FIRE_MAX_HEAT_LEVEL;
if ( m_flHeatLevel != m_flLastHeatLevel )
{
m_flLastHeatLevel = m_flHeatLevel;
// Make the effect the appropriate size given the heat level
m_hEffect->Scale( strength, 0.5f );
}
// add heat to myself (grow)
float addedHeat = (m_flAttackTime > 0) ? m_flMaxHeat / m_flAttackTime : m_flMaxHeat;
addedHeat *= simTime * fire_growthrate.GetFloat();
AddHeat( addedHeat, true );
// add heat to nearby fires
float outputHeat = strength * m_flHeatLevel;
Vector fireMins;
Vector fireMaxs;
Vector fireEntityDamageMins;
Vector fireEntityDamageMaxs;
GetFireDimensions( &fireMins, &fireMaxs );
if ( FIRE_SPREAD_DAMAGE_MULTIPLIER != 1.0 ) // if set to 1.0, optimizer will remove this code
{
fireEntityDamageMins = fireMins / FIRE_SPREAD_DAMAGE_MULTIPLIER;
fireEntityDamageMaxs = fireMaxs / FIRE_SPREAD_DAMAGE_MULTIPLIER;
}
//NDebugOverlay::Box( GetAbsOrigin(), fireMins, fireMaxs, 255, 255, 255, 0, fire_dmginterval.GetFloat() );
fireMins += GetAbsOrigin();
fireMaxs += GetAbsOrigin();
if ( FIRE_SPREAD_DAMAGE_MULTIPLIER != 1.0 )
{
fireEntityDamageMins += GetAbsOrigin();
fireEntityDamageMaxs += GetAbsOrigin();
}
CBaseEntity *pNearby[256];
CFire *pFires[16];
int nearbyCount = UTIL_EntitiesInBox( pNearby, ARRAYSIZE(pNearby), fireMins, fireMaxs, 0 );
int fireCount = 0;
int i;
// is it time to do damage?
bool damage = false;
int outputDamage = 0;
if ( m_flDamageTime <= gpGlobals->curtime )
{
m_flDamageTime = gpGlobals->curtime + fire_dmginterval.GetFloat();
outputDamage = (fire_dmgbase.GetFloat() + outputHeat * fire_dmgscale.GetFloat() * m_flDamageScale) * fire_dmginterval.GetFloat();
if ( outputDamage )
{
damage = true;
}
}
int damageFlags = (m_nFireType == FIRE_NATURAL) ? DMG_BURN : DMG_PLASMA;
for ( i = 0; i < nearbyCount; i++ )
{
CBaseEntity *pOther = pNearby[i];
if ( pOther == this )
{
continue;
}
else if ( FClassnameIs( pOther, "env_fire" ) )
{
if ( fireCount < ARRAYSIZE(pFires) )
{
pFires[fireCount] = (CFire *)pOther;
fireCount++;
}
continue;
}
else if ( pOther->m_takedamage == DAMAGE_NO )
{
pNearby[i] = NULL;
}
else if ( damage )
{
bool bDoDamage;
if ( FIRE_SPREAD_DAMAGE_MULTIPLIER != 1.0 && !pOther->IsPlayer() ) // if set to 1.0, optimizer will remove this code
{
Vector otherMins, otherMaxs;
pOther->CollisionProp()->WorldSpaceAABB( &otherMins, &otherMaxs );
bDoDamage = IsBoxIntersectingBox( otherMins, otherMaxs,
fireEntityDamageMins, fireEntityDamageMaxs );
}
else
bDoDamage = true;
if ( bDoDamage )
{
// Make sure can actually see entity (don't damage through walls)
trace_t tr;
UTIL_TraceLine( this->WorldSpaceCenter(), pOther->WorldSpaceCenter(), MASK_FIRE_SOLID, pOther, COLLISION_GROUP_NONE, &tr );
if (tr.fraction == 1.0 && !tr.startsolid)
{
pOther->TakeDamage( CTakeDamageInfo( this, this, outputDamage, damageFlags ) );
}
}
}
}
outputHeat *= fire_heatscale.GetFloat() * simTime;
if ( fireCount > 0 )
{
outputHeat /= fireCount;
for ( i = 0; i < fireCount; i++ )
{
pFires[i]->AddHeat( outputHeat, false );
}
}
}
void CPointEntityFinder::FindByDistance( void )
{
m_hEntity = NULL;
CBaseFilter *pFilter = m_hFilter.Get();
// go through each entity and determine whether it's closer or farther from the current entity. Pick according to Method selected.
float flBestDist = 0;
CBaseEntity *pEntity = gEntList.FirstEnt();
while ( pEntity )
{
if ( FStrEq( STRING( pEntity->m_iClassname ), "worldspawn" )
|| FStrEq( STRING( pEntity->m_iClassname ), "soundent" )
|| FStrEq( STRING( pEntity->m_iClassname ), "player_manager" )
|| FStrEq( STRING( pEntity->m_iClassname ), "bodyque" )
|| FStrEq( STRING( pEntity->m_iClassname ), "ai_network" )
|| pEntity == this
|| ( pFilter && !( pFilter->PassesFilter( this, pEntity ) ) ) )
{
pEntity = gEntList.NextEnt( pEntity );
continue;
}
// if we have a reference entity, use that, otherwise, check against 'this'
Vector vecStart;
if ( m_hReference )
{
vecStart = m_hReference->GetAbsOrigin();
}
else
{
vecStart = GetAbsOrigin();
}
// init m_hEntity with a valid entity.
if (m_hEntity == NULL )
{
m_hEntity = pEntity;
flBestDist = ( pEntity->GetAbsOrigin() - vecStart ).LengthSqr();
}
float flNewDist = ( pEntity->GetAbsOrigin() - vecStart ).LengthSqr();
switch ( m_FindMethod )
{
case ( ENT_FIND_METHOD_NEAREST ):
if ( flNewDist < flBestDist )
{
m_hEntity = pEntity;
flBestDist = flNewDist;
}
break;
case ( ENT_FIND_METHOD_FARTHEST ):
if ( flNewDist > flBestDist )
{
m_hEntity = pEntity;
flBestDist = flNewDist;
}
break;
default:
Assert( false );
break;
}
pEntity = gEntList.NextEnt( pEntity );
}
}
