示例#1
0
            private void KeysInput()
            {
                while (Game)
                {
                    var currntKey = Console.ReadKey(true);

                    switch (currntKey.Key)
                    {
                    case ConsoleKey.W:
                        key = PressedKey.Up;
                        break;

                    case ConsoleKey.A:
                        key = PressedKey.Left;
                        break;

                    case ConsoleKey.D:
                        key = PressedKey.Right;
                        break;

                    case ConsoleKey.S:
                        key = PressedKey.Down;
                        break;

                    case ConsoleKey.F:
                        key = PressedKey.Fire;
                        break;

                    default:
                        key = PressedKey.None;
                        break;
                    }
                }
            }
示例#2
0
            private void PlayerAction()
            {
                int dx = 0, dy = 0;

                switch (key)
                {
                case PressedKey.Up:
                    dy = -1;
                    break;

                case PressedKey.Down:
                    dy = 1;
                    break;

                case PressedKey.Left:
                    dx = -1;
                    break;

                case PressedKey.Right:
                    dx = 1;
                    break;

                case PressedKey.Fire:
                    bullets.Add(new Bullet(player.X, player.Y, player.CurrentDirection));
                    key = PressedKey.None;
                    break;
                }

                player.Rotate(dx, dy);
                if (gameField.CanMakeStep(player.X + dx, player.Y + dy))
                {
                    player.MakeStep(dx, dy);
                    key = PressedKey.None;
                }
            }
示例#3
0
            public void ChangeKeyState(Key pressedKey)
            {
                switch (pressedKey)
                {
                case Key.W:
                case Key.Up:
                    key = PressedKey.Up;
                    break;

                case Key.S:
                case Key.Down:
                    key = PressedKey.Down;
                    break;

                case Key.A:
                case Key.Left:
                    key = PressedKey.Left;
                    break;

                case Key.D:
                case Key.Right:
                    key = PressedKey.Right;
                    break;

                case Key.F:
                case Key.Space:
                    key = PressedKey.Fire;
                    break;

                default:
                    key = PressedKey.None;
                    break;
                }
            }
示例#4
0
 public Level(int level, Canvas canvas)
 {
     Game    = true;
     bullets = new BulletCollection();
     key     = PressedKey.None;
     new LevelLoader(level).LoadField(out gameField, out player, out enemies);
     Level.canvas = canvas;
 }
示例#5
0
        public void Window_KeyUp(object sender, KeyEventArgs e)
        {
            PressedKey pk = pressedKeys.Find(x => x.key == e.Key);

            if (pk != null)
            {
                Channels[pk.channel].State = ChannelState.KeyOff;
                pressedKeys.Remove(pk);
            }
            e.Handled = true;
        }
    // ....
    public override string ToString()
    {
        string display = string.Empty;

        display += ((Keyboard.Modifiers & ModifierKeys.Control) > 0) ? "Ctrl + " : string.Empty;
        display += ((Keyboard.Modifiers & ModifierKeys.Alt) > 0) ? "Alt + " : string.Empty;
        display += ((Keyboard.Modifiers & ModifierKeys.Shift) > 0) ? "Shift + " : string.Empty;
        display += ((Keyboard.Modifiers & ModifierKeys.Windows) > 0) ? "Win + " : string.Empty;
        display += PressedKey.ToString();
        return(display);
    }
示例#7
0
    // Verifies whether there is a subscriber to the OnPressedKey
    // If there is any tells them that a key was pressed
    private void tellAboutPressedKey()
    {
        PressedKey handlerOnPressedKey = OnPressedKey;

        if (handlerOnPressedKey != null)
        {
            handlerOnPressedKey();
        }

        PressedKeyIdentification handlerOnPressedKeyIndentify = OnPressedKeyIdentify;

        if (handlerOnPressedKeyIndentify != null)
        {
            handlerOnPressedKeyIndentify(keyName);
        }
    }
示例#8
0
        public void HandleKeys(GameTime gameTime, KeyboardState keyState)
        {
            var keysUp = new HashSet <Keys>(_LastKeyboardState.GetPressedKeys());

            keysUp.ExceptWith(keyState.GetPressedKeys());

            var keysDown = new HashSet <Keys>(keyState.GetPressedKeys());

            keysDown.ExceptWith(_LastKeyboardState.GetPressedKeys());

            foreach (var key in keysUp)
            {
                _Listeners.ForEach(l => l.KeyUp(key));
                InvokeListener(_KeyUpListeners, key);
                if (_PressedKeys.Remove(key))
                {
                    _Listeners.ForEach(l => l.KeyPress(key));
                    InvokeListener(_KeyPressListeners, key);
                }
            }
            foreach (var key in keysDown)
            {
                _PressedKeys[key] = new PressedKey(key, gameTime.TotalGameTime);
                InvokeKeyDown(key, false);
            }

            // Simulate key repeat
            var delayThreshold  = gameTime.TotalGameTime.Subtract(KEY_DELAY);
            var repeatThreshold = gameTime.TotalGameTime.Subtract(KEY_REPEAT);
            var pressedKeys     = new List <PressedKey>(_PressedKeys.Values);

            foreach (var pressedKey in pressedKeys)
            {
                if (pressedKey.ProcessRepeat(gameTime.TotalGameTime, delayThreshold, repeatThreshold))
                {
                    InvokeKeyDown(pressedKey.Key, true);
                }
            }

            _LastKeyboardState = keyState;
        }
示例#9
0
        private void MidiThread()
        {
            while (MidiTicks <= MaxMidiTicks)
            {
                Thread.Sleep(midisleeptime);

                MidiEvent[] me = null;
                MidiEventsByTick.TryGetValue(MidiTicks, out me);
                MidiTicks++;
                if (me == null)
                {
                    continue;
                }

                foreach (MidiEvent item in me)
                {
                    if (item.Channel == 10)
                    {
                        continue;
                    }
                    if (item is TempoEvent)
                    {
                        TempoEvent te     = (TempoEvent)item;
                        int        interv = te.MicrosecondsPerQuarterNote / ticksPerBeat / 1000;
                        midisleeptime = interv == 0 ? 1 : interv;
                    }
                    if (item is NoteOnEvent)
                    {
                        NoteOnEvent ne = (NoteOnEvent)item;
                        PressedKey  pk = pressedKeys.Find(x => x.midiNoteNumber == ne.NoteNumber);

                        if (pk != null)
                        {
                            if (ne.Velocity == 0 || ne.CommandCode == MidiCommandCode.NoteOff) //Keyoff
                            {
                                Channels[pk.channel].State = ChannelState.KeyOff;
                                pressedKeys.Remove(pk);
                            }
                            continue;
                        }

                        int channel = GetChannel();

                        var freq = MidiNumberToFreq[ne.NoteNumber];
                        if (freq != 0)
                        {
                            pressedKeys.Add(new PressedKey()
                            {
                                key = Key.None, channel = channel, midiNoteNumber = ne.NoteNumber
                            });
                            Channels[channel].Freq = freq;
                            if (Channels[channel].State == ChannelState.Inactive)
                            {
                                Channels[channel].State = ChannelState.KeyOn;
                            }
                            else
                            {
                                Channels[channel].State = ChannelState.ReKeyOn;
                            }
                        }
                    }
                }
            }
            return;
        }
示例#10
0
 private void StartThread()
 {
     key       = PressedKey.None;
     keyThread = new Thread(KeysInput);
     keyThread.Start();
 }
示例#11
0
 public bool isPressed(PressedKey key)
 {
     return (pressedKeys & key) != Player.PressedKey.None;
 }
示例#12
0
        private Task KeyInputAsync(string inputType, PressedKey key, CancellationToken cancellationToken)
        {
            string encodedKey = key.Match(InputEncoding.EncodeSpecialKey, InputEncoding.EncodeChar);

            return(this.PostAsync($"{inputType}/{encodedKey}", cancellationToken));
        }
示例#13
0
 Task IRokuDeviceInput.KeyUpAsync(PressedKey key, CancellationToken cancellationToken)
 {
     return(this.KeyInputAsync("keyup", key, cancellationToken));
 }
 public PlayerCommandMessage(PressedKey pressedKey)
 {
     this._pressedKey = pressedKey;
 }
示例#15
0
 /// <summary>
 /// Invokes event that says which key was pressed and what is actual reading position.
 /// </summary>
 /// <param name="key">pressed key</param>
 /// <param name="position">actual reading position</param>
 protected virtual void OnKeyPressed(char key, int position)
 {
     PressedKey?.Invoke(this, new PressedKeyEventArgs(key, position));
 }
示例#16
0
 /// <summary>
 /// Invokes event that says no key was pressed and what is actual reading position.
 /// </summary>
 /// <param name="position">actual reading position</param>
 protected virtual void OnKeyNotPressed(int position)
 {
     PressedKey?.Invoke(this, new PressedKeyEventArgs(position));
 }
示例#17
0
 public void SetPressedKeys(PressedKey keys)
 {
     pressedKeys = keys;
 }