The-Homebrew-Cloud/Genesis-Plus-GX
2
0
Fork 0
mirror of https://github.com/ekeeke/Genesis-Plus-GX.git synced 2024-11-12 13:55:07 +01:00
Code Issues Packages Projects Releases Wiki Activity
1bb58b69b9
Genesis-Plus-GX/source/input.c
ekeeke31 217ca8de3f
2007-08-10 20:34:06 +00:00

509 lines
13 KiB
C
Raw Blame History

/*
Copyright (C) 1999, 2000, 2001, 2002, 2003 Charles MacDonald
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
*/
/*
NGC port (June 2007): Added various Peripherals emulation (Eke-Eke)
*/
#include "shared.h"
t_input input;
uint8 current_pad = 0;
uint8 j_cart = 0;
void gamepad_reset(uint8 num);
void gamepad_update(uint8 num);
void gamepad_raz(uint8 num);
void lightgun_update(void);
void lightgun_reset(void);
void teamplayer_reset(uint8 port);
/*****************************************************************************
* Generic INPUTS Control
*
*****************************************************************************/
void input_reset (int padtype)
{
uint8 i;
input.max = 0;
for (i=0; i<MAX_DEVICES; i++)
{
input.dev[i] = NO_DEVICE;
input.pad[i] = 0;
}
switch (input.system[0])
{
case SYSTEM_GAMEPAD:
if (input.max++ < MAX_INPUTS) input.dev[0] = padtype;
gamepad_reset(0);
break;
case SYSTEM_WAYPLAY:
for (i=0; i<4; i++)
{
if (input.max++ < MAX_INPUTS) input.dev[i] = padtype;
gamepad_reset(i);
}
current_pad = 0;
break;
case SYSTEM_TEAMPLAYER:
for (i=0; i<4; i++)
{
if (input.max++ < MAX_INPUTS) input.dev[i] = padtype;
}
teamplayer_reset(0);
break;
}
switch (input.system[1])
{
case SYSTEM_GAMEPAD:
if (input.max++ < MAX_INPUTS) input.dev[4] = padtype;
gamepad_reset(4);
break;
case SYSTEM_TEAMPLAYER:
for (i=4; i<8; i++)
{
if (input.max++ < MAX_INPUTS) input.dev[i] = padtype;
}
teamplayer_reset(1);
break;
case SYSTEM_MENACER:
if (input.max++ < MAX_INPUTS) input.dev[4] = DEVICE_LIGHTGUN;
lightgun_reset();
break;
}
if (input.max > MAX_INPUTS) input.max = MAX_INPUTS;
/* J-CART: add two gamepad inputs */
if (j_cart)
{
input.dev[5] = padtype;
input.dev[6] = padtype;
gamepad_reset(5);
gamepad_reset(6);
input.max+=2;
}
}
void input_update()
{
uint8 i;
switch (input.system[0])
{
case SYSTEM_GAMEPAD:
if (input.dev[0] == DEVICE_6BUTTON) gamepad_update(0);
break;
case SYSTEM_WAYPLAY:
for (i=0; i<4; i++)
{
if (input.dev[i] == DEVICE_6BUTTON) gamepad_update(i);
}
break;
}
switch (input.system[1])
{
case SYSTEM_GAMEPAD:
if (input.dev[4] == DEVICE_6BUTTON) gamepad_update(4);
break;
case SYSTEM_MENACER:
lightgun_update();
break;
}
}
void input_raz()
{
uint8 i;
switch (input.system[0])
{
case SYSTEM_GAMEPAD:
if (input.dev[0] == DEVICE_6BUTTON) gamepad_raz(0);
break;
case SYSTEM_WAYPLAY:
for (i=0; i<4; i++)
{
if (input.dev[i] == DEVICE_6BUTTON) gamepad_raz(i);
}
break;
}
switch (input.system[1])
{
case SYSTEM_GAMEPAD:
if (input.dev[4] == DEVICE_6BUTTON) gamepad_raz(4);
break;
}
}
/*****************************************************************************
* LIGHTGUN specific functions
*
*****************************************************************************/
struct gun
{
int16 x;
int16 y;
} lightgun;
void lightgun_reset(void)
{
lightgun.x = bitmap.viewport.w >> 1;
lightgun.y = bitmap.viewport.h >> 1;
}
void lightgun_update(void)
{
if ((v_counter == lightgun.y))
{
if (reg[0x0B] & 8) m68k_set_irq(2);
if (reg[0x00] & 2)
{
hc_latch = lightgun.x + 166;
if (hc_latch >= bitmap.viewport.w + 52) hc_latch -= (bitmap.viewport.w + 52 + 48);
hc_latch >>= 1;
}
}
}
void lightgun_set ()
{
if ((input.pad[4] & INPUT_RIGHT)) lightgun.x ++;
if ((input.pad[4] & INPUT_LEFT)) lightgun.x --;
if ((input.pad[4] & INPUT_UP)) lightgun.y --;
if ((input.pad[4] & INPUT_DOWN)) lightgun.y ++;
if (lightgun.x < 0) lightgun.x = 0;
else if (lightgun.x > bitmap.viewport.w-34) lightgun.x = bitmap.viewport.w-34;
if (lightgun.y < 0) lightgun.y = 0;
else if (lightgun.y > bitmap.viewport.h-8) lightgun.y = bitmap.viewport.h-8;
}
uint8 lightgun_read (void)
{
uint8 retval = 0x00;
if ((input.pad[4] & INPUT_B)) retval |= 0x01;
if ((input.pad[4] & INPUT_A)) retval |= 0x02;
if ((input.pad[4] & INPUT_C)) retval |= 0x04;
if ((input.pad[4] & INPUT_START)) retval |= 0x08;
return (retval & 0x7F);
}
/*****************************************************************************
* GAMEPAD specific functions (2PLAYERS/4WAYPLAY)
*
*****************************************************************************/
struct pad
{
uint8 State;
uint8 Counter;
uint8 Delay;
} gamepad[MAX_DEVICES];
void gamepad_reset(uint8 i)
{
gamepad[i].State = 0x40;
if (input.dev[i] == DEVICE_6BUTTON) gamepad_raz(i);
}
void gamepad_raz(uint8 i)
{
gamepad[i].Counter = 0;
gamepad[i].Delay = 0;
}
void gamepad_update(uint8 i)
{
if (gamepad[i].Delay++ > 25) gamepad_raz(i);
}
uint8 gamepad_read (uint8 i)
{
int control;
unsigned char retval = 0xFF;
if (input.dev[i] == NO_DEVICE) return 0x7F;
control = (gamepad[i].State & 0x40) >> 6; /* current TH state */
if (input.dev[i] == DEVICE_6BUTTON)
{
control += (gamepad[i].Counter & 3) << 1; /* TH transitions counter */
}
switch (control)
{
case 1: /*** First High ***/
case 3: /*** Second High ***/
case 5: /*** Third High ***/
/* TH = 1 : ?1CBRLDU */
if (input.pad[i] & INPUT_C) retval &= ~0x20;
if (input.pad[i] & INPUT_B) retval &= ~0x10;
if (input.pad[i] & INPUT_UP) retval &= ~0x01;
if (input.pad[i] & INPUT_DOWN) retval &= ~0x02;
if (input.pad[i] & INPUT_LEFT) retval &= ~0x04;
if (input.pad[i] & INPUT_RIGHT) retval &= ~0x08;
break;
case 0: /*** First low ***/
case 2: /*** Second low ***/
/* TH = 0 : ?0SA00DU */
if (input.pad[i] & INPUT_A) retval &= ~0x10;
if (input.pad[i] & INPUT_START) retval &= ~0x20;
if (input.pad[i] & INPUT_UP) retval &= ~0x01;
if (input.pad[i] & INPUT_DOWN) retval &= ~0x02;
retval &= 0xB3;
break;
/* 6buttons specific (taken from gen-hw.txt) */
/* A 6-button gamepad allows the extra buttons to be read based on how */
/* many times TH is switched from 1 to 0 (and not 0 to 1). Observe the */
/* following sequence */
/*
TH = 1 : ?1CBRLDU 3-button pad return value
TH = 0 : ?0SA00DU 3-button pad return value
TH = 1 : ?1CBRLDU 3-button pad return value
TH = 0 : ?0SA0000 D3-0 are forced to '0'
TH = 1 : ?1CBMXYZ Extra buttons returned in D3-0
TH = 0 : ?0SA1111 D3-0 are forced to '1'
*/
case 4: /*** Third Low ***/
/* TH = 0 : ?0SA0000 D3-0 are forced to '0'*/
if (input.pad[i] & INPUT_A) retval &= ~0x10;
if (input.pad[i] & INPUT_START) retval &= ~0x20;
retval &= 0xB0;
break;
case 6: /*** Fourth Low ***/
/* TH = 0 : ?0SA1111 D3-0 are forced to '1'*/
if (input.pad[i] & INPUT_A) retval &= ~0x10;
if (input.pad[i] & INPUT_START) retval &= ~0x20;
retval &= 0xBF;
break;
case 7: /*** Fourth High ***/
/* TH = 1 : ?1CBMXYZ Extra buttons returned in D3-0*/
if (input.pad[i] & INPUT_X) retval &= ~0x04;
if (input.pad[i] & INPUT_Y) retval &= ~0x02;
if (input.pad[i] & INPUT_Z) retval &= ~0x01;
if (input.pad[i] & INPUT_B) retval &= ~0x10;
if (input.pad[i] & INPUT_C) retval &= ~0x20;
if (input.pad[i] & INPUT_MODE) retval &= ~0x08;
break;
default:
break;
}
/* bit7 is latched*/
return (retval&0x7f);
}
void gamepad_write (uint8 i, uint8 data)
{
if (input.dev[i] == DEVICE_6BUTTON)
{
/* TH=0 to TH=1 transition */
if (!(gamepad[i].State & 0x40) && (data & 0x40))
{
gamepad[i].Counter++;
gamepad[i].Delay = 0;
}
}
gamepad[i].State = data;
}
/*****************************************************************************
* TEAMPLAYER specific functions
*
*****************************************************************************/
struct teamplayer
{
uint8 State;
uint8 Counter;
uint8 Table[12];
} teamplayer[2];
void teamplayer_reset(uint8 port)
{
uint8 i;
uint8 index = 0;
uint8 pad_input = 0;
teamplayer[port].State = 0x60; /* TH = 1, TR = 1 */
teamplayer[port].Counter = 0;
/* this table determines which gamepad input should be returned during acquisition sequence
index = teamplayer read table index: 0=1st read, 1=2nd read, ...
pad_input = gamepad input 0-14: 0=P1_DIR, 1=P1_SABC, 2=P1_MXYZ, 4=P2_DIR, 5=P2_SABC, ...
*/
for (i=0; i<4; i++)
{
if (input.dev[(4*port) + i] == DEVICE_3BUTTON)
{
teamplayer[port].Table[index++] = pad_input;
teamplayer[port].Table[index++] = pad_input + 1;
}
else if (input.dev[(4*port) + i] == DEVICE_6BUTTON)
{
teamplayer[port].Table[index++] = pad_input;
teamplayer[port].Table[index++] = pad_input + 1;
teamplayer[port].Table[index++] = pad_input + 2;
}
pad_input += 4;
}
}
/* SEGA teamplayer returns successively:
- PAD1 inputs
- PAD2 inputs
- PAD3 inputs
- PAD4 inputs
Each PAD inputs is obtained through 2 or 3 sequential reads:
1/ DIR buttons
2/ START,A,C,B buttons
3/ MODE, X,Y,Z buttons (6Button only !)
*/
uint8 teamplayer_read(uint8 port, uint8 index)
{
uint8 retval = 0x7F;
uint8 pad_input = teamplayer[port].Table[index] & 0x03;
uint8 pad_num = (4 * port) + ((teamplayer[port].Table[index] >> 2) & 0x03);
switch (pad_input)
{
case 0:
/* Directions Buttons */
if (input.pad[pad_num] & INPUT_UP) retval &= ~0x01;
if (input.pad[pad_num] & INPUT_DOWN) retval &= ~0x02;
if (input.pad[pad_num] & INPUT_LEFT) retval &= ~0x04;
if (input.pad[pad_num] & INPUT_RIGHT) retval &= ~0x08;
break;
case 1:
/* S,A,C,B Buttons */
if (input.pad[pad_num] & INPUT_B) retval &= ~0x01;
if (input.pad[pad_num] & INPUT_C) retval &= ~0x02;
if (input.pad[pad_num] & INPUT_A) retval &= ~0x04;
if (input.pad[pad_num] & INPUT_START) retval &= ~0x08;
break;
case 2:
/* M,X,Y,Z Buttons (6-Buttons only)*/
if (input.pad[pad_num] & INPUT_Z) retval &= ~0x01;
if (input.pad[pad_num] & INPUT_Y) retval &= ~0x02;
if (input.pad[pad_num] & INPUT_X) retval &= ~0x04;
if (input.pad[pad_num] & INPUT_MODE) retval &= ~0x08;
break;
}
return retval;
}
/*****************************************************************************
* MULTITAP generic functions (TEAMPLAYER/4WAYPLAY)
*
*****************************************************************************/
void multitap_write (uint8 port, uint8 data)
{
uint8 old_state;
switch (input.system[port])
{
case SYSTEM_WAYPLAY:
if (!port) gamepad_write(current_pad, data);
else current_pad = (data >> 4) & 0x07;
break;
case SYSTEM_TEAMPLAYER:
old_state = teamplayer[port].State;
teamplayer[port].State = (data & io_reg[port+4]) | (teamplayer[port].State & ~io_reg[port+4]);
if (old_state != teamplayer[port].State) teamplayer[port].Counter ++;
if ((data&0x60) == 0x60) teamplayer[port].Counter = 0;
break;
}
}
uint8 multitap_read (uint8 port)
{
uint8 retval = 0x7F;
uint8 padnum;
switch (input.system[port])
{
case SYSTEM_WAYPLAY:
if (port == 1) return 0x7F;
if (current_pad >= 4) return 0x70; /* multitap detection (TH2 = 1) */
return gamepad_read(current_pad); /* 0x0C = Pad1, 0x1C = Pad2, ... */
case SYSTEM_TEAMPLAYER:
switch (teamplayer[port].Counter) /* acquisition sequence steps */
{
case 0: /* initial state: TH = 1, TR = 1 */
retval = 0x73;
break;
case 1: /* start request: TH = 0, TR = 1 */
retval = 0x3F;
break;
case 2:
case 3: /* ack request: TH=0, TR handshake */
retval = 0x00;
break;
case 4:
case 5:
case 6:
case 7: /* gamepads type */
padnum = (4 * port) + teamplayer[port].Counter - 4;
retval = input.dev[padnum];
break;
default: /* gamepads inputs acquisition */
retval = teamplayer_read(port, teamplayer[port].Counter - 8);
break;
}
/* TL must match TR state */
retval &= ~0x10;
if (teamplayer[port].State & 0x20) retval |= 0x10;
return retval;
}
return retval;
}
Reference in New Issue View Git Blame Copy Permalink