示例#1
0
            public BreezeInputState CloneMe()
            {
                var result = new BreezeInputState();

                foreach (var t in states)
                {
                    result.states.Add(t.Key, t.Value);
                }

                result.MousePosition = new Vector2(MousePosition.X, MousePosition.Y);

                result.PressedKeys = PressedKeys.ToList();
                return(result);
            }
示例#2
0
        //TODO Move ME
        //private void MidiInPort_MessageReceived(MidiInPort sender, MidiMessageReceivedEventArgs args)
        //{
        //    IMidiMessage receivedMidiMessage = args.Message;

        //    //System.Diagnostics.Debug.WriteLine(receivedMidiMessage.Timestamp.ToString());

        //    if (receivedMidiMessage.Type == MidiMessageType.NoteOn || receivedMidiMessage.Type == MidiMessageType.NoteOff)
        //    {
        //        int velocity = -1;
        //        byte note = receivedMidiMessage.Type == MidiMessageType.NoteOn ? ((MidiNoteOnMessage)receivedMidiMessage).Note : ((MidiNoteOffMessage)receivedMidiMessage).Note;
        //        if (receivedMidiMessage.Type == MidiMessageType.NoteOn)
        //        {
        //            velocity = ((MidiNoteOnMessage)receivedMidiMessage).Velocity;
        //        }
        //        MidiNote midiNote = new MidiNote(note, velocity);

        //        if (receivedMidiMessage.Type == MidiMessageType.NoteOn)
        //        {
        //            Solids.Mixer.NoteOn(midiNote);
        //        }

        //        if (receivedMidiMessage.Type == MidiMessageType.NoteOff)
        //        {
        //            Solids.Mixer.NoteOff(midiNote);
        //        }

        //        //  System.Diagnostics.Debug.WriteLine(((MidiNoteOnMessage)receivedMidiMessage).Velocity);
        //    }
        //}
#endif

        public void Update(GameTime gameTime)
        {
            if (newState != null)
            {
                LastScrollPos = newState.ScrollPos;

                oldState = newState.CloneMe();
            }
            else
            {
                newState = new BreezeInputState();
            }

            // newState = new BreezeInputState();
            newState.UpdateState();
            MousePosition = newState.MousePosition;
            if (MousePosition != PreviousMousePosition)
            {
                MouseActive = true;
            }

            PreviousMousePosition = MousePosition;

            MouseScreenPosition = new Vector2(newState.MousePosition.X / Solids.Instance.SpriteBatch.GraphicsDevice.Viewport.Bounds.Width, newState.MousePosition.Y / Solids.Instance.SpriteBatch.GraphicsDevice.Viewport.Bounds.Height);

            bool?mba = newState.ShouldMouseBeActive();

            if (mba != null)
            {
                MouseActive = mba.Value;
            }

            //---------------------------------

            CurrentStack = new InputStack();

            var currentKeyState = Keyboard.GetState();

            GamePadState[] currentGamePadState = new GamePadState[GamePad.MaximumGamePadCount];

            List <Buttons> currentButtons = new List <Buttons>();

            for (int i = 0; i < GamePad.MaximumGamePadCount; i++)
            {
                currentGamePadState[i] = GamePad.GetState(i);

                foreach (Buttons b in Enum.GetValues(typeof(Buttons)))
                {
                    if (currentGamePadState[i].IsButtonDown(b))
                    {
                        currentButtons.Add(b);
                        MouseActive = false;
                    }
                }
            }

            var justPressedButtons  = currentButtons.Where(x => !previousButtons.Contains(x));
            var justReleasedButtons = previousButtons.Where(x => !currentButtons.Contains(x));
            var heldButtons         = previousButtons.Where(x => currentButtons.Contains(x));
            var notPressedButtons   = PossibleGamePadButtons.Where(x => !currentButtons.Contains(x));

            foreach (Buttons justPressedKey in justPressedButtons)
            {
                holdCounter.Add("GPB_" + justPressedKey.ToString(), 0);
                CurrentStack.Inputs.Add(new GamepadControl(justPressedKey, PressType.Press));
                CurrentStack.Inputs.Add(new GamepadControl(justPressedKey, PressType.PressThenHolding));
            }

            foreach (Buttons heldKey in heldButtons)
            {
                holdCounter["GPB_" + heldKey.ToString()]++;

                if (holdCounter["GPB_" + heldKey.ToString()] == SHORTHOLD)
                {
                    CurrentStack.Inputs.Add(new GamepadControl(heldKey, PressType.HoldingTriggered));
                }

                if (holdCounter["GPB_" + heldKey.ToString()] > LONGHOLD + LONGHOLDREPEAT)
                {
                    CurrentStack.Inputs.Add(new GamepadControl(heldKey, PressType.LongHoldingRepeat));
                    holdCounter["GPB_" + heldKey.ToString()] = LONGHOLD + 1;
                }


                if (holdCounter["GPB_" + heldKey.ToString()] > LONGHOLD)
                {
                    CurrentStack.Inputs.Add(new GamepadControl(heldKey, PressType.LongHolding));
                }

                if (holdCounter["GPB_" + heldKey.ToString()] > SHORTHOLD)
                {
                    CurrentStack.Inputs.Add(new GamepadControl(heldKey, PressType.Holding));
                    CurrentStack.Inputs.Add(new GamepadControl(heldKey, PressType.PressThenHolding));
                }
            }

            foreach (Buttons justReleasedKey in justReleasedButtons)
            {
                if (holdCounter["GPB_" + justReleasedKey.ToString()] < SHORTHOLD)
                {
                    CurrentStack.Inputs.Add(new GamepadControl(justReleasedKey, PressType.Tap));
                }
                else
                {
                    CurrentStack.Inputs.Add(new GamepadControl(justReleasedKey, PressType.LongTapped));
                }

                CurrentStack.Inputs.Add(new GamepadControl(justReleasedKey, PressType.Released));

                holdCounter.Remove("GPB_" + justReleasedKey.ToString());
            }

            foreach (Buttons notPressed in notPressedButtons)
            {
                CurrentStack.Inputs.Add(new GamepadControl(notPressed, PressType.NotPressed));
            }

            previousButtons = currentButtons.ToArray().ToList();

            List <MouseButtons> currentMouseButtons = new List <MouseButtons>();

            if (newState.VirtualMouse.PrimaryDown)
            {
                currentMouseButtons.Add(MouseButtons.LeftClick);
            }
            if (newState.VirtualMouse.SecondaryDown)
            {
                currentMouseButtons.Add(MouseButtons.RightClick);
            }
            if (newState.VirtualMouse.MiddleDown)
            {
                currentMouseButtons.Add(MouseButtons.MiddleClick);
            }


#if WINDOWS_UAP
            //if (state.HorizontalScrollWheelValue < previousMouseState.HorizontalScrollWheelValue)
            //{
            //    currentMouseButtons.Add(MouseButtons.MouseWheelUp);
            //}

            //if (state.HorizontalScrollWheelValue > previousMouseState.HorizontalScrollWheelValue)
            //{
            //    currentMouseButtons.Add(MouseButtons.MouseWheelDown);
            //}
#endif

            var justPressedMouseButtons  = currentMouseButtons.Where(x => previousMouseButtons.Contains(x) == false);
            var justReleasedMouseButtons = previousMouseButtons.Where(x => currentMouseButtons.Contains(x) == false);
            var heldMouseButtons         = currentMouseButtons.Where(x => previousMouseButtons.Contains(x));
            var notPressedMouseButtons   = PossibleMouseButtons.Where(x => !currentMouseButtons.Contains(x));

            foreach (MouseButtons notPressedMouseButton in notPressedMouseButtons)
            {
                CurrentStack.Inputs.Add(new MouseControl(notPressedMouseButton, PressType.NotPressed));
            }

            foreach (MouseButtons justPressedKey in justPressedMouseButtons)
            {
                holdCounter.Add("MB_" + justPressedKey.ToString(), 0);
                CurrentStack.Inputs.Add(new MouseControl(justPressedKey, PressType.Press));
                CurrentStack.Inputs.Add(new MouseControl(justPressedKey, PressType.PressThenHolding));
                MouseActive = true;
            }

            foreach (MouseButtons heldKey in heldMouseButtons)
            {
                holdCounter["MB_" + heldKey.ToString()]++;

                CurrentStack.Inputs.Add(new MouseControl(heldKey, PressType.Held));

                if (holdCounter["MB_" + heldKey.ToString()] == SHORTHOLD)
                {
                    CurrentStack.Inputs.Add(new MouseControl(heldKey, PressType.HoldingTriggered));
                }

                if (holdCounter["MB_" + heldKey.ToString()] > LONGHOLD + LONGHOLDREPEAT)
                {
                    CurrentStack.Inputs.Add(new MouseControl(heldKey, PressType.LongHoldingRepeat));
                    holdCounter["MB_" + heldKey.ToString()] = LONGHOLD + 1;
                }


                if (holdCounter["MB_" + heldKey.ToString()] > LONGHOLD)
                {
                    CurrentStack.Inputs.Add(new MouseControl(heldKey, PressType.LongHolding));
                }
                // else
                {
                    if (holdCounter["MB_" + heldKey.ToString()] > SHORTHOLD)
                    {
                        CurrentStack.Inputs.Add(new MouseControl(heldKey, PressType.Holding));
                        CurrentStack.Inputs.Add(new MouseControl(heldKey, PressType.PressThenHolding));
                    }
                }
            }

            foreach (MouseButtons justReleasedKey in justReleasedMouseButtons)
            {
                Console.WriteLine(holdCounter["MB_" + justReleasedKey.ToString()]);
                if (holdCounter["MB_" + justReleasedKey.ToString()] < SHORTHOLD)
                {
                    CurrentStack.Inputs.Add(new MouseControl(justReleasedKey, PressType.Tap));
                }
                else
                {
                    CurrentStack.Inputs.Add(new MouseControl(justReleasedKey, PressType.LongTapped));
                }

                CurrentStack.Inputs.Add(new MouseControl(justReleasedKey, PressType.Released));

                holdCounter.Remove("MB_" + justReleasedKey.ToString());
            }

            previousMouseButtons = currentMouseButtons.ToArray().ToList();


            var currentKeys      = currentKeyState.GetPressedKeys();
            var previousKeys     = previousKeyState.GetPressedKeys();
            var justPressedKeys  = currentKeys.Where(x => previousKeys.Contains(x) == false);
            var justReleasedKeys = previousKeys.Where(x => currentKeys.Contains(x) == false);
            var heldKeys         = currentKeys.Where(x => previousKeys.Contains(x));
            var notPressedKeys   = PossibleKeyboardKeys.Where(x => !currentKeys.Contains(x));

            foreach (var notPressedKey in notPressedKeys)
            {
                CurrentStack.Inputs.Add(new KeyboardControl(notPressedKey, PressType.NotPressed));
            }

            foreach (Keys justPressedKey in justPressedKeys)
            {
                holdCounter.Add("Key_" + justPressedKey.ToString(), 0);
                CurrentStack.Inputs.Add(new KeyboardControl(justPressedKey, PressType.Press));
            }

            foreach (Keys heldKey in heldKeys)
            {
                holdCounter["Key_" + heldKey.ToString()]++;

                if (holdCounter["Key_" + heldKey.ToString()] == SHORTHOLD)
                {
                    CurrentStack.Inputs.Add(new KeyboardControl(heldKey, PressType.HoldingTriggered));
                }

                if (holdCounter["Key_" + heldKey.ToString()] > LONGHOLD + LONGHOLDREPEAT)
                {
                    CurrentStack.Inputs.Add(new KeyboardControl(heldKey, PressType.LongHoldingRepeat));
                    holdCounter["Key_" + heldKey.ToString()] = LONGHOLD + 1;
                }


                if (holdCounter["Key_" + heldKey.ToString()] > LONGHOLD)
                {
                    CurrentStack.Inputs.Add(new KeyboardControl(heldKey, PressType.LongHolding));
                }
                //   else
                {
                    if (holdCounter["Key_" + heldKey.ToString()] > SHORTHOLD)
                    {
                        CurrentStack.Inputs.Add(new KeyboardControl(heldKey, PressType.Holding));
                    }
                }
            }

            foreach (Keys justReleasedKey in justReleasedKeys)
            {
                if (holdCounter["Key_" + justReleasedKey.ToString()] < SHORTHOLD)
                {
                    CurrentStack.Inputs.Add(new KeyboardControl(justReleasedKey, PressType.Tap));
                }
                else
                {
                    CurrentStack.Inputs.Add(new KeyboardControl(justReleasedKey, PressType.LongTapped));
                }

                CurrentStack.Inputs.Add(new KeyboardControl(justReleasedKey, PressType.Released));

                holdCounter.Remove("Key_" + justReleasedKey.ToString());
            }

            previousKeyState = currentKeyState;
        }