Beispiel #1
0
        private bool QueueProcessor()
        {
            if (KillMe)
            {
                return(true);
            }
            var queue = new List <byte>();

            if (_recievedData.Count != 0)
            {
                var f = DeQueueByte(); //_recievedData.Dequeue();
                if (f == 0xE0)
                {
                    var  count = 0;
                    byte size  = 0;
                    while (true)
                    {
                        if (KillMe)
                        {
                            return(true);
                        }
                        if (count == 0)
                        {
                            queue.Add(f);
                            count++;
                        }
                        else if (_recievedData.Count > 2 && count == 1)
                        {
                            queue.Add(DeQueueByte()); // _recievedData.Dequeue());
                            size = DeQueueByte();     //_recievedData.Dequeue();
                            queue.Add(size);
                            count++;
                        }
                        else if (count == 2 && _recievedData.Count >= size)
                        {
                            for (int i = 0; i < size; i++)
                            {
                                queue.Add(DeQueueByte()); //_recievedData.Dequeue());
                            }
                            //_lastPackage.Clear();
                            //_lastPackage.AddRange(queue);
                            var reply = JvsPackageEmulator.GetReply(queue.ToArray());
                            if (reply.Length != 0)
                            {
                                _stream.Write(reply, 0, reply.Length);
                                //Console.WriteLine(reply.Length);
                            }
                            break;
                        }
                    }
                }
            }
            Thread.Sleep(10);
            return(false);
        }
        public void JVS_RESET_ShouldReturnNothing()
        {
            // Arrange
            var requestBytes = JvsHelper.CraftJvsPackage((byte)JVSPacket.BROADCAST, new byte[] { (byte)JVSPacket.OP_RESET, 0xD9 });

            // Act
            var reply = JvsPackageEmulator.GetReply(requestBytes);

            // Assert
            Assert.NotNull(reply);
            Assert.Empty(reply);
        }
        public void JVS_GET_COMMUNICATIONVERSION_ShouldReturnVersionTwoPointZero()
        {
            // Arrange
            var requestBytes  = JvsHelper.CraftJvsPackage(1, new byte[] { 0x13 });
            var espectedBytes = JvsHelper.CraftJvsPackageWithStatusAndReport(0, new byte[] { 0x10 }); // Version 1.0

            // Act
            var reply = JvsPackageEmulator.GetReply(requestBytes);

            // Assert
            Assert.NotNull(reply);
            Assert.Equal(reply.Length, espectedBytes.Length);
            Assert.True(reply.SequenceEqual(espectedBytes));
        }
        public void JVS_READ_COIN_ShouldReturnOneCoinSlotWithOkStatus(byte slots, byte[] expected)
        {
            // Arrange
            var requestBytes  = JvsHelper.CraftJvsPackage(1, new[] { (byte)JVSRead.COIN, slots }); // 22 = Request coin slots, 1 slot
            var espectedBytes = JvsHelper.CraftJvsPackageWithStatusAndReport(0, expected);         // Coin Normal Operation, 0 coins inserted.

            // Act
            var reply = JvsPackageEmulator.GetReply(requestBytes);

            // Assert
            Assert.NotNull(reply);
            Assert.Equal(reply.Length, espectedBytes.Length);
            Assert.True(reply.SequenceEqual(espectedBytes));
        }
        public void JVS_GENERALPURPOSEOUTPUT2_ShouldReturnJVSOK_REPORTOK()
        {
            // Arrange
            var requestBytes  = JvsHelper.CraftJvsPackage(1, new byte[] { 0x32, 0x03, 0x00, 0x00, 0x00 });
            var espectedBytes = JvsHelper.CraftJvsPackageWithStatusAndReport(0, new byte[] { });

            // Act
            var reply = JvsPackageEmulator.GetReply(requestBytes);

            // Assert
            Assert.NotNull(reply);
            Assert.Equal(reply.Length, espectedBytes.Length);
            Assert.True(reply.SequenceEqual(espectedBytes));
        }
        public void JVS_ADDRESS_2_ShouldReturnPackage()
        {
            // Arrange
            var requestBytes  = JvsHelper.CraftJvsPackage((byte)JVSPacket.BROADCAST, new byte[] { (byte)JVSPacket.OP_ADDRESS, 0x02 }); // 0x01 = Bus address
            var espectedBytes = JvsHelper.CraftJvsPackageWithStatusAndReport(0, new byte[] { });

            // Act
            var reply = JvsPackageEmulator.GetReply(requestBytes);

            // Assert
            Assert.NotNull(reply);
            Assert.Equal(reply.Length, espectedBytes.Length);
            Assert.True(reply.SequenceEqual(espectedBytes));
        }
        public void JVS_GET_IDENTIFIER_ShouldReturnIdentifier()
        {
            // Arrange
            var requestBytes  = JvsHelper.CraftJvsPackage(1, new byte[] { (byte)JVSRead.ID_DATA });
            var espectedBytes = JvsHelper.CraftJvsPackageWithStatusAndReport(0, Encoding.ASCII.GetBytes(JVSIdentifiers.Sega2005Jvs14572));

            // Act
            var reply = JvsPackageEmulator.GetReply(requestBytes);

            // Assert
            Assert.NotNull(reply);
            Assert.Equal(reply.Length, espectedBytes.Length);
            Assert.True(reply.SequenceEqual(espectedBytes));
        }
        public void JVS_GET_COMMUNICATIONVERSION_JVSVERSION_COMMANDREV_ShouldReturnRightValues()
        {
            // Arrange
            var requestBytes  = JvsHelper.CraftJvsPackage(1, new byte[] { 0x13, 0x12, 0x11 });
            var espectedBytes = JvsHelper.CraftJvsPackageWithStatusAndReport(0, new byte[] { 0x10, 0x01, 0x20, 0x01, 0x13 });

            // Act
            var reply = JvsPackageEmulator.GetReply(requestBytes);

            // Assert
            Assert.NotNull(reply);
            Assert.Equal(reply.Length, espectedBytes.Length);
            Assert.True(reply.SequenceEqual(espectedBytes));
        }
        public void JVS_GET_COMMANDREV_ShouldReturnVersionOnePointThree()
        {
            // Arrange
            var requestBytes  = JvsHelper.CraftJvsPackage(1, new byte[] { 0x11 });
            var espectedBytes = JvsHelper.CraftJvsPackageWithStatusAndReport(0, new byte[] { 0x13 }); // Revision 1.3

            // Act
            var reply = JvsPackageEmulator.GetReply(requestBytes);

            // Assert
            Assert.NotNull(reply);
            Assert.Equal(reply.Length, espectedBytes.Length);
            Assert.True(reply.SequenceEqual(espectedBytes));
        }
        public void JVS_READ_DIGINAL_ShouldReturnPlayerOne()
        {
            // Arrange
            InputCode.PlayerDigitalButtons[0].Button1 = true;
            InputCode.PlayerDigitalButtons[0].Test    = true;
            var requestBytes  = JvsHelper.CraftJvsPackage(1, new byte[] { (byte)JVSRead.DIGITAL, 0x01, 0x01 }); // 22 = REQUEST DIGITAL, 1 = Player Count, 1 Bytes Per Player
            var espectedBytes = JvsHelper.CraftJvsPackageWithStatusAndReport(0, new byte[] { 0x80, 0x02 });     // Special Switches, P1

            // Act
            var reply = JvsPackageEmulator.GetReply(requestBytes);

            // Assert
            Assert.NotNull(reply);
            Assert.Equal(reply.Length, espectedBytes.Length);
            Assert.True(reply.SequenceEqual(espectedBytes));
        }
        public void JVS_GETMULTIPLEPACKAGES_ShouldReturnJVSOK_REPORTOK()
        {
            // Arrange
            var requestBytes  = JvsHelper.CraftJvsPackage(1, new byte[] { 0x20, 0x02, 0x02, 0x32, 0x03, 0x00, 0x00, 0x00, 0x30, 0x01, 0xf0, 0x0d, 0x21, 0x02, 0x22, 0x08 });
            var espectedBytes = JvsHelper.CraftJvsPackageWithStatusAndReport(0, new byte[] { });

            // Act
            var    reply = JvsPackageEmulator.GetReply(requestBytes);
            string str   = "";

            foreach (var b in reply)
            {
                str += b.ToString("X2") + " ";
            }
            Console.WriteLine(reply);
        }
        public void JVS_GET_ANALOG_ShouldReturnThreeChannels()
        {
            // Arrange
            InputCode.AnalogBytes[0] = 0xBA;
            InputCode.AnalogBytes[2] = 0xBE;
            InputCode.AnalogBytes[4] = 0xBE;
            var requestBytes  = JvsHelper.CraftJvsPackage(1, new byte[] { (byte)JVSRead.ANALOG, 0x03 }); // 22 = REQUEST ANALOG, 3 = 3 Channels
            var espectedBytes = JvsHelper.CraftJvsPackageWithStatusAndReport(0, new byte[] { (byte)InputCode.AnalogBytes[0], 0x00, (byte)InputCode.AnalogBytes[2], 0x00, (byte)InputCode.AnalogBytes[4], 0x00 });

            // Act
            var reply = JvsPackageEmulator.GetReply(requestBytes);

            // Assert
            Assert.NotNull(reply);
            Assert.Equal(reply.Length, espectedBytes.Length);
            Assert.True(reply.SequenceEqual(espectedBytes));
        }
        public void JVS_READ_DIGINAL_READ_ANALOG_ShouldReturnPlayerOneAndPlayerTwoButtonsAndExtAndThreeAnalogChannels()
        {
            // Arrange
            InputCode.PlayerDigitalButtons[0].Button1 = true;
            InputCode.PlayerDigitalButtons[0].Button4 = true;
            InputCode.PlayerDigitalButtons[1].Button1 = true;
            InputCode.PlayerDigitalButtons[1].Button4 = true;
            InputCode.PlayerDigitalButtons[0].Test    = true;
            InputCode.AnalogBytes[0] = 0xBA;
            InputCode.AnalogBytes[2] = 0xBE;
            InputCode.AnalogBytes[4] = 0xBE;
            var requestBytes  = JvsHelper.CraftJvsPackage(1, new byte[] { (byte)JVSRead.DIGITAL, 0x02, 0x02, (byte)JVSRead.ANALOG, 0x03 });                                                                                                           // 22 = REQUEST DIGITAL, 2 = Player Count, 2 Bytes Per Player, 22 = REQUEST ANALOG, 3 = 3 Channels
            var espectedBytes = JvsHelper.CraftJvsPackageWithStatusAndReport(0, new byte[] { 0x80, 0x02, 0x40, 0x02, 0x40, 0x01, (byte)InputCode.AnalogBytes[0], 0x00, (byte)InputCode.AnalogBytes[2], 0x00, (byte)InputCode.AnalogBytes[4], 0x00 }); // Special Switches, P1, P1Ext, P2, P2Ext

            // Act
            var reply = JvsPackageEmulator.GetReply(requestBytes);

            // Assert
            Assert.NotNull(reply);
            Assert.Equal(reply.Length, espectedBytes.Length);
            Assert.True(reply.SequenceEqual(espectedBytes));
        }
Beispiel #14
0
        private void HandleXinput(JoystickButtons joystickButtons, State state, State previousState, int index)
        {
            var button = joystickButtons.XInputButton;

            switch (joystickButtons.InputMapping)
            {
            case InputMapping.Test:
            {
                if (InputCode.ButtonMode == EmulationProfile.NamcoMkdx ||
                    InputCode.ButtonMode == EmulationProfile.NamcoMachStorm ||
                    InputCode.ButtonMode == EmulationProfile.NamcoWmmt5)
                {
                    var result     = DigitalHelper.GetButtonPressXinput(button, state, index);
                    var prevResult = DigitalHelper.GetButtonPressXinput(button, previousState, index);
                    if ((result != null && result.Value) && ((prevResult == null) || (!prevResult.Value)))
                    {
                        if (mkdxTest)
                        {
                            InputCode.PlayerDigitalButtons[0].Test = false;
                            mkdxTest = false;
                        }
                        else
                        {
                            InputCode.PlayerDigitalButtons[0].Test = true;
                            mkdxTest = true;
                        }
                    }
                }
                else
                {
                    InputCode.PlayerDigitalButtons[0].Test = DigitalHelper.GetButtonPressXinput(button, state, index);
                }
                break;
            }

            case InputMapping.Service1:
                InputCode.PlayerDigitalButtons[0].Service = DigitalHelper.GetButtonPressXinput(button, state, index);
                break;

            case InputMapping.Service2:
                InputCode.PlayerDigitalButtons[1].Service = DigitalHelper.GetButtonPressXinput(button, state, index);
                break;

            case InputMapping.Coin1:
                InputCode.PlayerDigitalButtons[0].Coin = DigitalHelper.GetButtonPressXinput(button, state, index);
                JvsPackageEmulator.UpdateCoinCount(0);
                break;

            case InputMapping.Coin2:
                InputCode.PlayerDigitalButtons[1].Coin = DigitalHelper.GetButtonPressXinput(button, state, index);
                JvsPackageEmulator.UpdateCoinCount(1);
                break;

            case InputMapping.P1Button1:
                if (_gameProfile.EmulationProfile == EmulationProfile.Theatrhythm)
                {
                    DigitalHelper.GetDirectionPressXinput(InputCode.PlayerDigitalButtons[0], button, state, Direction.FFUp, index);
                }
                else
                {
                    InputCode.PlayerDigitalButtons[0].Button1 = DigitalHelper.GetButtonPressXinput(button, state, index);
                }
                break;

            case InputMapping.P1Button2:
                if (_gameProfile.EmulationProfile == EmulationProfile.Theatrhythm)
                {
                    DigitalHelper.GetDirectionPressXinput(InputCode.PlayerDigitalButtons[0], button, state, Direction.FFDown, index);
                }
                else
                {
                    InputCode.PlayerDigitalButtons[0].Button2 = DigitalHelper.GetButtonPressXinput(button, state, index);
                }
                break;

            case InputMapping.P1Button3:
                if (_gameProfile.EmulationProfile == EmulationProfile.Theatrhythm)
                {
                    DigitalHelper.GetDirectionPressXinput(InputCode.PlayerDigitalButtons[0], button, state, Direction.FFLeft, index);
                }
                else
                {
                    InputCode.PlayerDigitalButtons[0].Button3 = DigitalHelper.GetButtonPressXinput(button, state, index);
                }
                break;

            case InputMapping.P1Button4:
                if (_gameProfile.EmulationProfile == EmulationProfile.Theatrhythm)
                {
                    DigitalHelper.GetDirectionPressXinput(InputCode.PlayerDigitalButtons[0], button, state, Direction.FFRight, index);
                }
                else
                {
                    InputCode.PlayerDigitalButtons[0].Button4 = DigitalHelper.GetButtonPressXinput(button, state, index);
                }
                break;

            case InputMapping.P1Button5:
                InputCode.PlayerDigitalButtons[0].Button5 = DigitalHelper.GetButtonPressXinput(button, state, index);
                break;

            case InputMapping.P1Button6:
                InputCode.PlayerDigitalButtons[0].Button6 = DigitalHelper.GetButtonPressXinput(button, state, index);
                break;

            case InputMapping.P1ButtonUp:
                DigitalHelper.GetDirectionPressXinput(InputCode.PlayerDigitalButtons[0], button, state, Direction.Up, index);
                break;

            case InputMapping.P1ButtonDown:
                DigitalHelper.GetDirectionPressXinput(InputCode.PlayerDigitalButtons[0], button, state, Direction.Down, index);
                break;

            case InputMapping.P1ButtonLeft:
                DigitalHelper.GetDirectionPressXinput(InputCode.PlayerDigitalButtons[0], button, state, Direction.Left, index);
                break;

            case InputMapping.P1ButtonRight:
                DigitalHelper.GetDirectionPressXinput(InputCode.PlayerDigitalButtons[0], button, state, Direction.Right, index);
                break;

            case InputMapping.P1ButtonStart:
                InputCode.PlayerDigitalButtons[0].Start = DigitalHelper.GetButtonPressXinput(button, state, index);
                break;

            case InputMapping.P2Button1:
                InputCode.PlayerDigitalButtons[1].Button1 = DigitalHelper.GetButtonPressXinput(button, state, index);
                break;

            case InputMapping.P2Button2:
                InputCode.PlayerDigitalButtons[1].Button2 = DigitalHelper.GetButtonPressXinput(button, state, index);
                break;

            case InputMapping.P2Button3:
                InputCode.PlayerDigitalButtons[1].Button3 = DigitalHelper.GetButtonPressXinput(button, state, index);
                break;

            case InputMapping.P2Button4:
                InputCode.PlayerDigitalButtons[1].Button4 = DigitalHelper.GetButtonPressXinput(button, state, index);
                break;

            case InputMapping.P2Button5:
                InputCode.PlayerDigitalButtons[1].Button5 = DigitalHelper.GetButtonPressXinput(button, state, index);
                break;

            case InputMapping.P2Button6:
                InputCode.PlayerDigitalButtons[1].Button6 = DigitalHelper.GetButtonPressXinput(button, state, index);
                break;

            case InputMapping.P2ButtonUp:
                DigitalHelper.GetDirectionPressXinput(InputCode.PlayerDigitalButtons[1], button, state, Direction.Up, index);
                break;

            case InputMapping.P2ButtonDown:
                DigitalHelper.GetDirectionPressXinput(InputCode.PlayerDigitalButtons[1], button, state, Direction.Down, index);
                break;

            case InputMapping.P2ButtonLeft:
                DigitalHelper.GetDirectionPressXinput(InputCode.PlayerDigitalButtons[1], button, state, Direction.Left, index);
                break;

            case InputMapping.P2ButtonRight:
                DigitalHelper.GetDirectionPressXinput(InputCode.PlayerDigitalButtons[1], button, state, Direction.Right, index);
                break;

            case InputMapping.P2ButtonStart:
                InputCode.PlayerDigitalButtons[1].Start = DigitalHelper.GetButtonPressXinput(button, state, index);
                break;

            case InputMapping.Analog0:
                InputCode.SetAnalogByte(0, ModifyAnalog(joystickButtons, state, index));
                break;

            case InputMapping.Analog1:
                InputCode.SetAnalogByte(1, ModifyAnalog(joystickButtons, state, index));
                break;

            case InputMapping.Analog2:
                InputCode.SetAnalogByte(2, ModifyAnalog(joystickButtons, state, index));
                break;

            case InputMapping.Analog3:
                InputCode.SetAnalogByte(3, ModifyAnalog(joystickButtons, state, index));
                break;

            case InputMapping.Analog4:
                InputCode.SetAnalogByte(4, ModifyAnalog(joystickButtons, state, index));
                break;

            case InputMapping.Analog5:
                InputCode.SetAnalogByte(5, ModifyAnalog(joystickButtons, state, index));
                break;

            case InputMapping.Analog6:
                InputCode.SetAnalogByte(6, ModifyAnalog(joystickButtons, state, index));
                break;

            case InputMapping.Analog7:
                InputCode.SetAnalogByte(7, ModifyAnalog(joystickButtons, state, index));
                break;

            case InputMapping.Analog8:
                InputCode.SetAnalogByte(8, ModifyAnalog(joystickButtons, state, index));
                break;

            case InputMapping.Analog9:
                InputCode.SetAnalogByte(9, ModifyAnalog(joystickButtons, state, index));
                break;

            case InputMapping.Analog10:
                InputCode.SetAnalogByte(10, ModifyAnalog(joystickButtons, state, index));
                break;

            case InputMapping.Analog11:
                InputCode.SetAnalogByte(11, ModifyAnalog(joystickButtons, state, index));
                break;

            case InputMapping.Analog12:
                InputCode.SetAnalogByte(12, ModifyAnalog(joystickButtons, state, index));
                break;

            case InputMapping.Analog13:
                InputCode.SetAnalogByte(13, ModifyAnalog(joystickButtons, state, index));
                break;

            case InputMapping.Analog14:
                InputCode.SetAnalogByte(14, ModifyAnalog(joystickButtons, state, index));
                break;

            case InputMapping.Analog15:
                InputCode.SetAnalogByte(15, ModifyAnalog(joystickButtons, state, index));
                break;

            case InputMapping.Analog16:
                InputCode.SetAnalogByte(16, ModifyAnalog(joystickButtons, state, index));
                break;

            case InputMapping.Analog17:
                InputCode.SetAnalogByte(17, ModifyAnalog(joystickButtons, state, index));
                break;

            case InputMapping.Analog18:
                InputCode.SetAnalogByte(18, ModifyAnalog(joystickButtons, state, index));
                break;

            case InputMapping.Analog19:
                InputCode.SetAnalogByte(19, ModifyAnalog(joystickButtons, state, index));
                break;

            case InputMapping.Analog20:
                InputCode.SetAnalogByte(20, ModifyAnalog(joystickButtons, state, index));
                break;

            case InputMapping.SrcGearChange1:
            {
                if (DigitalHelper.GetButtonPressXinput(joystickButtons.XInputButton, state, index) == true)
                {
                    DigitalHelper.ChangeSrcGear(1);
                }
            }
            break;

            case InputMapping.SrcGearChange2:
            {
                if (DigitalHelper.GetButtonPressXinput(joystickButtons.XInputButton, state, index) == true)
                {
                    DigitalHelper.ChangeSrcGear(2);
                }
            }
            break;

            case InputMapping.SrcGearChange3:
            {
                if (DigitalHelper.GetButtonPressXinput(joystickButtons.XInputButton, state, index) == true)
                {
                    DigitalHelper.ChangeSrcGear(3);
                }
            }
            break;

            case InputMapping.SrcGearChange4:
            {
                if (DigitalHelper.GetButtonPressXinput(joystickButtons.XInputButton, state, index) == true)
                {
                    DigitalHelper.ChangeSrcGear(4);
                }
            }
            break;

            case InputMapping.ExtensionOne1:
                InputCode.PlayerDigitalButtons[0].ExtensionButton1 = DigitalHelper.GetButtonPressXinput(button, state, index);
                break;

            case InputMapping.ExtensionOne2:
                InputCode.PlayerDigitalButtons[0].ExtensionButton2 = DigitalHelper.GetButtonPressXinput(button, state, index);
                break;

            case InputMapping.ExtensionOne3:
                InputCode.PlayerDigitalButtons[0].ExtensionButton3 = DigitalHelper.GetButtonPressXinput(button, state, index);
                break;

            case InputMapping.ExtensionOne4:
                InputCode.PlayerDigitalButtons[0].ExtensionButton4 = DigitalHelper.GetButtonPressXinput(button, state, index);
                break;

            case InputMapping.ExtensionOne11:
                InputCode.PlayerDigitalButtons[0].ExtensionButton1_1 = DigitalHelper.GetButtonPressXinput(button, state, index);
                break;

            case InputMapping.ExtensionOne12:
                InputCode.PlayerDigitalButtons[0].ExtensionButton1_2 = DigitalHelper.GetButtonPressXinput(button, state, index);
                break;

            case InputMapping.ExtensionOne13:
                InputCode.PlayerDigitalButtons[0].ExtensionButton1_3 = DigitalHelper.GetButtonPressXinput(button, state, index);
                break;

            case InputMapping.ExtensionOne14:
                InputCode.PlayerDigitalButtons[0].ExtensionButton1_4 = DigitalHelper.GetButtonPressXinput(button, state, index);
                break;

            case InputMapping.ExtensionOne15:
                InputCode.PlayerDigitalButtons[0].ExtensionButton1_5 = DigitalHelper.GetButtonPressXinput(button, state, index);
                break;

            case InputMapping.ExtensionOne16:
                InputCode.PlayerDigitalButtons[0].ExtensionButton1_6 = DigitalHelper.GetButtonPressXinput(button, state, index);
                break;

            case InputMapping.ExtensionOne17:
                InputCode.PlayerDigitalButtons[0].ExtensionButton1_7 = DigitalHelper.GetButtonPressXinput(button, state, index);
                break;

            case InputMapping.ExtensionOne18:
                InputCode.PlayerDigitalButtons[0].ExtensionButton1_8 = DigitalHelper.GetButtonPressXinput(button, state, index);
                break;

            case InputMapping.ExtensionTwo1:
                InputCode.PlayerDigitalButtons[1].ExtensionButton1 = DigitalHelper.GetButtonPressXinput(button, state, index);
                break;

            case InputMapping.ExtensionTwo2:
                InputCode.PlayerDigitalButtons[1].ExtensionButton2 = DigitalHelper.GetButtonPressXinput(button, state, index);
                break;

            case InputMapping.ExtensionTwo3:
                InputCode.PlayerDigitalButtons[1].ExtensionButton3 = DigitalHelper.GetButtonPressXinput(button, state, index);
                break;

            case InputMapping.ExtensionTwo4:
                InputCode.PlayerDigitalButtons[1].ExtensionButton4 = DigitalHelper.GetButtonPressXinput(button, state, index);
                break;

            case InputMapping.ExtensionTwo11:
                InputCode.PlayerDigitalButtons[1].ExtensionButton1_1 = DigitalHelper.GetButtonPressXinput(button, state, index);
                break;

            case InputMapping.ExtensionTwo12:
                InputCode.PlayerDigitalButtons[1].ExtensionButton1_2 = DigitalHelper.GetButtonPressXinput(button, state, index);
                break;

            case InputMapping.ExtensionTwo13:
                InputCode.PlayerDigitalButtons[1].ExtensionButton1_3 = DigitalHelper.GetButtonPressXinput(button, state, index);
                break;

            case InputMapping.ExtensionTwo14:
                InputCode.PlayerDigitalButtons[1].ExtensionButton1_4 = DigitalHelper.GetButtonPressXinput(button, state, index);
                break;

            case InputMapping.ExtensionTwo15:
                InputCode.PlayerDigitalButtons[1].ExtensionButton1_5 = DigitalHelper.GetButtonPressXinput(button, state, index);
                break;

            case InputMapping.ExtensionTwo16:
                InputCode.PlayerDigitalButtons[1].ExtensionButton1_6 = DigitalHelper.GetButtonPressXinput(button, state, index);
                break;

            case InputMapping.ExtensionTwo17:
                InputCode.PlayerDigitalButtons[1].ExtensionButton1_7 = DigitalHelper.GetButtonPressXinput(button, state, index);
                break;

            case InputMapping.ExtensionTwo18:
                InputCode.PlayerDigitalButtons[1].ExtensionButton1_8 = DigitalHelper.GetButtonPressXinput(button, state, index);
                break;

            // Jvs Board 2

            case InputMapping.JvsTwoService1:
                InputCode.PlayerDigitalButtons[2].Service = DigitalHelper.GetButtonPressXinput(button, state, index);
                break;

            case InputMapping.JvsTwoService2:
                InputCode.PlayerDigitalButtons[3].Service = DigitalHelper.GetButtonPressXinput(button, state, index);
                break;

            case InputMapping.JvsTwoCoin1:
                InputCode.PlayerDigitalButtons[2].Coin = DigitalHelper.GetButtonPressXinput(button, state, index);
                JvsPackageEmulator.UpdateCoinCount(2);
                break;

            case InputMapping.JvsTwoCoin2:
                InputCode.PlayerDigitalButtons[3].Coin = DigitalHelper.GetButtonPressXinput(button, state, index);
                JvsPackageEmulator.UpdateCoinCount(3);
                break;

            case InputMapping.JvsTwoP1Button1:
                InputCode.PlayerDigitalButtons[2].Button1 = DigitalHelper.GetButtonPressXinput(button, state, index);
                break;

            case InputMapping.JvsTwoP1Button2:
                InputCode.PlayerDigitalButtons[2].Button2 = DigitalHelper.GetButtonPressXinput(button, state, index);
                break;

            case InputMapping.JvsTwoP1Button3:
                InputCode.PlayerDigitalButtons[2].Button3 = DigitalHelper.GetButtonPressXinput(button, state, index);
                break;

            case InputMapping.JvsTwoP1Button4:
                InputCode.PlayerDigitalButtons[2].Button4 = DigitalHelper.GetButtonPressXinput(button, state, index);
                break;

            case InputMapping.JvsTwoP1Button5:
                InputCode.PlayerDigitalButtons[2].Button5 = DigitalHelper.GetButtonPressXinput(button, state, index);
                break;

            case InputMapping.JvsTwoP1Button6:
                InputCode.PlayerDigitalButtons[2].Button6 = DigitalHelper.GetButtonPressXinput(button, state, index);
                break;

            case InputMapping.JvsTwoP1ButtonUp:
                DigitalHelper.GetDirectionPressXinput(InputCode.PlayerDigitalButtons[2], button, state, Direction.Up, index);
                break;

            case InputMapping.JvsTwoP1ButtonDown:
                DigitalHelper.GetDirectionPressXinput(InputCode.PlayerDigitalButtons[2], button, state, Direction.Down, index);
                break;

            case InputMapping.JvsTwoP1ButtonLeft:
                DigitalHelper.GetDirectionPressXinput(InputCode.PlayerDigitalButtons[2], button, state, Direction.Left, index);
                break;

            case InputMapping.JvsTwoP1ButtonRight:
                DigitalHelper.GetDirectionPressXinput(InputCode.PlayerDigitalButtons[2], button, state, Direction.Right, index);
                break;

            case InputMapping.JvsTwoP1ButtonStart:
                InputCode.PlayerDigitalButtons[2].Start = DigitalHelper.GetButtonPressXinput(button, state, index);
                break;

            case InputMapping.JvsTwoP2Button1:
                InputCode.PlayerDigitalButtons[3].Button1 = DigitalHelper.GetButtonPressXinput(button, state, index);
                break;

            case InputMapping.JvsTwoP2Button2:
                InputCode.PlayerDigitalButtons[3].Button2 = DigitalHelper.GetButtonPressXinput(button, state, index);
                break;

            case InputMapping.JvsTwoP2Button3:
                InputCode.PlayerDigitalButtons[3].Button3 = DigitalHelper.GetButtonPressXinput(button, state, index);
                break;

            case InputMapping.JvsTwoP2Button4:
                InputCode.PlayerDigitalButtons[3].Button4 = DigitalHelper.GetButtonPressXinput(button, state, index);
                break;

            case InputMapping.JvsTwoP2Button5:
                InputCode.PlayerDigitalButtons[3].Button5 = DigitalHelper.GetButtonPressXinput(button, state, index);
                break;

            case InputMapping.JvsTwoP2Button6:
                InputCode.PlayerDigitalButtons[3].Button6 = DigitalHelper.GetButtonPressXinput(button, state, index);
                break;

            case InputMapping.JvsTwoP2ButtonUp:
                DigitalHelper.GetDirectionPressXinput(InputCode.PlayerDigitalButtons[3], button, state, Direction.Up, index);
                break;

            case InputMapping.JvsTwoP2ButtonDown:
                DigitalHelper.GetDirectionPressXinput(InputCode.PlayerDigitalButtons[3], button, state, Direction.Down, index);
                break;

            case InputMapping.JvsTwoP2ButtonLeft:
                DigitalHelper.GetDirectionPressXinput(InputCode.PlayerDigitalButtons[3], button, state, Direction.Left, index);
                break;

            case InputMapping.JvsTwoP2ButtonRight:
                DigitalHelper.GetDirectionPressXinput(InputCode.PlayerDigitalButtons[3], button, state, Direction.Right, index);
                break;

            case InputMapping.JvsTwoP2ButtonStart:
                InputCode.PlayerDigitalButtons[3].Start = DigitalHelper.GetButtonPressXinput(button, state, index);
                break;

            case InputMapping.JvsTwoExtensionOne1:
                InputCode.PlayerDigitalButtons[2].ExtensionButton1 = DigitalHelper.GetButtonPressXinput(button, state, index);
                break;

            case InputMapping.JvsTwoExtensionOne2:
                InputCode.PlayerDigitalButtons[2].ExtensionButton2 = DigitalHelper.GetButtonPressXinput(button, state, index);
                break;

            case InputMapping.JvsTwoExtensionOne3:
                InputCode.PlayerDigitalButtons[2].ExtensionButton3 = DigitalHelper.GetButtonPressXinput(button, state, index);
                break;

            case InputMapping.JvsTwoExtensionOne4:
                InputCode.PlayerDigitalButtons[2].ExtensionButton4 = DigitalHelper.GetButtonPressXinput(button, state, index);
                break;

            case InputMapping.JvsTwoExtensionOne11:
                InputCode.PlayerDigitalButtons[2].ExtensionButton1_1 = DigitalHelper.GetButtonPressXinput(button, state, index);
                break;

            case InputMapping.JvsTwoExtensionOne12:
                InputCode.PlayerDigitalButtons[2].ExtensionButton1_2 = DigitalHelper.GetButtonPressXinput(button, state, index);
                break;

            case InputMapping.JvsTwoExtensionOne13:
                InputCode.PlayerDigitalButtons[2].ExtensionButton1_3 = DigitalHelper.GetButtonPressXinput(button, state, index);
                break;

            case InputMapping.JvsTwoExtensionOne14:
                InputCode.PlayerDigitalButtons[2].ExtensionButton1_4 = DigitalHelper.GetButtonPressXinput(button, state, index);
                break;

            case InputMapping.JvsTwoExtensionOne15:
                InputCode.PlayerDigitalButtons[2].ExtensionButton1_5 = DigitalHelper.GetButtonPressXinput(button, state, index);
                break;

            case InputMapping.JvsTwoExtensionOne16:
                InputCode.PlayerDigitalButtons[2].ExtensionButton1_6 = DigitalHelper.GetButtonPressXinput(button, state, index);
                break;

            case InputMapping.JvsTwoExtensionOne17:
                InputCode.PlayerDigitalButtons[2].ExtensionButton1_7 = DigitalHelper.GetButtonPressXinput(button, state, index);
                break;

            case InputMapping.JvsTwoExtensionOne18:
                InputCode.PlayerDigitalButtons[2].ExtensionButton1_8 = DigitalHelper.GetButtonPressXinput(button, state, index);
                break;

            case InputMapping.JvsTwoExtensionTwo1:
                InputCode.PlayerDigitalButtons[3].ExtensionButton1 = DigitalHelper.GetButtonPressXinput(button, state, index);
                break;

            case InputMapping.JvsTwoExtensionTwo2:
                InputCode.PlayerDigitalButtons[3].ExtensionButton2 = DigitalHelper.GetButtonPressXinput(button, state, index);
                break;

            case InputMapping.JvsTwoExtensionTwo3:
                InputCode.PlayerDigitalButtons[3].ExtensionButton3 = DigitalHelper.GetButtonPressXinput(button, state, index);
                break;

            case InputMapping.JvsTwoExtensionTwo4:
                InputCode.PlayerDigitalButtons[3].ExtensionButton4 = DigitalHelper.GetButtonPressXinput(button, state, index);
                break;

            case InputMapping.JvsTwoExtensionTwo11:
                InputCode.PlayerDigitalButtons[3].ExtensionButton1_1 = DigitalHelper.GetButtonPressXinput(button, state, index);
                break;

            case InputMapping.JvsTwoExtensionTwo12:
                InputCode.PlayerDigitalButtons[3].ExtensionButton1_2 = DigitalHelper.GetButtonPressXinput(button, state, index);
                break;

            case InputMapping.JvsTwoExtensionTwo13:
                InputCode.PlayerDigitalButtons[3].ExtensionButton1_3 = DigitalHelper.GetButtonPressXinput(button, state, index);
                break;

            case InputMapping.JvsTwoExtensionTwo14:
                InputCode.PlayerDigitalButtons[3].ExtensionButton1_4 = DigitalHelper.GetButtonPressXinput(button, state, index);
                break;

            case InputMapping.JvsTwoExtensionTwo15:
                InputCode.PlayerDigitalButtons[3].ExtensionButton1_5 = DigitalHelper.GetButtonPressXinput(button, state, index);
                break;

            case InputMapping.JvsTwoExtensionTwo16:
                InputCode.PlayerDigitalButtons[3].ExtensionButton1_6 = DigitalHelper.GetButtonPressXinput(button, state, index);
                break;

            case InputMapping.JvsTwoExtensionTwo17:
                InputCode.PlayerDigitalButtons[3].ExtensionButton1_7 = DigitalHelper.GetButtonPressXinput(button, state, index);
                break;

            case InputMapping.JvsTwoExtensionTwo18:
                InputCode.PlayerDigitalButtons[3].ExtensionButton1_8 = DigitalHelper.GetButtonPressXinput(button, state, index);
                break;

            case InputMapping.JvsTwoAnalog0:
                InputCode.SetAnalogByte(0, ModifyAnalog(joystickButtons, state, index), true);
                break;

            case InputMapping.JvsTwoAnalog1:
                InputCode.SetAnalogByte(1, ModifyAnalog(joystickButtons, state, index), true);
                break;

            case InputMapping.JvsTwoAnalog2:
                InputCode.SetAnalogByte(2, ModifyAnalog(joystickButtons, state, index), true);
                break;

            case InputMapping.JvsTwoAnalog3:
                InputCode.SetAnalogByte(3, ModifyAnalog(joystickButtons, state, index), true);
                break;

            case InputMapping.JvsTwoAnalog4:
                InputCode.SetAnalogByte(4, ModifyAnalog(joystickButtons, state, index), true);
                break;

            case InputMapping.JvsTwoAnalog5:
                InputCode.SetAnalogByte(5, ModifyAnalog(joystickButtons, state, index), true);
                break;

            case InputMapping.JvsTwoAnalog6:
                InputCode.SetAnalogByte(6, ModifyAnalog(joystickButtons, state, index), true);
                break;

            case InputMapping.JvsTwoAnalog7:
                InputCode.SetAnalogByte(7, ModifyAnalog(joystickButtons, state, index), true);
                break;

            case InputMapping.JvsTwoAnalog8:
                InputCode.SetAnalogByte(8, ModifyAnalog(joystickButtons, state, index), true);
                break;

            case InputMapping.JvsTwoAnalog9:
                InputCode.SetAnalogByte(9, ModifyAnalog(joystickButtons, state, index), true);
                break;

            case InputMapping.JvsTwoAnalog10:
                InputCode.SetAnalogByte(10, ModifyAnalog(joystickButtons, state, index), true);
                break;

            case InputMapping.JvsTwoAnalog11:
                InputCode.SetAnalogByte(11, ModifyAnalog(joystickButtons, state, index), true);
                break;

            case InputMapping.JvsTwoAnalog12:
                InputCode.SetAnalogByte(12, ModifyAnalog(joystickButtons, state, index), true);
                break;

            case InputMapping.JvsTwoAnalog13:
                InputCode.SetAnalogByte(13, ModifyAnalog(joystickButtons, state, index), true);
                break;

            case InputMapping.JvsTwoAnalog14:
                InputCode.SetAnalogByte(14, ModifyAnalog(joystickButtons, state, index), true);
                break;

            case InputMapping.JvsTwoAnalog15:
                InputCode.SetAnalogByte(15, ModifyAnalog(joystickButtons, state, index), true);
                break;

            case InputMapping.JvsTwoAnalog16:
                InputCode.SetAnalogByte(16, ModifyAnalog(joystickButtons, state, index), true);
                break;

            case InputMapping.JvsTwoAnalog17:
                InputCode.SetAnalogByte(17, ModifyAnalog(joystickButtons, state, index), true);
                break;

            case InputMapping.JvsTwoAnalog18:
                InputCode.SetAnalogByte(18, ModifyAnalog(joystickButtons, state, index), true);
                break;

            case InputMapping.JvsTwoAnalog19:
                InputCode.SetAnalogByte(19, ModifyAnalog(joystickButtons, state, index), true);
                break;

            case InputMapping.JvsTwoAnalog20:
                InputCode.SetAnalogByte(20, ModifyAnalog(joystickButtons, state, index), true);
                break;


            case InputMapping.Analog0Special1:
            case InputMapping.Analog0Special2:
                InputCode.SetAnalogByte(0, ModifyAnalog(joystickButtons, state, index));
                break;

            case InputMapping.Analog2Special1:
            case InputMapping.Analog2Special2:
                InputCode.SetAnalogByte(2, ModifyAnalog(joystickButtons, state, index));
                break;

            case InputMapping.Wmmt5GearChange1:
            {
                if (DigitalHelper.GetButtonPressXinput(joystickButtons.XInputButton, state, index) == true)
                {
                    DigitalHelper.ChangeWmmt5Gear(1);
                }
            }
            break;

            case InputMapping.Wmmt5GearChange2:
            {
                if (DigitalHelper.GetButtonPressXinput(joystickButtons.XInputButton, state, index) == true)
                {
                    DigitalHelper.ChangeWmmt5Gear(2);
                }
            }
            break;

            case InputMapping.Wmmt5GearChange3:
            {
                if (DigitalHelper.GetButtonPressXinput(joystickButtons.XInputButton, state, index) == true)
                {
                    DigitalHelper.ChangeWmmt5Gear(3);
                }
            }
            break;

            case InputMapping.Wmmt5GearChange4:
            {
                if (DigitalHelper.GetButtonPressXinput(joystickButtons.XInputButton, state, index) == true)
                {
                    DigitalHelper.ChangeWmmt5Gear(4);
                }
            }
            break;

            case InputMapping.Wmmt5GearChange5:
            {
                if (DigitalHelper.GetButtonPressXinput(joystickButtons.XInputButton, state, index) == true)
                {
                    DigitalHelper.ChangeWmmt5Gear(5);
                }
            }
            break;

            case InputMapping.Wmmt5GearChange6:
            {
                if (DigitalHelper.GetButtonPressXinput(joystickButtons.XInputButton, state, index) == true)
                {
                    DigitalHelper.ChangeWmmt5Gear(6);
                }
            }
            break;

            case InputMapping.Wmmt5GearChangeUp:
            {
                if (DigitalHelper.GetButtonPressXinput(joystickButtons.XInputButton, state, index) == true)
                {
                    if (!changeWmmt5GearUp)
                    {
                        DigitalHelper.ChangeWmmt5GearUp();
                    }
                    changeWmmt5GearUp = true;
                }
                else
                {
                    changeWmmt5GearUp = false;
                }
            }
            break;

            case InputMapping.Wmmt5GearChangeDown:
            {
                if (DigitalHelper.GetButtonPressXinput(joystickButtons.XInputButton, state, index) == true)
                {
                    if (!changeWmmt5GearDown)
                    {
                        DigitalHelper.ChangeWmmt5GearDown();
                    }
                    changeWmmt5GearDown = true;
                }
                else
                {
                    changeWmmt5GearDown = false;
                }
            }
            break;

            case InputMapping.SrcGearChangeUp:
            {
                if (DigitalHelper.GetButtonPressXinput(joystickButtons.XInputButton, state, index) == true)
                {
                    if (!changeSrcGearUp)
                    {
                        DigitalHelper.ChangeSrcGearUp();
                    }
                    changeSrcGearUp = true;
                }
                else
                {
                    changeSrcGearUp = false;
                }
            }
            break;

            case InputMapping.SrcGearChangeDown:
            {
                if (DigitalHelper.GetButtonPressXinput(joystickButtons.XInputButton, state, index) == true)
                {
                    if (!changeSrcGearDown)
                    {
                        DigitalHelper.ChangeSrcGearDown();
                    }
                    changeSrcGearDown = true;
                }
                else
                {
                    changeSrcGearDown = false;
                }
            }
            break;

            case InputMapping.InitialDRealGear1:
            {
                if (DigitalHelper.GetButtonPressXinput(joystickButtons.XInputButton, state, index) == true)
                {
                    DigitalHelper.ChangeIdGear(1);
                }
            }
            break;

            case InputMapping.InitialDRealGear2:
            {
                if (DigitalHelper.GetButtonPressXinput(joystickButtons.XInputButton, state, index) == true)
                {
                    DigitalHelper.ChangeIdGear(2);
                }
            }
            break;

            case InputMapping.InitialDRealGear3:
            {
                if (DigitalHelper.GetButtonPressXinput(joystickButtons.XInputButton, state, index) == true)
                {
                    DigitalHelper.ChangeIdGear(3);
                }
            }
            break;

            case InputMapping.InitialDRealGear4:
            {
                if (DigitalHelper.GetButtonPressXinput(joystickButtons.XInputButton, state, index) == true)
                {
                    DigitalHelper.ChangeIdGear(4);
                }
            }
            break;

            case InputMapping.InitialDRealGear5:
            {
                if (DigitalHelper.GetButtonPressXinput(joystickButtons.XInputButton, state, index) == true)
                {
                    DigitalHelper.ChangeIdGear(5);
                }
            }
            break;

            case InputMapping.InitialDRealGear6:
            {
                if (DigitalHelper.GetButtonPressXinput(joystickButtons.XInputButton, state, index) == true)
                {
                    DigitalHelper.ChangeIdGear(6);
                }
            }
            break;

            case InputMapping.PokkenButtonUp:
                DigitalHelper.GetDirectionPressXinput(InputCode.PokkenInputButtons, button, state, Direction.Up, index);
                break;

            case InputMapping.PokkenButtonDown:
                DigitalHelper.GetDirectionPressXinput(InputCode.PokkenInputButtons, button, state, Direction.Down, index);
                break;

            case InputMapping.PokkenButtonLeft:
                DigitalHelper.GetDirectionPressXinput(InputCode.PokkenInputButtons, button, state, Direction.Left, index);
                break;

            case InputMapping.PokkenButtonRight:
                DigitalHelper.GetDirectionPressXinput(InputCode.PokkenInputButtons, button, state, Direction.Right, index);
                break;

            case InputMapping.PokkenButtonStart:
                InputCode.PokkenInputButtons.Start = DigitalHelper.GetButtonPressXinput(button, state, index);
                break;

            case InputMapping.PokkenButtonA:
                InputCode.PokkenInputButtons.ButtonA = DigitalHelper.GetButtonPressXinput(button, state, index);
                break;

            case InputMapping.PokkenButtonB:
                InputCode.PokkenInputButtons.ButtonB = DigitalHelper.GetButtonPressXinput(button, state, index);
                break;

            case InputMapping.PokkenButtonX:
                InputCode.PokkenInputButtons.ButtonX = DigitalHelper.GetButtonPressXinput(button, state, index);
                break;

            case InputMapping.PokkenButtonY:
                InputCode.PokkenInputButtons.ButtonY = DigitalHelper.GetButtonPressXinput(button, state, index);
                break;

            case InputMapping.PokkenButtonL:
                InputCode.PokkenInputButtons.ButtonL = DigitalHelper.GetButtonPressXinput(button, state, index);
                break;

            case InputMapping.PokkenButtonR:
                InputCode.PokkenInputButtons.ButtonR = DigitalHelper.GetButtonPressXinput(button, state, index);
                break;

            default:
                break;
                //throw new ArgumentOutOfRangeException();
            }
        }
Beispiel #15
0
        private void HandleRawInputButton(JoystickButtons joystickButton, bool pressed)
        {
            // Ignore when alt+tabbed
            if (!_windowFocus && pressed)
            {
                return;
            }

            switch (joystickButton.InputMapping)
            {
            case InputMapping.Test:
                InputCode.PlayerDigitalButtons[0].Test = pressed;
                break;

            case InputMapping.Service1:
                InputCode.PlayerDigitalButtons[0].Service = pressed;
                break;

            case InputMapping.Service2:
                InputCode.PlayerDigitalButtons[1].Service = pressed;
                break;

            case InputMapping.Coin1:
                InputCode.PlayerDigitalButtons[0].Coin = pressed;
                JvsPackageEmulator.UpdateCoinCount(0);
                break;

            case InputMapping.Coin2:
                InputCode.PlayerDigitalButtons[1].Coin = pressed;
                JvsPackageEmulator.UpdateCoinCount(1);
                break;

            // P1
            case InputMapping.P1ButtonStart:
                InputCode.PlayerDigitalButtons[0].Start = pressed;
                break;

            case InputMapping.P1Button1:
                InputCode.PlayerDigitalButtons[0].Button1 = pressed;
                break;

            case InputMapping.P1Button2:
                InputCode.PlayerDigitalButtons[0].Button2 = pressed;
                break;

            case InputMapping.P1Button3:
                InputCode.PlayerDigitalButtons[0].Button3 = pressed;
                break;

            case InputMapping.P1Button4:
                InputCode.PlayerDigitalButtons[0].Button4 = pressed;
                break;

            case InputMapping.P1Button5:
                InputCode.PlayerDigitalButtons[0].Button5 = pressed;
                break;

            case InputMapping.P1Button6:
                InputCode.PlayerDigitalButtons[0].Button6 = pressed;
                break;

            case InputMapping.P1ButtonLeft:
                if (pressed)
                {
                    InputCode.SetPlayerDirection(InputCode.PlayerDigitalButtons[0], Direction.Left);
                }
                else
                {
                    InputCode.SetPlayerDirection(InputCode.PlayerDigitalButtons[0], Direction.HorizontalCenter);
                }
                break;

            case InputMapping.P1ButtonRight:
                if (pressed)
                {
                    InputCode.SetPlayerDirection(InputCode.PlayerDigitalButtons[0], Direction.Right);
                }
                else
                {
                    InputCode.SetPlayerDirection(InputCode.PlayerDigitalButtons[0], Direction.HorizontalCenter);
                }
                break;

            // P2
            case InputMapping.P2ButtonStart:
                InputCode.PlayerDigitalButtons[1].Start = pressed;
                break;

            case InputMapping.P2Button1:
                InputCode.PlayerDigitalButtons[1].Button1 = pressed;
                break;

            case InputMapping.P2Button2:
                InputCode.PlayerDigitalButtons[1].Button2 = pressed;
                break;

            case InputMapping.P2Button3:
                InputCode.PlayerDigitalButtons[1].Button3 = pressed;
                break;

            case InputMapping.P2Button4:
                InputCode.PlayerDigitalButtons[1].Button4 = pressed;
                break;

            case InputMapping.P2Button5:
                InputCode.PlayerDigitalButtons[1].Button5 = pressed;
                break;

            case InputMapping.P2Button6:
                InputCode.PlayerDigitalButtons[1].Button6 = pressed;
                break;

            // Ext1
            case InputMapping.ExtensionOne1:
                InputCode.PlayerDigitalButtons[0].ExtensionButton1 = pressed;
                break;

            case InputMapping.ExtensionOne2:
                InputCode.PlayerDigitalButtons[0].ExtensionButton2 = pressed;
                break;

            case InputMapping.ExtensionOne3:
                InputCode.PlayerDigitalButtons[0].ExtensionButton3 = pressed;
                break;

            case InputMapping.ExtensionOne4:
                InputCode.PlayerDigitalButtons[0].ExtensionButton4 = pressed;
                break;

            case InputMapping.ExtensionOne11:
                InputCode.PlayerDigitalButtons[0].ExtensionButton1_1 = pressed;
                break;

            case InputMapping.ExtensionOne12:
                InputCode.PlayerDigitalButtons[0].ExtensionButton1_2 = pressed;
                break;

            case InputMapping.ExtensionOne13:
                InputCode.PlayerDigitalButtons[0].ExtensionButton1_3 = pressed;
                break;

            case InputMapping.ExtensionOne14:
                InputCode.PlayerDigitalButtons[0].ExtensionButton1_4 = pressed;
                break;

            case InputMapping.ExtensionOne15:
                InputCode.PlayerDigitalButtons[0].ExtensionButton1_5 = pressed;
                break;

            case InputMapping.ExtensionOne16:
                InputCode.PlayerDigitalButtons[0].ExtensionButton1_6 = pressed;
                break;

            case InputMapping.ExtensionOne17:
                InputCode.PlayerDigitalButtons[0].ExtensionButton1_7 = pressed;
                break;

            case InputMapping.ExtensionOne18:
                InputCode.PlayerDigitalButtons[0].ExtensionButton1_8 = pressed;
                break;

            // Ext2
            case InputMapping.ExtensionTwo1:
                InputCode.PlayerDigitalButtons[1].ExtensionButton1 = pressed;
                break;

            case InputMapping.ExtensionTwo2:
                InputCode.PlayerDigitalButtons[1].ExtensionButton2 = pressed;
                break;

            case InputMapping.ExtensionTwo3:
                InputCode.PlayerDigitalButtons[1].ExtensionButton3 = pressed;
                break;

            case InputMapping.ExtensionTwo4:
                InputCode.PlayerDigitalButtons[1].ExtensionButton4 = pressed;
                break;

            case InputMapping.ExtensionTwo11:
                InputCode.PlayerDigitalButtons[1].ExtensionButton1_1 = pressed;
                break;

            case InputMapping.ExtensionTwo12:
                InputCode.PlayerDigitalButtons[1].ExtensionButton1_2 = pressed;
                break;

            case InputMapping.ExtensionTwo13:
                InputCode.PlayerDigitalButtons[1].ExtensionButton1_3 = pressed;
                break;

            case InputMapping.ExtensionTwo14:
                InputCode.PlayerDigitalButtons[1].ExtensionButton1_4 = pressed;
                break;

            case InputMapping.ExtensionTwo15:
                InputCode.PlayerDigitalButtons[1].ExtensionButton1_5 = pressed;
                break;

            case InputMapping.ExtensionTwo16:
                InputCode.PlayerDigitalButtons[1].ExtensionButton1_6 = pressed;
                break;

            case InputMapping.ExtensionTwo17:
                InputCode.PlayerDigitalButtons[1].ExtensionButton1_7 = pressed;
                break;

            case InputMapping.ExtensionTwo18:
                InputCode.PlayerDigitalButtons[1].ExtensionButton1_8 = pressed;
                break;

            default:
                break;
            }
        }
        private void GameRunning_OnLoaded(object sender, RoutedEventArgs e)
        {
            JvsPackageEmulator.Initialize();
            if (InputCode.ButtonMode == EmulationProfile.EuropaRFordRacing || InputCode.ButtonMode == EmulationProfile.EuropaRSegaRally3)
            {
                if (_europa == null)
                {
                    _europa = new EuropaRPipeHandler();
                }
                _europa.StartListening(InputCode.ButtonMode == EmulationProfile.EuropaRSegaRally3);
            }
            if (InputCode.ButtonMode == EmulationProfile.FastIo)
            {
                if (_fastIo == null)
                {
                    _fastIo = new FastIoPipe();
                }
                _fastIo.StartListening();
            }
            if (_rawInputListener == null)
            {
                _rawInputListener = new RawInputListener();
            }

            if (InputCode.ButtonMode == EmulationProfile.SegaJvsLetsGoIsland || InputCode.ButtonMode == EmulationProfile.SegaJvsLetsGoJungle)
            {
                InputCode.AnalogBytes[0] = 127;
                InputCode.AnalogBytes[2] = 127;
                InputCode.AnalogBytes[4] = 127;
                InputCode.AnalogBytes[6] = 127;
            }
            else
            {
                InputCode.AnalogBytes[0] = 0;
                InputCode.AnalogBytes[2] = 0;
                InputCode.AnalogBytes[4] = 0;
                InputCode.AnalogBytes[6] = 0;
            }

            if (_parrotData.UseMouse && _gameProfile.GunGame)
            {
                _rawInputListener.ListenToDevice(InputCode.ButtonMode == EmulationProfile.SegaJvsGoldenGun || InputCode.ButtonMode == EmulationProfile.Hotd4);
            }

            switch (InputCode.ButtonMode)
            {
            case EmulationProfile.NamcoPokken:
                _controlSender = new Pokken();
                break;

            case EmulationProfile.ExBoard:
                _controlSender = new ExBoard();
                break;

            case EmulationProfile.GtiClub3:
                _controlSender = new GtiClub3();
                break;

            case EmulationProfile.Daytona3:
                _controlSender = new Daytona3();
                break;

            case EmulationProfile.GRID:
                _controlSender = new GRID();
                break;
            }

            _controlSender?.Start();

            if (_gameProfile.GunGame)
            {
                KillGunListener = false;
                LgiThread       = new Thread(HandleLgiControls);
                LgiThread.Start();
            }

            if (!_runEmuOnly)
            {
                WriteConfigIni();
            }

            if (InputCode.ButtonMode != EmulationProfile.EuropaRFordRacing && InputCode.ButtonMode != EmulationProfile.EuropaRSegaRally3 && InputCode.ButtonMode != EmulationProfile.FastIo)
            {
                // TODO: MAYBE MAKE THESE XML BASED?
                switch (InputCode.ButtonMode)
                {
                case EmulationProfile.VirtuaRLimit:
                case EmulationProfile.ChaseHq2:
                case EmulationProfile.WackyRaces:
                {
                    JvsPackageEmulator.EnableTaito    = true;
                    JvsPackageEmulator.JvsSwitchCount = 0x18;
                }
                break;

                case EmulationProfile.TaitoTypeXBattleGear:
                {
                    JvsPackageEmulator.JvsVersion            = 0x30;
                    JvsPackageEmulator.EnableTaitoStick      = true;
                    JvsPackageEmulator.EnableTaitoBattleGear = true;
                    JvsPackageEmulator.JvsSwitchCount        = 0x18;
                }
                break;

                case EmulationProfile.TaitoTypeXGeneric:
                {
                    JvsPackageEmulator.JvsVersion       = 0x30;
                    JvsPackageEmulator.EnableTaitoStick = true;
                    JvsPackageEmulator.JvsSwitchCount   = 0x18;
                }
                break;

                case EmulationProfile.BorderBreak:
                {
                    InputCode.AnalogBytes[0] = 0x7F;         // Center analog
                    InputCode.AnalogBytes[2] = 0x7F;         // Center analog
                }
                break;

                case EmulationProfile.NamcoPokken:
                {
                    JvsPackageEmulator.JvsVersion         = 0x31;
                    JvsPackageEmulator.JvsCommVersion     = 0x31;
                    JvsPackageEmulator.JvsCommandRevision = 0x31;
                    JvsPackageEmulator.JvsIdentifier      = JvsHelper.JVS_IDENTIFIER_NBGI_Pokken;
                    JvsPackageEmulator.EnableNamco        = true;
                }
                break;

                case EmulationProfile.NamcoWmmt5:
                case EmulationProfile.NamcoMkdx:
                {
                    JvsPackageEmulator.JvsVersion         = 0x31;
                    JvsPackageEmulator.JvsCommVersion     = 0x31;
                    JvsPackageEmulator.JvsCommandRevision = 0x31;
                    JvsPackageEmulator.JvsIdentifier      = JvsHelper.JVS_IDENTIFIER_NBGI_MarioKart3;
                    JvsPackageEmulator.EnableNamco        = true;
                    JvsPackageEmulator.JvsSwitchCount     = 0x18;
                }
                break;

                case EmulationProfile.NamcoMachStorm:
                {
                    JvsPackageEmulator.JvsVersion         = 0x31;
                    JvsPackageEmulator.JvsCommVersion     = 0x31;
                    JvsPackageEmulator.JvsCommandRevision = 0x31;
                    JvsPackageEmulator.JvsIdentifier      = JvsHelper.JVS_IDENTIFIER_StarWars;
                    JvsPackageEmulator.EnableNamco        = true;
                    JvsPackageEmulator.JvsSwitchCount     = 0x18;
                }
                break;

                case EmulationProfile.DevThing1:
                {
                    JvsPackageEmulator.JvsVersion             = 0x30;
                    JvsPackageEmulator.EnableTaitoStick       = true;
                    JvsPackageEmulator.EnableTaitoBattleGear  = true;
                    JvsPackageEmulator.EnableDualJvsEmulation = true;
                    JvsPackageEmulator.JvsSwitchCount         = 0x18;
                }
                break;

                case EmulationProfile.VirtuaTennis4:
                case EmulationProfile.ArcadeLove:
                {
                    JvsPackageEmulator.EnableDualJvsEmulation = true;
                }
                break;

                case EmulationProfile.LGS:
                {
                    JvsPackageEmulator.JvsCommVersion     = 0x30;
                    JvsPackageEmulator.JvsVersion         = 0x30;
                    JvsPackageEmulator.JvsCommandRevision = 0x30;
                    JvsPackageEmulator.JvsIdentifier      = JvsHelper.JVS_IDENTIFIER_SegaLetsGoSafari;
                }
                break;
                }
                _serialPortHandler.StopListening();
                Thread.Sleep(1000);
                _jvsThread = new Thread(() => _serialPortHandler.ListenPipe("TeknoParrot_JVS"));
                _jvsThread.Start();
                _processQueueThread = new Thread(_serialPortHandler.ProcessQueue);
                _processQueueThread.Start();
            }

            if (_parrotData.UseMouse && _gameProfile.GunGame)
            {
                _diThread?.Abort(0);
                _diThread = null;
            }
            else
            {
                _diThread?.Abort(0);
                _diThread = CreateInputListenerThread(_parrotData.XInputMode);
            }

            if (_parrotData.UseDiscordRPC)
            {
                DiscordRPC.UpdatePresence(new DiscordRPC.RichPresence
                {
                    details       = _gameProfile.GameName,
                    largeImageKey = _gameProfile.GameName.Replace(" ", "").ToLower(),
                    //https://stackoverflow.com/a/17632585
                    startTimestamp = (long)DateTime.UtcNow.Subtract(new DateTime(1970, 1, 1)).TotalSeconds
                });
            }

            // Wait before launching second thread.
            if (!_runEmuOnly)
            {
                Thread.Sleep(1000);
                _gameRunning = true;
                CreateGameProcess();
            }
            else
            {
                if (_parrotData.UseHaptic && _gameProfile.ForceFeedback)
                {
                    StartFfb();
                }
            }
        }
Beispiel #17
0
        private void GameRunning_OnLoaded(object sender, RoutedEventArgs e)
        {
            JvsPackageEmulator.Initialize();
            switch (InputCode.ButtonMode)
            {
            case EmulationProfile.EuropaRFordRacing:
                if (_pipe == null)
                {
                    _pipe = new EuropaRPipe();
                }
                break;

            case EmulationProfile.EuropaRSegaRally3:
                if (_pipe == null)
                {
                    _pipe = new SegaRallyPipe();
                }
                break;

            case EmulationProfile.FastIo:
                if (_pipe == null)
                {
                    _pipe = new FastIOPipe();
                }
                break;
            }

            _pipe?.Start();

            var invertButtons =
                _gameProfile.ConfigValues.Any(x => x.FieldName == "Invert Buttons" && x.FieldValue == "1");

            if (invertButtons)
            {
                JvsPackageEmulator.InvertMaiMaiButtons = true;
            }

            if (_rawInputListener == null)
            {
                _rawInputListener = new RawInputListener();
            }

            if (InputCode.ButtonMode == EmulationProfile.SegaJvsLetsGoIsland ||
                InputCode.ButtonMode == EmulationProfile.SegaJvsLetsGoJungle)
            {
                InputCode.AnalogBytes[0] = 127;
                InputCode.AnalogBytes[2] = 127;
                InputCode.AnalogBytes[4] = 127;
                InputCode.AnalogBytes[6] = 127;
            }
            else
            {
                InputCode.AnalogBytes[0] = 0;
                InputCode.AnalogBytes[2] = 0;
                InputCode.AnalogBytes[4] = 0;
                InputCode.AnalogBytes[6] = 0;
            }

            bool useMouseForGun =
                _gameProfile.ConfigValues.Any(x => x.FieldName == "UseMouseForGun" && x.FieldValue == "1");

            if (useMouseForGun && _gameProfile.GunGame)
            {
                _rawInputListener.ListenToDevice(InputCode.ButtonMode == EmulationProfile.SegaJvsGoldenGun ||
                                                 InputCode.ButtonMode == EmulationProfile.Hotd4);
            }

            switch (InputCode.ButtonMode)
            {
            case EmulationProfile.NamcoPokken:
                _controlSender = new Pokken();
                break;

            case EmulationProfile.ExBoard:
                _controlSender = new ExBoard();
                break;

            case EmulationProfile.GtiClub3:
                _controlSender = new GtiClub3();
                break;

            case EmulationProfile.Daytona3:
                _controlSender = new Daytona3();
                break;

            case EmulationProfile.GRID:
                _controlSender = new GRID();
                break;
            }

            _controlSender?.Start();

            if (_gameProfile.GunGame)
            {
                _killGunListener = false;
                _gunThread       = new Thread(HandleGun);
                _gunThread.Start();
            }

            if (!_runEmuOnly)
            {
                WriteConfigIni();
            }

            if (InputCode.ButtonMode != EmulationProfile.EuropaRFordRacing &&
                InputCode.ButtonMode != EmulationProfile.EuropaRSegaRally3 &&
                InputCode.ButtonMode != EmulationProfile.FastIo)
            {
                // TODO: MAYBE MAKE THESE XML BASED?
                switch (InputCode.ButtonMode)
                {
                case EmulationProfile.VirtuaRLimit:
                case EmulationProfile.ChaseHq2:
                case EmulationProfile.WackyRaces:
                    JvsPackageEmulator.Taito          = true;
                    JvsPackageEmulator.JvsSwitchCount = 0x18;
                    break;

                case EmulationProfile.TaitoTypeXBattleGear:
                    JvsPackageEmulator.JvsVersion      = 0x30;
                    JvsPackageEmulator.TaitoStick      = true;
                    JvsPackageEmulator.TaitoBattleGear = true;
                    JvsPackageEmulator.JvsSwitchCount  = 0x18;
                    break;

                case EmulationProfile.TaitoTypeXGeneric:
                    JvsPackageEmulator.JvsVersion     = 0x30;
                    JvsPackageEmulator.TaitoStick     = true;
                    JvsPackageEmulator.JvsSwitchCount = 0x18;
                    break;

                case EmulationProfile.BorderBreak:
                    InputCode.AnalogBytes[0] = 0x7F;     // Center analog
                    InputCode.AnalogBytes[2] = 0x7F;     // Center analog
                    break;

                case EmulationProfile.NamcoPokken:
                    JvsPackageEmulator.JvsVersion         = 0x31;
                    JvsPackageEmulator.JvsCommVersion     = 0x31;
                    JvsPackageEmulator.JvsCommandRevision = 0x31;
                    JvsPackageEmulator.JvsIdentifier      = JVSIdentifiers.NBGI_Pokken;
                    JvsPackageEmulator.Namco = true;
                    break;

                case EmulationProfile.NamcoWmmt5:
                case EmulationProfile.NamcoMkdx:
                    JvsPackageEmulator.JvsVersion         = 0x31;
                    JvsPackageEmulator.JvsCommVersion     = 0x31;
                    JvsPackageEmulator.JvsCommandRevision = 0x31;
                    JvsPackageEmulator.JvsIdentifier      = JVSIdentifiers.NBGI_MarioKart3;
                    JvsPackageEmulator.Namco          = true;
                    JvsPackageEmulator.JvsSwitchCount = 0x18;
                    break;

                case EmulationProfile.NamcoMachStorm:
                    JvsPackageEmulator.JvsVersion         = 0x31;
                    JvsPackageEmulator.JvsCommVersion     = 0x31;
                    JvsPackageEmulator.JvsCommandRevision = 0x31;
                    JvsPackageEmulator.JvsIdentifier      = JVSIdentifiers.NamcoMultipurpose;
                    JvsPackageEmulator.Namco          = true;
                    JvsPackageEmulator.JvsSwitchCount = 0x18;
                    break;

                case EmulationProfile.DevThing1:
                    JvsPackageEmulator.JvsVersion       = 0x30;
                    JvsPackageEmulator.TaitoStick       = true;
                    JvsPackageEmulator.TaitoBattleGear  = true;
                    JvsPackageEmulator.DualJvsEmulation = true;
                    JvsPackageEmulator.JvsSwitchCount   = 0x18;
                    break;

                case EmulationProfile.VirtuaTennis4:
                case EmulationProfile.ArcadeLove:
                    JvsPackageEmulator.DualJvsEmulation = true;
                    break;

                case EmulationProfile.LGS:
                    JvsPackageEmulator.JvsCommVersion     = 0x30;
                    JvsPackageEmulator.JvsVersion         = 0x30;
                    JvsPackageEmulator.JvsCommandRevision = 0x30;
                    JvsPackageEmulator.JvsIdentifier      = JVSIdentifiers.SegaLetsGoSafari;
                    break;
                }

                _serialPortHandler.StopListening();
                Thread.Sleep(1000);
                _jvsThread = new Thread(() => _serialPortHandler.ListenPipe("TeknoParrot_JVS"));
                _jvsThread.Start();
                _processQueueThread = new Thread(_serialPortHandler.ProcessQueue);
                _processQueueThread.Start();
            }

            if (useMouseForGun && _gameProfile.GunGame)
            {
                _diThread?.Abort(0);
                _diThread = null;
            }
            else
            {
                _diThread?.Abort(0);
                _diThread = CreateInputListenerThread(
                    _gameProfile.ConfigValues.Any(x => x.FieldName == "XInput" && x.FieldValue == "1"));
            }

            if (_parrotData.UseDiscordRPC)
            {
                DiscordRPC.UpdatePresence(new DiscordRPC.RichPresence
                {
                    details       = _gameProfile.GameName,
                    largeImageKey = _gameProfile.GameName.Replace(" ", "").ToLower(),
                    //https://stackoverflow.com/a/17632585
                    startTimestamp = (long)DateTime.UtcNow.Subtract(new DateTime(1970, 1, 1)).TotalSeconds
                });
            }

            // Wait before launching second thread.
            if (!_runEmuOnly)
            {
                Thread.Sleep(1000);
                _gameRunning = true;
                CreateGameProcess();
            }
        }
Beispiel #18
0
        private void GameRunning_OnLoaded(object sender, RoutedEventArgs e)
        {
            JvsPackageEmulator.Initialize();
            switch (InputCode.ButtonMode)
            {
            case EmulationProfile.EuropaRFordRacing:
                if (_pipe == null)
                {
                    _pipe = new EuropaRPipe();
                }
                break;

            case EmulationProfile.EuropaRSegaRally3:
                if (_pipe == null)
                {
                    _pipe = new SegaRallyPipe();
                }
                break;

            case EmulationProfile.FastIo:
                if (_pipe == null)
                {
                    _pipe = new FastIOPipe();
                }
                break;

            case EmulationProfile.Theatrhythm:
                if (_pipe == null)
                {
                    _pipe = new FastIOPipe();
                }
                break;
            }

            _pipe?.Start(_runEmuOnly);

            var invertButtons =
                _gameProfile.ConfigValues.Any(x => x.FieldName == "Invert Buttons" && x.FieldValue == "1");

            if (invertButtons)
            {
                JvsPackageEmulator.InvertMaiMaiButtons = true;
            }

            if (_rawInputListener == null)
            {
                _rawInputListener = new RawInputListener();
            }

            bool flag = InputCode.ButtonMode == EmulationProfile.SegaJvsLetsGoIsland || InputCode.ButtonMode == EmulationProfile.SegaJvsLetsGoJungle || InputCode.ButtonMode == EmulationProfile.LuigisMansion;

            //fills 0, 2, 4, 6
            for (int i = 0; i <= 6; i += 2)
            {
                InputCode.AnalogBytes[i] = flag ? (byte)127 : (byte)0;
            }

            bool useMouseForGun =
                _gameProfile.ConfigValues.Any(x => x.FieldName == "UseMouseForGun" && x.FieldValue == "1");

            if (useMouseForGun && _gameProfile.GunGame)
            {
                _rawInputListener.ListenToDevice(_gameProfile.InvertedMouseAxis, _gameProfile);
            }

            switch (InputCode.ButtonMode)
            {
            case EmulationProfile.NamcoPokken:
                _controlSender = new Pokken();
                break;

            case EmulationProfile.ExBoard:
                _controlSender = new ExBoard();
                break;

            case EmulationProfile.GtiClub3:
                _controlSender = new GtiClub3();
                break;

            case EmulationProfile.Daytona3:
                _controlSender = new Daytona3();
                break;

            case EmulationProfile.GRID:
                _controlSender = new GRID();
                break;

            case EmulationProfile.RawThrillsFNF:
                _controlSender = new RawThrills();
                break;

            case EmulationProfile.LuigisMansion:
                _controlSender = new LuigisMansion();
                break;

            case EmulationProfile.GHA:
                _controlSender = new GHA();
                break;
            }

            _controlSender?.Start();

            if (_gameProfile.GunGame)
            {
                _killGunListener = false;
                if (_gameProfile.EmulationProfile == EmulationProfile.TooSpicy)
                {
                    new Thread(HandleGunControls2Spicy).Start();
                }
                else
                {
                    new Thread(HandleGunControls).Start();
                }
            }

            if (!_runEmuOnly)
            {
                WriteConfigIni();
            }

            if (InputCode.ButtonMode != EmulationProfile.EuropaRFordRacing &&
                InputCode.ButtonMode != EmulationProfile.EuropaRSegaRally3 &&
                InputCode.ButtonMode != EmulationProfile.Theatrhythm &&
                InputCode.ButtonMode != EmulationProfile.FastIo)
            {
                bool DualJvsEmulation = _gameProfile.ConfigValues.Any(x => x.FieldName == "DualJvsEmulation" && x.FieldValue == "1");

                // TODO: MAYBE MAKE THESE XML BASED?
                switch (InputCode.ButtonMode)
                {
                case EmulationProfile.VirtuaRLimit:
                case EmulationProfile.ChaseHq2:
                case EmulationProfile.WackyRaces:
                    JvsPackageEmulator.Taito          = true;
                    JvsPackageEmulator.JvsSwitchCount = 0x18;
                    break;

                case EmulationProfile.TaitoTypeXBattleGear:
                    JvsPackageEmulator.JvsVersion      = 0x30;
                    JvsPackageEmulator.TaitoStick      = true;
                    JvsPackageEmulator.TaitoBattleGear = true;
                    JvsPackageEmulator.JvsSwitchCount  = 0x18;
                    break;

                case EmulationProfile.TaitoTypeXGeneric:
                    JvsPackageEmulator.JvsVersion     = 0x30;
                    JvsPackageEmulator.TaitoStick     = true;
                    JvsPackageEmulator.JvsSwitchCount = 0x18;
                    break;

                case EmulationProfile.BorderBreak:
                    InputCode.AnalogBytes[0] = 0x7F;     // Center analog
                    InputCode.AnalogBytes[2] = 0x7F;     // Center analog
                    break;

                case EmulationProfile.NamcoPokken:
                    JvsPackageEmulator.JvsVersion         = 0x31;
                    JvsPackageEmulator.JvsCommVersion     = 0x31;
                    JvsPackageEmulator.JvsCommandRevision = 0x31;
                    JvsPackageEmulator.JvsIdentifier      = JVSIdentifiers.NBGI_Pokken;
                    JvsPackageEmulator.Namco = true;
                    break;

                case EmulationProfile.NamcoWmmt5:
                case EmulationProfile.NamcoMkdx:
                    JvsPackageEmulator.JvsVersion         = 0x31;
                    JvsPackageEmulator.JvsCommVersion     = 0x31;
                    JvsPackageEmulator.JvsCommandRevision = 0x31;
                    JvsPackageEmulator.JvsIdentifier      = JVSIdentifiers.NBGI_MarioKart3;
                    JvsPackageEmulator.Namco          = true;
                    JvsPackageEmulator.JvsSwitchCount = 0x18;
                    break;

                case EmulationProfile.NamcoMachStorm:
                    JvsPackageEmulator.JvsVersion         = 0x31;
                    JvsPackageEmulator.JvsCommVersion     = 0x31;
                    JvsPackageEmulator.JvsCommandRevision = 0x31;
                    JvsPackageEmulator.JvsIdentifier      = JVSIdentifiers.NamcoMultipurpose;
                    JvsPackageEmulator.Namco          = true;
                    JvsPackageEmulator.JvsSwitchCount = 0x18;
                    break;

                case EmulationProfile.DevThing1:
                    JvsPackageEmulator.JvsVersion       = 0x30;
                    JvsPackageEmulator.TaitoStick       = true;
                    JvsPackageEmulator.TaitoBattleGear  = true;
                    JvsPackageEmulator.DualJvsEmulation = true;
                    JvsPackageEmulator.JvsSwitchCount   = 0x18;
                    break;

                case EmulationProfile.VirtuaTennis4:
                    JvsPackageEmulator.DualJvsEmulation = DualJvsEmulation;
                    break;

                case EmulationProfile.ArcadeLove:
                    JvsPackageEmulator.DualJvsEmulation = true;
                    break;

                case EmulationProfile.LGS:
                    JvsPackageEmulator.JvsCommVersion     = 0x30;
                    JvsPackageEmulator.JvsVersion         = 0x30;
                    JvsPackageEmulator.JvsCommandRevision = 0x30;
                    JvsPackageEmulator.JvsIdentifier      = JVSIdentifiers.SegaLetsGoSafari;
                    JvsPackageEmulator.LetsGoSafari       = true;
                    JvsPackageEmulator.JvsSwitchCount     = 0x16;
                    break;
                }

                _serialPortHandler.StopListening();
                Thread.Sleep(1000);
                new Thread(() => _serialPortHandler.ListenPipe("TeknoParrot_JVS")).Start();
                new Thread(_serialPortHandler.ProcessQueue).Start();
            }

            if (useMouseForGun && _gameProfile.GunGame)
            {
                _diThread?.Abort(0);
                _diThread = null;
            }
            else
            {
                _diThread?.Abort(0);
                _diThread = CreateInputListenerThread(
                    _gameProfile.ConfigValues.Any(x => x.FieldName == "XInput" && x.FieldValue == "1"));
            }

            if (Lazydata.ParrotData.UseDiscordRPC)
            {
                DiscordRPC.UpdatePresence(new DiscordRPC.RichPresence
                {
                    details       = _gameProfile.GameName,
                    largeImageKey = _gameProfile.GameName.Replace(" ", "").ToLower(),
                    //https://stackoverflow.com/a/17632585
                    startTimestamp = (long)DateTime.UtcNow.Subtract(new DateTime(1970, 1, 1)).TotalSeconds
                });
            }

            // Wait before launching second thread.
            if (!_runEmuOnly)
            {
                Thread.Sleep(1000);
                CreateGameProcess();
            }
            else
            {
#if DEBUG
                if (jvsDebug != null)
                {
                    new Thread(() =>
                    {
                        while (true)
                        {
                            if (jvsDebug.JvsOverride)
                            {
                                Dispatcher.Invoke(DispatcherPriority.Normal, new ThreadStart(jvsDebug.DoCheckBoxesDude));
                            }
                        }
                    }).Start();
                }
#endif
            }
        }