public void ProcessInputs(ProcessInputsEvent _)
        {
            if (this.gamepad_[FaceButtonType.SECONDARY].IsPressed)
            {
                ++this.currentItemIndex_.Value;
            }

            this.CurrentItem.ProcessInputs(_);
        }
예제 #2
0
        public void ProcessInputs(ProcessInputsEvent _)
        {
            var secondaryAnalogStick = this.gamepad_[AnalogStickType.SECONDARY];
            var secStickX            = secondaryAnalogStick.RawAxes.X;
            var secStickY            = secondaryAnalogStick.RawAxes.Y;

            var secStickMag = TrigMath.DistanceBetween(0, 0, secStickX, secStickY);

            if (secStickMag < GamepadConstants.DEADZONE)
            {
                secStickMag = 0;
            }

            var wasShieldOut = this.isShieldOut_;

            this.isShieldOut_ = secStickMag > 0;

            if (this.isShieldOut_)
            {
                var secStickDeg = TrigMath.DegreesBetween(0, 0, secStickX, secStickY);

                var toHandDeg = secStickDeg;

                var maxHorizontalHandDis = this.playerRigidbody_.Width / 2 + 2;
                var maxVerticalHandDis   = this.playerRigidbody_.Height / 2 + 2;
                var maxHandDis           =
                    FloatMath.Abs(
                        TrigMath.LenDegX(maxHorizontalHandDis, secStickDeg)) +
                    FloatMath.Abs(
                        TrigMath.LenDegY(maxVerticalHandDis, secStickDeg));

                var toHandDis = maxHandDis * secStickMag;

                if (!wasShieldOut)
                {
                    this.handDis_ = toHandDis;
                    this.handDeg_ = toHandDeg;
                }
                else
                {
                    var accFactor = 3;

                    this.handDis_ += (toHandDis - this.handDis_) / accFactor;
                    this.handDeg_ +=
                        TrigMath.DifferenceInDegrees(toHandDeg, this.handDeg_) /
                        accFactor;
                }
            }
        }
예제 #3
0
        public void ProcessInputs(ProcessInputsEvent _)
        {
            if (this.whipTimeFraction_ >= 1)
            {
                this.isWhipping_ = false;
            }
            if (this.isWhipping_)
            {
                this.whipTimeFraction_ = MathF.Min(this.whipTimeFraction_ + .1f, 1);
                return;
            }

            var secondaryAnalogStick = this.gamepad_[AnalogStickType.SECONDARY];
            var secStickX            = secondaryAnalogStick.RawAxes.X;
            var secStickY            = secondaryAnalogStick.RawAxes.Y;

            var secStickMag = TrigMath.DistanceBetween(0, 0, secStickX, secStickY);

            if (secStickMag < GamepadConstants.DEADZONE)
            {
                secStickMag = 0;
            }

            this.isStoring_ = secStickMag > .8f;
            if (this.isStoring_)
            {
                var secStickDeg = TrigMath.DegreesBetween(0, 0, secStickX, secStickY);

                this.storedWhipTimer_ = 5;
                this.whipStrength_    = secStickMag;
                this.whipDeg_         = secStickDeg + 180;
            }

            var wasFlicked = this.storedWhipTimer_-- > 0 && secStickMag == 0;

            if (wasFlicked)
            {
                this.isStoring_       = false;
                this.storedWhipTimer_ = -1;

                this.isWhipping_       = true;
                this.whipTimeFraction_ = 0;

                // TODO: Move this out.
                this.playerSounds_.PlayWhipSound();
            }
        }
예제 #4
0
        private void ProcessInputs_(ProcessInputsEvent _)
        {
            var joypad = this.mmu_.MemoryMap.IoAddresses.Joypad;

            var dpad = this.gamepad_[AnalogStickType.PRIMARY].RawAxes;

            var(dpadX, dpadY) = (dpad.X, dpad.Y);
            joypad.ToggleDpadRight(dpadX > .5);
            joypad.ToggleDpadLeft(dpadX < -.5);
            joypad.ToggleDpadUp(dpadY > .5);
            joypad.ToggleDpadDown(dpadY < -.5);

            var buttonA      = this.gamepad_[FaceButtonType.PRIMARY];
            var buttonB      = this.gamepad_[FaceButtonType.SECONDARY];
            var buttonSelect = this.gamepad_[FaceButtonType.SELECT];
            var buttonStart  = this.gamepad_[FaceButtonType.START];

            joypad.ToggleButtonA(buttonA.IsDown);
            joypad.ToggleButtonB(buttonB.IsDown);
            joypad.ToggleButtonSelect(buttonSelect.IsDown);
            joypad.ToggleButtonStart(buttonStart.IsDown);
        }
예제 #5
0
 public void ProcessInputs(ProcessInputsEvent _)
 {
     this.ProcessManualInputs_();
 }
예제 #6
0
        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();
        }