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); }