[fceu.git] / input.c

/* FCE Ultra - NES/Famicom Emulator
 *
 * Copyright notice for this file:
 *  Copyright (C) 1998 BERO
 *  Copyright (C) 2002 Ben Parnell
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
#include <string.h>
#include "types.h"
#include "x6502.h"

#include "fce.h"
#include "sound.h"
#include "netplay.h"
#include "svga.h"

#include "input.h"
#include "state.h"
#include "movie.h"

#include "fds.h"
#include "vsuni.h"
#include "dprintf.h"

extern INPUTC *FCEU_InitZapper(int w);
extern INPUTC *FCEU_InitPowerpadA(int w);
extern INPUTC *FCEU_InitArkanoid(int w);

extern INPUTCFC *FCEU_InitArkanoidFC(void);
extern INPUTCFC *FCEU_InitSpaceShadow(void);
extern INPUTCFC *FCEU_InitFKB(void);
static uint8 joy_readbit[2];
static uint8 joy[4]={0,0,0,0};
static uint8 LastStrobe;

static int FSDisable=0;	/* Set to 1 if NES-style four-player adapter is disabled. */
static int JPAttrib[2]={0,0};
static int JPType[2]={0,0};
static void *InputDataPtr[2];

static int JPAttribFC=0;
static int JPTypeFC=0;
static void *InputDataPtrFC;

void (*InputScanlineHook)(uint8 *bg, uint8 *spr, uint32 linets, int final);

static INPUTC DummyJPort={0,0,0,0,0};
static INPUTC *JPorts[2]={&DummyJPort,&DummyJPort};
static INPUTCFC *FCExp=0;

/* This function is a quick hack to get the NSF player to use emulated gamepad
   input.
*/
uint8 FCEU_GetJoyJoy(void)
{
 return(joy[0]|joy[1]|joy[2]|joy[3]);
}

static uint8 FP_FASTAPASS(1) ReadGPVS(int w)
{
                uint8 ret=0;

		if(joy_readbit[w]>=8)
		 ret=1;
		else
		{
                 ret = ((joy[w]>>(joy_readbit[w]))&1);
                 joy_readbit[w]++;
		}
                return ret;
}

static uint8 FP_FASTAPASS(1) ReadGP(int w)
{
                uint8 ret;
                //if(JoyMulti)
		//{
                 //ret = ((joy[w]>>(joy_readbit[w]))&1)|
                 //(((joy[w]>>(joy_readbit[w]+8))&1)<<1);
                 //if(joy_readbit[w]>8) ret=0;
		//}
                ret = ((joy[w]>>(joy_readbit[w]))&1);
		if(FSDisable)
		{
	  	 if(joy_readbit[w]>=8) ret|=1;
		}
		else
		{
                 if(joy_readbit[w]==19-w) ret|=1;
		}
		joy_readbit[w]++;
                return ret;
}

static DECLFR(JPRead)
{
	uint8 ret=0;

	if(JPorts[A&1]->Read)
	 ret|=JPorts[A&1]->Read(A&1);

	if(FCExp)
	 if(FCExp->Read)
	  ret=FCExp->Read(A&1,ret);

	ret|=X.DB&0xC0;
	dprintf("JPRead %i %02x", A&1, ret);
	return(ret);
}

static DECLFW(B4016)
{
	if(FCExp)
	 if(FCExp->Write)
	  FCExp->Write(V&7);

	if(JPorts[0]->Write)
	 JPorts[0]->Write(V&1);
        if(JPorts[1]->Write)
         JPorts[1]->Write(V&1);

        if((LastStrobe&1) && (!(V&1)))
        {
	 /* This strobe code is just for convenience.  If it were
	    with the code in input / *.c, it would more accurately represent
	    what's really going on.  But who wants accuracy? ;)
	    Seriously, though, this shouldn't be a problem.
	 */
	 if(JPorts[0]->Strobe)
	  JPorts[0]->Strobe(0);
         if(JPorts[1]->Strobe)
          JPorts[1]->Strobe(1);
	 if(FCExp)
	  if(FCExp->Strobe)
	   FCExp->Strobe();
	 }
         LastStrobe=V&1;
}

static void FP_FASTAPASS(1) StrobeGP(int w)
{
	joy_readbit[w]=0;
}

static INPUTC GPC={ReadGP,0,StrobeGP,0,0,0};
static INPUTC GPCVS={ReadGPVS,0,StrobeGP,0,0,0};

void DrawInput(uint8 *buf)
{
 int x;

 for(x=0;x<2;x++)
  if(JPorts[x]->Draw)
   JPorts[x]->Draw(x,buf,JPAttrib[x]);
 if(FCExp)
  if(FCExp->Draw)
   FCExp->Draw(buf,JPAttribFC);
}

void UpdateInput(void)
{
	int x;

	for(x=0;x<2;x++)
	{
	 switch(JPType[x])
	 {
	  case SI_GAMEPAD:
		if(!x) joy[0]=*(uint16 *)InputDataPtr[0];
		else joy[1]=*(uint16 *)InputDataPtr[1];
		break;
	  default:
		if(JPorts[x]->Update)
		 JPorts[x]->Update(x,InputDataPtr[x],JPAttrib[x]);
		break;
	 }
	}
	if(FCExp)
	 if(FCExp->Update)
	  FCExp->Update(InputDataPtrFC,JPAttribFC);

        if(FCEUGameInfo.type==GIT_VSUNI)
        {
	 uint16 t=joy[0];
	 joy[0]=(joy[0]&0xC)|(joy[1]&0xF3);
	 joy[1]=(joy[1]&0xC)|(t&0xF3);
	 if(coinon) coinon--;
	}
	#ifdef NETWORK
	if(netplay) NetplayUpdate(&joy[0],&joy[1]);
	#endif
	if (current < 0) FCEUMOV_AddJoy(joy);
	else framecount++; // for debug
	//FlushCommandQueue();
}

static DECLFR(VSUNIRead0)
{
	uint8 ret=0;

        if(JPorts[0]->Read)
         ret|=(JPorts[0]->Read(0))&1;

	ret|=(vsdip&3)<<3;
	if(coinon)
	 ret|=0x4;
	return ret;
}

static DECLFR(VSUNIRead1)
{
        uint8 ret=0;

        if(JPorts[1]->Read)
         ret|=(JPorts[1]->Read(1))&1;
        ret|=vsdip&0xFC;
        return ret;
}

static void SLHLHook(uint8 *bg, uint8 *spr, uint32 linets, int final)
{
 int x;

 for(x=0;x<2;x++)
  if(JPorts[x]->SLHook)
   JPorts[x]->SLHook(x,bg,spr,linets,final);
 if(FCExp)
  if(FCExp->SLHook)
   FCExp->SLHook(bg,spr,linets,final);
}

static void CheckSLHook(void)
{
        InputScanlineHook=0;
        if(JPorts[0]->SLHook || JPorts[1]->SLHook)
         InputScanlineHook=SLHLHook;
        if(FCExp)
         if(FCExp->SLHook)
          InputScanlineHook=SLHLHook;
}

static void FASTAPASS(1) SetInputStuff(int x)
{
 	 switch(JPType[x])
	 {
	  case SI_GAMEPAD:
           if(FCEUGameInfo.type==GIT_VSUNI)
	    JPorts[x]=&GPCVS;
	   else
	    JPorts[x]=&GPC;
	  break;
	  case SI_ARKANOID:JPorts[x]=FCEU_InitArkanoid(x);break;
	  case SI_ZAPPER:JPorts[x]=FCEU_InitZapper(x);break;
          case SI_POWERPADA:JPorts[x]=FCEU_InitPowerpadA(x);break;
	  case SI_NONE:JPorts[x]=&DummyJPort;break;
         }

	CheckSLHook();
}

static uint8 F4ReadBit[2];
static void StrobeFami4(void)
{
 F4ReadBit[0]=F4ReadBit[1]=0;
}

static uint8 FP_FASTAPASS(2) ReadFami4(int w, uint8 ret)
{
 ret&=1;

 ret |= ((joy[w]>>(F4ReadBit[w]+8))&1)<<1;
 if(F4ReadBit[w]>=8) ret|=2;
 else F4ReadBit[w]++;

 return(ret);
}

static INPUTCFC FAMI4C={ReadFami4,0,StrobeFami4,0,0,0};
static void SetInputStuffFC(void)
{
        switch(JPTypeFC)
        {
         case SIFC_NONE:FCExp=0;break;
         case SIFC_ARKANOID:FCExp=FCEU_InitArkanoidFC();break;
	 case SIFC_SHADOW:FCExp=FCEU_InitSpaceShadow();break;
         case SIFC_4PLAYER:FCExp=&FAMI4C;memset(&F4ReadBit,0,sizeof(F4ReadBit));break;
	 case SIFC_FKB:FCExp=FCEU_InitFKB();break;
        }
	CheckSLHook();
}

// VS Unisystem code called after SetInputMap() hooks B4016.  Need to
// rewrite code to make this more sane?

void InitializeInput(void)
{
	memset(joy_readbit,0,sizeof(joy_readbit));
	memset(joy,0,sizeof(joy));
        LastStrobe=0;

        if(FCEUGameInfo.type==GIT_VSUNI)
        {
         SetReadHandler(0x4016,0x4016,VSUNIRead0);
         SetReadHandler(0x4017,0x4017,VSUNIRead1);
        }
        else
         SetReadHandler(0x4016,0x4017,JPRead);
        SetWriteHandler(0x4016,0x4016,B4016);

        SetInputStuff(0);
        SetInputStuff(1);
	SetInputStuffFC();
}

void FCEUI_SetInput(int port, int type, void *ptr, int attrib)
{
 JPAttrib[port]=attrib;
 JPType[port]=type;
 InputDataPtr[port]=ptr;
 SetInputStuff(port);
}

void FCEUI_DisableFourScore(int s)
{
 FSDisable=s;
}

void FCEUI_SetInputFC(int type, void *ptr, int attrib)
{
 JPAttribFC=attrib;
 JPTypeFC=type;
 InputDataPtrFC=ptr;
 SetInputStuffFC();
}

void FCEU_DoSimpleCommand(int cmd)
{
   printf("FCEU_DoSimpleCommand: %i\n", cmd);
 switch(cmd)
 {
   case FCEUNPCMD_FDSINSERT: FCEU_FDSInsert();break;
   case FCEUNPCMD_FDSSELECT: FCEU_FDSSelect();break;
//   case FCEUNPCMD_FDSEJECT: FCEU_FDSEject();break;
   case FCEUNPCMD_VSUNICOIN: FCEU_VSUniCoin(); break;
   case FCEUNPCMD_VSUNIDIP0 ... (FCEUNPCMD_VSUNIDIP0 + 7): FCEU_VSUniToggleDIP(cmd - FCEUNPCMD_VSUNIDIP0);break;
   case FCEUNPCMD_POWER: PowerNES();break;
   case FCEUNPCMD_RESET: ResetNES();break;
   default: printf("FCEU_DoSimpleCommand: can't handle cmd %i\n", cmd); break;
 }
}

void FCEU_QSimpleCommand(int cmd)
{
// if(FCEUnetplay)
//  FCEUNET_SendCommand(cmd, 0);
// else
 {
  // totally wrong:
//  if(!FCEUMOV_IsPlaying())
//   FCEU_DoSimpleCommand(cmd);
//  else
//   FCEUMOV_AddCommand(cmd);

  FCEU_DoSimpleCommand(cmd);
//  if(FCEUMOV_IsRecording())
//   FCEUMOV_AddCommand(cmd);
 }
}

void FCEUI_FDSSelect(void)
{
 FCEU_QSimpleCommand(FCEUNPCMD_FDSSELECT);
}

int FCEUI_FDSInsert(void)
{
 FCEU_QSimpleCommand(FCEUNPCMD_FDSINSERT);
 return(1);
}

/*
int FCEUI_FDSEject(void)
{
    FCEU_QSimpleCommand(FCEUNPCMD_FDSEJECT);
    return(1);
}
*/
void FCEUI_VSUniToggleDIP(int w)
{
 FCEU_QSimpleCommand(FCEUNPCMD_VSUNIDIP0 + w);
}

void FCEUI_VSUniCoin(void)
{
 FCEU_QSimpleCommand(FCEUNPCMD_VSUNICOIN);
}

void FCEUI_ResetNES(void)
{
	FCEU_QSimpleCommand(FCEUNPCMD_RESET);
}

void FCEUI_PowerNES(void)
{
        FCEU_QSimpleCommand(FCEUNPCMD_POWER);
}


SFORMAT FCEUCTRL_STATEINFO[]={
 { joy_readbit, 2, "JYRB"},
 { joy, 4, "JOYS"},
 { &LastStrobe, 1, "LSTS"},
 { 0 }
};
Commit	Line	Data
	1	/* FCE Ultra - NES/Famicom Emulator
	2	*
	3	* Copyright notice for this file:
	4	* Copyright (C) 1998 BERO
	5	* Copyright (C) 2002 Ben Parnell
	6	*
	7	* This program is free software; you can redistribute it and/or modify
	8	* it under the terms of the GNU General Public License as published by
	9	* the Free Software Foundation; either version 2 of the License, or
	10	* (at your option) any later version.
	11	*
	12	* This program is distributed in the hope that it will be useful,
	13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	* GNU General Public License for more details.
	16	*
	17	* You should have received a copy of the GNU General Public License
	18	* along with this program; if not, write to the Free Software
	19	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	20	*/
	21	#include <string.h>
	22	#include "types.h"
	23	#include "x6502.h"
	24
	25	#include "fce.h"
	26	#include "sound.h"
	27	#include "netplay.h"
	28	#include "svga.h"
	29
	30	#include "input.h"
	31	#include "state.h"
	32	#include "movie.h"
	33
	34	#include "fds.h"
	35	#include "vsuni.h"
	36	#include "dprintf.h"
	37
	38	extern INPUTC *FCEU_InitZapper(int w);
	39	extern INPUTC *FCEU_InitPowerpadA(int w);
	40	extern INPUTC *FCEU_InitArkanoid(int w);
	41
	42	extern INPUTCFC *FCEU_InitArkanoidFC(void);
	43	extern INPUTCFC *FCEU_InitSpaceShadow(void);
	44	extern INPUTCFC *FCEU_InitFKB(void);
	45	static uint8 joy_readbit[2];
	46	static uint8 joy[4]={0,0,0,0};
	47	static uint8 LastStrobe;
	48
	49	static int FSDisable=0; /* Set to 1 if NES-style four-player adapter is disabled. */
	50	static int JPAttrib[2]={0,0};
	51	static int JPType[2]={0,0};
	52	static void *InputDataPtr[2];
	53
	54	static int JPAttribFC=0;
	55	static int JPTypeFC=0;
	56	static void *InputDataPtrFC;
	57
	58	void (InputScanlineHook)(uint8 bg, uint8 *spr, uint32 linets, int final);
	59
	60	static INPUTC DummyJPort={0,0,0,0,0};
	61	static INPUTC *JPorts[2]={&DummyJPort,&DummyJPort};
	62	static INPUTCFC *FCExp=0;
	63
	64	/* This function is a quick hack to get the NSF player to use emulated gamepad
	65	input.
	66	*/
	67	uint8 FCEU_GetJoyJoy(void)
	68	{
	69	return(joy[0]\|joy[1]\|joy[2]\|joy[3]);
	70	}
	71
	72	static uint8 FP_FASTAPASS(1) ReadGPVS(int w)
	73	{
	74	uint8 ret=0;
	75
	76	if(joy_readbit[w]>=8)
	77	ret=1;
	78	else
	79	{
	80	ret = ((joy[w]>>(joy_readbit[w]))&1);
	81	joy_readbit[w]++;
	82	}
	83	return ret;
	84	}
	85
	86	static uint8 FP_FASTAPASS(1) ReadGP(int w)
	87	{
	88	uint8 ret;
	89	//if(JoyMulti)
	90	//{
	91	//ret = ((joy[w]>>(joy_readbit[w]))&1)\|
	92	//(((joy[w]>>(joy_readbit[w]+8))&1)<<1);
	93	//if(joy_readbit[w]>8) ret=0;
	94	//}
	95	ret = ((joy[w]>>(joy_readbit[w]))&1);
	96	if(FSDisable)
	97	{
	98	if(joy_readbit[w]>=8) ret\|=1;
	99	}
	100	else
	101	{
	102	if(joy_readbit[w]==19-w) ret\|=1;
	103	}
	104	joy_readbit[w]++;
	105	return ret;
	106	}
	107
	108	static DECLFR(JPRead)
	109	{
	110	uint8 ret=0;
	111
	112	if(JPorts[A&1]->Read)
	113	ret\|=JPorts[A&1]->Read(A&1);
	114
	115	if(FCExp)
	116	if(FCExp->Read)
	117	ret=FCExp->Read(A&1,ret);
	118
	119	ret\|=X.DB&0xC0;
	120	dprintf("JPRead %i %02x", A&1, ret);
	121	return(ret);
	122	}
	123
	124	static DECLFW(B4016)
	125	{
	126	if(FCExp)
	127	if(FCExp->Write)
	128	FCExp->Write(V&7);
	129
	130	if(JPorts[0]->Write)
	131	JPorts[0]->Write(V&1);
	132	if(JPorts[1]->Write)
	133	JPorts[1]->Write(V&1);
	134
	135	if((LastStrobe&1) && (!(V&1)))
	136	{
	137	/* This strobe code is just for convenience. If it were
	138	with the code in input / *.c, it would more accurately represent
	139	what's really going on. But who wants accuracy? ;)
	140	Seriously, though, this shouldn't be a problem.
	141	*/
	142	if(JPorts[0]->Strobe)
	143	JPorts[0]->Strobe(0);
	144	if(JPorts[1]->Strobe)
	145	JPorts[1]->Strobe(1);
	146	if(FCExp)
	147	if(FCExp->Strobe)
	148	FCExp->Strobe();
	149	}
	150	LastStrobe=V&1;
	151	}
	152
	153	static void FP_FASTAPASS(1) StrobeGP(int w)
	154	{
	155	joy_readbit[w]=0;
	156	}
	157
	158	static INPUTC GPC={ReadGP,0,StrobeGP,0,0,0};
	159	static INPUTC GPCVS={ReadGPVS,0,StrobeGP,0,0,0};
	160
	161	void DrawInput(uint8 *buf)
	162	{
	163	int x;
	164
	165	for(x=0;x<2;x++)
	166	if(JPorts[x]->Draw)
	167	JPorts[x]->Draw(x,buf,JPAttrib[x]);
	168	if(FCExp)
	169	if(FCExp->Draw)
	170	FCExp->Draw(buf,JPAttribFC);
	171	}
	172
	173	void UpdateInput(void)
	174	{
	175	int x;
	176
	177	for(x=0;x<2;x++)
	178	{
	179	switch(JPType[x])
	180	{
	181	case SI_GAMEPAD:
	182	if(!x) joy[0]=(uint16 )InputDataPtr[0];
	183	else joy[1]=(uint16 )InputDataPtr[1];
	184	break;
	185	default:
	186	if(JPorts[x]->Update)
	187	JPorts[x]->Update(x,InputDataPtr[x],JPAttrib[x]);
	188	break;
	189	}
	190	}
	191	if(FCExp)
	192	if(FCExp->Update)
	193	FCExp->Update(InputDataPtrFC,JPAttribFC);
	194
	195	if(FCEUGameInfo.type==GIT_VSUNI)
	196	{
	197	uint16 t=joy[0];
	198	joy[0]=(joy[0]&0xC)\|(joy[1]&0xF3);
	199	joy[1]=(joy[1]&0xC)\|(t&0xF3);
	200	if(coinon) coinon--;
	201	}
	202	#ifdef NETWORK
	203	if(netplay) NetplayUpdate(&joy[0],&joy[1]);
	204	#endif
	205	if (current < 0) FCEUMOV_AddJoy(joy);
	206	else framecount++; // for debug
	207	//FlushCommandQueue();
	208	}
	209
	210	static DECLFR(VSUNIRead0)
	211	{
	212	uint8 ret=0;
	213
	214	if(JPorts[0]->Read)
	215	ret\|=(JPorts[0]->Read(0))&1;
	216
	217	ret\|=(vsdip&3)<<3;
	218	if(coinon)
	219	ret\|=0x4;
	220	return ret;
	221	}
	222
	223	static DECLFR(VSUNIRead1)
	224	{
	225	uint8 ret=0;
	226
	227	if(JPorts[1]->Read)
	228	ret\|=(JPorts[1]->Read(1))&1;
	229	ret\|=vsdip&0xFC;
	230	return ret;
	231	}
	232
	233	static void SLHLHook(uint8 bg, uint8 spr, uint32 linets, int final)
	234	{
	235	int x;
	236
	237	for(x=0;x<2;x++)
	238	if(JPorts[x]->SLHook)
	239	JPorts[x]->SLHook(x,bg,spr,linets,final);
	240	if(FCExp)
	241	if(FCExp->SLHook)
	242	FCExp->SLHook(bg,spr,linets,final);
	243	}
	244
	245	static void CheckSLHook(void)
	246	{
	247	InputScanlineHook=0;
	248	if(JPorts[0]->SLHook \|\| JPorts[1]->SLHook)
	249	InputScanlineHook=SLHLHook;
	250	if(FCExp)
	251	if(FCExp->SLHook)
	252	InputScanlineHook=SLHLHook;
	253	}
	254
	255	static void FASTAPASS(1) SetInputStuff(int x)
	256	{
	257	switch(JPType[x])
	258	{
	259	case SI_GAMEPAD:
	260	if(FCEUGameInfo.type==GIT_VSUNI)
	261	JPorts[x]=&GPCVS;
	262	else
	263	JPorts[x]=&GPC;
	264	break;
	265	case SI_ARKANOID:JPorts[x]=FCEU_InitArkanoid(x);break;
	266	case SI_ZAPPER:JPorts[x]=FCEU_InitZapper(x);break;
	267	case SI_POWERPADA:JPorts[x]=FCEU_InitPowerpadA(x);break;
	268	case SI_NONE:JPorts[x]=&DummyJPort;break;
	269	}
	270
	271	CheckSLHook();
	272	}
	273
	274	static uint8 F4ReadBit[2];
	275	static void StrobeFami4(void)
	276	{
	277	F4ReadBit[0]=F4ReadBit[1]=0;
	278	}
	279
	280	static uint8 FP_FASTAPASS(2) ReadFami4(int w, uint8 ret)
	281	{
	282	ret&=1;
	283
	284	ret \|= ((joy[w]>>(F4ReadBit[w]+8))&1)<<1;
	285	if(F4ReadBit[w]>=8) ret\|=2;
	286	else F4ReadBit[w]++;
	287
	288	return(ret);
	289	}
	290
	291	static INPUTCFC FAMI4C={ReadFami4,0,StrobeFami4,0,0,0};
	292	static void SetInputStuffFC(void)
	293	{
	294	switch(JPTypeFC)
	295	{
	296	case SIFC_NONE:FCExp=0;break;
	297	case SIFC_ARKANOID:FCExp=FCEU_InitArkanoidFC();break;
	298	case SIFC_SHADOW:FCExp=FCEU_InitSpaceShadow();break;
	299	case SIFC_4PLAYER:FCExp=&FAMI4C;memset(&F4ReadBit,0,sizeof(F4ReadBit));break;
	300	case SIFC_FKB:FCExp=FCEU_InitFKB();break;
	301	}
	302	CheckSLHook();
	303	}
	304
	305	// VS Unisystem code called after SetInputMap() hooks B4016. Need to
	306	// rewrite code to make this more sane?
	307
	308	void InitializeInput(void)
	309	{
	310	memset(joy_readbit,0,sizeof(joy_readbit));
	311	memset(joy,0,sizeof(joy));
	312	LastStrobe=0;
	313
	314	if(FCEUGameInfo.type==GIT_VSUNI)
	315	{
	316	SetReadHandler(0x4016,0x4016,VSUNIRead0);
	317	SetReadHandler(0x4017,0x4017,VSUNIRead1);
	318	}
	319	else
	320	SetReadHandler(0x4016,0x4017,JPRead);
	321	SetWriteHandler(0x4016,0x4016,B4016);
	322
	323	SetInputStuff(0);
	324	SetInputStuff(1);
	325	SetInputStuffFC();
	326	}
	327
	328	void FCEUI_SetInput(int port, int type, void *ptr, int attrib)
	329	{
	330	JPAttrib[port]=attrib;
	331	JPType[port]=type;
	332	InputDataPtr[port]=ptr;
	333	SetInputStuff(port);
	334	}
	335
	336	void FCEUI_DisableFourScore(int s)
	337	{
	338	FSDisable=s;
	339	}
	340
	341	void FCEUI_SetInputFC(int type, void *ptr, int attrib)
	342	{
	343	JPAttribFC=attrib;
	344	JPTypeFC=type;
	345	InputDataPtrFC=ptr;
	346	SetInputStuffFC();
	347	}
	348
	349	void FCEU_DoSimpleCommand(int cmd)
	350	{
	351	printf("FCEU_DoSimpleCommand: %i\n", cmd);
	352	switch(cmd)
	353	{
	354	case FCEUNPCMD_FDSINSERT: FCEU_FDSInsert();break;
	355	case FCEUNPCMD_FDSSELECT: FCEU_FDSSelect();break;
	356	// case FCEUNPCMD_FDSEJECT: FCEU_FDSEject();break;
	357	case FCEUNPCMD_VSUNICOIN: FCEU_VSUniCoin(); break;
	358	case FCEUNPCMD_VSUNIDIP0 ... (FCEUNPCMD_VSUNIDIP0 + 7): FCEU_VSUniToggleDIP(cmd - FCEUNPCMD_VSUNIDIP0);break;
	359	case FCEUNPCMD_POWER: PowerNES();break;
	360	case FCEUNPCMD_RESET: ResetNES();break;
	361	default: printf("FCEU_DoSimpleCommand: can't handle cmd %i\n", cmd); break;
	362	}
	363	}
	364
	365	void FCEU_QSimpleCommand(int cmd)
	366	{
	367	// if(FCEUnetplay)
	368	// FCEUNET_SendCommand(cmd, 0);
	369	// else
	370	{
	371	// totally wrong:
	372	// if(!FCEUMOV_IsPlaying())
	373	// FCEU_DoSimpleCommand(cmd);
	374	// else
	375	// FCEUMOV_AddCommand(cmd);
	376
	377	FCEU_DoSimpleCommand(cmd);
	378	// if(FCEUMOV_IsRecording())
	379	// FCEUMOV_AddCommand(cmd);
	380	}
	381	}
	382
	383	void FCEUI_FDSSelect(void)
	384	{
	385	FCEU_QSimpleCommand(FCEUNPCMD_FDSSELECT);
	386	}
	387
	388	int FCEUI_FDSInsert(void)
	389	{
	390	FCEU_QSimpleCommand(FCEUNPCMD_FDSINSERT);
	391	return(1);
	392	}
	393
	394	/*
	395	int FCEUI_FDSEject(void)
	396	{
	397	FCEU_QSimpleCommand(FCEUNPCMD_FDSEJECT);
	398	return(1);
	399	}
	400	*/
	401	void FCEUI_VSUniToggleDIP(int w)
	402	{
	403	FCEU_QSimpleCommand(FCEUNPCMD_VSUNIDIP0 + w);
	404	}
	405
	406	void FCEUI_VSUniCoin(void)
	407	{
	408	FCEU_QSimpleCommand(FCEUNPCMD_VSUNICOIN);
	409	}
	410
	411	void FCEUI_ResetNES(void)
	412	{
	413	FCEU_QSimpleCommand(FCEUNPCMD_RESET);
	414	}
	415
	416	void FCEUI_PowerNES(void)
	417	{
	418	FCEU_QSimpleCommand(FCEUNPCMD_POWER);
	419	}
	420
	421
	422
	423	SFORMAT FCEUCTRL_STATEINFO[]={
	424	{ joy_readbit, 2, "JYRB"},
	425	{ joy, 4, "JOYS"},
	426	{ &LastStrobe, 1, "LSTS"},
	427	{ 0 }
	428	};
	429
	430