Exemple #1
0
        /// <summary>
        /// Sends a message containing information about a specific key
        /// </summary>
        /// <param name="keyState">The state of the key Down/Pressed/Up</param>
        /// <param name="key">The <see cref="Keys"/> that changed it's state</param>
        private void SendKeyMessage(MessageType keyState, Keys key, GameTime gameTime)
        {
            switch (keyState)
            {
            case MessageType.KeyDown:
            {
                MsgKeyPressed keyMessage = ObjectPool.Aquire <MsgKeyPressed>();
                keyMessage.Key  = key;
                keyMessage.Time = gameTime;
                this.Game.SendMessage(keyMessage);
            }
            break;

            case MessageType.KeyHeld:
            {
                MsgKeyHeld keyMessage = ObjectPool.Aquire <MsgKeyHeld>();
                keyMessage.Key  = key;
                keyMessage.Time = gameTime;
                this.Game.SendMessage(keyMessage);
            }
            break;

            case MessageType.KeyUp:
            {
                MsgKeyReleased keyMessage = ObjectPool.Aquire <MsgKeyReleased>();
                keyMessage.Key  = key;
                keyMessage.Time = gameTime;
                this.Game.SendMessage(keyMessage);
            }
            break;

            default:
                break;
            }
        }
Exemple #2
0
    /// <summary>
    /// Message handler for the input polling handler.
    /// </summary>
    /// <param name="message">Incoming message</param>
    private void Game_GameMessage(IMessage message)
    {
        switch (message.Type)
        {
        case MessageType.KeyDown:
            MsgKeyPressed keyDownMessage = message as MsgKeyPressed;
            message.TypeCheck(keyDownMessage);
            Press(keyDownMessage.Key);
            break;

        case MessageType.KeyUp:
            MsgKeyReleased keyUpMessage = message as MsgKeyReleased;
            message.TypeCheck(keyUpMessage);
            Release(keyUpMessage.Key);
            break;

        case MessageType.KeyHeld:
            MsgKeyHeld keyPressMessage = message as MsgKeyHeld;
            message.TypeCheck(keyPressMessage);
            SetHeld(keyPressMessage.Key, true);
            break;
        }
    }
Exemple #3
0
        /// <summary>
        /// Message handler for the input polling handler.
        /// </summary>
        /// <param name="message">Incoming message</param>
        private void Game_GameMessage(IMessage message)
        {
            switch (message.Type)
            {
            case MessageType.KeyDown:
                MsgKeyPressed keyDownMessage = message as MsgKeyPressed;
                message.TypeCheck(keyDownMessage);

                Press(keyDownMessage.Key);
                break;

            case MessageType.KeyUp:
                MsgKeyReleased keyUpMessage = message as MsgKeyReleased;
                message.TypeCheck(keyUpMessage);

                Release(keyUpMessage.Key);
                break;

            case MessageType.KeyHeld:
                MsgKeyHeld keyPressMessage = message as MsgKeyHeld;
                message.TypeCheck(keyPressMessage);

                SetHeld(keyPressMessage.Key, true);
                break;

            case MessageType.MouseDown:
                MsgMouseButtonPressed mouseDownMessage = message as MsgMouseButtonPressed;
                message.TypeCheck(mouseDownMessage);

                Press(mouseDownMessage.Button);
                break;

            case MessageType.MouseUp:
                MsgMouseButtonReleased mouseUpMessage = message as MsgMouseButtonReleased;
                message.TypeCheck(mouseUpMessage);

                Release(mouseUpMessage.Button);
                break;

            case MessageType.MouseHeld:
                MsgMouseButtonHeld mousePressMessage = message as MsgMouseButtonHeld;
                message.TypeCheck(mousePressMessage);

                SetHeld(mousePressMessage.Button, true);
                break;

            case MessageType.Thumbstick:
                MsgGamePadThumbstick thumbstickMessage = message as MsgGamePadThumbstick;
                message.TypeCheck(thumbstickMessage);

                // Store previous state
                this.previousThumbsticks[(int)thumbstickMessage.PlayerIndex, (int)thumbstickMessage.StickType] =
                    this.thumbsticks[(int)thumbstickMessage.PlayerIndex, (int)thumbstickMessage.StickType];

                this.thumbsticks[(int)thumbstickMessage.PlayerIndex, (int)thumbstickMessage.StickType] =
                    thumbstickMessage.StickValues;
                break;

            case MessageType.ThumbstickRelease:
                MsgGamePadThumbstickReleased thumbstickReleaseMessage = message as MsgGamePadThumbstickReleased;
                message.TypeCheck(thumbstickReleaseMessage);

                // Store previous state
                this.previousThumbsticks[(int)thumbstickReleaseMessage.PlayerIndex, (int)thumbstickReleaseMessage.StickType] =
                    this.thumbsticks[(int)thumbstickReleaseMessage.PlayerIndex, (int)thumbstickReleaseMessage.StickType];

                ReleaseThumbstick(thumbstickReleaseMessage.Data);
                break;

            case MessageType.Trigger:
                MsgGamePadTrigger triggerMessage = message as MsgGamePadTrigger;
                message.TypeCheck(triggerMessage);

                // Store previous state
                this.previousTriggers[(int)triggerMessage.PlayerIndex, (int)triggerMessage.GamePadInputSide] =
                    this.triggers[(int)triggerMessage.PlayerIndex, (int)triggerMessage.GamePadInputSide];

                this.triggers[(int)triggerMessage.PlayerIndex, (int)triggerMessage.GamePadInputSide] =
                    triggerMessage.TriggerValue;
                break;

            case MessageType.TriggerRelease:
                MsgGamePadTriggerReleased triggerReleaseMessage = message as MsgGamePadTriggerReleased;
                message.TypeCheck(triggerReleaseMessage);

                // Store previous state
                previousTriggers[(int)triggerReleaseMessage.PlayerIndex, (int)triggerReleaseMessage.GamePadInputSide] =
                    triggers[(int)triggerReleaseMessage.PlayerIndex, (int)triggerReleaseMessage.GamePadInputSide];

                ReleaseTrigger(triggerReleaseMessage.Data);
                break;

            case MessageType.ButtonDown:
                MsgGamePadButtonPressed buttonDownMessage = message as MsgGamePadButtonPressed;
                message.TypeCheck(buttonDownMessage);

                Press(buttonDownMessage.Button, buttonDownMessage.PlayerIndex);
                break;

            case MessageType.ButtonUp:
                MsgGamePadButtonReleased buttonUpMessage = message as MsgGamePadButtonReleased;
                message.TypeCheck(buttonUpMessage);

                Release(buttonUpMessage.Button, buttonUpMessage.PlayerIndex);
                break;

            case MessageType.ButtonHeld:
                MsgGamePadButtonHeld buttonHeldMessage = message as MsgGamePadButtonHeld;
                message.TypeCheck(buttonHeldMessage);

                SetHeld(buttonHeldMessage.Button, buttonHeldMessage.PlayerIndex, true);
                break;
            }
        }