public override void StartMovement()
{
apostleController.CheckForHorizontalInput();
CheckFacingDirection();
if (apostleController.Jog)
{
apostleStatusVariables.isJogging = !apostleStatusVariables.isJogging;
}
if (!MathHelpers.Approximately(apostleController.HorizontalMove, 0, float.Epsilon))
{
if (apostleController.Run)
{
HorizontalMovementState = HorizontalMovementState.Running;
}
else if (apostleStatusVariables.isJogging)
{
HorizontalMovementState = HorizontalMovementState.Jogging;
}
else
{
HorizontalMovementState = HorizontalMovementState.Walking;
}
}
else
{
HorizontalMovementState = HorizontalMovementState.Idle;
}
}
public void CheckForCurrentTransitionFloor(Transform transform, CapsuleCollider2D collider2D,
ref Floor currentFloor,
ref TransitionFloor currentTransitionFloor, TransitionFloorType type)
{
if (type == TransitionFloorType.Obstacle)
{
currentFloor = new Floor(-1);
currentTransitionFloor = this.transitionFloorList.Find(lambdaExpression =>
lambdaExpression.transform != null &&
MathHelpers.Approximately(lambdaExpression.transform.position.x, transform.position.x, 0.5f) &&
MathHelpers.Approximately(lambdaExpression.transform.position.y, transform.position.y, 3f));
}
else if (type == TransitionFloorType.Ladder)
{
currentFloor = new Floor(-1);
currentTransitionFloor = this.transitionFloorList.Find(lambdaExpression =>
lambdaExpression.transform != null &&
MathHelpers.Approximately(lambdaExpression.transform.position.x, transform.position.x, 0.5f) &&
transform.position.y >= lambdaExpression.colliderBounds.bottomMid.y &&
transform.position.y <= lambdaExpression.colliderBounds.topMid.y + collider2D.size.y / 2);
}
else if (type == TransitionFloorType.Stairs)
{
currentFloor = new Floor(-1);
currentTransitionFloor = this.transitionFloorList.Find(lambdaExpression =>
!lambdaExpression.colliderBounds.Equals(null) &&
lambdaExpression.colliderBounds.bottomLeft.x <= transform.position.x &&
lambdaExpression.colliderBounds.bottomRight.x >= transform.position.x &&
lambdaExpression.colliderBounds.boundingBoxBottomY.y <= transform.position.y &&
lambdaExpression.colliderBounds.boundingBoxTopY.y >= transform.position.y);
}
}
public void TestOtherProperties()
{
{
//get length
Vector2 v1 = new Vector2(4.5f, 6.789f);
float len = v1.Length;
float lenManual = (float)System.Math.Sqrt(v1.x * v1.x + v1.y * v1.y);
Assert.IsTrue(len == lenManual, "Length get test fails for Vector2");
Vec2 v1b = new Vec2(v1.x, v1.y);
float v1bLen = v1b.GetLength();
Assert.IsTrue(v1bLen == len, "Length comparison fails for Vector2 and Vec2");
}
{
//set length
Vector2 v1 = new Vector2(10.0f, 10.0f);
float len = v1.Length;
Vector2 v2 = new Vector2(1f, 1f);
v2.Length = len;
Assert.IsTrue(v1.x == v2.x, "Length set fails for x for Vector2");
Assert.IsTrue(v1.y == v2.y, "Length set fails for y for Vector2");
}
{
//Normalized
Vector2 vec2 = new Vector2(10.0f, 1.0f);
Vector2 unitVec2 = vec2.Normalized;
Assert.IsTrue(MathHelpers.Approximately(1.0f, unitVec2.Length), " Normalized Vector2 fails for Length");
Vec2 vec2a = new Vec2(vec2.x, vec2.y);
Assert.IsTrue(MathHelpers.Approximately(vec2a.GetNormalized().GetLength(), unitVec2.Length), " Normalized fails for Length comparison");
}
}
public bool CheckForPreventSlideOnSlopes()
{
return(!MathHelpers.Approximately(playerCollisionHandler.SurfaceAngle, 0, float.Epsilon) &&
(HorizontalMovementState == HorizontalMovementState.Idle ||
HorizontalMovementState == HorizontalMovementState.CrouchIdle || rigidbody2D.velocity.y < 0) &&
!playerStatusVariables.isOnAir);
}
void ComputeClampRect()
{
var prt = PRT;
switch (ClampMode)
{
case ClampMode.Full:
_clampRect = _bounds.Pad(Spacing);
// Use intersection if parent and own rect exist
if (prt != null && prt.ClampRect.Size > 0 && _clampRect.Size > 0)
{
_clampRect = prt._clampRect & _clampRect;
}
// Take over Parent CR if self null
if (MathHelpers.Approximately(_clampRect.Size, 0) && prt != null)
{
_clampRect = prt._clampRect;
}
break;
case ClampMode.Self:
_clampRect = Bounds.Pad(Spacing);
break;
case ClampMode.Parent:
_clampRect = prt != null ? prt._clampRect : new Rect();
break;
case ClampMode.None:
_clampRect = new Rect();
break;
}
}
public virtual bool CheckGroundWithPerifericalRays(float distance, bool rightRay)
{
distance += offsetForPerifericalRays;
if (rightRay)
{
if (!MathHelpers.Approximately(SurfaceAngle, 0, float.Epsilon))
{
distance = RaycastHit2DPoints.midRightDownwardRay.distance <= distance ||
RaycastHit2DPoints.midRightDownwardRay.distance > 0.25f + offsetForPerifericalRays
? distance
: RaycastHit2DPoints.midRightDownwardRay.distance;
}
return(RaycastHit2DPoints.midRightDownwardRay.collider != null &&
RaycastHit2DPoints.midRightDownwardRay.distance <= distance);
}
if (!MathHelpers.Approximately(SurfaceAngle, 0, float.Epsilon))
{
distance = RaycastHit2DPoints.midLeftDownwardRay.distance <= distance ||
RaycastHit2DPoints.midLeftDownwardRay.distance > 0.25f + offsetForPerifericalRays
? distance
: RaycastHit2DPoints.midLeftDownwardRay.distance;
}
return(RaycastHit2DPoints.midLeftDownwardRay.collider != null &&
RaycastHit2DPoints.midLeftDownwardRay.distance <= distance);
}
void Update()
{
RegenStamina();
if (!MathHelpers.Approximately(lifeBar.value, currentLife, float.Epsilon))
{
lifeBar.value = currentLife;
}
if (!CheckIfOnTransitionFloor())
{
navigation.CheckForCurrentFloor(transform, collider2D, ref currentFloor, ref currentTransitionFloor);
}
else
{
if (playerStatusVariables.isClimbingObstacle)
{
navigation.CheckForCurrentTransitionFloor(transform, collider2D, ref currentFloor,
ref currentTransitionFloor,
TransitionFloorType.Obstacle);
}
else if (playerStatusVariables.isClimbingLadder)
{
navigation.CheckForCurrentTransitionFloor(transform, collider2D, ref currentFloor,
ref currentTransitionFloor,
TransitionFloorType.Ladder);
}
else if (playerStatusVariables.isClimbingStairs)
{
navigation.CheckForCurrentTransitionFloor(transform, collider2D, ref currentFloor,
ref currentTransitionFloor,
TransitionFloorType.Stairs);
}
}
}
public static Vector2 HorizontalMovementByForce(float acceleration, float constant,
float maxSpeed, float direction, Rigidbody2D rigidBody, float surfaceAngle, Vector2 surfaceNormal)
{
var velocity = (maxSpeed / 3.6f) * constant;
var force = ForceCalcByAcceleration(acceleration * constant, rigidBody.mass) +
FrictionForceCalc(0.4f, Physics2D.gravity.y, rigidBody.mass) +
SlopeForceCalc(surfaceAngle, surfaceNormal, direction, rigidBody.mass, Physics2D.gravity.y);
var forceApplied = new Vector2(force, 0) * direction;
if (!MathHelpers.Approximately(surfaceAngle, 0, float.Epsilon))
{
forceApplied = new Vector2(
force * MathHelpers.AbsCos(surfaceAngle),
force * (!SlopeInclinationRight(surfaceNormal)
? -MathHelpers.AbsSin(surfaceAngle)
: MathHelpers.AbsSin(surfaceAngle))) * direction;
}
if (rigidBody.velocity.magnitude > velocity)
{
rigidBody.AddRelativeForce(-forceApplied);
}
rigidBody.AddRelativeForce(forceApplied);
return(forceApplied);
}
private void DrawSection(float x, float y, float w, float h, float u0, float v0, float u1, float v1)
{
float crx = x, cry = y, crw = w, crh = h;
if (ClampRect.Size > 0)
{
crx = ClampRect.x;
cry = ClampRect.y;
crw = ClampRect.w;
crh = ClampRect.h;
}
if (MathHelpers.Approximately(ClampRect.Size, 0) || (crx <= x && cry <= y && crx + crw >= x + w && cry + crh >= y + h))
{
if (RoundLocation)
{
x = (int)x;
y = (int)y;
}
TargetCanvas.PushTexturePart(this, x, y, w, h, u0, v0, u1, v1, Angle, Color);
}
else
{
if (crx >= x + w || crx + crw <= x || cry >= y + h || cry + crh <= y || crw <= 0 || crh <= 0)
{
return;
}
float cx = x, cy = y, cw = w, ch = h, cu0 = u0, cv0 = v0, cu1 = u1, cv1 = v1;
if (crx > x)
{
cu0 = u0 + (u1 - u0) * (crx - x) / w;
cx = crx;
cw = cw - (crx - x);
}
if (crx + crw < x + w)
{
cu1 = u1 - (u1 - u0) * (x + w - crx - crw) / w;
cw = crx + crw - cx;
}
if (cry > y)
{
cv0 = v0 + (v1 - v0) * (cry - y) / h;
cy = cry;
ch = ch - (cry - y);
}
if (cry + crh < y + h)
{
cv1 = v1 - (v1 - v0) * (y + h - cry - crh) / h;
ch = cry + crh - cy;
}
if (RoundLocation)
{
cx = (int)cx; cy = (int)cy;
}
TargetCanvas.PushTexturePart(this, cx, cy, cw, ch, cu0, cv0, cu1, cv1, Angle, Color);
}
}
public override void StartMovement()
{
playerController.CheckForHorizontalInput();
CheckFacingDirection();
if (playerController.Jog)
{
playerStatusVariables.isJoggingActive = !playerStatusVariables.isJoggingActive;
}
if (playerController.Crouch)
{
Crouch();
}
else if (playerStatusVariables.isCrouching)
{
Raise();
}
playerStatusVariables.isDodging = playerController.Dodge && player.CheckStamina(30, true);
playerStatusVariables.isRunning = false;
playerStatusVariables.isJogging = false;
if (!MathHelpers.Approximately(playerController.HorizontalMove, 0, float.Epsilon) &&
!playerStatusVariables.isDodging)
{
if (playerStatusVariables.isCrouching)
{
HorizontalMovementState = HorizontalMovementState.CrouchWalking;
}
else if (playerController.Run && player.CheckStamina(10, false))
{
playerStatusVariables.isRunning = true;
HorizontalMovementState = HorizontalMovementState.Running;
}
else if (playerStatusVariables.isJoggingActive && player.CheckStamina(5, false))
{
HorizontalMovementState = HorizontalMovementState.Jogging;
playerStatusVariables.isJogging = true;
}
else
{
HorizontalMovementState = HorizontalMovementState.Walking;
}
}
else if (playerStatusVariables.isDodging)
{
HorizontalPressMovementState = HorizontalPressMovementState.Dodge;
HorizontalMovementState = HorizontalMovementState.Idle;
}
else if (playerStatusVariables.isCrouching)
{
HorizontalMovementState = HorizontalMovementState.CrouchIdle;
}
else
{
HorizontalMovementState = HorizontalMovementState.Idle;
}
}
public override void ResolvePendencies()
{
if (apostleStatusVariables.isOnAir)
{
if (lastFramePositionWhileFalling >= rigidbody2D.position.y && rigidbody2D.velocity.y < 0)
{
distanceWhileFalling += lastFramePositionWhileFalling - rigidbody2D.position.y;
}
if (apostleStatusVariables.canJump &&
(rigidbody2D.velocity.y < 0 || MathHelpers.Approximately(rigidbody2D.velocity.y, 0, float.Epsilon)))
{
if (distanceWhileFalling >= minimumFallingDistanceForDamage)
{
apostle.TakeDamage(minimumDamageForFalling * distanceWhileFalling /
minimumFallingDistanceForDamage);
}
distanceWhileFalling = 0;
apostleStatusVariables.isOnAir = false;
apostleController.RevokeControl(0.1f, true, ControlTypeToRevoke.AllMovement, monoBehaviour);
}
lastFramePositionWhileFalling = rigidbody2D.position.y;
}
else
{
lastFramePositionWhileFalling = 0;
}
if (!MathHelpers.Approximately(rigidbody2D.velocity.y, 0, float.Epsilon) &&
MathHelpers.Approximately(apostleController.VerticalMovement, 0, float.Epsilon) &&
apostleStatusVariables.isClimbingLadder)
{
PhysicsHelpers.ResetVelocityY(rigidbody2D);
}
if (!apostleStatusVariables.isClimbingStairs)
{
// PhysicsHelpers.IgnoreLayerCollision(rigidbody2D.gameObject.layer, LayerMask.NameToLayer("Stairs Ground"),
// true);
apostleCollisionHandler.SetLayerForCollisions(new[] { "Ground", "Ground Ignore" });
var leftRayCollider = apostleCollisionHandler.CastLeftwardRay(LayerMask.GetMask("Stairs Ground")).collider;
var rightRayCollider =
apostleCollisionHandler.CastRightwardRay(LayerMask.GetMask("Stairs Ground")).collider;
if (leftRayCollider != null && !Physics2D.GetIgnoreCollision(capsuleCollider2D, leftRayCollider))
{
PhysicsHelpers.IgnoreCollision(capsuleCollider2D, leftRayCollider, true);
}
else if (rightRayCollider && !Physics2D.GetIgnoreCollision(capsuleCollider2D, rightRayCollider))
{
PhysicsHelpers.IgnoreCollision(capsuleCollider2D, rightRayCollider, true);
}
}
}
public void ApplyOnSelfSizeChanged(float dWidth, float dHeight, bool applyPivot)
{
int cnt = _defs.Count;
if (cnt == 0)
{
return;
}
float ox = _owner.x;
float oy = _owner.y;
for (int i = 0; i < cnt; i++)
{
RelationDef info = _defs[i];
switch (info.type)
{
case RelationType.Center_Center:
_owner.x -= (0.5f - (applyPivot ? _owner.pivotX : 0)) * dWidth;
break;
case RelationType.Right_Center:
case RelationType.Right_Left:
case RelationType.Right_Right:
_owner.x -= (1 - (applyPivot ? _owner.pivotX : 0)) * dWidth;
break;
case RelationType.Middle_Middle:
_owner.y -= (0.5f - (applyPivot ? _owner.pivotY : 0)) * dHeight;
break;
case RelationType.Bottom_Middle:
case RelationType.Bottom_Top:
case RelationType.Bottom_Bottom:
_owner.y -= (1 - (applyPivot ? _owner.pivotY : 0)) * dHeight;
break;
}
}
if (!MathHelpers.Approximately(ox, _owner.x) || !MathHelpers.Approximately(oy, _owner.y))
{
ox = _owner.x - ox;
oy = _owner.y - oy;
_owner.UpdateGearFromRelations(1, ox, oy);
if (_owner.parent != null)
{
int transCount = _owner.parent._transitions.Count;
for (int i = 0; i < transCount; i++)
{
_owner.parent._transitions[i].UpdateFromRelations(_owner.id, ox, oy);
}
}
}
}
public void TestOtherProperties()
{
{
//get length
Vector3 v1 = new Vector3(1.1f, 2.2f, 3.3f);
float len = v1.Length;
float lenManual = (float)System.Math.Sqrt(v1.x * v1.x + v1.y * v1.y + v1.z * v1.z);
Assert.IsTrue(len == lenManual, "Length get test fails for Vector3");
Vec3 v2 = new Vec3(v1.x, v1.y, v1.z);
float v2Len = v2.len();
Assert.IsTrue(len == lenManual, "Length Comparison test fails for Vector3 and Vec3");
//get magnitude
float magnitude = v1.Magnitude;
Assert.IsTrue(len == magnitude, "Length and magnitude are not equal");
}
{
//LengthSquared
Vector3 v1 = new Vector3(1.2f, 0.3f, 1.5f);
float lengthSquared = v1.LengthSquared;
float lengthSquared2 = (v1.x * v1.x) + (v1.y * v1.y) + (v1.z * v1.z);
Assert.IsTrue(MathHelpers.Approximately(lengthSquared, lengthSquared2, 0.0000001f), "LengthSquared fails for Vector3");
}
{
//Length2D
Vector2 v2 = new Vector2(1.2f, 0.3f);
Vector3 v2_to_v3 = new Vector3(v2);
float v2Length = v2.Length;
float v2_to_v3Length = v2_to_v3.Length2D;
Assert.IsTrue(MathHelpers.Approximately(v2Length, v2_to_v3Length, 0.0000001f), "Length2D fails for Vector3");
float v2LengthSquared = v2.LengthSquared;
float v2_to_v3LengthSquared = v2_to_v3.Length2DSquared;
Assert.IsTrue(MathHelpers.Approximately(v2LengthSquared, v2_to_v3LengthSquared, 0.0000001f), "Length2DSquared fails for Vector3");
}
{
//Normalized
Vector3 v3 = new Vector3(0, 0, 0);
Vector3 v3Unit = v3.Normalized;
Assert.IsTrue(NativeExtensions.TestVectorsAreEqual(v3, v3Unit), "Normalized fails for Vector3");
}
{
//Volume
Vector3 v3 = new Vector3(1f, 2f, 10f);
float volume = v3.Volume;
float vol = v3.x * v3.y * v3.z;
Assert.IsTrue(volume == vol, "Volume fails for Vector3");
}
}
public void TestSlerp()
{
{
//native
Vec2 vec2p = new Vec2(1f, 1f);
vec2p.Normalize();
Vec2 vec2q = new Vec2(10.0f, 10.0f);
vec2q.Normalize();
Vec2 vec2Mid = Vec2.CreateSlerp(vec2p, vec2q, 0.5f);
//managed
Vector2 vector2p = new Vector2(vec2p.x, vec2p.y);
vector2p = vector2p.Normalized;
Vector2 vector2q = new Vector2(vec2q.x, vec2q.y);
vector2q = vector2q.Normalized;
Vector2 vector2Mid = Vector2.Slerp(vector2p, vector2q, 0.5f);
Assert.IsTrue(MathHelpers.Approximately(vec2Mid.x, vector2Mid.x, 0.000001f) && MathHelpers.Approximately(vec2Mid.y, vector2Mid.y, 0.000001f), " Slerp tests fails for native and managed vector2 1");
}
{
Vec2 vec2p = new Vec2(1f, 1f);
vec2p.Normalize();
Vec2 vec2q = new Vec2(10.0f, 10.0f);
vec2q.Normalize();
Vec2 vec2Start = Vec2.CreateSlerp(vec2p, vec2q, 0.0f);
//managed
Vector2 vector2p = new Vector2(vec2p.x, vec2p.y);
vector2p = vector2p.Normalized;
Vector2 vector2q = new Vector2(vec2q.x, vec2q.y);
vector2q = vector2q.Normalized;
Vector2 vector2Start = Vector2.Slerp(vector2p, vector2q, 0.0f);
Assert.IsTrue(NativeExtensions.TestVectorsAreEqual(vec2Start, vector2Start), "Slerp tests fails for vector2 2a");
Assert.IsTrue(NativeExtensions.TestVectorsAreEqual(vec2Start, vec2p), "Slerp tests fails for vector2 2b " + vec2Start.PrintString() + "," + vec2p.PrintString());
Assert.IsTrue(NativeExtensions.TestVectorsAreEqual(vector2Start, vector2p), "Slerp tests fails for vector2 2c");
}
{
Vec2 vec2p = new Vec2(1f, 1f);
vec2p.Normalize();
Vec2 vec2q = new Vec2(10.0f, 10.0f);
vec2q.Normalize();
Vec2 vec2Start = Vec2.CreateSlerp(vec2p, vec2q, 1.0f);
//managed
Vector2 vector2p = new Vector2(vec2p.x, vec2p.y);
vector2p = vector2p.Normalized;
Vector2 vector2q = new Vector2(vec2q.x, vec2q.y);
vector2q = vector2q.Normalized;
Vector2 vector2Start = Vector2.Slerp(vector2p, vector2q, 1.0f);
Assert.IsTrue(NativeExtensions.TestVectorsAreEqual(vec2Start, vector2Start), "Slerp tests fails for vector2 3a");
Assert.IsTrue(NativeExtensions.TestVectorsAreEqual(vec2Start, vec2q), "Slerp tests fails for vector2 3b");
Assert.IsTrue(NativeExtensions.TestVectorsAreEqual(vector2Start, vector2q), "Slerp tests fails for vector2 3c");
}
}
void __targetSizeChanged(EventContext context)
{
if (_owner.relations.handling != null ||
_owner.group != null && _owner.group._updating != 0)
{
_targetData.z = _target._width;
_targetData.w = _target._height;
return;
}
_owner.relations.handling = (GObject)context.sender;
float ox = _owner.x;
float oy = _owner.y;
float ow = _owner._rawWidth;
float oh = _owner._rawHeight;
int cnt = _defs.Count;
for (int i = 0; i < cnt; i++)
{
ApplyOnSizeChanged(_defs[i]);
}
_targetData.z = _target._width;
_targetData.w = _target._height;
if (!MathHelpers.Approximately(ox, _owner.x) || !MathHelpers.Approximately(oy, _owner.y))
{
ox = _owner.x - ox;
oy = _owner.y - oy;
_owner.UpdateGearFromRelations(1, ox, oy);
if (_owner.parent != null)
{
int transCount = _owner.parent._transitions.Count;
for (int i = 0; i < transCount; i++)
{
_owner.parent._transitions[i].UpdateFromRelations(_owner.id, ox, oy);
}
}
}
if (!MathHelpers.Approximately(ow, _owner._rawWidth) || !MathHelpers.Approximately(oh, _owner._rawHeight))
{
ow = _owner._rawWidth - ow;
oh = _owner._rawHeight - oh;
_owner.UpdateGearFromRelations(2, ow, oh);
}
_owner.relations.handling = null;
}
private IEnumerator ClimbOntoObstacleCoroutine(Vector2 position, float changeRate)
{
while (playerStatusVariables.isCrouching)
{
yield return(new WaitForFixedUpdate());
}
var playerSizeX = (position.x > rigidbody2D.position.x)
? capsuleCollider2D.size.x / 2
: -capsuleCollider2D.size.x / 2;
var playerSizeY = capsuleCollider2D.size.y / 2;
var desiredPositionX = position.x + playerSizeX;
var desiredPositionY = position.y + playerSizeY;
var f = 0.0f;
var initialPositionForY = rigidbody2D.position;
var initialPositionForX = new Vector2(rigidbody2D.position.x, desiredPositionY);
// Bug Corrigido, usar a posição do rigidBody no lerp era a causa, pode ser um quirck do unity
while (!MathHelpers.Approximately(rigidbody2D.position.x, desiredPositionX, 0.01f) ||
!MathHelpers.Approximately(rigidbody2D.position.y, desiredPositionY, 0.01f))
{
if (!MathHelpers.Approximately(rigidbody2D.position.y, desiredPositionY, 0.001f))
{
f += changeRate;
if (f >= 1)
{
f = 1;
}
rigidbody2D.MovePosition(Vector2.Lerp(initialPositionForY,
new Vector2(initialPositionForY.x, desiredPositionY), f));
}
else
{
if (MathHelpers.Approximately(rigidbody2D.position.x, initialPositionForX.x, 0.01f) &&
MathHelpers.Approximately(rigidbody2D.position.y, initialPositionForX.y, 0.01f))
{
f = 0;
}
f += changeRate;
if (f >= 1)
{
f = 1;
}
rigidbody2D.MovePosition(Vector2.Lerp(initialPositionForX,
new Vector2(desiredPositionX, initialPositionForX.y), f));
}
yield return(new WaitForFixedUpdate());
}
CoroutineManager.FindCoroutine("ClimbOntoObstacleCoroutine").IsRunning = false;
playerController.RevokeControl(false, ControlTypeToRevoke.AllMovement);
}
public virtual bool CheckGroundForJump(float distance)
{
if (!MathHelpers.Approximately(SurfaceAngle, 0, float.Epsilon))
{
distance = RaycastHit2DPoints.bottomMidDownwardRay.distance <= distance ||
RaycastHit2DPoints.bottomMidDownwardRay.distance > 0.25f
? distance
: RaycastHit2DPoints.bottomMidDownwardRay.distance;
}
return(RaycastHit2DPoints.bottomMidDownwardRay.collider != null &&
RaycastHit2DPoints.bottomMidDownwardRay.distance <= distance);
}
/// <summary>
///
/// </summary>
/// <param name="wv"></param>
/// <param name="hv"></param>
public void SetSize(float wv, float hv)
{
bool wc = !MathHelpers.Approximately(wv, _contentRect.Width);
bool hc = !MathHelpers.Approximately(hv, _contentRect.Height);
if (wc || hc)
{
_contentRect.Width = wv;
_contentRect.Height = hv;
OnSizeChanged(wc, hc);
}
}
private void ResetDropdownValues()
{
resolutionDropdown.value = -1;
ratioDropdown.value = -1;
ratioDropdown.value =
MathHelpers.Approximately(GetResolutionRatio(currentResolution.width, currentResolution.height),
(double)4 / 3, float.Epsilon)
? (int)Ratio.FourByThree
: (int)Ratio.SixteenByNine;
resolutionDropdown.value =
resolutionDropdown.options.FindIndex(lambdaExpression =>
lambdaExpression.text == GetTextFromResolution(currentResolution));
}
public void CheckFacingDirection()
{
if (MathHelpers.Approximately(apostleController.HorizontalMove, 1, float.Epsilon))
{
apostleStatusVariables.facingDirection = FacingDirection.Right;
}
else if (MathHelpers.Approximately(apostleController.HorizontalMove, -1, float.Epsilon))
{
apostleStatusVariables.facingDirection = FacingDirection.Left;
}
spriteRenderer.flipX = (apostleStatusVariables.facingDirection != FacingDirection.Right);
}
public void TestApproximately()
{
{
float a = 1.10234567f;
Assert.IsTrue(MathHelpers.Approximately(a, a, CryEngine.MathHelpers.Epsilon), "Approximately failed for no precision test");
}
{
float a = 1.10234567f;
float b = 1.1234567f;
Assert.IsTrue(MathHelpers.Approximately(a, b, 0.1f), "Approximately failed for precision 1");
}
{
float a = 1.120234567f;
float b = 1.1234567f;
Assert.IsTrue(MathHelpers.Approximately(a, b, 0.01f), "Approximately failed for precision 2 a");
}
{
float a = 1.1230567f;
float b = 1.1234567f;
Assert.IsTrue(MathHelpers.Approximately(a, b, 0.001f), "Approximately failed for precision 3 a");
}
{
float a = 1.1234567f;
float b = 1.1234789f;
Assert.IsTrue(MathHelpers.Approximately(a, b, 0.0001f), "Approximately failed for precision 4 a");
}
{
float a = 1.1234512f;
float b = 1.1234523f;
Assert.IsTrue(MathHelpers.Approximately(a, b, 0.00001f), "Approximately failed for precision 5 a");
}
{
float a = 1.1234560f;
float b = 1.1234563f;
Assert.IsTrue(MathHelpers.Approximately(a, b, 0.000001f), "Approximately failed for precision 6 a");
}
{
float a = 1.12345678f;
float b = 1.12345679f;
Assert.IsTrue(MathHelpers.Approximately(a, b, 0.0000001f), "Approximately failed for precision 7 a");
}
{
//test value "1"
float a = 1.0f;
float b = 1 / 1.0f;
Assert.IsTrue(MathHelpers.Approximately(a, b, CryEngine.MathHelpers.Epsilon));
}
{
//use Quaternion result to test
}
}
public void CheckForCurrentFloor(Transform transform, CapsuleCollider2D collider2D, ref Floor currentFloor,
ref TransitionFloor currentTransitionFloor)
{
//Altura como safe check
/* currentTransitionFloor = new TransitionFloor();
* var temporaryFloors = this.floorList.FindAll(lambdaExpression =>
* lambdaExpression.FloorInfo.startPointX.x <= transform.position.x &&
* lambdaExpression.FloorInfo.endPointX.x >= transform.position.x &&
* lambdaExpression.FloorInfo.startPointY.y <= transform.position.y &&
* lambdaExpression.FloorInfo.endPointY.y >= transform.position.y);*/
var temporaryFloors = this.floorList.FindAll(lambdaExpression =>
lambdaExpression.FloorInfo.startPointX.x <= transform.position.x &&
lambdaExpression.FloorInfo.endPointX.x >= transform.position.x &&
lambdaExpression.FloorInfo.startPointY.y <= transform.position.y &&
lambdaExpression.FloorInfo.endPointY.y >= transform.position.y);
Floor currentFloorForTest = null;
Collider2D[] colliders2D = new Collider2D[5];
foreach (var temporaryFloor in temporaryFloors)
{
temporaryFloor.collider2D.GetContacts(this.contactFilter2DForFloorCheck, colliders2D);
if (colliders2D.Where(contactCollider2D => contactCollider2D != null)
.Any(contactCollider2D => contactCollider2D == collider2D &&
contactCollider2D.gameObject.layer == transform.gameObject.layer))
{
currentFloorForTest = temporaryFloor;
}
if (currentFloorForTest != null)
{
break;
}
}
if (currentFloorForTest == null)
{
return;
}
if (!MathHelpers.Approximately(currentFloorForTest.transform.rotation.z, 0, float.Epsilon))
{
var raycastHit2D = Physics2D
.Raycast(transform.position, Vector2.up, 100f, LayerMask.GetMask("Ground", "Obstacle"));
if (raycastHit2D.collider != null &&
raycastHit2D.collider.transform == currentFloorForTest.transform)
{
return;
}
}
currentTransitionFloor = new TransitionFloor();
currentFloor = currentFloorForTest;
}
private void UpdateColliderBounds(BoxCollider2D boxCollider2D)
{
if (boxCollider2D == null)
{
return;
}
var center = boxCollider2D.offset;
colliderBounds.midLeft =
boxCollider2D.transform.TransformPoint(new Vector2(center.x - boxCollider2D.size.x / 2,
center.y));
colliderBounds.midRight =
boxCollider2D.transform.TransformPoint(new Vector2(center.x + boxCollider2D.size.x / 2,
center.y));
colliderBounds.bottomMid = boxCollider2D.transform.TransformPoint(new Vector2(
center.x,
center.y - boxCollider2D.size.y / 2));
colliderBounds.bottomLeft = boxCollider2D.transform.TransformPoint(new Vector2(
center.x - boxCollider2D.size.x / 2,
center.y - boxCollider2D.size.y / 2));
colliderBounds.bottomRight = boxCollider2D.transform.TransformPoint(new Vector2(
center.x + boxCollider2D.size.x / 2,
center.y - boxCollider2D.size.y / 2));
colliderBounds.topLeft =
boxCollider2D.transform.TransformPoint(new Vector2(center.x - boxCollider2D.size.x / 2,
center.y + boxCollider2D.size.y / 2));
colliderBounds.topRight =
boxCollider2D.transform.TransformPoint(new Vector2(center.x + boxCollider2D.size.x / 2,
center.y + boxCollider2D.size.y / 2));
colliderBounds.topMid =
boxCollider2D.transform.TransformPoint(new Vector2(center.x,
center.y + boxCollider2D.size.y / 2));
center = boxCollider2D.transform.TransformPoint(boxCollider2D.offset);
colliderBounds.boundingBoxBottomY =
new Vector2(center.x,
boxCollider2D.bounds.min.y);
if (!MathHelpers.Approximately(boxCollider2D.transform.rotation.z, 0, float.Epsilon))
{
colliderBounds.boundingBoxTopY =
new Vector2(center.x, center.y + boxCollider2D.bounds.size.y / 2 + 1f);
}
else
{
colliderBounds.boundingBoxTopY =
new Vector2(center.x, center.y + boxCollider2D.bounds.size.y / 2);
}
}
protected virtual void CheckGroundForSlopes()
{
if (!spriteRenderer.flipX &&
RaycastHit2DPoints.midRightDownwardRay.collider != null)
{
var rotationAngle = Vector2.Angle(RaycastHit2DPoints.midRightDownwardRay.normal, Vector2.up);
var surfaceNormal = RaycastHit2DPoints.midRightDownwardRay.normal;
if (RaycastHit2DPoints.midRightDownwardRay.normal.x > 0 && rotationAngle > SurfaceAngle)
{
rotationAngle = Vector2.Angle(RaycastHit2DPoints.midLeftDownwardRay.normal, Vector2.up);
surfaceNormal = RaycastHit2DPoints.midLeftDownwardRay.normal;
}
else if (MathHelpers.Approximately(RaycastHit2DPoints.midRightDownwardRay.normal.x, 0, 0.05f) &&
rotationAngle < SurfaceAngle)
{
rotationAngle = Vector2.Angle(RaycastHit2DPoints.bottomMidDownwardRay.normal, Vector2.up);
surfaceNormal = RaycastHit2DPoints.bottomMidDownwardRay.normal;
}
if (rotationAngle <= maxAngle)
{
SurfaceAngle = rotationAngle;
SurfaceNormal = surfaceNormal;
}
}
else if (spriteRenderer.flipX &&
RaycastHit2DPoints.midLeftDownwardRay.collider != null)
{
var rotationAngle = Vector2.Angle(RaycastHit2DPoints.midLeftDownwardRay.normal, Vector2.up);
var surfaceNormal = RaycastHit2DPoints.midLeftDownwardRay.normal;
if (RaycastHit2DPoints.midLeftDownwardRay.normal.x < 0 && rotationAngle > SurfaceAngle)
{
rotationAngle = Vector2.Angle(RaycastHit2DPoints.midRightDownwardRay.normal, Vector2.up);
surfaceNormal = RaycastHit2DPoints.midRightDownwardRay.normal;
}
else if (MathHelpers.Approximately(RaycastHit2DPoints.midLeftDownwardRay.normal.x, 0, 0.05f) &&
rotationAngle < SurfaceAngle)
{
rotationAngle = Vector2.Angle(RaycastHit2DPoints.bottomMidDownwardRay.normal, Vector2.up);
surfaceNormal = RaycastHit2DPoints.bottomMidDownwardRay.normal;
}
if (rotationAngle <= maxAngle)
{
SurfaceAngle = rotationAngle;
SurfaceNormal = surfaceNormal;
}
}
}
public void Raise()
{
if (capsuleCollider2D.size.y < characterHeight &&
Physics2D.Raycast(rigidbody2D.position, Vector2.up).distance >= characterHeight)
{
capsuleCollider2D.size = new Vector2(capsuleCollider2D.size.x, capsuleCollider2D.size.y + crouchingSpeed);
capsuleCollider2D.offset =
new Vector2(capsuleCollider2D.offset.x, capsuleCollider2D.offset.y + (crouchingSpeed / 2));
}
else if (MathHelpers.Approximately(capsuleCollider2D.size.y, characterHeight, 0.1f))
{
playerStatusVariables.isCrouching = false;
}
}
public void CheckFacingDirection()
{
if (MathHelpers.Approximately(playerController.HorizontalMove, 1, float.Epsilon) &&
!playerStatusVariables.isAiming)
{
playerStatusVariables.facingDirection = FacingDirection.Right;
}
else if (MathHelpers.Approximately(playerController.HorizontalMove, -1, float.Epsilon) &&
!playerStatusVariables.isAiming)
{
playerStatusVariables.facingDirection = FacingDirection.Left;
}
spriteRenderer.flipX = (playerStatusVariables.facingDirection != FacingDirection.Right);
}
//Para não poluir o código - Revisar isso mais tarde
private float GetClimbLadderMovement()
{
if ((Input.GetKey("w") && Input.GetKey("s")) || (!Input.GetKey("w") && !Input.GetKey("s")))
{
return(0);
}
if (Input.GetKey("w"))
{
return(!MathHelpers.Approximately(VerticalMovement, -1, float.Epsilon) ? 1 : 0);
}
if (Input.GetKey("s"))
{
return(!MathHelpers.Approximately(VerticalMovement, 1, float.Epsilon) ? -1 : 0);
}
return(0);
}
public void TestEpsilonRules()
{
float minVal = float.MinValue;
float minValIncre = minVal + CryEngine.MathHelpers.Epsilon;
Assert.IsTrue(MathHelpers.Approximately(minVal, minValIncre), "Epsilon test failed for float min increment");
float maxValDecr = minVal - CryEngine.MathHelpers.Epsilon;
Assert.IsTrue(MathHelpers.Approximately(maxValDecr, minVal), "Epsilon test failed for float min decrement");
float zeroVal = 0f;
Assert.IsTrue(MathHelpers.Approximately(zeroVal + CryEngine.MathHelpers.Epsilon, CryEngine.MathHelpers.Epsilon), "Epsilon test failed for 0 increment");
Assert.IsTrue(MathHelpers.Approximately(zeroVal - CryEngine.MathHelpers.Epsilon, -CryEngine.MathHelpers.Epsilon), "Epsilon test failed for 0 decrement");
}
public void TestClamp()
{
{
//float
float minVal = 10f;
float maxVal = 20.5f;
float fval = 21.5f;
float clampedValue = MathHelpers.Clamp(fval, minVal, maxVal);
Assert.IsTrue(clampedValue <= maxVal && clampedValue >= minVal);
Assert.IsTrue(MathHelpers.Approximately(clampedValue, 20.5000000f, 0.0000001f));
float fval2 = 9.0f;
float clampedValue2 = MathHelpers.Clamp(fval2, minVal, maxVal);
Assert.IsTrue(clampedValue2 <= maxVal && clampedValue2 >= minVal);
Assert.IsTrue(MathHelpers.Approximately(clampedValue2, 10.0000000f, 0.0000001f));
}
{
//int
int minVal = 10;
int maxVal = 20;
int ival = 21;
int clampedValue = MathHelpers.Clamp(ival, minVal, maxVal);
Assert.IsTrue(clampedValue <= maxVal && clampedValue >= minVal);
ival = 20;
clampedValue = MathHelpers.Clamp(ival, minVal, maxVal);
Assert.IsTrue(clampedValue <= maxVal && clampedValue >= minVal);
Assert.IsTrue(clampedValue == 20);
int ival2 = 9;
int clampedValue2 = MathHelpers.Clamp(ival2, minVal, maxVal);
Assert.IsTrue(clampedValue2 <= maxVal && clampedValue2 >= minVal);
ival2 = 10;
clampedValue2 = MathHelpers.Clamp(ival2, minVal, maxVal);
Assert.IsTrue(clampedValue2 <= maxVal && clampedValue2 >= minVal);
Assert.IsTrue(clampedValue2 == 10);
}
{
//clamp01
float val = -0.1f;
float clamped = MathHelpers.Clamp01(val);
Assert.IsTrue(MathHelpers.Approximately(clamped, 0.0000000f, 0.0000001f));
val = 1.0000001f;
clamped = MathHelpers.Clamp01(val);
Assert.IsTrue(MathHelpers.Approximately(clamped, 1.0000000f, 0.0000001f));
}
}
private IEnumerator ClimbOntoLadderCoroutine(Vector2 position, float changeRate)
{
var f = 0.0f;
var initialPosition = rigidbody2D.position;
while (!MathHelpers.Approximately(rigidbody2D.position.x, position.x, 0.01f) ||
!MathHelpers.Approximately(rigidbody2D.position.y, position.y, 0.01f))
{
f += changeRate;
rigidbody2D.MovePosition(Vector2.Lerp(initialPosition, new Vector2(position.x, position.y), f));
yield return(new WaitForFixedUpdate());
}
CoroutineManager.FindCoroutine("ClimbOntoLadderCoroutine").IsRunning = false;
playerController.RevokeControl(false, ControlTypeToRevoke.LadderMovement);
}
