//------------------------------------------------------------------------------ // Purpose : // Input : // Output : //------------------------------------------------------------------------------ bool CWeaponBrickbat::Deploy( void ) { SetModel( GetViewModel() ); m_bNeedDraw = false; m_bNeedThrow = false; return DefaultDeploy( (char*)GetViewModel(), (char*)GetWorldModel(), ACT_VM_DRAW, (char*)GetAnimPrefix() ); }
bool CWeapon_SLAM::Deploy( void ) { CBaseCombatCharacter *pOwner = GetOwner(); if (!pOwner) { return false; } m_bDetonatorArmed = AnyUndetonatedCharges(); SetModel( GetViewModel() ); m_tSlamState = (int)SLAM_SATCHEL_THROW; // ------------------------------ // Pick the right draw animation // ------------------------------ int iActivity; // If detonator is already armed m_bNeedReload = false; if (m_bDetonatorArmed) { if (pOwner->GetAmmoCount(m_iSecondaryAmmoType) <= 0) { iActivity = ACT_SLAM_DETONATOR_DRAW; m_bNeedReload = true; } else if (CanAttachSLAM()) { iActivity = ACT_SLAM_DETONATOR_STICKWALL_DRAW; SetSlamState(SLAM_TRIPMINE_READY); } else { iActivity = ACT_SLAM_DETONATOR_THROW_DRAW; SetSlamState(SLAM_SATCHEL_THROW); } } else { if (CanAttachSLAM()) { iActivity = ACT_SLAM_TRIPMINE_DRAW; SetSlamState(SLAM_TRIPMINE_READY); } else { iActivity = ACT_SLAM_THROW_ND_DRAW; SetSlamState(SLAM_SATCHEL_THROW); } } return DefaultDeploy( (char*)GetViewModel(), (char*)GetWorldModel(), iActivity, (char*)GetAnimPrefix() ); }
void DesktopSearchResultPoiController::OnViewOpened() { const Search::SdkModel::SearchResultModel& searchResultModel = GetViewModel().GetSearchResultModel(); GetView().Show(searchResultModel, GetViewModel().IsPinned()); std::string imageUrl = ""; Search::SdkModel::TryParseImageDetails(searchResultModel, imageUrl); GetMessageBus().Publish(SearchResultPoiViewOpenedMessage(imageUrl)); }
//----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- bool CWeaponBuilder::Deploy( ) { #if !defined( CLIENT_DLL ) if ( m_hObjectBeingBuilt.Get() && m_hObjectBeingBuilt->IsAnUpgrade() ) return DefaultDeploy( (char*)GetViewModel(), (char*)GetWorldModel(), ACT_SLAM_STICKWALL_ND_DRAW, (char*)GetAnimPrefix() ); return DefaultDeploy( (char*)GetViewModel(), (char*)GetWorldModel(), ACT_VM_DRAW, (char*)GetAnimPrefix() ); #else return true; #endif }
void CHL2MPScriptedWeapon::Precache( void ) { BaseClass::Precache(); InitScriptedWeapon(); // Get the ammo indexes for the ammo's specified in the data file if ( GetWpnData().szAmmo1[0] ) { m_iPrimaryAmmoType = GetAmmoDef()->Index( GetWpnData().szAmmo1 ); if (m_iPrimaryAmmoType == -1) { Msg("ERROR: Weapon (%s) using undefined primary ammo type (%s)\n",GetClassname(), GetWpnData().szAmmo1); } } if ( GetWpnData().szAmmo2[0] ) { m_iSecondaryAmmoType = GetAmmoDef()->Index( GetWpnData().szAmmo2 ); if (m_iSecondaryAmmoType == -1) { Msg("ERROR: Weapon (%s) using undefined secondary ammo type (%s)\n",GetClassname(),GetWpnData().szAmmo2); } } // Precache models (preload to avoid hitch) m_iViewModelIndex = 0; m_iWorldModelIndex = 0; if ( GetViewModel() && GetViewModel()[0] ) { m_iViewModelIndex = CBaseEntity::PrecacheModel( GetViewModel() ); } if ( GetWorldModel() && GetWorldModel()[0] ) { m_iWorldModelIndex = CBaseEntity::PrecacheModel( GetWorldModel() ); } // Precache sounds, too for ( int i = 0; i < NUM_SHOOT_SOUND_TYPES; ++i ) { const char *shootsound = GetShootSound( i ); if ( shootsound && shootsound[0] ) { CBaseEntity::PrecacheScriptSound( shootsound ); } } #if defined ( LUA_SDK ) && !defined( CLIENT_DLL ) BEGIN_LUA_CALL_WEAPON_METHOD( "Precache" ); END_LUA_CALL_WEAPON_METHOD( 0, 0 ); #endif }
bool CWeaponFlowerLauncher::Deploy( void ) { if ( m_iClip1 <= 0 ) return DefaultDeploy( (char*)GetViewModel(), (char*)GetWorldModel(), ACT_CROSSBOW_DRAW_UNLOADED, (char*)GetAnimPrefix() ); return BaseClass::Deploy(); }
//----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- bool CTFWeaponBuilder::Deploy( void ) { bool bDeploy = BaseClass::Deploy(); if ( bDeploy ) { SetCurrentState( BS_PLACING ); StartPlacement(); m_flNextPrimaryAttack = gpGlobals->curtime + 0.35f; m_flNextSecondaryAttack = gpGlobals->curtime; // asap CTFPlayer *pPlayer = ToTFPlayer( GetOwner() ); if (!pPlayer) return false; pPlayer->SetNextAttack( gpGlobals->curtime ); m_iViewModelIndex = modelinfo->GetModelIndex( GetViewModel(0) ); m_iWorldModelIndex = modelinfo->GetModelIndex( GetWorldModel() ); m_flNextDenySound = 0; // Set off the hint here, because we don't know until now if our building // is rotate-able or not. if ( m_hObjectBeingBuilt && !m_hObjectBeingBuilt->MustBeBuiltOnAttachmentPoint() ) { // set the alt-fire hint so it gets removed when we holster m_iAltFireHint = HINT_ALTFIRE_ROTATE_BUILDING; pPlayer->StartHintTimer( m_iAltFireHint ); } } return bDeploy; }
//----------------------------------------------------------------------------- // Purpose: // Output : Returns true on success, false on failure. //----------------------------------------------------------------------------- bool CBaseHL2MPCombatWeapon::Deploy( void ) { // If we should be lowered, deploy in the lowered position // We have to ask the player if the last time it checked, the weapon was lowered if ( GetOwner() && GetOwner()->IsPlayer() ) { CHL2MP_Player *pPlayer = assert_cast<CHL2MP_Player*>( GetOwner() ); if ( pPlayer->IsWeaponLowered() ) { if ( SelectWeightedSequence( ACT_VM_IDLE_LOWERED ) != ACTIVITY_NOT_AVAILABLE ) { if ( DefaultDeploy( (char*)GetViewModel(), (char*)GetWorldModel(), ACT_VM_IDLE_LOWERED, (char*)GetAnimPrefix() ) ) { m_bLowered = true; // Stomp the next attack time to fix the fact that the lower idles are long pPlayer->SetNextAttack( gpGlobals->curtime + 1.0 ); m_flNextPrimaryAttack = gpGlobals->curtime + 1.0; m_flNextSecondaryAttack = gpGlobals->curtime + 1.0; return true; } } } } m_bLowered = false; return BaseClass::Deploy(); }
void CHL2MP_Player::PostThink( void ) { BaseClass::PostThink(); if ( GetFlags() & FL_DUCKING ) { SetCollisionBounds( VEC_CROUCH_TRACE_MIN, VEC_CROUCH_TRACE_MAX ); } m_PlayerAnimState.Update(); // Store the eye angles pitch so the client can compute its animation state correctly. m_angEyeAngles = EyeAngles(); QAngle angles = GetLocalAngles(); angles[PITCH] = 0; SetLocalAngles( angles ); if (!IsDead()) { if (m_afButtonReleased & IN_KICK && m_flNextKickAttack < gpGlobals->curtime /* && m_flNextKickAttack < gpGlobals->curtime && !m_bIsKicking*/) { KickAttack(); m_bIsKicking = true; } } CBaseCombatWeapon *pWeapon = this->GetActiveWeapon(); if (pWeapon != NULL) { if (m_afButtonPressed & IN_IRONSIGHT) { pWeapon->EnableIronsights(); } else if (m_afButtonReleased & IN_IRONSIGHT) { pWeapon->DisableIronsights(); } } if (!IsDead()) { if (m_flNextKickAttack < gpGlobals->curtime) { m_bIsKicking = false; CBaseViewModel *vm = GetViewModel(1); if (vm) { int idealSequence = vm->SelectWeightedSequence(ACT_VM_IDLE); if (idealSequence >= 0) { vm->SendViewModelMatchingSequence(idealSequence); } } } } }
void DesktopSearchResultPoiController::OnPinCreationSelected() { ISearchResultPoiViewModel& viewModel = GetViewModel(); if (viewModel.IsOpen()) { viewModel.Close(); } }
void DesktopSearchResultPoiController::OnInteriorSelectionChanged(const Eegeo::Resources::Interiors::InteriorId& interiorId) { ISearchResultPoiViewModel& viewModel = GetViewModel(); if (viewModel.IsOpen()) { viewModel.Close(); } }
void CWarsWeapon::Equip( CBaseCombatCharacter *pOwner ) { BaseClass::Equip( pOwner ); if ( GetCommander() ) { SetModel( GetViewModel() ); } }
//================= // EV_MuzzleFlash //================= void EV_MuzzleFlash( void ) { // Add muzzle flash to current weapon model edict_t *ent = GetViewModel(); if ( !ent ) return; // Or in the muzzle flash ent->v.effects |= EF_MUZZLEFLASH; }
//----------------------------------------------------------------------------- // Purpose: // Output : Returns true on success, false on failure. //----------------------------------------------------------------------------- bool CWeaponGrapple::Deploy( void ) { if ( m_bMustReload ) { return DefaultDeploy( (char*)GetViewModel(), (char*)GetWorldModel(), ACT_CROSSBOW_DRAW_UNLOADED, (char*)GetAnimPrefix() ); } return BaseClass::Deploy(); }
//----------------------------------------------------------------------------- // Purpose: // Output : Returns true on success, false on failure. //----------------------------------------------------------------------------- bool CWeaponCrossbow::Deploy( void ) { if ( m_iClip1 <= 0 ) { return DefaultDeploy( (char*)GetViewModel(), (char*)GetWorldModel(), ACT_CROSSBOW_DRAW_UNLOADED, (char*)GetAnimPrefix() ); } SetSkin( BOLT_SKIN_GLOW ); return BaseClass::Deploy(); }
void CBasePlayer::CalcViewModelView( const Vector& eyeOrigin, const QAngle& eyeAngles) { for ( int i = 0; i < MAX_VIEWMODELS; i++ ) { CBaseViewModel *vm = GetViewModel( i ); if ( !vm ) continue; vm->CalcViewModelView( this, eyeOrigin, eyeAngles ); } }
int CHud :: MsgFunc_SetSkin( const char *pszName, int iSize, void *pbuf ) { BEGIN_READ( pszName, iSize, pbuf ); edict_t *viewmodel = GetViewModel(); viewmodel->v.skin = READ_BYTE(); END_READ(); return 1; }
bool CWeapon_Tripwire::Deploy( void ) { CBaseCombatCharacter *pOwner = GetOwner(); if (!pOwner) { return false; } SetModel( GetViewModel() ); // ------------------------------ // Pick the right draw animation // ------------------------------ int iActivity; // If detonator is already armed m_bNeedReload = false; iActivity = ACT_SLAM_STICKWALL_ND_DRAW; return DefaultDeploy( (char*)GetViewModel(), (char*)GetWorldModel(), iActivity, (char*)GetAnimPrefix() ); }
void CASW_Weapon::Equip(CBaseCombatCharacter *pOwner) { BaseClass::Equip(pOwner); SetModel( GetViewModel() ); //IHasAttributes *pOwnerAttribInterface = dynamic_cast<IHasAttributes *>( pOwner ); //if ( pOwnerAttribInterface ) //{ //pOwnerAttribInterface->GetAttributeManager()->AddProvider( this ); //} }
void CWeapon_Manhack::Spawn( ) { // Call base class first BaseClass::Spawn(); Precache( ); SetModel( GetViewModel() ); FallInit();// get ready to fall down. m_flBladeYaw = NULL; AddSolidFlags( FSOLID_NOT_SOLID ); }
void CBasePlayer::DoMuzzleFlash() { for ( int i = 0; i < MAX_VIEWMODELS; i++ ) { CBaseViewModel *vm = GetViewModel( i ); if ( !vm ) continue; vm->DoMuzzleFlash(); } BaseClass::DoMuzzleFlash(); }
//----------------------------------------------------------------------------- // Purpose: Sets HL2 specific defaults. //----------------------------------------------------------------------------- void CHL2MP_Player::Spawn(void) { m_flNextModelChangeTime = 0.0f; m_flNextTeamChangeTime = 0.0f; PickDefaultSpawnTeam(); BaseClass::Spawn(); if ( !IsObserver() ) { pl.deadflag = false; RemoveSolidFlags( FSOLID_NOT_SOLID ); RemoveEffects( EF_NODRAW ); GiveDefaultItems(); } SetNumAnimOverlays( 3 ); ResetAnimation(); m_nRenderFX = kRenderNormal; m_Local.m_iHideHUD = 0; AddFlag(FL_ONGROUND); // set the player on the ground at the start of the round. m_impactEnergyScale = HL2MPPLAYER_PHYSDAMAGE_SCALE; if ( HL2MPRules()->IsIntermission() ) { AddFlag( FL_FROZEN ); } else { RemoveFlag( FL_FROZEN ); } m_iSpawnInterpCounter = (m_iSpawnInterpCounter + 1) % 8; m_Local.m_bDucked = false; SetPlayerUnderwater(false); m_bReady = false; m_flNextKickAttack = gpGlobals->curtime; CBaseViewModel *Leg = GetViewModel(1); Leg->SetWeaponModel("models/weapons/v_kick.mdl", NULL); }
void CSDKPlayer::DoMuzzleFlash() { #ifdef CLIENT_DLL if (prediction->InPrediction() && !prediction->IsFirstTimePredicted()) return; C_SDKPlayer* pLocalPlayer = C_SDKPlayer::GetLocalSDKPlayer(); C_WeaponSDKBase* pActiveWeapon = GetActiveSDKWeapon(); if (pLocalPlayer) { if (pLocalPlayer == this && !::input->CAM_IsThirdPerson() || pLocalPlayer->GetObserverMode() == OBS_MODE_IN_EYE && pLocalPlayer->GetObserverTarget() == this) { for ( int i = 0; i < MAX_VIEWMODELS; i++ ) { CBaseViewModel *vm = GetViewModel( i ); if ( !vm ) continue; vm->DoMuzzleFlash(); } } else if (pActiveWeapon) { // Force world model so the attachments work. pActiveWeapon->SetModelIndex( pActiveWeapon->GetWorldModelIndex() ); switch (pActiveWeapon->GetWeaponType()) { case WT_PISTOL: default: pActiveWeapon->ParticleProp()->Create( "muzzleflash_pistol", PATTACH_POINT_FOLLOW, "muzzle" ); break; case WT_SMG: pActiveWeapon->ParticleProp()->Create( "muzzleflash_smg", PATTACH_POINT_FOLLOW, "muzzle" ); break; case WT_RIFLE: pActiveWeapon->ParticleProp()->Create( "muzzleflash_rifle", PATTACH_POINT_FOLLOW, "muzzle" ); break; case WT_SHOTGUN: pActiveWeapon->ParticleProp()->Create( "muzzleflash_shotgun", PATTACH_POINT_FOLLOW, "muzzle" ); break; } } } #endif }
void CHL2MP_Player::CreateViewModel( int index /*=0*/ ) { Assert( index >= 0 && index < MAX_VIEWMODELS ); if ( GetViewModel( index ) ) return; CPredictedViewModel *vm = ( CPredictedViewModel * )CreateEntityByName( "predicted_viewmodel" ); if ( vm ) { vm->SetAbsOrigin( GetAbsOrigin() ); vm->SetOwner( this ); vm->SetIndex( index ); DispatchSpawn( vm ); vm->FollowEntity( this, false ); m_hViewModel.Set( index, vm ); } }
//----------------------------------------------------------------------------- // Purpose: Override base class so player can reset autoaim // Input : // Output : //----------------------------------------------------------------------------- bool CBasePlayer::Weapon_Switch( CBaseCombatWeapon *pWeapon, int viewmodelindex /*=0*/ ) { CBaseCombatWeapon *pLastWeapon = GetActiveWeapon(); if ( BaseClass::Weapon_Switch( pWeapon, viewmodelindex )) { if ( pLastWeapon && Weapon_ShouldSetLast( pLastWeapon, GetActiveWeapon() ) ) { Weapon_SetLast( pLastWeapon->GetLastWeapon() ); } CBaseViewModel *pViewModel = GetViewModel( viewmodelindex ); Assert( pViewModel ); if ( pViewModel ) pViewModel->RemoveEffects( EF_NODRAW ); ResetAutoaim( ); return true; } return false; }
//----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- void CWarsWeapon::SetViewModel() { CUnitBase *pUnit; CHL2WarsPlayer *pOwner; pUnit = GetOwner()->MyUnitPointer(); if ( pUnit ) { pOwner = pUnit->GetCommander(); if( pOwner ) { CBaseViewModel *vm = pOwner->GetViewModel( m_nViewModelIndex ); if ( vm == NULL ) return; Assert( vm->ViewModelIndex() == m_nViewModelIndex ); vm->SetWeaponModel( GetViewModel( m_nViewModelIndex ), this ); } } BaseClass::SetViewModel(); }
//----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- bool C_TFWeaponBuilder::Deploy( void ) { bool bDeploy = BaseClass::Deploy(); if ( bDeploy ) { m_flNextPrimaryAttack = gpGlobals->curtime + 0.35f; m_flNextSecondaryAttack = gpGlobals->curtime; // asap CTFPlayer *pPlayer = ToTFPlayer( GetOwner() ); if (!pPlayer) return false; pPlayer->SetNextAttack( gpGlobals->curtime ); m_iWorldModelIndex = modelinfo->GetModelIndex( GetWorldModel() ); m_iViewModelIndex = modelinfo->GetModelIndex( GetViewModel(0) ); } return bDeploy; }
//----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- bool CWeaponMortar::Deploy( ) { return DefaultDeploy( (char*)GetViewModel(), (char*)GetWorldModel(), ACT_SLAM_TRIPMINE_DRAW, (char*)GetAnimPrefix() ); }
void HUD_UpdateEntityVars( edict_t *ent, const entity_state_t *state, const entity_state_t *prev ) { float m_fLerp; if( state->ed_type == ED_CLIENT && state->ed_flags & ESF_NO_PREDICTION ) m_fLerp = 1.0f; else m_fLerp = GetLerpFrac(); if( state->flags & FL_PROJECTILE && state->ed_flags & ( ESF_NO_PREDICTION|ESF_NODELTA )) { // cut rocket trail, dont pass it from teleport // FIXME: don't work g_pViewRenderBeams->KillDeadBeams( ent ); } // copy state to progs ent->v.modelindex = state->modelindex; ent->v.weaponmodel = state->weaponmodel; ent->v.sequence = state->sequence; ent->v.gaitsequence = state->gaitsequence; ent->v.body = state->body; ent->v.skin = state->skin; ent->v.effects = state->effects; ent->v.velocity = state->velocity; ent->v.basevelocity = state->basevelocity; ent->v.oldorigin = ent->v.origin; // previous origin holds ent->v.mins = state->mins; ent->v.maxs = state->maxs; ent->v.framerate = state->framerate; ent->v.colormap = state->colormap; ent->v.rendermode = state->rendermode; ent->v.renderfx = state->renderfx; ent->v.fov = state->fov; ent->v.scale = state->scale; ent->v.weapons = state->weapons; ent->v.gravity = state->gravity; ent->v.health = state->health; ent->v.solid = state->solid; ent->v.movetype = state->movetype; ent->v.flags = state->flags; ent->v.ideal_pitch = state->idealpitch; ent->v.animtime = state->animtime; ent->v.ltime = state->localtime; if( state->groundent != -1 ) ent->v.groundentity = GetEntityByIndex( state->groundent ); else ent->v.groundentity = NULL; if( state->aiment != -1 ) ent->v.aiment = GetEntityByIndex( state->aiment ); else ent->v.aiment = NULL; switch( ent->v.movetype ) { case MOVETYPE_NONE: case MOVETYPE_STEP: // monster's steps will be interpolated on render-side ent->v.origin = state->origin; ent->v.angles = state->angles; ent->v.oldorigin = prev->origin; // used for lerp 'monster view' ent->v.oldangles = prev->angles; // used for lerp 'monster view' break; default: ent->v.angles = LerpAngle( prev->angles, state->angles, m_fLerp ); ent->v.origin = LerpPoint( prev->origin, state->origin, m_fLerp ); ent->v.basevelocity = LerpPoint( prev->basevelocity, state->basevelocity, m_fLerp ); break; } // interpolate scale, renderamount etc ent->v.scale = LerpPoint( prev->scale, state->scale, m_fLerp ); ent->v.rendercolor = LerpPoint( prev->rendercolor, state->rendercolor, m_fLerp ); ent->v.renderamt = LerpPoint( prev->renderamt, state->renderamt, m_fLerp ); if( ent->v.animtime ) { // use normal studio lerping ent->v.frame = state->frame; } else { // round sprite and brushmodel frames ent->v.frame = Q_rint( state->frame ); } switch( state->ed_type ) { case ED_CLIENT: ent->v.punchangle = LerpAngle( prev->punch_angles, state->punch_angles, m_fLerp ); ent->v.viewangles = LerpAngle( prev->viewangles, state->viewangles, m_fLerp ); ent->v.view_ofs = LerpPoint( prev->viewoffset, state->viewoffset, m_fLerp ); if( prev->fov != 90.0f && state->fov == 90.0f ) ent->v.fov = state->fov; // fov is reset, so don't lerping else ent->v.fov = LerpPoint( prev->fov, state->fov, m_fLerp ); ent->v.maxspeed = state->maxspeed; ent->v.iStepLeft = state->iStepLeft; ent->v.flFallVelocity = state->flFallVelocity; if( ent == GetLocalPlayer()) { edict_t *viewent = GetViewModel(); // if viewmodel has changed update sequence here if( viewent->v.modelindex != state->viewmodel ) { // ALERT( at_console, "Viewmodel changed\n" ); SendWeaponAnim( viewent->v.sequence, viewent->v.body, viewent->v.framerate ); } // setup player viewmodel (only for local player!) viewent->v.modelindex = state->viewmodel; gHUD.m_flFOV = ent->v.fov; // keep client fov an actual } break; case ED_PORTAL: case ED_MOVER: case ED_BSPBRUSH: ent->v.movedir = BitsToDir( state->body ); ent->v.oldorigin = state->oldorigin; break; case ED_SKYPORTAL: { skyportal_t *sky = &gpViewParams->skyportal; // setup sky portal sky->vieworg = ent->v.origin; sky->viewanglesOffset.x = sky->viewanglesOffset.z = 0.0f; sky->viewanglesOffset.y = gHUD.m_flTime * ent->v.angles[1]; sky->scale = (ent->v.scale ? 1.0f / ent->v.scale : 0.0f ); // critical stuff sky->fov = ent->v.fov; } break; case ED_BEAM: ent->v.oldorigin = state->oldorigin; // beam endpoint ent->v.frags = state->gaitsequence; if( state->owner != -1 ) ent->v.owner = GetEntityByIndex( state->owner ); else ent->v.owner = NULL; // add server beam now g_pViewRenderBeams->AddServerBeam( ent ); break; default: ent->v.movedir = Vector( 0, 0, 0 ); break; } int i; // copy blendings for( i = 0; i < MAXSTUDIOBLENDS; i++ ) ent->v.blending[i] = state->blending[i]; // copy controllers for( i = 0; i < MAXSTUDIOCONTROLLERS; i++ ) ent->v.controller[i] = state->controller[i]; // g-cont. moved here because we may needs apply null scale to skyportal if( ent->v.scale == 0.0f && ent->v.skin >= 0 ) ent->v.scale = 1.0f; ent->v.pContainingEntity = ent; }
void CHL2MP_Player::KickAttack(void) { if (!IsDead()) { CBaseViewModel *vm = GetViewModel(1); if (vm) { int idealSequence = vm->SelectWeightedSequence(ACT_VM_PRIMARYATTACK); if (idealSequence >= 0) { vm->SendViewModelMatchingSequence(idealSequence); m_flNextKickAttack = gpGlobals->curtime + vm->SequenceDuration(idealSequence) - 0.5f; } QAngle recoil = QAngle(random->RandomFloat(1.0f, 2.0f), random->RandomFloat(-1.0f, 1.0f), 0); this->ViewPunch(recoil); // Trace up or down based on where the enemy is... // But only if we're basically facing that direction Vector vecDirection; int kick_maxrange = 120; AngleVectors(QAngle(clamp(EyeAngles().x, 20, kick_maxrange), EyeAngles().y, EyeAngles().z), &vecDirection); CBaseEntity *pEnemy = MyNPCPointer() ? MyNPCPointer()->GetEnemy() : NULL; if (pEnemy) { Vector vecDelta; VectorSubtract(pEnemy->WorldSpaceCenter(), Weapon_ShootPosition(), vecDelta); VectorNormalize(vecDelta); Vector2D vecDelta2D = vecDelta.AsVector2D(); Vector2DNormalize(vecDelta2D); if (DotProduct2D(vecDelta2D, vecDirection.AsVector2D()) > 0.8f) { vecDirection = vecDelta; } } Vector vecEnd; VectorMA(Weapon_ShootPosition(), 50, vecDirection, vecEnd); trace_t tr; UTIL_TraceHull(Weapon_ShootPosition(), vecEnd, Vector(-16, -16, -16), Vector(16, 16, 16), MASK_SHOT_HULL, this, COLLISION_GROUP_NONE, &tr); // did I hit someone? float KickDamageMult = 50 + (1 * ((fabs(GetAbsVelocity().x) + fabs(GetAbsVelocity().y) + fabs(GetAbsVelocity().z)) / 48)); float KickThrowForceMult = 20 + (1 * ((fabs(GetAbsVelocity().x) + fabs(GetAbsVelocity().y) + fabs(GetAbsVelocity().z)) / 48)); DevMsg("Kicking at %.2f of damage!\n", KickDamageMult); DevMsg("Kicking at %.2f of force!\n", KickThrowForceMult); if (tr.m_pEnt) { if (!(tr.m_pEnt)) { // return; } else { CBasePropDoor *pDoor = dynamic_cast<CBasePropDoor*>((CBaseEntity*)tr.m_pEnt); if (pDoor) { if (pDoor->HasSpawnFlags(SF_BREAKABLE_BY_PLAYER)) { AngularImpulse angVelocity(random->RandomFloat(0, 45), 18, random->RandomFloat(-45, 45)); pDoor->PlayBreakOpenSound(); pDoor->BreakDoor(Weapon_ShootPosition(), angVelocity); return; } pDoor->PlayBreakFailSound(); pDoor->KickFail(); return; } CBaseEntity *Victim = this->CheckTraceHullAttack(Weapon_ShootPosition(), vecEnd, Vector(-16, -16, -16), Vector(16, 16, 16), KickDamageMult, DMG_CRUSH, KickThrowForceMult, true); if (Victim) { EmitSound("HL2Player.kick_body"); return; } } } UTIL_TraceLine(Weapon_ShootPosition(), vecEnd, MASK_SHOT_HULL, this, COLLISION_GROUP_NONE, &tr);//IF we hit anything else if (tr.DidHit()) { EmitSound("HL2Player.kick_wall"); } else { EmitSound("HL2Player.kick_fire"); } } } }