public void TestAbs() { Assert.AreEqual(5, FinMath.Abs(5)); Assert.AreEqual(5, FinMath.Abs(-5)); Assert.AreEqual(5d, FinMath.Abs(5d)); Assert.AreEqual(5d, FinMath.Abs(-5d)); }
private void ProcessScheduledJump_() { if (this.scheduledJumpState_ == ScheduledState.STARTING) { if (this.StateMachine.CanJumpFromGround) { var isLongjump = this.StateMachine.State == PlayerState.SLIDING; var isBackflip = this.StateMachine.State == PlayerState.TURNING && FinMath.Abs(this.Rigidbody.XVelocity) > PlayerConstants.UPRIGHT_MAX_SLOW_XSPD; var newYVel = isLongjump ? PlayerConstants.LONGJUMP_SPEED : isBackflip ? PlayerConstants.BACKFLIP_JUMP_SPEED : PlayerConstants.JUMP_SPEED; var newState = isLongjump ? PlayerState.LONGJUMPING : isBackflip ? PlayerState.BACKFLIPPING : PlayerState.JUMPING; this.Rigidbody.YVelocity = newYVel; this.StateMachine.State = newState; // TODO: Longjump feels weird. if (isLongjump) { this.Rigidbody.XVelocity = this.Rigidbody.XVelocity / PlayerConstants.UPRIGHT_MAX_FAST_XSPD * PlayerConstants.LONGJUMP_MAX_XSPD; } else if (isBackflip) { // Instantly flip horizontal velocity. var moveDirection = FinMath.Sign(this.Rigidbody.XVelocity); this.Rigidbody.XVelocity = -moveDirection * PlayerConstants.BACKFLIP_XSPD; } } else if (this.StateMachine.State == PlayerState.WALL_SLIDING) { this.StateMachine.State = PlayerState.WALLJUMPING; this.Rigidbody.YVelocity = PlayerConstants.JUMP_SPEED; this.Rigidbody.XVelocity = (this.StateMachine.WallSlidingOnLeft ? 1 : -1) * PlayerConstants.WALL_SLIDING_XSPD; } } else if (this.scheduledJumpState_ == ScheduledState.STOPPING) { if (this.StateMachine.CanStallJumpingMomentum && this.Rigidbody.YVelocity < 0) { this.StateMachine.State = PlayerState.FALLING; this.Rigidbody.YVelocity /= 2; } } }
private void ProcessInputs_(ProcessInputsEvent _) { this.motor_.ClearScheduled(); var primaryAnalogStick = this.gamepad_[AnalogStickType.PRIMARY]; var heldAxes = primaryAnalogStick.RawAxes; //var runButton = this.gamepad_[FaceButtonType.SECONDARY]; var isRunning = true; var heldX = FinMath.Abs(heldAxes.X) > GamepadConstants.DEADZONE ? heldAxes.X : 0; this.motor_.ScheduleMoveAttempt(heldX, isRunning); var heldY = heldAxes.Y; var minHeldDuckAmount = -.75f; if (this.stateMachine_.CanDuck) { var maxHeldDuckAmount = -.25f; this.toDuckFraction_ = 1 - (FloatMath.Clamp(minHeldDuckAmount, heldY, maxHeldDuckAmount) - minHeldDuckAmount) / (maxHeldDuckAmount - minHeldDuckAmount); } else if (this.stateMachine_.IsDucked) { this.toDuckFraction_ = 1; } else { this.toDuckFraction_ = 0; } this.duckFraction_ += (this.toDuckFraction_ - this.duckFraction_) / 2; if (heldY <= minHeldDuckAmount) { this.motor_.ScheduleDuckStartAttempt(); } else { this.motor_.ScheduleDuckStopAttempt(); } var jumpButton = this.gamepad_[FaceButtonType.PRIMARY]; if (jumpButton.IsPressed) { this.motor_.ScheduleJumpStartAttempt(); } else if (jumpButton.IsReleased) { this.motor_.ScheduleJumpStopAttempt(); } this.motor_.ProcessInputs(); }
private void ProcessScheduledHorizontalMovement_() { var heldXAxis = this.HeldXAxis; var isRunning = this.IsRunning; var isTryingToRun = FloatMath.Abs(heldXAxis) > .5f; var heldXAxisSign = FinMath.Sign(heldXAxis); float?targetXVelocity = null; float xAcceleration = 0; if (this.StateMachine.CanMoveUprightOnGround) { var maxGroundXVelocity = isRunning ? PlayerConstants.UPRIGHT_MAX_FAST_XSPD : PlayerConstants.UPRIGHT_MAX_SLOW_XSPD; var groundAcceleration = isTryingToRun ? PlayerConstants.GROUND_UPRIGHT_FAST_XACC : PlayerConstants.GROUND_UPRIGHT_SLOW_XACC; var reactionFraction = heldXAxisSign == -FinMath.Sign(this.Rigidbody.XVelocity) ? PlayerConstants.GROUND_REACTION_FRAC : 1; targetXVelocity = maxGroundXVelocity * heldXAxis; xAcceleration = groundAcceleration * reactionFraction * heldXAxisSign; // If holding a direction on the ground, we're either turning, running, or walking. if (heldXAxisSign != 0) { this.StateMachine.State = reactionFraction != 1 ? PlayerState.TURNING : isTryingToRun ? PlayerState.RUNNING : PlayerState.WALKING; } // If not holding a direction on the ground but velocity is not zero, we're stopping. else if (FinMath.Abs(this.Rigidbody.XVelocity) > .001) { this.StateMachine.State = PlayerState.STOPPING; } } else if (this.StateMachine.CanMoveDuckedOnGround) { var maxGroundXVelocity = isRunning ? PlayerConstants.DUCKED_MAX_FAST_XSPD : PlayerConstants.DUCKED_MAX_SLOW_XSPD; var groundAcceleration = isTryingToRun ? PlayerConstants.GROUND_DUCKED_FAST_XACC : PlayerConstants.GROUND_DUCKED_SLOW_XACC; targetXVelocity = maxGroundXVelocity * heldXAxis; xAcceleration = groundAcceleration * heldXAxisSign; // If holding a direction on the ground, we're either turning, running, or walking. if (heldXAxisSign != 0) { this.StateMachine.State = PlayerState.DUCKWALKING; } } else if (this.StateMachine.CanMoveInAir) { var maxAirXVelocity = isRunning ? PlayerConstants.UPRIGHT_MAX_FAST_XSPD : PlayerConstants.UPRIGHT_MAX_SLOW_XSPD; var airAcceleration = isTryingToRun ? PlayerConstants.AIR_FAST_XACC : PlayerConstants.AIR_SLOW_XACC; targetXVelocity = maxAirXVelocity * heldXAxis; xAcceleration = airAcceleration * heldXAxisSign; } this.Rigidbody.TargetXVelocity = targetXVelocity; this.Rigidbody.XAcceleration = xAcceleration; }
private void TickPhysics_(TickPhysicsEvent _) { var heldX = this.motor_.HeldXAxis; var isRunning = this.motor_.IsRunning; // TODO: Wrap these in a struct. this.rigidbody_.MaxXSpeed = float.MaxValue; var duckedMaxXSpd = isRunning ? PlayerConstants.DUCKED_MAX_FAST_XSPD : PlayerConstants.DUCKED_MAX_SLOW_XSPD; if (this.stateMachine_.IsOnGround) { if (this.stateMachine_.State == PlayerState.SLIDING) { this.rigidbody_.Friction = PlayerConstants.GROUND_SLIDING_FRICTION; } else { this.rigidbody_.Friction = PlayerConstants.GROUND_FRICTION; } } else { this.rigidbody_.Friction = PlayerConstants.AIR_FRICTION; } var isWide = false; //this.stateMachine_.State == PlayerState.SLIDING; var isTall = !this.stateMachine_.IsDucked; // TODO: Might be a problem, this should probably just be a visible thing. // TODO: Might be a problem, this should probably just be a visible thing. this.playerRigidbody_.Width = (.8f * PlayerConstants.HSIZE) * (1 - this.duckFraction_) + PlayerConstants.HSIZE * this.duckFraction_; this.playerRigidbody_.Height = PlayerConstants.VSIZE * (1 - this.duckFraction_) + PlayerConstants.HSIZE * this.duckFraction_; //this.playerRigidbody_.Width = // !isWide ? PlayerConstants.HSIZE : PlayerConstants.VSIZE; // //this.playerRigidbody_.Height = // isTall ? PlayerConstants.VSIZE : PlayerConstants.HSIZE; this.rigidbody_.TickPhysics(3); var(xVelocity, yVelocity) = this.rigidbody_.Velocity; // When comes to a stop, start standing. if (xVelocity == 0) { if (this.stateMachine_.IsMovingUprightOnGround) { this.stateMachine_.State = PlayerState.STANDING; } else if (this.stateMachine_.IsMovingDuckedOnGround) { this.stateMachine_.State = PlayerState.DUCKING; } } if (this.stateMachine_.State == PlayerState.SLIDING && FinMath.Abs(heldX) > GamepadConstants.DEADZONE && FinMath.Abs(xVelocity) <= duckedMaxXSpd) { this.stateMachine_.State = PlayerState.DUCKWALKING; } // When transitions to downward y velocity in air after a jump, start // falling. if (this.stateMachine_.IsMovingUpwardInAirAndCanFall && yVelocity > 0) { this.stateMachine_.State = PlayerState.FALLING; } if (this.stateMachine_.State == PlayerState.INITIALLY_FALLING_OFF_LEDGE && --this.initiallyFallingTimer_ <= -1) { this.stateMachine_.State = PlayerState.FALLING; } }