596 lines
20 KiB
C#
596 lines
20 KiB
C#
//using Codice.CM.Client.Differences;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
|
|
namespace VirtualNes.Core
|
|
{
|
|
public class PAD
|
|
{
|
|
private NES nes;
|
|
private int excontroller_select;
|
|
private EXPAD expad;
|
|
private bool bStrobe;
|
|
private bool bSwapButton;
|
|
private bool bSwapPlayer;
|
|
private bool bZapperMode;
|
|
private VSType nVSSwapType;
|
|
private byte[] padbit = new byte[4];
|
|
private byte micbit;
|
|
private byte[] padbitsync = new byte[4];
|
|
private byte micbitsync;
|
|
private bool bBarcodeWorld;
|
|
private int[][] padcnt = new int[4][]
|
|
{
|
|
new int[2],new int[2],new int[2],new int[2],
|
|
};
|
|
|
|
public uint pad1bit, pad2bit, pad3bit, pad4bit;
|
|
|
|
private static int[] ren10fps = new int[6] { 1, 1, 1, 0, 0, 0 };
|
|
private static int[] ren15fps = new int[4] { 1, 1, 0, 0 };
|
|
private static int[] ren20fps = new int[3] { 1, 1, 0 };
|
|
private static int[] ren30fps = new int[2] { 1, 0 };
|
|
private static int[] renmask = new int[4] { 6, 4, 3, 2 };
|
|
public static Dictionary<int, int[]> rentbl = new Dictionary<int, int[]>()
|
|
{
|
|
{0,ren10fps },
|
|
{1,ren15fps },
|
|
{2,ren20fps },
|
|
{3,ren30fps },
|
|
};
|
|
|
|
public PAD(NES parent)
|
|
{
|
|
nes = parent;
|
|
excontroller_select = 0;
|
|
expad = null;
|
|
bStrobe = false;
|
|
bSwapButton = false;
|
|
bSwapPlayer = false;
|
|
bZapperMode = false;
|
|
nVSSwapType = VSType.VS_TYPE0;
|
|
|
|
padbit[0] = padbit[1] = padbit[2] = padbit[3] = 0;
|
|
micbit = 0;
|
|
|
|
padbitsync[0] = padbitsync[1] = padbitsync[2] = padbitsync[3] = 0;
|
|
micbitsync = 0;
|
|
}
|
|
|
|
internal byte Read(ushort addr)
|
|
{
|
|
byte data = 0x00;
|
|
|
|
if (addr == 0x4016)
|
|
{
|
|
data = (byte)(pad1bit & 1);
|
|
pad1bit >>= 1;
|
|
data |= (byte)(((pad3bit & 1)) << 1);
|
|
pad3bit >>= 1;
|
|
// Mic
|
|
if (!nes.rom.IsVSUNISYSTEM())
|
|
{
|
|
data |= micbitsync;
|
|
}
|
|
if (expad != null)
|
|
{
|
|
data |= expad.Read4016();
|
|
}
|
|
}
|
|
if (addr == 0x4017)
|
|
{
|
|
data = (byte)(pad2bit & 1);
|
|
pad2bit >>= 1;
|
|
data |= (byte)((pad4bit & 1) << 1);
|
|
pad4bit >>= 1;
|
|
|
|
if (expad != null)
|
|
{
|
|
data |= expad.Read4017();
|
|
}
|
|
|
|
if (bBarcodeWorld)
|
|
{
|
|
data |= nes.Barcode2();
|
|
}
|
|
}
|
|
|
|
return data;
|
|
}
|
|
public void Dispose() { }
|
|
|
|
internal void Write(ushort addr, byte data)
|
|
{
|
|
if (addr == 0x4016)
|
|
{
|
|
if ((data & 0x01) != 0)
|
|
{
|
|
bStrobe = true;
|
|
}
|
|
else if (bStrobe)
|
|
{
|
|
bStrobe = false;
|
|
|
|
Strobe();
|
|
if (expad != null)
|
|
{
|
|
expad.Strobe();
|
|
}
|
|
}
|
|
|
|
if (expad != null)
|
|
{
|
|
expad.Write4016(data);
|
|
}
|
|
}
|
|
if (addr == 0x4017)
|
|
{
|
|
if (expad != null)
|
|
{
|
|
expad.Write4017(data);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void Strobe()
|
|
{
|
|
// For VS-Unisystem
|
|
if (nes.rom.IsVSUNISYSTEM())
|
|
{
|
|
uint pad1 = (uint)(padbitsync[0] & 0xF3);
|
|
uint pad2 = (uint)(padbitsync[1] & 0xF3);
|
|
uint st1 = (uint)(padbitsync[0] & 0x08) >> 3;
|
|
uint st2 = (uint)(padbitsync[1] & 0x08) >> 3;
|
|
|
|
switch (nVSSwapType)
|
|
{
|
|
case VSType.VS_TYPE0:
|
|
pad1bit = pad1 | (st1 << 2);
|
|
pad2bit = pad2 | (st2 << 2);
|
|
break;
|
|
case VSType.VS_TYPE1:
|
|
pad1bit = pad2 | (st1 << 2);
|
|
pad2bit = pad1 | (st2 << 2);
|
|
break;
|
|
case VSType.VS_TYPE2:
|
|
pad1bit = pad1 | (st1 << 2) | (st2 << 3);
|
|
pad2bit = pad2;
|
|
break;
|
|
case VSType.VS_TYPE3:
|
|
pad1bit = pad2 | (st1 << 2) | (st2 << 3);
|
|
pad2bit = pad1;
|
|
break;
|
|
case VSType.VS_TYPE4:
|
|
pad1bit = pad1 | (st1 << 2) | 0x08; // 0x08=Start Protect
|
|
pad2bit = pad2 | (st2 << 2) | 0x08; // 0x08=Start Protect
|
|
break;
|
|
case VSType.VS_TYPE5:
|
|
pad1bit = pad2 | (st1 << 2) | 0x08; // 0x08=Start Protect
|
|
pad2bit = pad1 | (st2 << 2) | 0x08; // 0x08=Start Protect
|
|
break;
|
|
case VSType.VS_TYPE6:
|
|
pad1bit = pad1 | (st1 << 2) | (((uint)padbitsync[0] & 0x04) << 1);
|
|
pad2bit = pad2 | (st2 << 2) | (((uint)padbitsync[1] & 0x04) << 1);
|
|
break;
|
|
case VSType.VS_TYPEZ:
|
|
pad1bit = 0;
|
|
pad2bit = 0;
|
|
break;
|
|
}
|
|
|
|
// Coin 2偲旐傞堊偵徚偡
|
|
micbit = 0;
|
|
}
|
|
else
|
|
{
|
|
if (Supporter.Config.emulator.bFourPlayer)
|
|
{
|
|
// NES type
|
|
pad1bit = padbitsync[0] | ((uint)padbitsync[2] << 8) | 0x00080000;
|
|
pad2bit = padbitsync[1] | ((uint)padbitsync[3] << 8) | 0x00040000;
|
|
}
|
|
else
|
|
{
|
|
// Famicom type
|
|
pad1bit = padbitsync[0];
|
|
pad2bit = padbitsync[1];
|
|
}
|
|
}
|
|
pad3bit = padbitsync[2];
|
|
pad4bit = padbitsync[3];
|
|
}
|
|
|
|
internal void Reset()
|
|
{
|
|
pad1bit = pad2bit = 0;
|
|
bStrobe = false;
|
|
|
|
bBarcodeWorld = false;
|
|
|
|
for (int x = 0; x < 4; x++)
|
|
{
|
|
for (int y = 0; y < 2; y++)
|
|
{
|
|
padcnt[x][y] = 0;
|
|
}
|
|
}
|
|
|
|
// Select Extension Devices
|
|
uint crc = nes.rom.GetPROM_CRC();
|
|
|
|
if (crc == 0xfbfc6a6c // Adventures of Bayou Billy, The(E)
|
|
|| crc == 0xcb275051 // Adventures of Bayou Billy, The(U)
|
|
|| crc == 0xfb69c131 // Baby Boomer(Unl)(U)
|
|
|| crc == 0xf2641ad0 // Barker Bill's Trick Shooting(U)
|
|
|| crc == 0xbc1dce96 // Chiller (Unl)(U)
|
|
|| crc == 0x90ca616d // Duck Hunt(JUE)
|
|
|| crc == 0x59e3343f // Freedom Force(U)
|
|
|| crc == 0x242a270c // Gotcha!(U)
|
|
|| crc == 0x7b5bd2de // Gumshoe(UE)
|
|
|| crc == 0x255b129c // Gun Sight(J)
|
|
|| crc == 0x8963ae6e // Hogan's Alley(JU)
|
|
|| crc == 0x51d2112f // Laser Invasion(U)
|
|
|| crc == 0x0a866c94 // Lone Ranger, The(U)
|
|
// || crc == 0xe4c04eea // Mad City(J)
|
|
|| crc == 0x9eef47aa // Mechanized Attack(U)
|
|
|| crc == 0xc2db7551 // Shooting Range(U)
|
|
|| crc == 0x163e86c0 // To The Earth(U)
|
|
|| crc == 0x42d893e4 // Operation Wolf(J)
|
|
|| crc == 0x1388aeb9 // Operation Wolf(U)
|
|
|| crc == 0x0d3cf705 // Wild Gunman(J)
|
|
|| crc == 0x389960db)
|
|
{ // Wild Gunman(JUE)
|
|
SetExController(EXCONTROLLER.EXCONTROLLER_ZAPPER);
|
|
}
|
|
if (crc == 0x35893b67 // Arkanoid(J)
|
|
|| crc == 0x6267fbd1)
|
|
{ // Arkanoid 2(J)
|
|
SetExController(EXCONTROLLER.EXCONTROLLER_PADDLE);
|
|
}
|
|
if (crc == 0xff6621ce // Hyper Olympic(J)
|
|
|| crc == 0xdb9418e8 // Hyper Olympic(Tonosama Ban)(J)
|
|
|| crc == 0xac98cd70)
|
|
{ // Hyper Sports(J)
|
|
SetExController(EXCONTROLLER.EXCONTROLLER_HYPERSHOT);
|
|
}
|
|
if (crc == 0xf9def527 // Family BASIC(Ver2.0)
|
|
|| crc == 0xde34526e // Family BASIC(Ver2.1a)
|
|
|| crc == 0xf050b611 // Family BASIC(Ver3)
|
|
|| crc == 0x3aaeed3f // Family BASIC(Ver3)(Alt)
|
|
|| crc == 0x868FCD89 // Family BASIC(Ver1.0)
|
|
|| crc == 0x2D6B7E5A // PLAYBOX BASIC(J) (Prototype_v0.0)
|
|
|| crc == 0xDA03D908)
|
|
{ // PLAYBOX BASIC (J)
|
|
SetExController(EXCONTROLLER.EXCONTROLLER_KEYBOARD);
|
|
}
|
|
if (crc == 0x589b6b0d // Supor Computer V3.0
|
|
|| crc == 0x8b265862 // Supor English
|
|
|| crc == 0x41401c6d // Supor Computer V4.0
|
|
|| crc == 0x82F1Fb96 // Supor Computer(Russia) V1.0
|
|
|| crc == 0xd5d6eac4)
|
|
{ // EDU(C) Computer
|
|
SetExController(EXCONTROLLER.EXCONTROLLER_SUPOR_KEYBOARD);
|
|
nes.SetVideoMode(true);
|
|
}
|
|
if (crc == 0xc68363f6 // Crazy Climber(J)
|
|
|| crc == 0x2989ead6 // Smash TV(U) [!]
|
|
|| crc == 0x0b8f8128)
|
|
{ // Smash TV(E) [!]
|
|
SetExController(EXCONTROLLER.EXCONTROLLER_CRAZYCLIMBER);
|
|
}
|
|
if (crc == 0x20d22251)
|
|
{ // Top rider(J)
|
|
SetExController(EXCONTROLLER.EXCONTROLLER_TOPRIDER);
|
|
}
|
|
if (crc == 0x0cd00488)
|
|
{ // Space Shadow(J)
|
|
SetExController(EXCONTROLLER.EXCONTROLLER_SPACESHADOWGUN);
|
|
}
|
|
|
|
if (crc == 0x8c8fa83b // Family Trainer - Athletic World (J)
|
|
|| crc == 0x7e704a14 // Family Trainer - Jogging Race (J)
|
|
|| crc == 0x2330a5d3)
|
|
{ // Family Trainer - Rairai Kyonshiizu (J)
|
|
SetExController(EXCONTROLLER.EXCONTROLLER_FAMILYTRAINER_A);
|
|
}
|
|
if (crc == 0xf8da2506 // Family Trainer - Aerobics Studio (J)
|
|
|| crc == 0xca26a0f1 // Family Trainer - Dai Undoukai (J)
|
|
|| crc == 0x28068b8c // Family Trainer - Fuuun Takeshi Jou 2 (J)
|
|
|| crc == 0x10bb8f9a // Family Trainer - Manhattan Police (J)
|
|
|| crc == 0xad3df455 // Family Trainer - Meiro Dai Sakusen (J)
|
|
|| crc == 0x8a5b72c0 // Family Trainer - Running Stadium (J)
|
|
|| crc == 0x59794f2d)
|
|
{ // Family Trainer - Totsugeki Fuuun Takeshi Jou (J)
|
|
SetExController(EXCONTROLLER.EXCONTROLLER_FAMILYTRAINER_B);
|
|
}
|
|
if (crc == 0x9fae4d46 // Ide Yousuke Meijin no Jissen Mahjong (J)
|
|
|| crc == 0x7b44fb2a)
|
|
{ // Ide Yousuke Meijin no Jissen Mahjong 2 (J)
|
|
SetExController(EXCONTROLLER.EXCONTROLLER_MAHJANG);
|
|
}
|
|
if (crc == 0x786148b6)
|
|
{ // Exciting Boxing (J)
|
|
SetExController(EXCONTROLLER.EXCONTROLLER_EXCITINGBOXING);
|
|
}
|
|
if (crc == 0xc3c0811d // Oeka Kids - Anpanman no Hiragana Daisuki (J)
|
|
|| crc == 0x9d048ea4)
|
|
{ // Oeka Kids - Anpanman to Oekaki Shiyou!! (J)
|
|
SetExController(EXCONTROLLER.EXCONTROLLER_OEKAKIDS_TABLET);
|
|
}
|
|
|
|
if (crc == 0x67898319)
|
|
{ // Barcode World (J)
|
|
bBarcodeWorld = true;
|
|
}
|
|
|
|
// VS-Unisystem
|
|
if (nes.rom.IsVSUNISYSTEM())
|
|
{
|
|
if (crc == 0xff5135a3 // VS Hogan's Alley
|
|
|| crc == 0xed588f00 // VS Duck Hunt
|
|
|| crc == 0x17ae56be)
|
|
{ // VS Freedom Force
|
|
SetExController(EXCONTROLLER.EXCONTROLLER_VSZAPPER);
|
|
}
|
|
else
|
|
{
|
|
SetExController(EXCONTROLLER.EXCONTROLLER_VSUNISYSTEM);
|
|
}
|
|
}
|
|
|
|
if (crc == 0x21b099f3)
|
|
{ // Gyromite (JUE)
|
|
SetExController(EXCONTROLLER.EXCONTROLLER_GYROMITE);
|
|
}
|
|
}
|
|
|
|
internal void SetExController(EXCONTROLLER type)
|
|
{
|
|
excontroller_select = (int)type;
|
|
|
|
expad?.Dispose();
|
|
expad = null;
|
|
|
|
bZapperMode = false;
|
|
|
|
// ExPad Instance create
|
|
switch (type)
|
|
{
|
|
case EXCONTROLLER.EXCONTROLLER_ZAPPER:
|
|
expad = new EXPAD_Zapper(nes);
|
|
bZapperMode = true;
|
|
break;
|
|
case EXCONTROLLER.EXCONTROLLER_PADDLE:
|
|
expad = new EXPAD_Paddle(nes);
|
|
break;
|
|
case EXCONTROLLER.EXCONTROLLER_HYPERSHOT:
|
|
expad = new EXPAD_HyperShot(nes);
|
|
break;
|
|
case EXCONTROLLER.EXCONTROLLER_KEYBOARD:
|
|
expad = new EXPAD_Keyboard(nes);
|
|
break;
|
|
case EXCONTROLLER.EXCONTROLLER_SUPOR_KEYBOARD:
|
|
expad = new EXPAD_Supor_Keyboard(nes);
|
|
break;
|
|
case EXCONTROLLER.EXCONTROLLER_CRAZYCLIMBER:
|
|
expad = new EXPAD_CrazyClimber(nes);
|
|
break;
|
|
case EXCONTROLLER.EXCONTROLLER_TOPRIDER:
|
|
expad = new EXPAD_Toprider(nes);
|
|
break;
|
|
case EXCONTROLLER.EXCONTROLLER_SPACESHADOWGUN:
|
|
expad = new EXPAD_SpaceShadowGun(nes);
|
|
bZapperMode = true;
|
|
break;
|
|
case EXCONTROLLER.EXCONTROLLER_FAMILYTRAINER_A:
|
|
case EXCONTROLLER.EXCONTROLLER_FAMILYTRAINER_B:
|
|
expad = new EXPAD_FamlyTrainer(nes);
|
|
break;
|
|
case EXCONTROLLER.EXCONTROLLER_EXCITINGBOXING:
|
|
expad = new EXPAD_ExcitingBoxing(nes);
|
|
break;
|
|
case EXCONTROLLER.EXCONTROLLER_MAHJANG:
|
|
expad = new EXPAD_Mahjang(nes);
|
|
break;
|
|
case EXCONTROLLER.EXCONTROLLER_OEKAKIDS_TABLET:
|
|
expad = new EXPAD_OekakidsTablet(nes);
|
|
break;
|
|
case EXCONTROLLER.EXCONTROLLER_TURBOFILE:
|
|
expad = new EXPAD_TurboFile(nes);
|
|
break;
|
|
case EXCONTROLLER.EXCONTROLLER_VSUNISYSTEM:
|
|
expad = new EXPAD_VSUnisystem(nes);
|
|
break;
|
|
case EXCONTROLLER.EXCONTROLLER_VSZAPPER:
|
|
expad = new EXPAD_VSZapper(nes);
|
|
bZapperMode = true;
|
|
break;
|
|
|
|
case EXCONTROLLER.EXCONTROLLER_GYROMITE:
|
|
expad = new EXPAD_Gyromite(nes);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (expad != null)
|
|
{
|
|
expad.Reset();
|
|
}
|
|
}
|
|
|
|
public void Sync(ControllerState state)
|
|
{
|
|
padbit[0] = SyncSub(0, state);
|
|
padbit[1] = SyncSub(1, state);
|
|
padbit[2] = SyncSub(2, state);
|
|
padbit[3] = SyncSub(3, state);
|
|
|
|
// Mic
|
|
micbit = 0;
|
|
if (state.HasButton(1, EnumButtonType.MIC)) micbit |= 4;
|
|
|
|
// For Excontroller
|
|
if (expad != null)
|
|
{
|
|
expad.Sync();
|
|
}
|
|
}
|
|
|
|
private byte SyncSub(int no, ControllerState state)
|
|
{
|
|
ushort bit = 0;
|
|
|
|
// Up
|
|
if (state.HasButton(no, EnumButtonType.UP))
|
|
bit |= 1 << 4;
|
|
// Down
|
|
if (state.HasButton(no, EnumButtonType.DOWN))
|
|
bit |= 1 << 5;
|
|
// Left
|
|
if (state.HasButton(no, EnumButtonType.LEFT))
|
|
bit |= 1 << 6;
|
|
// Right
|
|
if (state.HasButton(no, EnumButtonType.RIGHT))
|
|
bit |= 1 << 7;
|
|
|
|
// 同時入力を禁止する
|
|
// if( (bit&((1<<4)|(1<<5))) == ((1<<4)|(1<<5)) )
|
|
// bit &= ~((1<<4)|(1<<5));
|
|
if ((bit & ((1 << 6) | (1 << 7))) == ((1 << 6) | (1 << 7)))
|
|
bit = (byte)(bit & ~((1 << 6) | (1 << 7)));
|
|
|
|
// A
|
|
if (state.HasButton(no, EnumButtonType.A)) bit |= 1 << 0;
|
|
// B
|
|
if (state.HasButton(no, EnumButtonType.B)) bit |= 1 << 1;
|
|
|
|
// Select
|
|
if (state.HasButton(no, EnumButtonType.SELECT)) bit |= 1 << 2;
|
|
// Start
|
|
if (state.HasButton(no, EnumButtonType.START)) bit |= 1 << 3;
|
|
|
|
// A rapid setup
|
|
if ((bit & (1 << 8)) != 0)
|
|
{
|
|
int spd = Supporter.Config.controller.nRapid[no][0];
|
|
if (spd >= 3) spd = 3;
|
|
|
|
int[] tbl = rentbl[spd];
|
|
|
|
if (padcnt[no][0] >= renmask[spd])
|
|
padcnt[no][0] = 0;
|
|
|
|
if ((tbl[padcnt[no][0]]) != 0)
|
|
bit |= (1 << 0);
|
|
else
|
|
bit = (byte)(bit & ~(1 << 0));
|
|
|
|
padcnt[no][0]++;
|
|
}
|
|
else
|
|
{
|
|
padcnt[no][0] = 0;
|
|
}
|
|
// B rapid setup
|
|
if ((bit & (1 << 9)) != 0)
|
|
{
|
|
int spd = Supporter.Config.controller.nRapid[no][1];
|
|
if (spd >= 3) spd = 3;
|
|
int[] tbl = rentbl[spd];
|
|
|
|
if (padcnt[no][1] >= renmask[spd])
|
|
padcnt[no][1] = 0;
|
|
|
|
if ((tbl[padcnt[no][1]]) != 0)
|
|
bit |= (1 << 1);
|
|
else
|
|
bit = (byte)(bit & ~(1 << 1));
|
|
|
|
padcnt[no][1]++;
|
|
}
|
|
else
|
|
{
|
|
padcnt[no][1] = 0;
|
|
}
|
|
|
|
return (byte)(bit & 0xFF);
|
|
}
|
|
|
|
internal bool IsZapperMode()
|
|
{
|
|
return bZapperMode;
|
|
}
|
|
|
|
internal void VSync()
|
|
{
|
|
padbitsync[0] = padbit[0];
|
|
padbitsync[1] = padbit[1];
|
|
padbitsync[2] = padbit[2];
|
|
padbitsync[3] = padbit[3];
|
|
micbitsync = micbit;
|
|
}
|
|
|
|
internal uint GetSyncData()
|
|
{
|
|
uint ret;
|
|
ret = (uint)(padbit[0] | (padbit[1] << 8) | (padbit[2] << 16) | (padbit[3] << 24));
|
|
ret |= (uint)(micbit << 8);
|
|
return ret;
|
|
}
|
|
|
|
internal void SetSyncData(uint data)
|
|
{
|
|
micbit = (byte)((data & 0x00000400) >> 8);
|
|
padbit[0] = (byte)data;
|
|
padbit[1] = (byte)(data >> 8);
|
|
padbit[2] = (byte)(data >> 16);
|
|
padbit[3] = (byte)(data >> 24);
|
|
}
|
|
|
|
internal int GetExController()
|
|
{
|
|
return excontroller_select;
|
|
}
|
|
}
|
|
|
|
public enum VSType
|
|
{
|
|
VS_TYPE0 = 0, // SELECT1P=START1P/SELECT2P=START2P 1P/2P No reverse
|
|
VS_TYPE1, // SELECT1P=START1P/SELECT2P=START2P 1P/2P Reverse
|
|
VS_TYPE2, // SELECT1P=START1P/START1P =START2P 1P/2P No reverse
|
|
VS_TYPE3, // SELECT1P=START1P/START1P =START2P 1P/2P Reverse
|
|
VS_TYPE4, // SELECT1P=START1P/SELECT2P=START2P 1P/2P No reverse (Protection)
|
|
VS_TYPE5, // SELECT1P=START1P/SELECT2P=START2P 1P/2P Reverse (Protection)
|
|
VS_TYPE6, // SELECT1P=START1P/SELECT2P=START2P 1P/2P Reverse (For Golf)
|
|
VS_TYPEZ, // ZAPPER
|
|
}
|
|
|
|
public enum EXCONTROLLER
|
|
{
|
|
EXCONTROLLER_NONE = 0,
|
|
EXCONTROLLER_PADDLE,
|
|
EXCONTROLLER_HYPERSHOT,
|
|
EXCONTROLLER_ZAPPER,
|
|
EXCONTROLLER_KEYBOARD,
|
|
EXCONTROLLER_CRAZYCLIMBER,
|
|
EXCONTROLLER_TOPRIDER,
|
|
EXCONTROLLER_SPACESHADOWGUN,
|
|
|
|
EXCONTROLLER_FAMILYTRAINER_A,
|
|
EXCONTROLLER_FAMILYTRAINER_B,
|
|
EXCONTROLLER_EXCITINGBOXING,
|
|
EXCONTROLLER_MAHJANG,
|
|
EXCONTROLLER_OEKAKIDS_TABLET,
|
|
EXCONTROLLER_TURBOFILE,
|
|
|
|
EXCONTROLLER_VSUNISYSTEM,
|
|
EXCONTROLLER_VSZAPPER,
|
|
|
|
EXCONTROLLER_GYROMITE,
|
|
EXCONTROLLER_STACKUP,
|
|
|
|
EXCONTROLLER_SUPOR_KEYBOARD,
|
|
}
|
|
}
|