float ApplyAntiOscilationFilter(float value, float filtersize)
{
float filterfraction = clamp_tpl(abs(value) / filtersize, 0.0f, 1.0f);
float filter = (0.5f - 0.5f * cos_tpl(filterfraction * gf_PI));
value *= filter;
return value;
}
void CPlayerStateSwim_WaterTestProxy::DebugDraw(const CPlayer& player, const Vec3& referencePosition)
{
// DEBUG RENDERING
const SPlayerStats& stats = *player.GetActorStats();
const bool debugSwimming = (g_pGameCVars->cl_debugSwimming != 0);
if (debugSwimming && (m_playerWaterLevel > -10.0f) && (m_playerWaterLevel < 10.0f))
{
const Vec3 surfacePosition(referencePosition.x, referencePosition.y, m_waterLevel);
const Vec3 vRight(player.GetBaseQuat().GetColumn0());
const static ColorF referenceColor(1,1,1,1);
const static ColorF surfaceColor1(0,0.5f,1,1);
const static ColorF surfaceColor0(0,0,0.5f,0);
const static ColorF bottomColor(0,0.5f,0,1);
gEnv->pRenderer->GetIRenderAuxGeom()->DrawSphere(referencePosition, 0.1f, referenceColor);
gEnv->pRenderer->GetIRenderAuxGeom()->DrawLine(referencePosition, surfaceColor1, surfacePosition, surfaceColor1, 2.0f);
gEnv->pRenderer->GetIRenderAuxGeom()->DrawSphere(surfacePosition, 0.2f, surfaceColor1);
gEnv->pRenderer->DrawLabel(referencePosition + vRight * 0.5f, 1.5f, "WaterLevel %3.2f (Head underwater: %d)", m_playerWaterLevel, m_headUnderwater ? 1 : 0);
const static int lines = 16;
const static float radius0 = 0.5f;
const static float radius1 = 1.0f;
const static float radius2 = 2.0f;
for (int i = 0; i < lines; ++i)
{
float radians = ((float)i / (float)lines) * gf_PI2;
Vec3 offset0(radius0 * cos_tpl(radians), radius0 * sin_tpl(radians), 0);
Vec3 offset1(radius1 * cos_tpl(radians), radius1 * sin_tpl(radians), 0);
Vec3 offset2(radius2 * cos_tpl(radians), radius2 * sin_tpl(radians), 0);
gEnv->pRenderer->GetIRenderAuxGeom()->DrawLine(surfacePosition+offset0, surfaceColor0, surfacePosition+offset1, surfaceColor1, 2.0f);
gEnv->pRenderer->GetIRenderAuxGeom()->DrawLine(surfacePosition+offset1, surfaceColor1, surfacePosition+offset2, surfaceColor0, 2.0f);
}
if (m_bottomLevel > 0.0f)
{
const Vec3 bottomPosition(referencePosition.x, referencePosition.y, m_bottomLevel);
gEnv->pRenderer->GetIRenderAuxGeom()->DrawLine(referencePosition, bottomColor, bottomPosition, bottomColor, 2.0f);
gEnv->pRenderer->GetIRenderAuxGeom()->DrawSphere(bottomPosition, 0.2f, bottomColor);
gEnv->pRenderer->DrawLabel(bottomPosition + Vec3(0,0,0.5f) - vRight * 0.5f, 1.5f, "BottomDepth %3.3f", m_waterLevel - m_bottomLevel);
}
}
}
void UpdateLookTarget()
{
const SLookAroundParams& params = GetParams();
//--- TODO! Context use of random number generator!
float yaw = cry_random(params.yawMin, params.yawMax);
float pitch = cry_random(params.pitchMin, params.pitchMax);
m_lookOffset.Set(sin_tpl(yaw), cos_tpl(yaw), 0.0f);
m_lookAroundTime = cry_random(params.timeMin, params.timeMax);
}
static void DrawDisc(const Vec3& center, Vec3 axis, float innerRadius, float outerRadius, const ColorB& innerColor, const ColorB& outerColor)
{
axis.NormalizeSafe(Vec3Constants<float>::fVec3_OneZ);
Vec3 u = ((axis * Vec3Constants<float>::fVec3_OneZ) > 0.5f) ? Vec3Constants<float>::fVec3_OneY : Vec3Constants<float>::fVec3_OneZ;
Vec3 v = u.cross(axis);
u = v.cross(axis);
float sides = ceil_tpl(3.0f * (float)g_PI * outerRadius);
//sides = 20.0f;
float step = 1.0f / sides;
for (float i = 0.0f; i < 0.99f; i += step)
{
float a0 = i * 2.0f * (float)g_PI;
float a1 = (i+step) * 2.0f * (float)g_PI;
Vec3 i0 = center + innerRadius * (u*cos_tpl(a0) + v*sin_tpl(a0));
Vec3 i1 = center + innerRadius * (u*cos_tpl(a1) + v*sin_tpl(a1));
Vec3 o0 = center + outerRadius * (u*cos_tpl(a0) + v*sin_tpl(a0));
Vec3 o1 = center + outerRadius * (u*cos_tpl(a1) + v*sin_tpl(a1));
gEnv->pRenderer->GetIRenderAuxGeom()->DrawTriangle(i0, innerColor, i1, innerColor, o1, outerColor);
gEnv->pRenderer->GetIRenderAuxGeom()->DrawTriangle(i0, innerColor, o1, outerColor, o0, outerColor);
}
}
void CBirdsFlock::UpdateLandingPoints()
{
int numPoints = m_boids.size() * 3 / 2;
if (m_LandingPoints.size() < (size_t)numPoints)
{
if (!m_landCollisionInfo.IsRequestingRayCast())
{
float maxradius = m_bc.fSpawnRadius * 0.6f;
Vec3 origin(m_bc.flockPos);
float angle = Boid::Frand() * gf_PI;
float radius = (Boid::Frand() + 1) / 2 * maxradius;
origin += Vec3(cos_tpl(angle) * radius, sin_tpl(angle) * radius, 5.f);
Vec3 vDir = Vec3(0, 0, -10);
m_landCollisionInfo.QueueRaycast(m_pEntity->GetId(), origin, vDir, &m_landCollisionCallback);
}
}
}
//--------------------------------------------------------
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 CSpectacularKill::ReadXmlData( const IItemParamsNode* pRootNode)
{
CRY_ASSERT(pRootNode);
ISharedParamsManager* pSharedParamsManager = gEnv->pGame->GetIGameFramework()->GetISharedParamsManager();
CRY_ASSERT(pSharedParamsManager);
// If we change the SharedParamsManager to accept CRCs on its interface we could compute this once and store
// the name's CRC32 instead of constructing it here each time this method is invoked (it shouldn't be invoked
// too often, though)
const char* szEntityClassName = m_pOwner->GetEntityClassName();
CryFixedStringT<64> sharedParamsName;
sharedParamsName.Format("%s_%s", SSharedSpectacularParams::s_typeInfo.GetName(), szEntityClassName);
ISharedParamsConstPtr pSharedParams = pSharedParamsManager->Get(sharedParamsName);
if (pSharedParams)
{
m_pParams = CastSharedParamsPtr<SSharedSpectacularParams>(pSharedParams);
return;
}
m_pParams.reset();
const IItemParamsNode* pParams = pRootNode->GetChild("SpectacularKill");
if (pParams)
{
SSharedSpectacularParams newParams;
const int childCount = pParams->GetChildCount();
newParams.paramsList.reserve(childCount);
for (int i = 0; i < childCount; ++i)
{
const IItemParamsNode* pTargetParams = pParams->GetChild(i);
CRY_ASSERT(pTargetParams);
IEntityClass* pTargetClass = gEnv->pEntitySystem->GetClassRegistry()->FindClass(pTargetParams->GetName());
if (pTargetClass)
{
SSpectacularKillParams targetParams;
const IItemParamsNode* pChildParamsNode = pTargetParams->GetChild("Params");
const IItemParamsNode* pChildAnimsNode = pTargetParams->GetChild("Anims");
targetParams.pEnemyClass = pTargetClass;
if(pChildParamsNode)
{
pChildParamsNode->GetAttribute("impulseScale", targetParams.impulseScale);
const char* szImpulseBone = pChildParamsNode->GetAttributeSafe("impulseBone");
ICharacterInstance* pCharacter = m_pOwner->GetEntity()->GetCharacter(0);
targetParams.impulseBone = pCharacter ? pCharacter->GetIDefaultSkeleton().GetJointIDByName(szImpulseBone) : -1;
}
if(pChildAnimsNode)
{
const int animCount = pChildAnimsNode->GetChildCount();
targetParams.animations.reserve(animCount);
for(int j = 0; j < animCount; j++)
{
const IItemParamsNode* pAnimNode = pChildAnimsNode->GetChild(j);
if(pAnimNode)
{
SSpectacularKillAnimation newAnimation;
newAnimation.victimAnimation = pAnimNode->GetAttributeSafe("victimAnimation");
newAnimation.killerAnimation = pAnimNode->GetAttributeSafe("killerAnimation");
pAnimNode->GetAttribute("optimalDist", newAnimation.optimalDist);
if (pAnimNode->GetAttribute("targetToKillerAngle", newAnimation.targetToKillerAngle))
newAnimation.targetToKillerAngle = DEG2RAD(newAnimation.targetToKillerAngle);
if (pAnimNode->GetAttribute("targetToKillerAngleRange", newAnimation.targetToKillerMinDot))
newAnimation.targetToKillerMinDot = cos_tpl(DEG2RAD(newAnimation.targetToKillerMinDot) / 2.0f);
pAnimNode->GetAttribute("obstacleCheckStartOffset", newAnimation.vKillerObstacleCheckOffset);
pAnimNode->GetAttribute("obstacleCheckLength", newAnimation.fObstacleCheckLength);
targetParams.animations.push_back(newAnimation);
}
}
}
CRY_ASSERT_MESSAGE(targetParams.animations.size() > 0, string().Format("No Animations defined for %s spectacular kill", pTargetClass->GetName()));
newParams.paramsList.push_back(targetParams);
}
#ifdef SPECTACULAR_KILL_DEBUG
else
{
GameWarning("spectacular Kill: Couldn't find entity of class '%s', skipping", pTargetParams->GetName());
}
#endif
}
m_pParams = CastSharedParamsPtr<SSharedSpectacularParams>(pSharedParamsManager->Register(sharedParamsName, newParams));
}
}
bool CScriptBind_Boids::ReadParamsTable(IScriptTable *pTable, struct SBoidContext &bc,SBoidsCreateContext &ctx )
{
pTable->BeginSetGetChain();
float fval;
const char *str;
ctx.models.clear();
ctx.boidsCount = 0;
pTable->GetValueChain( "count",ctx.boidsCount );
if (pTable->GetValueChain( "model",str ))
{
ctx.models.push_back(str);
}
if (pTable->GetValueChain( "model1",str ))
{
if (str[0])
ctx.models.push_back(str);
}
if (pTable->GetValueChain( "model2",str ))
{
if (str[0])
ctx.models.push_back(str);
}
if (pTable->GetValueChain( "model3",str ))
{
if (str[0])
ctx.models.push_back(str);
}
if (pTable->GetValueChain( "model4",str ))
{
if (str[0])
ctx.models.push_back(str);
}
if (pTable->GetValueChain( "character",str ))
{
ctx.characterModel = str;
}
if (pTable->GetValueChain( "animation",str ))
{
ctx.animation = str;
}
pTable->GetValueChain( "behavior",bc.behavior );
pTable->GetValueChain( "boid_mass",bc.fBoidMass);
pTable->GetValueChain( "boid_size",bc.boidScale );
pTable->GetValueChain( "boid_size_random",bc.boidRandomScale );
pTable->GetValueChain( "min_height",bc.MinHeight );
pTable->GetValueChain( "max_height",bc.MaxHeight );
pTable->GetValueChain( "min_attract_distance",bc.MinAttractDistance );
pTable->GetValueChain( "max_attract_distance",bc.MaxAttractDistance );
if(bc.MinAttractDistance <=0.05f)
bc.MinAttractDistance = 0.05f;
if(bc.MaxAttractDistance <=bc.MinAttractDistance)
bc.MaxAttractDistance =bc.MinAttractDistance +0.05f;
pTable->GetValueChain( "min_speed",bc.MinSpeed );
pTable->GetValueChain( "max_speed",bc.MaxSpeed );
pTable->GetValueChain( "factor_align",bc.factorAlignment );
pTable->GetValueChain( "factor_cohesion",bc.factorCohesion );
pTable->GetValueChain( "factor_separation",bc.factorSeparation );
pTable->GetValueChain( "factor_origin",bc.factorAttractToOrigin );
pTable->GetValueChain( "factor_keep_height",bc.factorKeepHeight );
pTable->GetValueChain( "factor_avoid_land",bc.factorAvoidLand );
pTable->GetValueChain( "factor_random_accel",bc.factorRandomAccel );
pTable->GetValueChain( "flight_time",bc.flightTime );
pTable->GetValueChain( "factor_take_off",bc.factorTakeOff );
pTable->GetValueChain( "land_deceleration_height",bc.landDecelerationHeight);
pTable->GetValueChain( "max_anim_speed",bc.MaxAnimationSpeed );
pTable->GetValueChain( "follow_player",bc.followPlayer );
pTable->GetValueChain( "no_landing",bc.noLanding );
pTable->GetValueChain( "start_on_ground",bc.bStartOnGround );
pTable->GetValueChain( "avoid_water",bc.bAvoidWater );
pTable->GetValueChain( "avoid_obstacles",bc.avoidObstacles );
pTable->GetValueChain( "max_view_distance",bc.maxVisibleDistance );
pTable->GetValueChain( "max_animation_distance",bc.animationMaxDistanceSq);
bc.animationMaxDistanceSq *= bc.animationMaxDistanceSq;
pTable->GetValueChain( "spawn_from_point", bc.bSpawnFromPoint );
pTable->GetValueChain( "pickable_alive", bc.bPickableWhenAlive );
pTable->GetValueChain( "pickable_dead", bc.bPickableWhenDead );
pTable->GetValueChain( "pickable_message", bc.pickableMessage );
pTable->GetValueChain( "spawn_radius",bc.fSpawnRadius);
//pTable->GetValueChain( "boid_radius",bc.fBoidRadius);
pTable->GetValueChain( "gravity_at_death",bc.fGravity);
pTable->GetValueChain( "boid_mass",bc.fBoidMass);
if (pTable->GetValueChain( "fov_angle",fval ))
{
fval = fval/2.0f; // Half angle used for cos of fov.
bc.cosFovAngle = cos_tpl(fval*gf_PI/180.0f);
}
pTable->GetValueChain("invulnerable", bc.bInvulnerable);
SmartScriptTable groundTable;
if (pTable->GetValueChain("ground",groundTable))
{
groundTable->BeginSetGetChain();
groundTable->GetValueChain( "factor_align",bc.factorAlignmentGround );
groundTable->GetValueChain( "factor_cohesion",bc.factorCohesionGround );
groundTable->GetValueChain( "factor_separation",bc.factorSeparationGround );
groundTable->GetValueChain( "factor_origin",bc.factorAttractToOriginGround );
groundTable->GetValueChain( "walk_speed",bc.walkSpeed);
groundTable->GetValueChain( "offset",bc.groundOffset);
groundTable->GetValueChain( "walk_to_idle_duration",bc.fWalkToIdleDuration);
groundTable->GetValueChain( "on_ground_idle_duration_min",bc.fOnGroundIdleDurationMin);
groundTable->GetValueChain( "on_ground_idle_duration_max",bc.fOnGroundIdleDurationMax);
groundTable->GetValueChain( "on_ground_walk_duration_min",bc.fOnGroundWalkDurationMin);
groundTable->GetValueChain( "on_ground_walk_duration_max",bc.fOnGroundWalkDurationMax);
groundTable->EndSetGetChain();
}
SmartScriptTable audio;
if (pTable->GetValueChain("Audio", audio))
{
bc.audio.clear();
for (int i = 1; i < audio->Count(); ++i)
{
str = "";
if (audio->GetAt(i, str))
{
TAudioControlID audioControlID = INVALID_AUDIO_CONTROL_ID;
gEnv->pAudioSystem->GetAudioTriggerID(str, audioControlID);
bc.audio.push_back(audioControlID);
}
}
}
SmartScriptTable animations;
if (pTable->GetValueChain("Animations",animations))
{
bc.animations.clear(); // related to CE-1736: clear contents from a previous call
for (int i = 1; i < 100; i++)
{
str = "";
if (animations->GetAt(i,str))
{
bc.animations.push_back(str);
}
else
break;
}
}
pTable->EndSetGetChain();
return true;
}
bool CDialogActorContext::DoLocalPlayerChecks(const float dt)
{
// don't check this every frame, but only every .2 secs
m_checkPlayerTimeOut-=dt;
if (m_checkPlayerTimeOut <= 0.0f)
{
do // a dummy loop to use break
{
float awareDistance;
float awareDistanceSq;
float awareAngle;
m_pSession->GetPlayerAwarenessValues(awareDistance, awareAngle);
awareDistanceSq=awareDistance*awareDistance;
m_checkPlayerTimeOut = PLAYER_CHECKTIME;
const float spotAngleCos = cos_tpl(DEG2RAD(awareAngle));
const CDialogSession::TActorContextMap& contextMap = m_pSession->GetAllContexts();
if (contextMap.size() == 1 && contextMap.begin()->first == m_actorID)
{
m_bIsAware = true;
break;
}
// early out, when we don't have to do any checks
if (awareDistance <= 0.0f && awareAngle <= 0.0f)
{
m_bIsAware = true;
break;
}
IEntity* pThisEntity = m_pSession->GetActorEntity(m_actorID);
if (!pThisEntity)
{
assert (false);
m_bIsAware = true;
break;
}
IMovementController* pMC = (m_pIActor != NULL) ? m_pIActor->GetMovementController() : NULL;
if (!pMC)
{
assert (false);
m_bIsAware = true;
break;
}
SMovementState moveState;
pMC->GetMovementState(moveState);
Vec3 viewPos = moveState.eyePosition;
Vec3 viewDir = moveState.eyeDirection;
viewDir.z = 0.0f;
viewDir.NormalizeSafe();
// check the player's position
// check the player's view direction
AABB groupBounds;
groupBounds.Reset();
CDialogSession::TActorContextMap::const_iterator iter = contextMap.begin();
CDialogScript::SActorSet lookingAt = 0;
while (iter != contextMap.end())
{
if (iter->first != m_actorID)
{
IEntity* pActorEntity = m_pSession->GetActorEntity(iter->first);
if (pActorEntity)
{
Vec3 vEntityPos = pActorEntity->GetWorldPos();
AABB worldBounds;
pActorEntity->GetWorldBounds(worldBounds);
groupBounds.Add(worldBounds);
// calc if we look at it somehow
Vec3 vEntityDir = vEntityPos - viewPos;
vEntityDir.z = 0.0f;
vEntityDir.NormalizeSafe();
if (viewDir.IsUnit() && vEntityDir.IsUnit())
{
const float dot = clamp_tpl(viewDir.Dot(vEntityDir),-1.0f,+1.0f); // clamping should not be needed
if (spotAngleCos <= dot)
lookingAt.SetActor(iter->first);
DiaLOG::Log(DiaLOG::eDebugC, "Angle to actor %d is %f deg", iter->first, RAD2DEG(acos_tpl(dot)));
}
}
}
++iter;
}
const float distanceSq = pThisEntity->GetWorldPos().GetSquaredDistance(groupBounds.GetCenter());
CCamera& camera=gEnv->pSystem->GetViewCamera();
const bool bIsInAABB = camera.IsAABBVisible_F(groupBounds);
const bool bIsInRange = distanceSq <= awareDistanceSq;
const bool bIsLooking = contextMap.empty() || lookingAt.NumActors() > 0;
m_bIsAwareLooking = awareAngle <= 0.0f || (bIsInAABB || bIsLooking);
m_bIsAwareInRange = awareDistance <= 0.0f || bIsInRange;
m_bIsAware = m_bIsAwareLooking && m_bIsAwareInRange;
DiaLOG::Log(DiaLOG::eDebugB, "[DIALOG] LPC: %s awDist=%f awAng=%f AABBVis=%d IsLooking=%d InRange=%d [Distance=%f LookingActors=%d] Final=%saware",
m_pSession->GetDebugName(), awareDistance, awareAngle, bIsInAABB, bIsLooking, bIsInRange, sqrt_tpl(distanceSq), lookingAt.NumActors(), m_bIsAware ? "" : "not ");
} while (false);
}
if (m_bIsAware)
{
m_playerAwareTimeOut = m_pSession->GetPlayerAwarenessGraceTime();
}
else
{
m_playerAwareTimeOut-= dt;
if (m_playerAwareTimeOut <= 0)
{
return false;
}
}
return true;
}
void CAnimatedCharacter::SetDesiredLocalLocation( ISkeletonAnim* pSkeletonAnim, const QuatT& desiredLocalLocation, float fDeltaTime)
{
CRY_ASSERT(desiredLocalLocation.IsValid());
{
uint32 NumAnimsInQueue = pSkeletonAnim->GetNumAnimsInFIFO(0);
uint32 nMaxActiveInQueue=MAX_EXEC_QUEUE;
if (nMaxActiveInQueue>NumAnimsInQueue)
nMaxActiveInQueue=NumAnimsInQueue;
if (NumAnimsInQueue>nMaxActiveInQueue)
NumAnimsInQueue=nMaxActiveInQueue;
uint32 active=0;
for (uint32 a=0; a<NumAnimsInQueue; a++)
{
const CAnimation& anim = pSkeletonAnim->GetAnimFromFIFO(0,a);
active += anim.IsActivated() ? 1 : 0;
}
if (active>nMaxActiveInQueue)
active=nMaxActiveInQueue;
nMaxActiveInQueue=active;
const SParametricSampler *pLMG = NULL;
for (int32 a=nMaxActiveInQueue-1; (a >= 0) && !pLMG; --a)
{
const CAnimation& anim = pSkeletonAnim->GetAnimFromFIFO(0,a);
pLMG = anim.GetParametricSampler();
}
}
const Vec3 dir = desiredLocalLocation.GetColumn1();
float turnAngle = atan2f(-dir.x, dir.y);
float turnSpeed = turnAngle / fDeltaTime;
const Vec2 deltaVector(desiredLocalLocation.t.x, desiredLocalLocation.t.y);
const float travelDist = deltaVector.GetLength();
const Vec2 deltaDir = (travelDist > 0.0f) ? (deltaVector / travelDist) : Vec2(0,0);
float travelAngle = (deltaDir.x == 0.0f && deltaDir.y == 0.0f ? 0.0f : atan2f(-deltaDir.x, deltaDir.y));
float travelSpeed;
if (gEnv->bMultiplayer)
{
travelSpeed = travelDist / fDeltaTime;
}
else
{
const float cosGroundSlope = fabsf(cosf(m_fGroundSlopeMoveDirSmooth));
travelSpeed = (cosGroundSlope > FLT_EPSILON) ? (travelDist / (fDeltaTime * cosGroundSlope)) : (travelDist / fDeltaTime);
}
// TravelAngle smoothing
{
const Vec2 newStrafe = Vec2(-sin_tpl(travelAngle), cos_tpl(travelAngle));
if (CAnimationGraphCVars::Get().m_enableTurnAngleSmoothing)
{
SmoothCD(m_fDesiredStrafeSmoothQTX, m_fDesiredStrafeSmoothRateQTX, fDeltaTime, newStrafe, 0.10f);
}
else
{
m_fDesiredStrafeSmoothQTX=newStrafe;
m_fDesiredStrafeSmoothRateQTX.zero();
}
travelAngle = Ang3::CreateRadZ(Vec2(0,1),m_fDesiredStrafeSmoothQTX);
}
const bool modulateTurnSpeedByTravelAngle = true;
if (modulateTurnSpeedByTravelAngle)
{
static float minimum = DEG2RAD(10.0f); // do not change turnSpeed when travelAngle is below this
static float maximum = DEG2RAD(40.0f); // force turnspeed to zero when travelAngle is above this
const float turnSpeedScale = 1.0f - clamp_tpl( fabsf(travelAngle) - minimum, 0.0f, maximum - minimum ) / ( maximum - minimum );
turnSpeed *= turnSpeedScale;
}
// TurnSpeed smoothing
{
if (CAnimationGraphCVars::Get().m_enableTurnSpeedSmoothing)
{
SmoothCD(m_fDesiredTurnSpeedSmoothQTX, m_fDesiredTurnSpeedSmoothRateQTX, fDeltaTime, turnSpeed, 0.40f);
}
else
{
m_fDesiredTurnSpeedSmoothQTX = turnSpeed;
m_fDesiredTurnSpeedSmoothRateQTX = 0.0f;
}
}
// TravelSpeed smoothing
{
if (CAnimationGraphCVars::Get().m_enableTravelSpeedSmoothing)
{
SmoothCD(m_fDesiredMoveSpeedSmoothQTX, m_fDesiredMoveSpeedSmoothRateQTX, fDeltaTime, travelSpeed, 0.04f);
}
else
{
m_fDesiredMoveSpeedSmoothQTX = travelSpeed;
m_fDesiredMoveSpeedSmoothRateQTX = 0.0f;
}
}
SetMotionParam(pSkeletonAnim, eMotionParamID_TravelSpeed, m_fDesiredMoveSpeedSmoothQTX);
SetMotionParam(pSkeletonAnim, eMotionParamID_TurnSpeed, m_fDesiredTurnSpeedSmoothQTX * CAnimationGraphCVars::Get().m_turnSpeedParamScale);
SetMotionParam(pSkeletonAnim, eMotionParamID_TravelAngle, travelAngle);
// eMotionParamID_TravelSlope
SetMotionParam(pSkeletonAnim, eMotionParamID_TurnAngle, turnAngle);
// eMotionParamID_TravelDist
SetMotionParam(pSkeletonAnim, eMotionParamID_StopLeg, 0);
}
//------------------------------------------------------------------------
int CMelee::Hit(const Vec3 &pt, const Vec3 &dir, const Vec3 &normal, IPhysicalEntity *pCollider, EntityId collidedEntityId, int partId, int ipart, int surfaceIdx, bool remote)
{
MeleeDebugLog ("CMelee<%p> HitPointDirNormal(remote=%s)", this, remote ? "true" : "false");
int hitTypeID = 0;
CActor *pOwnerActor = m_pWeapon->GetOwnerActor();
if (pOwnerActor)
{
IActor* pTargetActor = g_pGame->GetIGameFramework()->GetIActorSystem()->GetActor(collidedEntityId);
IEntity* pTarget = pTargetActor ? pTargetActor->GetEntity() : gEnv->pEntitySystem->GetEntity(collidedEntityId);
IEntity* pOwnerEntity = pOwnerActor->GetEntity();
IAIObject* pOwnerAI = pOwnerEntity->GetAI();
float damageScale = 1.0f;
bool silentHit = false;
if(pTargetActor)
{
IAnimatedCharacter* pTargetAC = pTargetActor->GetAnimatedCharacter();
IAnimatedCharacter* pOwnerAC = pOwnerActor->GetAnimatedCharacter();
if(pTargetAC && pOwnerAC)
{
Vec3 targetFacing(pTargetAC->GetAnimLocation().GetColumn1());
Vec3 ownerFacing(pOwnerAC->GetAnimLocation().GetColumn1());
float ownerFacingDot = ownerFacing.Dot(targetFacing);
float fromBehindDot = cos_tpl(DEG2RAD(g_pGameCVars->pl_melee.angle_limit_from_behind));
if(ownerFacingDot > fromBehindDot)
{
#ifndef _RELEASE
if (g_pGameCVars->g_LogDamage)
{
CryLog ("[DAMAGE] %s '%s' is%s meleeing %s '%s' from behind (because %f > %f)",
pOwnerActor->GetEntity()->GetClass()->GetName(), pOwnerActor->GetEntity()->GetName(), silentHit ? " silently" : "",
pTargetActor->GetEntity()->GetClass()->GetName(), pTargetActor->GetEntity()->GetName(),
ownerFacingDot, fromBehindDot);
}
#endif
damageScale *= g_pGameCVars->pl_melee.damage_multiplier_from_behind;
}
}
}
// Send target stimuli
if (!gEnv->bMultiplayer)
{
IAISystem *pAISystem = gEnv->pAISystem;
ITargetTrackManager *pTargetTrackManager = pAISystem ? pAISystem->GetTargetTrackManager() : NULL;
if (pTargetTrackManager && pOwnerAI)
{
IAIObject *pTargetAI = pTarget ? pTarget->GetAI() : NULL;
if (pTargetAI)
{
const tAIObjectID aiOwnerId = pOwnerAI->GetAIObjectID();
const tAIObjectID aiTargetId = pTargetAI->GetAIObjectID();
TargetTrackHelpers::SStimulusEvent eventInfo;
eventInfo.vPos = pt;
eventInfo.eStimulusType = TargetTrackHelpers::eEST_Generic;
eventInfo.eTargetThreat = AITHREAT_AGGRESSIVE;
pTargetTrackManager->HandleStimulusEventForAgent(aiTargetId, aiOwnerId, "MeleeHit",eventInfo);
pTargetTrackManager->HandleStimulusEventInRange(aiOwnerId, "MeleeHitNear", eventInfo, 5.0f);
}
}
}
//Check if is a friendly hit, in that case FX and Hit will be skipped
bool isFriendlyHit = (pOwnerEntity && pTarget) ? IsFriendlyHit(pOwnerEntity, pTarget) : false;
if(!isFriendlyHit)
{
CPlayer * pAttackerPlayer = pOwnerActor->IsPlayer() ? static_cast<CPlayer*>(pOwnerActor) : NULL;
float damage = m_pMeleeParams->meleeparams.damage_ai;
if(pOwnerActor->IsPlayer())
{
damage = m_slideKick ? m_pMeleeParams->meleeparams.slide_damage : GetMeleeDamage();
}
#ifndef _RELEASE
if (pTargetActor && g_pGameCVars->g_LogDamage)
{
CryLog ("[DAMAGE] %s '%s' is%s meleeing %s '%s' applying damage = %.3f x %.3f = %.3f",
pOwnerActor->GetEntity()->GetClass()->GetName(), pOwnerActor->GetEntity()->GetName(), silentHit ? " silently" : "",
pTargetActor->GetEntity()->GetClass()->GetName(), pTargetActor->GetEntity()->GetName(),
damage, damageScale, damage * damageScale);
}
#endif
//Generate Hit
if(pTarget)
{
CGameRules *pGameRules = g_pGame->GetGameRules();
CRY_ASSERT_MESSAGE(pGameRules, "No game rules! Melee can not apply hit damage");
if (pGameRules)
{
hitTypeID = silentHit ? CGameRules::EHitType::SilentMelee : m_hitTypeID;
HitInfo info(m_pWeapon->GetOwnerId(), pTarget->GetId(), m_pWeapon->GetEntityId(),
damage * damageScale, 0.0f, surfaceIdx, partId, hitTypeID, pt, dir, normal);
if (m_pMeleeParams->meleeparams.knockdown_chance>0 && Random(100) < m_pMeleeParams->meleeparams.knockdown_chance)
info.knocksDown = true;
info.remote = remote;
pGameRules->ClientHit(info);
}
if (pAttackerPlayer && pAttackerPlayer->IsClient())
{
const Vec3 posOffset = (pt - pTarget->GetWorldPos());
SMeleeHitParams params;
params.m_boostedMelee = false;
params.m_hitNormal = normal;
params.m_hitOffset = posOffset;
params.m_surfaceIdx = surfaceIdx;
params.m_targetId = pTarget->GetId();
pAttackerPlayer->OnMeleeHit(params);
}
}
else
{
//Play Material FX
PlayHitMaterialEffect(pt, normal, false, surfaceIdx);
}
}
if (pTarget)
{
CActor *pCTargetActor = static_cast<CActor*>(pTargetActor);
CPlayer* pTargetPlayer = (pTargetActor && pTargetActor->IsPlayer()) ? static_cast<CPlayer*>(pTargetActor) : NULL;
if(pTargetPlayer && pTargetPlayer->IsClient())
{
if(m_pMeleeParams->meleeparams.trigger_client_reaction)
{
pTargetPlayer->TriggerMeleeReaction();
}
}
}
}
return hitTypeID;
}
