//------------------------------------------------------------------------
int CVehicleUsableActionEnter::OnEvent(int eventType, SVehicleEventParams& eventParams)
{
if (eventType == eVAE_IsUsable)
{
EntityId& userId = eventParams.entityId;
for (TVehicleSeatIdVector::iterator ite = m_seatIds.begin(), end = m_seatIds.end(); ite != end; ++ite)
{
TVehicleSeatId seatId = *ite;
IVehicleSeat* pSeat = m_pVehicle->GetSeatById(seatId);
if (IsSeatAvailable(pSeat, userId))
{
eventParams.iParam = seatId;
return 1;
}
}
return 0;
}
else if (eventType == eVAE_OnUsed)
{
EntityId& userId = eventParams.entityId;
IVehicleSeat* pSeat = m_pVehicle->GetSeatById(eventParams.iParam);
if (IsSeatAvailable(pSeat, userId))
return pSeat->Enter(userId);
return -1;
}
return 0;
}
void CHUD::IndicateHit(bool enemyIndicator,IEntity *pEntity, bool explosionFeedback)
{
CPlayer *pPlayer = static_cast<CPlayer *>(gEnv->pGame->GetIGameFramework()->GetClientActor());
if(!pPlayer)
return;
if(explosionFeedback)
PlaySound(ESound_SpecialHitFeedback);
if(!pPlayer->GetLinkedVehicle())
m_pHUDCrosshair->GetFlashAnim()->Invoke("indicateHit");
else
{
IVehicleSeat *pSeat = pPlayer->GetLinkedVehicle()->GetSeatForPassenger(pPlayer->GetEntityId());
if(pSeat && !pSeat->IsDriver())
m_pHUDCrosshair->GetFlashAnim()->Invoke("indicateHit");
else
{
m_pHUDVehicleInterface->m_animMainWindow.Invoke("indicateHit", enemyIndicator);
if(pEntity && !gEnv->bMultiplayer)
{
float r = ((unsigned char) ((g_pGameCVars->hud_colorLine >> 16) & 0xFF)) / 255.0f;
float g = ((unsigned char) ((g_pGameCVars->hud_colorLine >> 8) & 0xFF)) / 255.0f;
float b = ((unsigned char) ((g_pGameCVars->hud_colorLine >> 0) & 0xFF)) / 255.0f;
// It should be useless to test if pEntity is an enemy (it's already done by caller func)
IActor *pActor = gEnv->pGame->GetIGameFramework()->GetIActorSystem()->GetActor(pEntity->GetId());
if(pActor)
m_pHUDSilhouettes->SetSilhouette(pActor,r,g,b,1.0f,5.0f,true);
else if(IVehicle *pVehicle = gEnv->pGame->GetIGameFramework()->GetIVehicleSystem()->GetVehicle(pEntity->GetId()))
m_pHUDSilhouettes->SetSilhouette(pVehicle,r,g,b,1.0f,5.0f);
}
}
}
void CVTOLVehicleManager::LockSeats(IVehicle* pVehicle, bool lock)
{
EVehicleSeatLockStatus newStatus = lock ? eVSLS_LockedForPlayers : eVSLS_Unlocked;
const int numSeats = pVehicle->GetSeatCount();
for(int i = 1; i <= numSeats; ++i)
{
IVehicleSeat* pSeat = pVehicle->GetSeatById(i);
if(pSeat && pSeat->GetLockedStatus() != eVSLS_Locked)
{
pSeat->SetLocked(newStatus);
}
}
}
//------------------------------------------------------------------------
int CScriptBind_Vehicle::EnterVehicle(IFunctionHandler* pH, ScriptHandle actorHandle, int seatId, bool isAnimationEnabled)
{
CVehicle* pVehicle = GetVehicle(pH);
if (!pVehicle || !actorHandle.n)
return pH->EndFunction(0);
IVehicleSeat* pSeat = pVehicle->GetSeatById(seatId);
bool ret = false;
if (pSeat)
ret = pSeat->Enter((EntityId)actorHandle.n, isAnimationEnabled);
return pH->EndFunction(ret);
}
//------------------------------------------------------------------------
bool CVehicleWeapon::CanZoom() const
{
if (!CWeapon::CanZoom())
return false;
if (!m_bOwnerInSeat)
return false;
IVehicle *pVehicle = GetVehicle();
if(!pVehicle)
return false;
IActor* pActor = GetOwnerActor();
IVehicleSeat* pSeat = pActor ? pVehicle->GetSeatForPassenger(pActor->GetEntityId()) : NULL;
IVehicleView* pView = pSeat ? pSeat->GetCurrentView() : NULL;
if (pView && pView->IsThirdPerson())
return false;
return true;
}
//------------------------------------------------------------------------
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 CVehicleMountedWeapon::CanZoom() const
{
if (!CHeavyMountedWeapon::CanZoom())
return false;
IVehicle *pVehicle = gEnv->pGame->GetIGameFramework()->GetIVehicleSystem()->GetVehicle(m_vehicleId);
if(pVehicle && !IsRippedOff())
{
if (m_pSeatUser != m_pOwnerSeat)
return false;
IActor* pActor = GetOwnerActor();
IVehicleSeat* pSeat = pActor ? pVehicle->GetSeatForPassenger(pActor->GetEntityId()) : NULL;
IVehicleView* pView = pSeat ? pSeat->GetCurrentView() : NULL;
if (pView && pView->IsThirdPerson())
return false;
}
return true;
}
void SetActive(const bool bActive)
{
if (m_bActive == bActive)
return;
m_bActive = bActive;
IVehicle* pVehicle;
pVehicle = gEnv->pGame->GetIGameFramework()->GetIVehicleSystem()->GetVehicle(m_entityId);
if (bActive)
{
CRY_ASSERT(pVehicle);
m_fStartedTime = gEnv->pTimer->GetFrameStartTime().GetSeconds();
m_actInfo.pGraph->SetRegularlyUpdated(m_actInfo.myID, true);
if (pVehicle)
{
pVehicle->RegisterVehicleEventListener(this, "CFlowVehicleDriveForward");
}
ActivateOutput(&m_actInfo, EOP_Started, true);
}
else
{
m_bNeedsCleanup = true; // To ensure event listener gets cleaned up when its safe to do so
if (pVehicle)
{
if (pVehicle->GetSeatCount() != 0) // Restore back
{
IVehicleSeat* pSeat = pVehicle->GetSeatById(1);
if (pSeat)
{
pSeat->SetLocked(m_prevSeatLockStatus);
//pSeat->ExitRemotely();
}
}
}
}
}
//-----------------------------------------------------------------------
void CVehiclePartLight::UpdateLight(const float frameTime)
{
if (m_slot == -1)
return;
// move to vehicle event change view?
if (m_diffuseMult[0] != m_diffuseMult[1])
{
SEntitySlotInfo info;
if (m_pVehicle->GetEntity()->GetSlotInfo(m_slot, info) && info.pLight)
{
CDLight& light = info.pLight->GetLightProperties();
IActor* pActor = CCryAction::GetCryAction()->GetClientActor();
bool localPlayer = (pActor != NULL) && (pActor->GetLinkedVehicle() == m_pVehicle);
IVehicleSeat* pSeat = pActor ? m_pVehicle->GetSeatForPassenger(pActor->GetEntityId()) : NULL;
IVehicleView* pView = pSeat? pSeat->GetView(pSeat->GetCurrentView()) : NULL;
bool isThirdPersonView = pView? pView->IsThirdPerson() : true;
if (localPlayer && !isThirdPersonView)
light.SetLightColor(ColorF(m_diffuseCol * m_diffuseMult[0], 1.f));
else
light.SetLightColor(ColorF(m_diffuseCol * m_diffuseMult[1], 1.f));
}
}
if (m_pHelper)
{
const static Matrix33 rot(Matrix33::CreateRotationXYZ(Ang3(0.f, 0.f, DEG2RAD(90.f))));
Matrix34 helperTM;
m_pHelper->GetVehicleTM(helperTM);
Matrix34 localTM = Matrix33(helperTM) * rot;
localTM.SetTranslation(helperTM.GetTranslation());
GetEntity()->SetSlotLocalTM(m_slot, localTM);
}
}
void CVehicleMovementHelicopter::OccupyWeaponSeats()
{
uint32 seatCount = m_pVehicle->GetSeatCount();
for (uint32 seatId = 1; !(seatId > seatCount); ++seatId)
{
IVehicleSeat *pSeat = m_pVehicle->GetSeatById(seatId);
if (pSeat)
{
IVehicleSeatAction *pWeaponAction = pSeat->GetISeatActionWeapons();
if (pWeaponAction)
{
pWeaponAction->ForceUsage();
}
}
}
m_pVehicle->GetGameObject()->EnableUpdateSlot(m_pVehicle, IVehicle::eVUS_AIControlled);
}
virtual void ProcessEvent(EFlowEvent flowEvent, SActivationInfo* pActivationInfo)
{
if (flowEvent == eFE_Activate && IsPortActive(pActivationInfo, EIP_StartDriving))
{
IEntity* pEntity = pActivationInfo->pEntity;
if(!pEntity)
return;
IVehicle* pVehicle;
pVehicle = gEnv->pGame->GetIGameFramework()->GetIVehicleSystem()->GetVehicle( pEntity->GetId() );
if(!pVehicle || pVehicle->IsDestroyed())
{
return;
}
IVehicleMovement* pMovement = pVehicle->GetMovement();
if (!pMovement)
return;
CVehicleMovementBase* pMovementBase = StaticCast_CVehicleMovementBase(pMovement);
if (!pMovementBase)
return;
IActor* pPlayer = g_pGame->GetIGameFramework()->GetClientActor();
if (!pPlayer)
return;
const EntityId localPlayer = pPlayer->GetEntityId();
if (pVehicle->GetSeatCount() == 0) // Don't need to remotely enter
{
pMovement->StartDriving(localPlayer);
}
else
{
pVehicle->EvictAllPassengers();
IVehicleSeat* pSeat = pVehicle->GetSeatById(1);
if (pSeat)
{
// Can't use remote entering to control otherwise if vehicle blows up, player dies
//pSeat->EnterRemotely(localPlayer);
pMovement->StartDriving(localPlayer);
m_prevSeatLockStatus = pSeat->GetLockedStatus();
pSeat->SetLocked(eVSLS_Locked);
}
}
m_fDuration = GetPortFloat(pActivationInfo, EIP_Time);
m_fSpeed = GetPortFloat(pActivationInfo, EIP_Speed);
m_actInfo = *pActivationInfo;
m_entityId = pEntity->GetId();
SetActive(true);
}
else if (flowEvent == eFE_Update)
{
if (!m_bActive)
{
if (m_bNeedsCleanup)
{
Cleanup();
}
return;
}
IEntity* pEntity = pActivationInfo->pEntity;
if(!pEntity)
{
SetActive(false);
return;
}
IVehicle* pVehicle;
pVehicle = gEnv->pGame->GetIGameFramework()->GetIVehicleSystem()->GetVehicle( pEntity->GetId() );
if(!pVehicle || pVehicle->IsDestroyed())
{
SetActive(false);
return;
}
const float curTime = gEnv->pTimer->GetFrameStartTime().GetSeconds();
if ((curTime - m_fStartedTime) >= m_fDuration)
{
SetActive(false);
ActivateOutput(pActivationInfo, EOP_TimeComplete, true);
}
else // Update every frame
{
IVehicleMovement* pMovement = pVehicle->GetMovement();
if (pMovement)
{
// prevent full pedal being kept pressed, but give it a bit
pMovement->OnAction(eVAI_MoveForward, eAAM_OnPress, 1.0f);
}
}
}
}
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();
}
virtual void ProcessEvent( EFlowEvent event,SActivationInfo *pActInfo )
{
IVehicleSystem * pVehicleSystem = NULL;
IVehicle * pVehicle = NULL;
switch(event)
{
case eFE_Initialize:
{
pActInfo->pGraph->SetRegularlyUpdated(pActInfo->myID, false);
break;
}
case eFE_Activate:
{
if (!pActInfo->pEntity)
return;
pVehicleSystem = gEnv->pGame->GetIGameFramework()->GetIVehicleSystem();
pVehicle = pVehicleSystem->GetVehicle(pActInfo->pEntity->GetId());
if (!pVehicleSystem || !pVehicle)
return;
string givenString = GetPortString(pActInfo, IN_PARTS);
currentParam = givenString.substr(0,givenString.find_first_of(":"));
currentSetting = givenString.substr(givenString.find_first_of(":")+1,(givenString.length()-givenString.find_first_of(":")));
column1 = 10.f;
column2 = 100.f;
if (IsPortActive(pActInfo,IN_SHOW))
pActInfo->pGraph->SetRegularlyUpdated(pActInfo->myID, true);
break;
}
case eFE_Update:
{
IRenderer * pRenderer = gEnv->pRenderer;
pVehicleSystem = gEnv->pGame->GetIGameFramework()->GetIVehicleSystem();
pVehicle = pVehicleSystem->GetVehicle(pActInfo->pEntity->GetId());
if(!pVehicleSystem || !pActInfo->pEntity || !pVehicle)
return;
pRenderer->Draw2dLabel(column1,10,GetPortFloat(pActInfo,IN_SIZE)+2.f,Col_Cyan,false,pActInfo->pEntity->GetName());
if(currentParam=="Seats")
{
loops = 0;
for(uint32 i=0;i<pVehicle->GetSeatCount();i++)
{
IVehicleSeat * currentSeat;
if(currentSetting=="All")
{
currentSeat = pVehicle->GetSeatById(i+1);
}
else
{
currentSeat = pVehicle->GetSeatById(pVehicle->GetSeatId(currentSetting));
i = pVehicle->GetSeatCount()-1;
}
loops += 1;
// column 1
string pMessage = ("%s:", currentSeat->GetSeatName());
if (column2<pMessage.size()*8*GetPortFloat(pActInfo, IN_SIZE))
column2=pMessage.size()*8*GetPortFloat(pActInfo, IN_SIZE);
pRenderer->Draw2dLabel(column1,(15*(float(loops+1))*GetPortFloat(pActInfo,IN_SIZE)),GetPortFloat(pActInfo,IN_SIZE),Col_Cyan,false,pMessage);
// column 2
if(currentSeat->GetPassenger(true))
{
pMessage = ("- %s", gEnv->pEntitySystem->GetEntity(currentSeat->GetPassenger(true))->GetName());
pRenderer->Draw2dLabel(column2,(15*(float(loops+1))*GetPortFloat(pActInfo,IN_SIZE)),GetPortFloat(pActInfo,IN_SIZE),Col_Cyan,false,pMessage);
}
}
}
else if(currentParam=="Wheels")
{
pRenderer->Draw2dLabel(column1,50.f,GetPortFloat(pActInfo,IN_SIZE)+1.f,Col_Red,false,"!");
}
else if(currentParam=="Weapons")
{
loops = 0;
for(int i=0;i<pVehicle->GetWeaponCount();i++)
{
IItemSystem * pItemSystem = gEnv->pGame->GetIGameFramework()->GetIItemSystem();
IWeapon * currentWeapon;
EntityId currentEntityId;
IItem * pItem;
if(currentSetting=="All")
{
currentEntityId = pVehicle->GetWeaponId(i+1);
}
else
{
currentEntityId = gEnv->pEntitySystem->FindEntityByName(currentSetting)->GetId();
i = pVehicle->GetWeaponCount()-1;
}
if(!pItemSystem->GetItem(currentEntityId))
return;
pItem = pItemSystem->GetItem(currentEntityId);
currentWeapon = pItem->GetIWeapon();
loops += 1;
// column 1
string pMessageName = string().Format("%s", gEnv->pEntitySystem->GetEntity(currentEntityId)->GetName());
pRenderer->Draw2dLabel(column1,(15*(float(loops+1))*GetPortFloat(pActInfo,IN_SIZE)),GetPortFloat(pActInfo,IN_SIZE),Col_Cyan,false,pMessageName);
if (column2<pMessageName.size()*8*GetPortFloat(pActInfo, IN_SIZE))
column2=pMessageName.size()*8*GetPortFloat(pActInfo, IN_SIZE);
// column 2
string pMessageValue = string().Format("seat: %s firemode: %i", pVehicle->GetWeaponParentSeat(currentEntityId)->GetSeatName(), currentWeapon->GetCurrentFireMode()).c_str();
pRenderer->Draw2dLabel(column2,(15*(float(loops+1))*GetPortFloat(pActInfo,IN_SIZE)),GetPortFloat(pActInfo,IN_SIZE),Col_Cyan,false,pMessageValue);
}
}
else if(currentParam=="Components")
{
loops = 0;
for(int i=0;i<pVehicle->GetComponentCount();i++)
{
IVehicleComponent * currentComponent;
if(currentSetting=="All")
{
currentComponent = pVehicle->GetComponent(i);
}
else
{
currentComponent = pVehicle->GetComponent(currentSetting);
i = pVehicle->GetComponentCount()-1;
}
loops += 1;
ColorF labelColor;
labelColor = ColorF(currentComponent->GetDamageRatio(),(1.f-currentComponent->GetDamageRatio()),0.f);
// column 1
string pMessageName = string().Format("%s", currentComponent->GetComponentName()).c_str();
pRenderer->Draw2dLabel(column1,(15*(float(loops+1))*GetPortFloat(pActInfo,IN_SIZE)),GetPortFloat(pActInfo,IN_SIZE),labelColor,false,pMessageName);
if (column2<pMessageName.size()*8*GetPortFloat(pActInfo, IN_SIZE))
column2=pMessageName.size()*8*GetPortFloat(pActInfo, IN_SIZE);
// column 2
string pMessageValue = string().Format("%5.2f (%3.2f)", currentComponent->GetDamageRatio()*currentComponent->GetMaxDamage(), currentComponent->GetDamageRatio()).c_str();
pRenderer->Draw2dLabel(column2,(15*(float(loops+1))*GetPortFloat(pActInfo,IN_SIZE)),GetPortFloat(pActInfo,IN_SIZE),labelColor,false,pMessageValue);
}
}
else
{
pRenderer->Draw2dLabel(column1,50.f,GetPortFloat(pActInfo,IN_SIZE)+1.f,Col_Red,false,"no component selected!");
}
break;
}
}
};
//------------------------------------------------------------------------
void CVehicleClient::OnAction(IVehicle* pVehicle, EntityId actorId, const ActionId& actionId, int activationMode, float value)
{
assert(pVehicle);
if (!pVehicle)
return;
TActionNameIdMap::const_iterator ite = m_actionNameIds.find(actionId);
if (ite == m_actionNameIds.end())
return;
IVehicleMovement *pMovement = pVehicle->GetMovement();
const bool isAir = pMovement && pMovement->GetMovementType()==IVehicleMovement::eVMT_Air;
IVehicleSeat* pCurrentSeat = pVehicle->GetSeatForPassenger(actorId);
const bool isThirdPerson = pCurrentSeat && pCurrentSeat->GetView(pCurrentSeat->GetCurrentView())->IsThirdPerson();
const bool isDriver = pCurrentSeat && pCurrentSeat->IsDriver();
switch (ite->second)
{
case (eVAI_XIMoveX):
{
if(pMovement && pMovement->GetMovementType() == IVehicleMovement::eVMT_Air)
{
//strafe instead of turning for air vehicles
if(value>0.f)
{
pVehicle->OnAction(eVAI_StrafeRight, eAAM_OnPress, value, actorId);
m_bMovementFlagRight = true;
}
else if(value==0.f)
{
if(m_bMovementFlagRight)
{
pVehicle->OnAction(eVAI_StrafeRight, eAAM_OnRelease, 0.f, actorId);
m_bMovementFlagRight = false;
}
else if(m_bMovementFlagLeft)
{
pVehicle->OnAction(eVAI_StrafeLeft, eAAM_OnRelease, 0.f, actorId);
m_bMovementFlagLeft = false;
}
}
else//value<0
{
pVehicle->OnAction(eVAI_StrafeLeft, eAAM_OnPress, -value, actorId);
m_bMovementFlagLeft = true;
}
}
else
{
if(value>0.f)
{
pVehicle->OnAction(eVAI_TurnRight, eAAM_OnPress, value, actorId);
m_bMovementFlagRight = true;
}
else if(value==0.f)
{
if(m_bMovementFlagRight)
{
pVehicle->OnAction(eVAI_TurnRight, eAAM_OnRelease, 0.f, actorId);
m_bMovementFlagRight = false;
}
else if(m_bMovementFlagLeft)
{
pVehicle->OnAction(eVAI_TurnLeft, eAAM_OnRelease, 0.f, actorId);
m_bMovementFlagLeft = false;
}
}
else//value<0
{
pVehicle->OnAction(eVAI_TurnLeft, eAAM_OnPress, -value, actorId);
m_bMovementFlagLeft = true;
}
}
break;
}
case (eVAI_XIMoveY):
{
EVehicleActionIds eForward = eVAI_MoveForward;
EVehicleActionIds eBack = eVAI_MoveBack;
if(!strcmp("Asian_helicopter",pVehicle->GetEntity()->GetClass()->GetName()))
{
eForward = eVAI_MoveUp;
eBack = eVAI_MoveDown;
}
if(value>0.f)
{
pVehicle->OnAction(eForward, eAAM_OnPress, value, actorId);
m_bMovementFlagForward = true;
}
else if(value==0.f)
{
if(m_bMovementFlagForward)
{
pVehicle->OnAction(eForward, eAAM_OnRelease, 0.f, actorId);
m_bMovementFlagForward = false;
}
else if(m_bMovementFlagBack)
{
pVehicle->OnAction(eBack, eAAM_OnRelease, 0.f, actorId);
m_bMovementFlagBack = false;
}
}
else//value<0.f
{
pVehicle->OnAction(eBack, eAAM_OnPress, -value, actorId);
m_bMovementFlagBack = true;
}
break;
}
case (eVAI_XIRotateYaw):
{
if (isAir && (isDriver || isThirdPerson))
{
pVehicle->OnAction(eVAI_RotateYaw, eAAM_OnPress, value / 5.f, actorId);
}
else
{
// action is sent to vehicle in PreUpdate, so it is repeated every frame.
m_xiRotation.x = (value*value*value);
}
break;
}
case (eVAI_XIRotatePitch):
{
if (isAir && (isDriver || isThirdPerson))
{
pVehicle->OnAction(eVAI_RotatePitch, eAAM_OnPress, value / 5.f, actorId);
}
else
{
// action is sent to vehicle in PreUpdate, so it is repeated every frame
m_xiRotation.y = -(value*value*value);
if(g_pGameCVars->cl_invertController)
m_xiRotation.y*=-1;
}
break;
}
case (eVAI_RotateYaw):
{
// attempt to normalise the input somewhat (to bring it in line with controller input).
const float scale = 0.75f, limit = 6.0f;
value = clamp_tpl<float>(scale * value * gEnv->pTimer->GetFrameTime(), -limit, limit);
if (isAir)
{
value *= 10.f;
}
pVehicle->OnAction(ite->second, activationMode, value, actorId);
break;
}
case (eVAI_RotatePitch):
{
// attempt to normalise the input somewhat (to bring it in line with controller input).
const float scale = 0.75f, limit = 6.0f;
value = clamp_tpl<float>(scale * value * gEnv->pTimer->GetFrameTime(), -limit, limit);
if (g_pGameCVars->cl_invertMouse)
value *= -1.f;
if (isAir)
{
value *= 10.f;
}
pVehicle->OnAction(ite->second, activationMode, value, actorId);
break;
}
case (eVAI_TurnLeft):
{
if (activationMode == eAAM_OnPress || activationMode == eAAM_OnRelease)
m_fLeftRight -= value*2.f - 1.f;
m_fLeftRight = CLAMP(m_fLeftRight, -1.0f, 1.0f);
pVehicle->OnAction(ite->second, activationMode, -m_fLeftRight, actorId);
break;
}
case (eVAI_TurnRight):
{
if (activationMode == eAAM_OnPress || activationMode == eAAM_OnRelease)
m_fLeftRight += value*2.f - 1.f;
m_fLeftRight = CLAMP(m_fLeftRight, -1.0f, 1.0f);
pVehicle->OnAction(ite->second, activationMode, m_fLeftRight, actorId);
break;
}
case (eVAI_MoveForward):
{
if (activationMode == eAAM_OnPress || activationMode == eAAM_OnRelease)
m_fForwardBackward += value*2.f - 1.f;
if(activationMode == eAAM_OnRelease)
m_fForwardBackward = CLAMP(m_fForwardBackward, 0.0f, 1.0f);
else
m_fForwardBackward = CLAMP(m_fForwardBackward, -1.0f, 1.0f);
pVehicle->OnAction(ite->second, activationMode, m_fForwardBackward, actorId);
break;
}
case (eVAI_MoveBack):
{
if (activationMode == eAAM_OnPress || activationMode == eAAM_OnRelease)
m_fForwardBackward -= value*2.f - 1.f;
if(activationMode == eAAM_OnRelease)
m_fForwardBackward = CLAMP(m_fForwardBackward, -1.0f, 0.0f);
else
m_fForwardBackward = CLAMP(m_fForwardBackward, -1.0f, 1.0f);
pVehicle->OnAction(ite->second, activationMode, -m_fForwardBackward, actorId);
break;
}
case (eVAI_ZoomIn):
case (eVAI_ZoomOut):
break;
default:
pVehicle->OnAction(ite->second, activationMode, value, actorId);
break;
}
}
//------------------------------------------------------------------------
void CGameRulesMPDamageHandling::SvOnExplosion(const ExplosionInfo &explosionInfo, const CGameRules::TExplosionAffectedEntities& affectedEntities)
{
// SinglePlayer.lua 1721
IActorSystem* pActorSystem = g_pGame->GetIGameFramework()->GetIActorSystem();
float totalDamage = 0.f;
// calculate damage for each entity
CGameRules::TExplosionAffectedEntities::const_iterator it = affectedEntities.begin();
for (; it != affectedEntities.end(); ++it)
{
bool success = false;
IEntity* entity = it->first;
float obstruction = 1.0f - it->second;
bool incone=true;
if (explosionInfo.angle > 0 && explosionInfo.angle < 2*3.1415f)
{
Vec3 explosionEntityPos = entity->GetWorldPos();
Vec3 entitypos = explosionEntityPos;
float ha = explosionInfo.angle * 0.5f;
Vec3 edir = entitypos - explosionInfo.pos;
edir.normalize();
float dot = 1;
if (edir != Vec3(ZERO))
{
dot = edir.dot(explosionInfo.dir);
}
float angle = abs(acos_tpl(dot));
if (angle > ha)
{
incone = false;
}
}
if (incone && gEnv->bServer)
{
float damage = explosionInfo.damage;
damage = floor_tpl(0.5f + CalcExplosionDamage(entity, explosionInfo, obstruction));
bool dead = false;
HitInfo explHit;
Vec3 dir = entity->GetWorldPos() - explosionInfo.pos;
explHit.pos = explosionInfo.pos;
explHit.radius = explosionInfo.radius;
explHit.partId = -1;
dir.Normalize();
explHit.targetId = entity->GetId();
explHit.weaponId = explosionInfo.weaponId;
explHit.shooterId = explosionInfo.shooterId;
explHit.projectileId = explosionInfo.projectileId;
explHit.projectileClassId = explosionInfo.projectileClassId;
uint16 weaponClass = ~uint16(0);
const IEntity* pWeaponEntity = gEnv->pEntitySystem->GetEntity(explosionInfo.weaponId);
if (pWeaponEntity)
{
g_pGame->GetIGameFramework()->GetNetworkSafeClassId(weaponClass, pWeaponEntity->GetClass()->GetName());
}
explHit.weaponClassId = weaponClass;
explHit.material = 0;
explHit.damage = damage;
explHit.type = explosionInfo.type;
explHit.hitViaProxy = explosionInfo.explosionViaProxy;
explHit.dir = dir;
explHit.normal = -dir; //set normal to reverse of direction to avoid backface cull of damage
if (explHit.damage > 0.0f || explosionInfo.damage == 0.f)
{
CActor* pActor = static_cast<CActor*>(pActorSystem->GetActor(entity->GetId()));
if (pActor)
{
const float damageMultiplier = pActor->GetBodyExplosionDamageMultiplier(explHit);
explHit.damage *= damageMultiplier;
// Protect players who are currently shielded
if(pActor->IsPlayer() && static_cast<CPlayer*>(pActor)->ShouldFilterOutExplosion(explHit))
{
explHit.damage = 0.0f;
}
}
else
{
CInteractiveObjectEx* pInteractiveObject = static_cast<CInteractiveObjectEx*>(g_pGame->GetIGameFramework()->QueryGameObjectExtension(entity->GetId(), "InteractiveObjectEx"));
if(pInteractiveObject)
{
pInteractiveObject->OnExploded(explHit.pos);
}
}
if(!explosionInfo.explosionViaProxy)
{
if(pActor)
{
if(!pActor->IsFriendlyEntity(explHit.shooterId))
{
totalDamage += damage;
}
}
else
{
IVehicle* pVehicle = g_pGame->GetIGameFramework()->GetIVehicleSystem()->GetVehicle(entity->GetId());
if(pVehicle)
{
IActor* pDriver = pVehicle->GetDriver();
int seatNum = 0;
int numSeats = pVehicle->GetSeatCount();
while(!pDriver && seatNum < numSeats)
{
IVehicleSeat* pSeat = pVehicle->GetSeatById(seatNum++);
EntityId passengerId = pSeat ? pSeat->GetPassenger(true) : 0;
pDriver = pActorSystem->GetActor(passengerId);
}
if(pDriver)
{
CActor* pDriverActor = static_cast<CActor*>(pDriver);
if(!pDriverActor->IsFriendlyEntity(explHit.shooterId))
{
totalDamage += damage;
}
}
}
}
}
m_pGameRules->ServerHit(explHit);
}
}
}
if (totalDamage > 0.f)
{
IGameRulesPlayerStatsModule* pPlayStatsMod = m_pGameRules->GetPlayerStatsModule();
if(pPlayStatsMod)
{
pPlayStatsMod->ProcessSuccessfulExplosion(explosionInfo.shooterId, totalDamage, explosionInfo.projectileClassId);
}
}
}
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 CPlayerStateJump::Landed(CPlayer& player, const bool isHeavyWeapon, float fallSpeed)
{
#ifdef STATE_DEBUG
bool remoteControlled = false;
IVehicle* pVehicle = player.GetLinkedVehicle();
if(pVehicle)
{
IVehicleSeat* pVehicleSeat = pVehicle->GetSeatForPassenger(player.GetEntityId());
if(pVehicleSeat && pVehicleSeat->IsRemoteControlled())
{
remoteControlled = true;
}
}
CRY_ASSERT_MESSAGE( player.GetLinkedEntity()==NULL || remoteControlled, "Cannot 'land' when you're linked to another entity!" );
#endif
const SPlayerStats& stats = player.m_stats;
Vec3 playerPosition = player.GetEntity()->GetWorldPos();
IPhysicalEntity *phys = player.GetEntity()->GetPhysics();
IMaterialEffects *mfx = gEnv->pGame->GetIGameFramework()->GetIMaterialEffects();
const SActorPhysics& actorPhysics = player.GetActorPhysics();
int matID = actorPhysics.groundMaterialIdx != -1 ? actorPhysics.groundMaterialIdx : mfx->GetDefaultSurfaceIndex();
const float fHeightofEntity = playerPosition.z;
const float worldWaterLevel = player.m_playerStateSwim_WaterTestProxy.GetWaterLevel();
TMFXEffectId effectId = mfx->GetEffectId("bodyfall", matID);
if (effectId != InvalidEffectId)
{
SMFXRunTimeEffectParams params;
Vec3 direction = Vec3(0,0,0);
if (IMovementController *pMV = player.GetMovementController())
{
SMovementState state;
pMV->GetMovementState(state);
direction = state.aimDirection;
}
params.pos = playerPosition + direction;
//params.soundSemantic = eSoundSemantic_Player_Foley;
float landFallParamVal = (float)__fsel( -(fallSpeed - 7.5f), 0.25f, 0.75f);
params.AddAudioRtpc("landfall", landFallParamVal);
const float speedParamVal = min(fabsf((actorPhysics.velocity.z * 0.1f)), 1.0f);
params.AddAudioRtpc("speed", speedParamVal);
mfx->ExecuteEffect(effectId, params);
}
bool heavyLanded = false;
IItem* pCurrentItem = player.GetCurrentItem();
CWeapon* pCurrentWeapon = pCurrentItem ? static_cast<CWeapon*>(pCurrentItem->GetIWeapon()) : NULL;
if (fallSpeed > 0.0f && player.IsPlayer())
{
if(!gEnv->bMultiplayer)
{
const float verticalSpeed = fabs(fallSpeed);
const float speedForHeavyLand = g_pGameCVars->pl_health.fallSpeed_HeavyLand;
if ((verticalSpeed >= speedForHeavyLand) && (player.GetPickAndThrowEntity() == 0) && !player.IsDead())
{
if ( !isHeavyWeapon )
{
if (pCurrentWeapon)
{
pCurrentWeapon->FumbleGrenade();
pCurrentWeapon->CancelCharge();
}
player.StartInteractiveActionByName("HeavyLand", false);
}
heavyLanded = true;
}
}
}
if(player.m_isClient)
{
if (fallSpeed > 0.0f)
{
const float fallIntensityMultiplier = stats.wasHit ? g_pGameCVars->pl_fall_intensity_hit_multiplier : g_pGameCVars->pl_fall_intensity_multiplier;
const float fallIntensityMax = g_pGameCVars->pl_fall_intensity_max;
const float fallTimeMultiplier = g_pGameCVars->pl_fall_time_multiplier;
const float fallTimeMax = g_pGameCVars->pl_fall_time_max;
const float zoomMultiplayer = (pCurrentWeapon && pCurrentWeapon->IsZoomed()) ? 0.2f : 1.0f;
const float direction = ((cry_rand()%2)==0) ? -1.0f : 1.0f;
const float intensity = clamp_tpl(fallIntensityMultiplier*fallSpeed*zoomMultiplayer, 0.0f, fallIntensityMax);
const float shakeTime = clamp_tpl(fallTimeMultiplier*fallSpeed*zoomMultiplayer, 0.0f, fallTimeMax);
const Vec3 rotation = Vec3(-0.5f, 0.15f*direction, 0.05f*direction);
if (CScreenEffects* pGameScreenEffects = g_pGame->GetScreenEffects())
{
pGameScreenEffects->CamShake(rotation*intensity, Vec3(0, 0, 0), shakeTime, shakeTime, 0.05f, CScreenEffects::eCS_GID_Player);
}
IForceFeedbackSystem* pForceFeedback = g_pGame->GetIGameFramework()->GetIForceFeedbackSystem();
assert(pForceFeedback);
ForceFeedbackFxId fxId = pForceFeedback->GetEffectIdByName("landFF");
pForceFeedback->PlayForceFeedbackEffect(fxId, SForceFeedbackRuntimeParams(intensity, 0.0f));
if(fallSpeed > 7.0f)
{
player.PlaySound(CPlayer::ESound_Fall_Drop);
}
CPlayer::EPlayerSounds playerSound = heavyLanded ? CPlayer::ESound_Gear_HeavyLand : CPlayer::ESound_Gear_Land;
player.PlaySound(playerSound, true);
}
CCCPOINT(PlayerMovement_LocalPlayerLanded);
}
if( gEnv->pAISystem )
{
// Notify AI
//If silent feet active, ignore here
const float noiseSupression = 0.0f;
const float fAISoundRadius = (g_pGameCVars->ai_perception.landed_baseRadius + (g_pGameCVars->ai_perception.landed_speedMultiplier * fallSpeed)) * (1.0f - noiseSupression);
SAIStimulus stim(AISTIM_SOUND, AISOUND_MOVEMENT_LOUD, player.GetEntityId(), 0,
player.GetEntity()->GetWorldPos() + player.GetEyeOffset(), ZERO, fAISoundRadius);
gEnv->pAISystem->RegisterStimulus(stim);
}
// Record 'Land' telemetry stats.
CStatsRecordingMgr::TryTrackEvent(&player, eGSE_Land, fallSpeed);
if (fallSpeed > 0.0f)
{
player.CreateScriptEvent( heavyLanded ? "heavylanded" : "landed",stats.fallSpeed);
}
}
