const ThermoType& Foam::egrMixture<ThermoType>::mixture
(
const scalar ft,
const scalar b,
const scalar egr
) const
{
if (ft < 0.0001)
{
return oxidant_;
}
else
{
scalar fu = b*ft + (1.0 - b)*fres(ft, stoicRatio().value());
scalar ox = 1 - ft - (ft - fu)*stoicRatio().value();
fu *= (1.0 - egr);
ox *= (1.0 - egr);
scalar pr = 1 - fu - ox;
mixture_ = fu/fuel_.W()*fuel_;
mixture_ += ox/oxidant_.W()*oxidant_;
mixture_ += pr/products_.W()*products_;
return mixture_;
}
}
void EntityEffects::CHeatController::AddHeatPulse( const float intensity, const float time )
{
const float currentPulseHeat = (float)fsel(-m_heatPulse.baseTime,
0.0f,
clamp_tpl((1.0f - (m_heatPulse.runningTime * (float)fres(m_heatPulse.baseTime + FLT_EPSILON))) * m_heatPulse.heat, 0.0f, 1.0f));
m_heatPulse.heat = clamp_tpl(currentPulseHeat + intensity, 0.0f, 1.0f - m_baseHeat);
m_heatPulse.baseTime = clamp_tpl((m_heatPulse.baseTime - m_heatPulse.runningTime) + time, 0.0f, 4.5f); //Fixed to maximum of 4.5secs to cool down
m_heatPulse.runningTime = 0.0f;
}
int64_t fraction::multReturnInt64(int64_t b) const {
int64_t ret = 0;
if(b < getInterimMultOverflowPt()) {
// b < interimMultOverflowPt
fraction fres(b * getNumer(), getDenom());
ret = fres.getI();
} else if(b <= getFinalMultOverflowPt()) {
// interimMultOverflowPt <= b <= finalMultInterimPt
ret = multNoInterimOverflow(b);
} else { // finalMultInterimPt < b
cerr << "fraction::multReturnInt64- a final overflow has occurred\n";
return I64_MAX;
}
return ret;
}
void CWaterGameEffects::Update( float frameTime )
{
if (m_waterDropletsAmount > 0.0f)
{
const float maxScreenTimeInv = (float)fres(1.5f);
const float newWaterDropletsAmount = m_waterDropletsAmount - (frameTime * maxScreenTimeInv);
m_waterDropletsAmount = newWaterDropletsAmount;
gEnv->p3DEngine->SetPostEffectParam( "WaterDroplets_Amount", newWaterDropletsAmount );
}
else
{
gEnv->p3DEngine->SetPostEffectParam( "WaterDroplets_Amount", 0.0f );
m_waterDropletsAmount = -1.0f;
SetActive( false );
}
}
float EntityEffects::CHeatController::UpdateHeat( const float frameTime )
{
m_heatPulse.runningTime += frameTime;
const float pulseFraction = clamp_tpl(m_heatPulse.runningTime * (float)fres(m_heatPulse.baseTime), 0.0f, 1.0f);
const bool pulseActive = (pulseFraction < 1.0f);
float pulseHeat = 0.0f;
if (pulseActive)
{
pulseHeat = (m_heatPulse.heat * (1.0f - pulseFraction));
}
else
{
m_heatPulse.Reset();
}
return clamp_tpl(m_baseHeat + pulseHeat, 0.0f, 1.0f);
}
//-------------------------------------------------------------------------
bool CWeapon::OnActionModify(EntityId actorId, const ActionId& actionId, int activationMode, float value)
{
if (IsZoomed() || IsZoomingInOrOut())
return false;
if (CanModify() && ((!IsReloading() && !IsBusy()) || AreAnyItemFlagsSet(eIF_Modifying)))
{
if (m_fm)
m_fm->StopFire();
if (AreAnyItemFlagsSet(eIF_Modifying))
{
m_enterModifyAction = 0;
PlayAction(GetFragmentIds().leave_modify, 0);
s_dofSpeed = fres(-g_pGameCVars->i_weapon_customisation_transition_time);
s_dofValue = 1.0f;
s_focusValue = -1.0f;
GetScheduler()->TimerAction(g_pGameCVars->i_weapon_customisation_transition_time, CSchedulerAction<ScheduleLayer_Leave>::Create(this), false);
SetItemFlags( eIF_Transitioning );
ClearItemFlags( eIF_Modifying );
GetGameObject()->InvokeRMI(CItem::SvRequestLeaveModify(), CItem::EmptyParams(), eRMI_ToServer);
}
else
{
gEnv->p3DEngine->SetPostEffectParam("Dof_Active", 1.0f);
gEnv->p3DEngine->SetPostEffectParam("Dof_UseMask", 0.f);
gEnv->p3DEngine->SetPostEffectParam("Dof_FocusRange", -1.f);
gEnv->p3DEngine->SetPostEffectParam("Dof_FocusMin", 0.5f);
gEnv->p3DEngine->SetPostEffectParam("Dof_FocusMax", 1.0f);
gEnv->p3DEngine->SetPostEffectParam("Dof_FocusLimit", 1.5f);
gEnv->p3DEngine->SetPostEffectParam("Dof_FocusMinZ", 0.0f);
gEnv->p3DEngine->SetPostEffectParam("Dof_FocusMinZScale", 0.0f);
m_itemLowerMode = eILM_Raised;
TagState tagState = TAG_STATE_EMPTY;
m_enterModifyAction = new CItemAction(PP_PlayerAction, GetFragmentIds().enter_modify, tagState);
PlayFragment(m_enterModifyAction);
s_dofSpeed = fres(g_pGameCVars->i_weapon_customisation_transition_time);
s_dofValue = 0.0f;
SetItemFlags(eIF_Transitioning);
GetScheduler()->TimerAction(g_pGameCVars->i_weapon_customisation_transition_time, CSchedulerAction<ScheduleLayer_Enter>::Create(this), false);
SetItemFlags(eIF_Modifying);
CPlayer *pPlayer = static_cast<CPlayer*>(GetOwnerActor());
if (pPlayer)
{
SPlayerStats *pStats = static_cast<SPlayerStats*>(pPlayer->GetActorStats());
assert(pStats);
pStats->bIgnoreSprinting = true;
}
GetGameObject()->InvokeRMI(CItem::SvRequestEnterModify(), CItem::EmptyParams(), eRMI_ToServer);
}
}
return true;
}
void CMountedGunController::Update(EntityId mountedGunID, float frameTime)
{
CRY_ASSERT_MESSAGE(m_pControlledPlayer, "Controlled player not initialized");
CItem* pMountedGun = static_cast<CItem*>(gEnv->pGame->GetIGameFramework()->GetIItemSystem()->GetItem(mountedGunID));
bool canUpdateMountedGun = (pMountedGun != NULL) && (pMountedGun->GetStats().mounted);
if (canUpdateMountedGun)
{
IMovementController * pMovementController = m_pControlledPlayer->GetMovementController();
assert(pMovementController);
SMovementState info;
pMovementController->GetMovementState(info);
IEntity* pMountedGunEntity = pMountedGun->GetEntity();
const Matrix34& lastMountedGunWorldTM = pMountedGunEntity->GetWorldTM();
Vec3 desiredAimDirection = info.aimDirection.GetNormalized();
// AI can switch directions too fast, prevent snapping
if(!m_pControlledPlayer->IsPlayer())
{
const Vec3 currentDir = lastMountedGunWorldTM.GetColumn1();
const float dot = clamp_tpl(currentDir.Dot(desiredAimDirection), -1.0f, 1.0f);
const float reqAngle = acos_tpl(dot);
const float maxRotSpeed = 2.0f;
const float maxAngle = frameTime * maxRotSpeed;
if(fabs(reqAngle) > maxAngle)
{
const Vec3 axis = currentDir.Cross(desiredAimDirection);
if(axis.GetLengthSquared() > 0.001f) // current dir and new dir are enough different
{
desiredAimDirection = currentDir.GetRotated(axis.GetNormalized(),sgn(reqAngle)*maxAngle);
}
}
}
bool isUserClient = m_pControlledPlayer->IsClient();
IEntity* pMountedGunParentEntity = pMountedGunEntity->GetParent();
IVehicle *pVehicle = NULL;
if(pMountedGunParentEntity && m_pControlledPlayer)
pVehicle = m_pControlledPlayer->GetLinkedVehicle();
CRecordingSystem* pRecordingSystem = g_pGame->GetRecordingSystem();
//For client update always, for others only when there is notable change
if (!pVehicle && (isUserClient || (!desiredAimDirection.IsEquivalent(lastMountedGunWorldTM.GetColumn1(), 0.003f))))
{
Quat rotation = Quat::CreateRotationVDir(desiredAimDirection, 0.0f);
pMountedGunEntity->SetRotation(rotation);
if (isUserClient && pRecordingSystem)
{
// Only record the gun position if you're using the gun.
pRecordingSystem->OnMountedGunRotate(pMountedGunEntity, rotation);
}
}
const Vec3 vInitialAimDirection = GetMountDirection(pMountedGun, pMountedGunParentEntity);
assert( vInitialAimDirection.IsUnit() );
//Adjust gunner position and animations
UpdateGunnerLocation(pMountedGun, pMountedGunParentEntity, vInitialAimDirection);
const float aimrad = Ang3::CreateRadZ(Vec2(vInitialAimDirection),Vec2(-desiredAimDirection));
const float pitchLimit = sin_tpl(DEG2RAD(30.0f));
const float animHeight = fabs_tpl(clamp_tpl(desiredAimDirection.z * (float)fres(pitchLimit), -1.0f, 1.0f));
const float aimUp = (float)fsel(-desiredAimDirection.z, 0.0f, animHeight);
const float aimDown = (float)fsel(desiredAimDirection.z, 0.0f, animHeight);
if (pRecordingSystem)
{
pRecordingSystem->OnMountedGunUpdate(m_pControlledPlayer, aimrad, aimUp, aimDown);
}
if(!m_pControlledPlayer->IsThirdPerson())
{
UpdateFirstPersonAnimations(pMountedGun, desiredAimDirection);
}
if(m_pMovementAction)
{
const float aimUpParam = aimUp;
const float aimDownParam = aimDown;
const float aimMovementParam = CalculateAnimationTime(aimrad);
m_pMovementAction->SetParam(MountedGunCRCs.aimUpParam, aimUpParam);
m_pMovementAction->SetParam(MountedGunCRCs.aimDownParam, aimDownParam);
m_pMovementAction->SetParam(MountedGunCRCs.aimMovementParam, aimMovementParam);
}
UpdateIKMounted(pMountedGun);
}
}
