// INTERNALS
public void UpdateEffector()
{
TSCollider2D[] colliders = TSPhysics2D.OverlapCircleAll(tsTransform2D.position, m_Radius, m_LayerMask);
if (colliders != null)
{
if (colliders.Length > 0)
{
for (int index = 0; index < colliders.Length; ++index)
{
TSCollider2D currentCollider = colliders[index];
if (currentCollider == null)
{
continue;
}
TSTransform2D transform2d = currentCollider.tsTransform;
TSVector2 direction = transform2d.position - tsTransform2D.position;
direction = direction.normalized;
TSRigidBody2D rigidbody = currentCollider.GetComponent <TSRigidBody2D>();
if (rigidbody != null)
{
rigidbody.AddForce(direction * m_ForceMagnitude);
}
}
}
}
}
// INERNALS
private void ComputeTimeScale(out FP o_TimeScale)
{
o_TimeScale = FP.One;
//bool slowMotionEnabled;
//GameSettings.TryGetBoolMain(Settings.s_SlowMotionSetting, out slowMotionEnabled);
if (m_Reference == null || m_ReferenceTransform == null /*|| !slowMotionEnabled*/)
{
return;
}
TSVector2 velocity = m_Reference.velocity;
if (velocity.LengthSquared() < m_MinReferenceSpeed * m_MinReferenceSpeed)
{
o_TimeScale = 1f;
return;
}
if (m_UseRaycast)
{
TSVector2 rayOrigin = m_Reference.position;
TSVector2 rayDirection = velocity.normalized;
FP speed = velocity.magnitude;
FP rayDistance = speed * m_TimeToReach;
rayDistance = MathFP.Max(rayDistance, m_DistanceThreshold);
TSRaycastHit2D[] raycastHit = TSPhysics2D.Raycast(rayOrigin, rayDirection, rayDistance, m_RaycastMask);
if (raycastHit == null || raycastHit.Length == 0)
{
o_TimeScale = 1f;
return;
}
TSRaycastHit2D hitResult = raycastHit[0];
FP timeScale = MathFP.GetClampedPercentage(hitResult.distance, m_MinDistance, m_MaxDistance);
timeScale = MathFP.Max(timeScale, m_MinTimeScale);
o_TimeScale = timeScale;
}
else // Do a simple line check.
{
TSVector2 delta = velocity * m_TimeToReach;
if (delta.magnitude > m_DistanceThreshold)
{
delta = delta.normalized * m_DistanceThreshold;
}
TSVector2 rayStart = m_Reference.position;
TSVector2 rayEnd = rayStart + delta;
// Check each stored segment.
for (int segmentIndex = 0; segmentIndex < m_SegmentCount; ++segmentIndex)
{
TSVector2 pointA = m_Segments[segmentIndex * 2];
TSVector2 pointB = m_Segments[segmentIndex * 2 + 1];
FP t;
TSVector2 intersectionPoint;
if (Test2DSegmentSegment(pointA, pointB, rayStart, rayEnd, out t, out intersectionPoint))
{
TSVector2 distance = intersectionPoint - rayStart;
FP timeScale = MathFP.GetClampedPercentage(distance.magnitude, m_MinDistance, m_MaxDistance);
timeScale = MathFP.Max(timeScale, m_MinTimeScale);
o_TimeScale = timeScale;
return;
}
}
}
}
// INTERNALS
private bool Kick(LayerMask i_Mask, FP i_AppliedForce, FP i_DeltaTime, bool i_InvertVelocity = false)
{
bool kickedAnything = false;
TSCollider2D[] colliders = TSPhysics2D.OverlapCircleAll(tsTransform2D.position, m_Radius, i_Mask);
if (colliders != null)
{
for (int colliderIndex = 0; colliderIndex < colliders.Length; ++colliderIndex)
{
TSCollider2D currentCollider = colliders[colliderIndex];
if (currentCollider == null)
{
continue;
}
GameObject currentGo = currentCollider.gameObject;
if (m_CharacterController != null)
{
int currentLayer = m_CharacterController.currentLayer;
if (currentLayer == m_ChargingLayer)
{
continue;
}
}
tnKickable kickable = currentGo.GetComponent <tnKickable>();
if (kickable == null)
{
continue;
}
TSTransform2D kickableTransform = kickable.tsTransform2D;
if (kickableTransform == null)
{
continue;
}
TSVector2 kickablePosition = kickableTransform.position;
kickedAnything = true;
// Evaluate force.
TSVector2 direction = kickablePosition - tsTransform2D.position;
direction.Normalize();
TSVector2 force = direction * i_AppliedForce;
if (i_InvertVelocity)
{
if (i_DeltaTime > FP.Zero)
{
FP otherMass = kickable.mass;
TSVector2 otherVelocity = kickable.currentVelocity;
TSVector2 oppositeForce = (otherMass * otherVelocity) / i_DeltaTime;
oppositeForce = oppositeForce * -FP.One;
force += oppositeForce;
}
}
// Kick.
kickable.Kick(force, gameObject);
// Notify listeners.
if (m_KickEvent != null)
{
m_KickEvent(kickable);
}
}
}
return(kickedAnything);
}
