Exemplo n.º 1
0
        public PlayerController(GraphicsDevice graphics, World world, InputManager inputManager, Player player, PlayerIndex playerIndex)
        {
            Player      = player;
            Graphics    = graphics;
            World       = world;
            PlayerIndex = playerIndex;

            //  IsFreeCam = true;

            GlobalInputManager = inputManager;
            InputManager       = inputManager.GetOrAddPlayerManager(playerIndex);
            InputManager.AddListener(MouseInputListener = new MouseInputListener(playerIndex));

            if (InputManager.TryGetListener <GamePadInputListener>(out var gamePadInputListener))
            {
                GamePadInputListener = gamePadInputListener;
            }
            else
            {
                GamePadInputListener = null;
            }

            var optionsProvider = Alex.Instance.Services.GetService <IOptionsProvider>();

            CursorSensitivity = optionsProvider.AlexOptions.MouseSensitivity.Value;

            optionsProvider.AlexOptions.MouseSensitivity.Bind(
                (value, newValue) =>
            {
                CursorSensitivity = newValue;
            });

            GamepadSensitivity = optionsProvider.AlexOptions.ControllerOptions.RightJoystickSensitivity.Value;
            optionsProvider.AlexOptions.ControllerOptions.RightJoystickSensitivity.Bind(
                (value, newValue) =>
            {
                GamepadSensitivity = newValue;
            });

            /*Cameras = new Camera[]
             * {
             *      new FirstPersonCamera(Vector3.Zero, Vector3.Zero),
             *      new ThirdPersonCamera(Vector3.Zero, Vector3.Zero, ThirdPersonCamera.ThirdPersonCameraMode.Front),
             *      new ThirdPersonCamera(Vector3.Zero, Vector3.Zero, ThirdPersonCamera.ThirdPersonCameraMode.Back)
             * };*/
        }
Exemplo n.º 2
0
        private void UpdateMovementInput(GameTime gt)
        {
            if (!_allowMovementInput)
            {
                Player.Movement.UpdateHeading(Vector3.Zero);
                return;
            }

            var moveVector = Vector3.Zero;
            var now        = DateTime.UtcNow;

            if (Player.CanFly)
            {
                if (InputManager.IsPressed(InputCommand.ToggleCameraFree))
                {
                    Player.IsFlying = !Player.IsFlying;
                }
                else if (InputManager.IsDown(InputCommand.MoveUp) || InputManager.IsDown(InputCommand.Jump))
                {
                    if ((InputManager.IsBeginPress(InputCommand.MoveUp) || InputManager.IsBeginPress(InputCommand.Jump)) &&
                        now.Subtract(_lastUp).TotalMilliseconds <= 125)
                    {
                        Player.IsFlying = !Player.IsFlying;
                    }

                    _lastUp = now;
                }
            }

            //float speedFactor = (float)Player.CalculateMovementSpeed();

            if (InputManager.IsDown(InputCommand.MoveForwards))
            {
                moveVector.Z += 1;
                if (!Player.IsSprinting && Player.CanSprint)
                {
                    if (InputManager.IsBeginPress(InputCommand.MoveForwards) &&
                        now.Subtract(_lastForward).TotalMilliseconds <= 125)
                    {
                        Player.IsSprinting = true;
                    }
                }

                _lastForward = now;
            }
            else
            {
                if (Player.IsSprinting)
                {
                    Player.IsSprinting = false;
                }
            }

            if (InputManager.IsDown(InputCommand.MoveBackwards))
            {
                moveVector.Z -= 1;
            }

            if (InputManager.IsDown(InputCommand.MoveLeft))
            {
                moveVector.X += 1;
            }

            if (InputManager.IsDown(InputCommand.MoveRight))
            {
                moveVector.X -= 1;
            }

            if (Player.IsFlying)
            {
                //speedFactor *= 1f + (float)Player.FlyingSpeed;
                //speedFactor *= 2.5f;

                if (InputManager.IsDown(InputCommand.MoveUp))
                {
                    moveVector.Y += 1;
                }

                if (InputManager.IsDown(InputCommand.MoveDown))
                {
                    moveVector.Y     -= 1;
                    Player.IsSneaking = true;
                }
                else
                {
                    Player.IsSneaking = false;
                }
            }
            else
            {
                if (Player.FeetInWater && InputManager.IsDown(InputCommand.MoveUp))
                {
                    Player.Velocity = new Vector3(Player.Velocity.X, 1f, Player.Velocity.Z);
                }
                else if (!Player.IsInWater && Player.KnownPosition.OnGround && (InputManager.IsDown(InputCommand.Jump) || InputManager.IsDown(InputCommand.MoveUp)))
                {
                    if (Player.Velocity.Y <= 0.00001f && Player.Velocity.Y >= -0.00001f &&
                        Math.Abs(LastVelocity.Y - Player.Velocity.Y) < 0.0001f)
                    {
                        //	moveVector.Y += 42f;
                        //	Player.Velocity += new Vector3(0f, 4.65f, 0f); // //, 0);
                        Player.Jump();
                    }
                }

                if (!Player.IsInWater)                 //Sneaking in water is not a thing.
                {
                    if (InputManager.IsDown(InputCommand.MoveDown) || InputManager.IsDown(InputCommand.Sneak))
                    {
                        Player.IsSneaking = true;
                    }
                    else                     //if (_prevKeyState.IsKeyDown(KeyBinds.Down))
                    {
                        Player.IsSneaking = false;
                    }
                }
            }

            WasInWater = Player.FeetInWater;
            Player.Movement.UpdateHeading(moveVector);

            // LastSpeedFactor = speedFactor;
            if (IgnoreNextUpdate)
            {
                IgnoreNextUpdate = false;
            }
            else
            {
                var checkMouseInput = true;
                if (GamePadInputListener != null && GamePadInputListener.IsConnected)
                {
                    var inputValue = GamePadInputListener.GetCursorPosition();

                    if (inputValue != Vector2.Zero)
                    {
                        checkMouseInput = false;

                        var look = (new Vector2((inputValue.X), (inputValue.Y)) * (float)GamepadSensitivity)
                                   * (float)(gt.ElapsedGameTime.TotalSeconds);

                        look = -look;

                        Player.KnownPosition.HeadYaw -= look.X;
                        Player.KnownPosition.Pitch   -= look.Y;
                        Player.KnownPosition.HeadYaw  = MathUtils.NormDeg(Player.KnownPosition.HeadYaw);
                        Player.KnownPosition.Pitch    = MathHelper.Clamp(Player.KnownPosition.Pitch, -89.9f, 89.9f);
                    }
                }

                if (checkMouseInput)
                {
                    var e = MouseInputListener.GetCursorPosition();

                    if (e.X < 10 || e.X > Graphics.Viewport.Width - 10 || e.Y < 10 ||
                        e.Y > Graphics.Viewport.Height - 10)
                    {
                        CenterCursor();
                        IgnoreNextUpdate = true;
                    }
                    else
                    {
                        var mouseDelta =
                            _previousMousePosition
                            - e;                             //this.GlobalInputManager.CursorInputListener.GetCursorPositionDelta();

                        var look = (new Vector2((-mouseDelta.X), (mouseDelta.Y)) * (float)CursorSensitivity) * (float)(gt.ElapsedGameTime.TotalSeconds);

                        look = -look;

                        Player.KnownPosition.HeadYaw -= look.X;
                        Player.KnownPosition.Pitch   -= look.Y;
                        Player.KnownPosition.HeadYaw  = MathUtils.NormDeg(Player.KnownPosition.HeadYaw);
                        Player.KnownPosition.Pitch    = MathHelper.Clamp(Player.KnownPosition.Pitch, -89.9f, 89.9f);

                        //Player.KnownPosition.Pitch = MathHelper.Clamp(Player.KnownPosition.Pitch + look.Y, -89.9f, 89.9f);
                        // Player.KnownPosition.Yaw = (Player.KnownPosition.Yaw + look.X) % 360f;
                        // Player.KnownPosition.Yaw %= 360f;
                        _previousMousePosition = e;
                    }
                }
            }

            LastVelocity = Player.Velocity;
        }