//-----------------------------------------------------------------------
void CSpectacularKill::DeathBlow(CActor& targetActor)
{
CRY_ASSERT_MESSAGE(m_isBusy, "spectacular kill should be in progress when triggering the death blow");
if (!m_isBusy)
return;
if (targetActor.IsDead())
return;
Vec3 targetDir = targetActor.GetEntity()->GetForwardDir();
{
HitInfo hitInfo;
hitInfo.shooterId = m_pOwner->GetEntityId();
hitInfo.targetId = targetActor.GetEntityId();
hitInfo.damage = 99999.0f; // CERTAIN_DEATH
hitInfo.dir = targetDir;
hitInfo.normal = -hitInfo.dir; // this has to be in an opposite direction from the hitInfo.dir or the hit is ignored as a 'backface' hit
hitInfo.type = CGameRules::EHitType::StealthKill;
g_pGame->GetGameRules()->ClientHit(hitInfo);
}
// WARNING: RagDollize resets the entity's rotation!
// [7/30/2010 davidr] FixMe: If the entity isn't dead here (because is immortal or any other reason) ragdollizing it will
// leave it on an inconsistent state (usually only reproducible on debug scenarios)
targetActor.GetGameObject()->SetAspectProfile(eEA_Physics, eAP_Ragdoll);
// Give a small nudge in the hit direction to make the target fall over
const SSpectacularKillParams* pSpectacularKillParams = GetParamsForClass(targetActor.GetEntity()->GetClass());
CRY_ASSERT(pSpectacularKillParams);
if (pSpectacularKillParams && (pSpectacularKillParams->impulseScale > 0.0f) && (pSpectacularKillParams->impulseBone != -1))
{
const float killDeathBlowVelocity = pSpectacularKillParams->impulseScale; // desired velocity after impulse in meters per second
IPhysicalEntity* pTargetPhysics = targetActor.GetEntity()->GetPhysics();
if (pTargetPhysics)
{
pe_simulation_params simulationParams;
pTargetPhysics->GetParams(&simulationParams);
pe_action_impulse impulse;
impulse.partid = pSpectacularKillParams->impulseBone;
impulse.impulse = targetDir*killDeathBlowVelocity*simulationParams.mass; // RagDollize reset the entity's rotation so I have to use the value I cached earlier
pTargetPhysics->Action(&impulse);
}
}
m_deathBlowState = eDBS_Done;
}
IMPLEMENT_RMI(CGameRules, ClEnteredGame)
{
if(!gEnv->bServer && m_pGameFramework->GetClientActor())
{
CActor* pActor = GetActorByChannelId(m_pGameFramework->GetClientActor()->GetChannelId());
if(pActor)
{
int status[2];
status[0] = GetTeam(pActor->GetEntityId());
status[1] = pActor->GetSpectatorMode();
m_pGameplayRecorder->Event(pActor->GetEntity(), GameplayEvent(eGE_Connected, 0, 0, (void*)status));
}
}
return true;
}
int CScriptBind_Actor::SetViewShake(IFunctionHandler *pH, Ang3 shakeAngle, Vec3 shakeShift, float duration, float frequency, float randomness)
{
CActor *pActor = GetActor(pH);
if (!pActor)
return pH->EndFunction();
EntityId actorId = pActor->GetEntityId();
IView* pView = m_pGameFW->GetIViewSystem()->GetViewByEntityId(actorId);
if (pView)
{
const int SCRIPT_SHAKE_ID = 42;
pView->SetViewShake(shakeAngle, shakeShift, duration, frequency, randomness, SCRIPT_SHAKE_ID);
}
return pH->EndFunction();
}
//-----------------------------------------------------------------------
void CSpectacularKill::Update(float frameTime)
{
CActor* pTargetActor = GetTarget();
if (IsBusy())
{
ICooperativeAnimationManager* pCooperativeAnimationManager = gEnv->pGame->GetIGameFramework()->GetICooperativeAnimationManager();
if (!pTargetActor ||
(!pCooperativeAnimationManager->IsActorBusy(m_pOwner->GetEntityId()) &&
!pCooperativeAnimationManager->IsActorBusy(pTargetActor->GetEntityId())) ||
(pTargetActor->IsDead() && (m_deathBlowState == eDBS_None)))
{
End();
}
}
}
//------------------------------------------------------------------------
bool CEditorGame::SetGameMode(bool bGameMode)
{
m_bGameMode = bGameMode;
bool on = bGameMode;
if (s_pEditorGameMode->GetIVal() == 0)
{
on = m_bPlayer;
}
bool ok = ConfigureNetContext( on );
if (ok)
{
if(gEnv->IsEditor())
{
m_pGame->EditorResetGame(bGameMode);
}
IGameFramework *pGameFramework = m_pGame->GetIGameFramework();
pGameFramework->OnEditorSetGameMode(bGameMode);
CActor *pActor = static_cast<CActor *>(m_pGame->GetIGameFramework()->GetClientActor());
if (pActor)
{
if (bGameMode)
{
// Revive actor in its current location (it will be moved to the editor viewpoint location later)
const Vec3 pos = pActor->GetEntity()->GetWorldPos();
const Quat rot = pActor->GetEntity()->GetWorldRotation();
const int teamId = g_pGame->GetGameRules()->GetTeam(pActor->GetEntityId());
pActor->NetReviveAt(pos, rot, teamId);
}
else
{
pActor->Reset(true);
}
}
}
else
{
GameWarning("Failed configuring net context");
}
return ok;
}
//------------------------------------------------------------------------
void CRapid::StopFire()
{
m_startedToFire = false;
if (m_pWeapon->IsBusy() && !m_pWeapon->IsZoomingInOrOut())
{
return;
}
if (m_zoomtimeout > 0.0f)
{
CActor *pActor = m_pWeapon->GetOwnerActor();
CScreenEffects *pSE = pActor ? pActor->GetScreenEffects() : NULL;
if (pSE)
{
float speed = 1.0f / .1f;
pSE->ResetBlendGroup(CScreenEffects::eSFX_GID_ZoomIn);
pSE->ResetBlendGroup(CScreenEffects::eSFX_GID_ZoomOut);
IBlendedEffect *fov = CBlendedEffect<CFOVEffect>::Create(CFOVEffect(pActor->GetEntityId(), 1.0f));
IBlendType *blend = CBlendType<CLinearBlend>::Create(CLinearBlend(1.0f));
pSE->StartBlend(fov, blend, speed, CScreenEffects::eSFX_GID_ZoomOut);
}
m_zoomtimeout = 0.0f;
}
if(m_acceleration >= 0.0f)
{
Accelerate(m_pShared->rapidparams.deceleration);
if (m_pWeapon->IsDestroyed())
{
FinishDeceleration();
}
}
SpinUpEffect(false);
if(m_firing)
{
SmokeEffect();
}
m_pWeapon->RequestStopFire();
}
void CAutoAimManager::RegisterCharacterTargetInfo(const CActor& targetActor, const SAutoaimTargetRegisterParams& registerParams)
{
SAutoaimTarget aimTarget;
aimTarget.entityId = targetActor.GetEntityId();
aimTarget.pActorWeak = targetActor.GetWeakPtr();
aimTarget.fallbackOffset = registerParams.fallbackOffset;
aimTarget.primaryBoneId = registerParams.primaryBoneId;
aimTarget.physicsBoneId = registerParams.physicsBoneId;
aimTarget.secondaryBoneId = registerParams.secondaryBoneId;
aimTarget.innerRadius = registerParams.innerRadius;
aimTarget.outerRadius = registerParams.outerRadius;
aimTarget.snapRadius = registerParams.snapRadius;
aimTarget.snapRadiusTagged = registerParams.snapRadiusTagged;
if (!gEnv->bMultiplayer)
{
IEntity* pTargetEntity = targetActor.GetEntity();
aimTarget.aiFaction = IFactionMap::InvalidFactionID;
//Instance properties, other stuff could be added here easily (grab enemy, sliding hit, etc)
SmartScriptTable props;
SmartScriptTable propsPlayerInteractions;
IScriptTable* pScriptTable = pTargetEntity->GetScriptTable();
if (pScriptTable && pScriptTable->GetValue("Properties", props))
{
if (props->GetValue("PlayerInteractions", propsPlayerInteractions))
{
int stealhKill = 0;
if (propsPlayerInteractions->GetValue("bStealthKill", stealhKill) && (stealhKill != 0))
{
aimTarget.SetFlag(eAATF_StealthKillable);
}
int canBeGrabbed = 0;
if (propsPlayerInteractions->GetValue("bCanBeGrabbed", canBeGrabbed) && (canBeGrabbed != 0))
{
aimTarget.SetFlag(eAATF_CanBeGrabbed);
}
}
}
}
m_autoaimTargets.push_back(aimTarget);
}
//------------------------------------------------------------------------
int CScriptBind_Actor::IsGhostPit(IFunctionHandler *pH)
{
CActor *pActor = GetActor(pH);
if (!pActor)
return pH->EndFunction();
bool hidden = false;
if (IVehicle* pVehicle = pActor->GetLinkedVehicle())
{
IVehicleSeat* pSeat = pVehicle->GetSeatForPassenger(pActor->GetEntityId());
if (pSeat)
{
if (IVehicleView* pView = pSeat->GetView(pSeat->GetCurrentView()))
hidden = pView->IsPassengerHidden();
}
}
return pH->EndFunction(hidden);
}
bool CAutoAimManager::RegisterAutoaimTargetActor(const CActor& targetActor, const SAutoaimTargetRegisterParams& registerParams)
{
if (IsEntityRegistered(targetActor.GetEntityId()))
{
GameWarning("Trying to register entity more than once in auto aim manager!");
return false;
}
if (!IsSpaceAvailable())
{
if (gEnv->IsEditor() == false)
{
GameWarning("Maximum number of entities reached for auto aim manager (%d)!", kMaxAutoaimTargets);
}
return false;
}
RegisterCharacterTargetInfo(targetActor, registerParams);
return true;
}
//------------------------------------------------------------------------
void CAutomatic::StopFire()
{
if(m_zoomtimeout > 0.0f)
{
CActor *pActor = m_pWeapon->GetOwnerActor();
CScreenEffects *pSE = pActor?pActor->GetScreenEffects():NULL;
if(pSE)
{
pSE->ResetBlendGroup(CScreenEffects::eSFX_GID_ZoomIn);
// this is so we will zoom out always at the right speed
//float speed = (1.0f/.1f) * (1.0f - pActor->GetScreenEffects()->GetCurrentFOV())/(1.0f - .75f);
//speed = fabs(speed);
float speed = 1.0f/.1f;
//if (pActor->GetScreenEffects()->HasJobs(pActor->m_autoZoomOutID))
// speed = pActor->GetScreenEffects()->GetAdjustedSpeed(pActor->m_autoZoomOutID);
pSE->ResetBlendGroup(CScreenEffects::eSFX_GID_ZoomOut);
IBlendedEffect *fov = CBlendedEffect<CFOVEffect>::Create(CFOVEffect(pActor->GetEntityId(),1.0f));
IBlendType *blend = CBlendType<CLinearBlend>::Create(CLinearBlend(1.0f));
pSE->StartBlend(fov, blend, speed, CScreenEffects::eSFX_GID_ZoomOut);
}
m_zoomtimeout = 0.0f;
}
if(m_firing)
SmokeEffect();
m_firing = false;
if(m_soundId)
{
m_pWeapon->StopSound(m_soundId);
m_soundId = INVALID_SOUNDID;
}
}
void CUIObjectives::OnRequestMissionObjectives( const SUIEvent& event )
{
CGameRules* pGameRules = GetGameRules();
if ( pGameRules && g_pGame->GetIGameFramework()->GetClientActor() )
{
CActor* pActor = pGameRules->GetActorByChannelId( g_pGame->GetIGameFramework()->GetClientActor()->GetChannelId() );
if ( pActor )
{
std::map< string, int > tmpList;
int teamID = pGameRules->GetTeam( pActor->GetEntityId() );
for ( TObjectiveMap::iterator it = m_ObjectiveMap.begin(); it != m_ObjectiveMap.end(); ++it )
{
CGameRules::TObjective* pObjective = pGameRules->GetObjective( teamID, it->first.c_str() );
if ( pObjective )
tmpList[ it->first ] = pObjective->status;
}
for ( std::map< string, int >::iterator it = tmpList.begin(); it != tmpList.end(); ++it )
MissionObjectiveAdded( it->first, it->second );
}
}
}
//--------------------------------------------------------
EntityId CMelee::GetNearestTarget()
{
CActor* pOwnerActor = m_pWeapon->GetOwnerActor();
if(pOwnerActor == NULL || (gEnv->bMultiplayer && m_slideKick))
return 0;
CRY_ASSERT(pOwnerActor->IsClient());
IMovementController* pMovementController = pOwnerActor->GetMovementController();
if (!pMovementController)
return 0;
SMovementState moveState;
pMovementController->GetMovementState(moveState);
const Vec3 playerDir = moveState.aimDirection;
const Vec3 playerPos = moveState.eyePosition;
const float range = g_pGameCVars->pl_melee.melee_snap_target_select_range;
const float angleLimit = cos_tpl(DEG2RAD(g_pGameCVars->pl_melee.melee_snap_angle_limit));
return m_collisionHelper.GetBestAutoAimTargetForUser(pOwnerActor->GetEntityId(), playerPos, playerDir, range, angleLimit);
}
void CHUDTagNames::Update()
{
CActor *pClientActor = static_cast<CActor *>(g_pGame->GetIGameFramework()->GetClientActor());
CGameRules *pGameRules = g_pGame->GetGameRules();
if(!pClientActor || !pGameRules || !gEnv->bMultiplayer)
return;
int iClientTeam = pGameRules->GetTeam(pClientActor->GetEntityId());
// Skip enemies, they need to be added only when shot
// (except in spectator mode when we display everyone)
for(int iTeam = 0; iTeam < pGameRules->GetTeamCount() + 1; ++iTeam)
{
if((iTeam == iClientTeam) || (pClientActor->GetSpectatorMode() != CActor::eASM_None))
{
int iTeamPlayerCount = pGameRules->GetTeamPlayerCount(iTeam);
for(int iPlayer=0; iPlayer<iTeamPlayerCount; iPlayer++)
{
IActor *pActor = g_pGame->GetIGameFramework()->GetIActorSystem()->GetActor(pGameRules->GetTeamPlayer(iTeam,iPlayer));
if(!pActor)
continue;
// Never display the local player
if(pActor == pClientActor)
continue;
// never display other spectators
if(static_cast<CActor*>(pActor)->GetSpectatorMode() != CActor::eASM_None)
continue;
// never display the name of the player we're spectating (it's shown separately with their current health)
if(pClientActor->GetSpectatorMode() == CActor::eASM_Follow && pClientActor->GetSpectatorTarget() == pActor->GetEntityId())
continue;
DrawTagName(pActor);
}
}
}
IVehicleSystem *pVehicleSystem = gEnv->pGame->GetIGameFramework()->GetIVehicleSystem();
if(!pVehicleSystem)
return;
IVehicleIteratorPtr pVehicleIter = pVehicleSystem->CreateVehicleIterator();
while(IVehicle *pVehicle=pVehicleIter->Next())
{
SVehicleStatus rVehicleStatus = pVehicle->GetStatus();
if(0 == rVehicleStatus.passengerCount)
continue;
// Skip enemy vehicles, they need to be added only when shot (except in spectator mode...)
bool bEnemyVehicle = true;
for(int iSeatId=1; iSeatId<=pVehicle->GetLastSeatId(); iSeatId++)
{
IVehicleSeat *pVehicleSeat = pVehicle->GetSeatById(iSeatId);
if(!pVehicleSeat)
continue;
EntityId uiEntityId = pVehicleSeat->GetPassenger();
if(0 == iClientTeam)
{
if(uiEntityId && IsFriendlyToClient(uiEntityId))
{
bEnemyVehicle = false;
}
}
else if(uiEntityId && pGameRules->GetTeam(uiEntityId) == iClientTeam)
{
bEnemyVehicle = false;
}
}
if(bEnemyVehicle && (pClientActor->GetSpectatorMode() == CActor::eASM_None)) // again, draw enemies in spectator mode
continue;
DrawTagName(pVehicle);
}
// don't need to do any of this if we're in spectator mode - all player names will have been drawn above.
if(pClientActor->GetSpectatorMode() == CActor::eASM_None)
{
for(TEnemyTagNamesList::iterator iter=m_enemyTagNamesList.begin(); iter!=m_enemyTagNamesList.end(); ++iter)
{
SEnemyTagName *pEnemyTagName = &(*iter);
if(gEnv->pTimer->GetAsyncTime().GetSeconds() >= pEnemyTagName->fSpawnTime+((float) g_pGameCVars->hud_mpNamesDuration))
{
// Note: iter=my_list.erase(iter) may not be standard/safe
TEnemyTagNamesList::iterator iterNext = iter;
++iterNext;
m_enemyTagNamesList.erase(iter);
iter = iterNext;
}
else
{
IActor *pActor = g_pGame->GetIGameFramework()->GetIActorSystem()->GetActor(pEnemyTagName->uiEntityId);
if(pActor)
DrawTagName(pActor);
IVehicle *pVehicle = gEnv->pGame->GetIGameFramework()->GetIVehicleSystem()->GetVehicle(pEnemyTagName->uiEntityId);
if(pVehicle)
DrawTagName(pVehicle);
}
}
}
}
void CHUDTagNames::DrawTagName(IVehicle *pVehicle)
{
CRY_ASSERT(pVehicle);
if(!pVehicle)
return;
CActor *pClientActor = static_cast<CActor *>(g_pGame->GetIGameFramework()->GetClientActor());
CGameRules *pGameRules = g_pGame->GetGameRules();
int iClientTeam = pGameRules->GetTeam(pClientActor->GetEntityId());
bool bThirdPerson = pClientActor->IsThirdPerson();
bool bDrawSeatTagNames = false;
if(pClientActor->GetSpectatorMode() == CActor::eASM_Follow)
{
IActor *pFollowedActor = g_pGame->GetIGameFramework()->GetIActorSystem()->GetActor(pClientActor->GetSpectatorTarget());
if(pFollowedActor)
bDrawSeatTagNames = (pVehicle == pFollowedActor->GetLinkedVehicle());
}
else
bDrawSeatTagNames = (pVehicle == pClientActor->GetLinkedVehicle());
if(bDrawSeatTagNames)
{
// When this is local player vehicle, we always display all passengers name above their head so that he can identify them
for(int iSeatId=1; iSeatId<=pVehicle->GetLastSeatId(); iSeatId++)
{
IVehicleSeat *pVehicleSeat = pVehicle->GetSeatById(iSeatId);
if(!pVehicleSeat)
continue;
IActor *pActor = g_pGame->GetIGameFramework()->GetIActorSystem()->GetActor(pVehicleSeat->GetPassenger());
if(!pActor || (pActor == pClientActor && !bThirdPerson))
continue;
DrawTagName(pActor,true);
}
return;
}
ColorF rgbTagName = COLOR_ENEMY;
// Driver seat is always 1
IVehicleSeat *pVehicleSeat = pVehicle->GetSeatById(1);
if(!pVehicleSeat)
return;
IVehicleHelper *pVehicleHelper = pVehicleSeat->GetSitHelper();
if(!pVehicleHelper)
return;
Vec3 vWorldPos = pVehicleHelper->GetWorldTM().GetTranslation();
// Add some offset to be above the driver/pilot
vWorldPos.z += 1.2f;
AABB box;
pVehicle->GetEntity()->GetWorldBounds(box);
bool bDrawOnTop = false;
if(ProjectOnSphere(vWorldPos,box))
{
bDrawOnTop = true;
}
m_tagNamesVector.resize(0);
for(int iSeatId=1; iSeatId<=pVehicle->GetLastSeatId(); iSeatId++)
{
IVehicleSeat *pVehicleSeat = pVehicle->GetSeatById(iSeatId);
if(!pVehicleSeat)
continue;
EntityId uiEntityId = pVehicleSeat->GetPassenger();
IActor *pActor = g_pGame->GetIGameFramework()->GetIActorSystem()->GetActor(uiEntityId);
if(!pActor)
continue;
const char *szRank = GetPlayerRank(uiEntityId);
IEntity *pEntity = pActor->GetEntity();
if(!pEntity)
continue;
char szText[HUD_MAX_STRING_SIZE];
if(szRank)
{
sprintf(szText,"%s %s",szRank,pEntity->GetName());
}
else
{
sprintf(szText,"%s",pEntity->GetName());
}
if(0 == iClientTeam)
{
if(uiEntityId && IsFriendlyToClient(uiEntityId))
{
rgbTagName = COLOR_FRIEND;
}
}
else if(uiEntityId && pGameRules->GetTeam(uiEntityId) == iClientTeam)
{
rgbTagName = COLOR_FRIEND;
}
if(pActor->GetHealth() <= 0)
{
rgbTagName = COLOR_DEAD;
}
m_tagNamesVector.resize(m_tagNamesVector.size()+1);
STagName *pTagName = &m_tagNamesVector[m_tagNamesVector.size()-1];
pTagName->strName = szText;
pTagName->vWorld = vWorldPos;
pTagName->bDrawOnTop = bDrawOnTop;
pTagName->rgb = rgbTagName;
}
DrawTagNames();
}