Pecus/libretro-atari800
1
0
Fork 0
mirror of https://github.com/Pecusx/libretro-atari800.git synced 2026-05-20 22:33:22 +02:00
Code Issues Packages Projects Releases Wiki Activity

Fix first run crashing on Xbox One. Added savestate support. Rewind … (#87)

Browse Source 
* Fix first run crashing on Xbox One.
* Added savestate support.
* Rewind works.  Fixes issue #83 and possibly #49.
* Added Disc Control menu.  Supports Disks, Tapes and M3U files (issue #66).
* Added in support for 5200 Super Carts.
* Better support for 5200 controller.
* Added Paddle support.
* Converted Core Options menu to v2.
* Moved some core options into submenus.
* Added controller mappings for Ports 2-4.
* Added options for Dual Stick and Swap Ports.  Fixes issue #76.
* Joystick/Console now controlled more easily with device type Atari Keyboard.
* Added 4 Hi-Res Artifacting modes.  Restart does something now.
* When core option changed only reboot if necessary.  Removed several hardcoded controller binds.  Fixed issue #29.  Joypad input ignored when virtual keyboard active.
* SIO Acceleration now defaults to enabled.  Fix for Bounty Bob (5200 & lift fix A800).
* Added Atari 800 carts to autodetect DB.
* Added more Carts to DB.
* Fixed Drive Index not being reset on 'restart'.
* Changed Atari Joystick default mappings to something more reasonable.
This commit is contained in:
greenchili2
2023-07-31 17:35:21 -04:00
committed by GitHub
parent 86be15db82
commit 20d59afb3f
50 changed files with 8226 additions and 2132 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Makefile.common
+5 -1
View File
@@ -19,6 +19,7 @@ SOURCES_C := \
$(LIBRETRO_COMM_DIR)/encodings/encoding_utf.c \
$(LIBRETRO_COMM_DIR)/file/file_path.c \
$(LIBRETRO_COMM_DIR)/file/file_path_io.c \
$(LIBRETRO_COMM_DIR)/streams/memory_stream.c \
$(LIBRETRO_COMM_DIR)/string/stdstring.c \
$(LIBRETRO_COMM_DIR)/time/rtime.c \
$(LIBRETRO_COMM_DIR)/vfs/vfs_implementation.c
@@ -27,7 +28,10 @@ SOURCES_C += \
$(CORE_DIR)/libretro/libretro-core.c \
$(CORE_DIR)/libretro/core-mapper.c \
$(CORE_DIR)/libretro/graph.c \
$(CORE_DIR)/libretro/vkbd.c
$(CORE_DIR)/libretro/vkbd.c \
$(CORE_DIR)/libretro/retro_strings.c \
$(CORE_DIR)/libretro/retro_utils.c \
$(CORE_DIR)/libretro/retro_disk_control.c
SOURCES_C += \
$(CORE_DIR)/atari800/src/afile.c \
atari800/src/android/jni/jni.c
+6 -1
View File
@@ -254,7 +254,12 @@ static jint JNICALL NativeRunAtariProgram(JNIEnv *env, jobject this,
CARTRIDGE_MEGA_2048_DESC,
CARTRIDGE_THECART_32M_DESC,
CARTRIDGE_THECART_64M_DESC,
CARTRIDGE_XEGS_8F_64_DESC
CARTRIDGE_XEGS_8F_64_DESC,
CARTRIDGE_5200_SUPER_64_DESC,
CARTRIDGE_5200_SUPER_128_DESC,
CARTRIDGE_5200_SUPER_256_DESC,
CARTRIDGE_5200_SUPER_512_DESC,
CARTRIDGE_ATMAX_NEW_1024_DESC
};
const jbyte *img_utf = NULL;
atari800/src/antic.c
+57
View File
@@ -4085,6 +4085,63 @@ case we have ANTIC_cpu2antic_ptr[ANTIC_WSYNC_C+1]-1 = 8 and in the 2nd =12 */
#ifndef BASIC
#if defined(__LIBRETRO__)
void Retro_ANTIC_StateSave(void)
{
Retro_SaveUBYTE(&ANTIC_DMACTL, 1);
Retro_SaveUBYTE(&ANTIC_CHACTL, 1);
Retro_SaveUBYTE(&ANTIC_HSCROL, 1);
Retro_SaveUBYTE(&ANTIC_VSCROL, 1);
Retro_SaveUBYTE(&ANTIC_PMBASE, 1);
Retro_SaveUBYTE(&ANTIC_CHBASE, 1);
Retro_SaveUBYTE(&ANTIC_NMIEN, 1);
Retro_SaveUBYTE(&ANTIC_NMIST, 1);
Retro_SaveUBYTE(&IR, 1);
Retro_SaveUBYTE(&anticmode, 1);
Retro_SaveUBYTE(&dctr, 1);
Retro_SaveUBYTE(&lastline, 1);
Retro_SaveUBYTE(&need_dl, 1);
Retro_SaveUBYTE(&vscrol_off, 1);
Retro_SaveUWORD(&ANTIC_dlist, 1);
Retro_SaveUWORD(&screenaddr, 1);
Retro_SaveINT(&ANTIC_xpos, 1);
Retro_SaveINT(&ANTIC_xpos_limit, 1);
Retro_SaveINT(&ANTIC_ypos, 1);
}
void Retro_ANTIC_StateRead(void)
{
Retro_ReadUBYTE(&ANTIC_DMACTL, 1);
Retro_ReadUBYTE(&ANTIC_CHACTL, 1);
Retro_ReadUBYTE(&ANTIC_HSCROL, 1);
Retro_ReadUBYTE(&ANTIC_VSCROL, 1);
Retro_ReadUBYTE(&ANTIC_PMBASE, 1);
Retro_ReadUBYTE(&ANTIC_CHBASE, 1);
Retro_ReadUBYTE(&ANTIC_NMIEN, 1);
Retro_ReadUBYTE(&ANTIC_NMIST, 1);
Retro_ReadUBYTE(&IR, 1);
Retro_ReadUBYTE(&anticmode, 1);
Retro_ReadUBYTE(&dctr, 1);
Retro_ReadUBYTE(&lastline, 1);
Retro_ReadUBYTE(&need_dl, 1);
Retro_ReadUBYTE(&vscrol_off, 1);
Retro_ReadUWORD(&ANTIC_dlist, 1);
Retro_ReadUWORD(&screenaddr, 1);
Retro_ReadINT(&ANTIC_xpos, 1);
Retro_ReadINT(&ANTIC_xpos_limit, 1);
Retro_ReadINT(&ANTIC_ypos, 1);
ANTIC_PutByte(ANTIC_OFFSET_DMACTL, ANTIC_DMACTL);
ANTIC_PutByte(ANTIC_OFFSET_CHACTL, ANTIC_CHACTL);
ANTIC_PutByte(ANTIC_OFFSET_PMBASE, ANTIC_PMBASE);
ANTIC_PutByte(ANTIC_OFFSET_CHBASE, ANTIC_CHBASE);
}
#endif /* __LIBRETRO__ */
void ANTIC_StateSave(void)
{
StateSav_SaveUBYTE(&ANTIC_DMACTL, 1);
atari800/src/antic.h
+5
View File
@@ -94,6 +94,11 @@ void ANTIC_SetPrior(UBYTE prior);
void ANTIC_StateSave(void);
void ANTIC_StateRead(void);
#if defined(__LIBRETRO__)
void Retro_ANTIC_StateSave(void);
void Retro_ANTIC_StateRead(void);
#endif
/* Pointer to 16 KB seen by ANTIC in 0x4000-0x7fff.
If it's the same what the CPU sees (and what's in memory[0x4000..0x7fff],
then NULL. */
atari800/src/atari.c
+126 -1
View File
@@ -147,7 +147,7 @@
#endif
#if defined(__LIBRETRO__)
extern const char *retro_system_directory;
#endif
#endif /* __LIBRETRO__ */
int Atari800_machine_type = Atari800_MACHINE_XLXE;
@@ -1377,6 +1377,131 @@ void Atari800_Frame(void)
#ifndef BASIC
#if defined(__LIBRETRO__)
void Retro_Atari800_StateSave(void)
{
UBYTE temp = Atari800_tv_mode == Atari800_TV_PAL;
Retro_SaveUBYTE(&temp, 1);
temp = Atari800_machine_type;
Retro_SaveUBYTE(&temp, 1);
if (Atari800_machine_type == Atari800_MACHINE_XLXE) {
temp = Atari800_builtin_basic;
Retro_SaveUBYTE(&temp, 1);
temp = Atari800_keyboard_leds;
Retro_SaveUBYTE(&temp, 1);
temp = Atari800_f_keys;
Retro_SaveUBYTE(&temp, 1);
temp = Atari800_jumper;
Retro_SaveUBYTE(&temp, 1);
temp = Atari800_builtin_game;
Retro_SaveUBYTE(&temp, 1);
temp = Atari800_keyboard_detached;
Retro_SaveUBYTE(&temp, 1);
}
}
void Retro_Atari800_StateRead(UBYTE version)
{
if (version >= 7) {
UBYTE temp;
Retro_ReadUBYTE(&temp, 1);
Atari800_SetTVMode(temp ? Atari800_TV_PAL : Atari800_TV_NTSC);
Retro_ReadUBYTE(&temp, 1);
if (temp < 0 || temp >= Atari800_MACHINE_SIZE) {
temp = Atari800_MACHINE_XLXE;
Log_print("Warning: Bad machine type read in from state save, defaulting to XL/XE");
}
Atari800_SetMachineType(temp);
if (Atari800_machine_type == Atari800_MACHINE_XLXE) {
Retro_ReadUBYTE(&temp, 1);
Atari800_builtin_basic = temp != 0;
Retro_ReadUBYTE(&temp, 1);
Atari800_keyboard_leds = temp != 0;
Retro_ReadUBYTE(&temp, 1);
Atari800_f_keys = temp != 0;
Retro_ReadUBYTE(&temp, 1);
Atari800_jumper = temp != 0;
Atari800_UpdateJumper();
Retro_ReadUBYTE(&temp, 1);
Atari800_builtin_game = temp != 0;
Retro_ReadUBYTE(&temp, 1);
Atari800_keyboard_detached = temp != 0;
Atari800_UpdateKeyboardDetached();
}
}
else { /* savestate from version 2.2.1 or earlier */
int new_tv_mode;
/* these are all for compatibility with previous versions */
UBYTE temp;
int default_tv_mode;
int os;
int default_system;
int pil_on;
Retro_ReadUBYTE(&temp, 1);
new_tv_mode = (temp == 0) ? Atari800_TV_PAL : Atari800_TV_NTSC;
Atari800_SetTVMode(new_tv_mode);
Retro_ReadUBYTE(&temp, 1);
Retro_ReadINT(&os, 1);
switch (temp) {
case 0:
Atari800_machine_type = Atari800_MACHINE_800;
MEMORY_ram_size = 48;
break;
case 1:
Atari800_machine_type = Atari800_MACHINE_XLXE;
MEMORY_ram_size = 64;
break;
case 2:
Atari800_machine_type = Atari800_MACHINE_XLXE;
MEMORY_ram_size = 128;
break;
case 3:
Atari800_machine_type = Atari800_MACHINE_XLXE;
MEMORY_ram_size = MEMORY_RAM_320_COMPY_SHOP;
break;
case 4:
Atari800_machine_type = Atari800_MACHINE_5200;
MEMORY_ram_size = 16;
break;
case 5:
Atari800_machine_type = Atari800_MACHINE_800;
MEMORY_ram_size = 16;
break;
case 6:
Atari800_machine_type = Atari800_MACHINE_XLXE;
MEMORY_ram_size = 16;
break;
case 7:
Atari800_machine_type = Atari800_MACHINE_XLXE;
MEMORY_ram_size = 576;
break;
case 8:
Atari800_machine_type = Atari800_MACHINE_XLXE;
MEMORY_ram_size = 1088;
break;
case 9:
Atari800_machine_type = Atari800_MACHINE_XLXE;
MEMORY_ram_size = 192;
break;
default:
Atari800_machine_type = Atari800_MACHINE_XLXE;
MEMORY_ram_size = 64;
Log_print("Warning: Bad machine type read in from state save, defaulting to 800 XL");
break;
}
Retro_ReadINT(&pil_on, 1);
Retro_ReadINT(&default_tv_mode, 1);
Retro_ReadINT(&default_system, 1);
Atari800_SetMachineType(Atari800_machine_type);
}
load_roms();
/* XXX: what about patches? */
}
#endif /* __LIBRETRO__ */
void Atari800_StateSave(void)
{
UBYTE temp = Atari800_tv_mode == Atari800_TV_PAL;
atari800/src/atari.h
+6
View File
@@ -187,4 +187,10 @@ void Atari800_StateRead(UBYTE version);
/* Change TV mode. */
void Atari800_SetTVMode(int mode);
#if defined(__LIBRETRO__)
/* Save State */
void Retro_Atari800_StateSave(void);
void Retro_Atari800_StateRead(UBYTE version);
#endif
#endif /* ATARI_H_ */
atari800/src/cartridge.c
+264 -20
View File
@@ -119,7 +119,12 @@ int const CARTRIDGE_kb[CARTRIDGE_LAST_SUPPORTED + 1] = {
2048, /* CARTRIDGE_MEGA_2048 */
32*1024, /* CARTRIDGE_THECART_32M */
64*1024, /* CARTRIDGE_THECART_64M */
64 /* CARTRIDGE_XEGS_64_8F */
64, /* CARTRIDGE_XEGS_64_8F */
64, /* CARTRIDGE_5200_SUPER_64 */
128, /* CARTRIDGE_5200_SUPER_128 */
256, /* CARTRIDGE_5200_SUPER_256 */
512, /* CARTRIDGE_5200_SUPER_512 */
1024, /* CARTRIDGE_ATMAX_NEW_1024 */
};
int CARTRIDGE_autoreboot = TRUE;
@@ -133,6 +138,10 @@ static int CartIsFor5200(int type)
case CARTRIDGE_5200_NS_16:
case CARTRIDGE_5200_8:
case CARTRIDGE_5200_4:
case CARTRIDGE_5200_SUPER_64:
case CARTRIDGE_5200_SUPER_128:
case CARTRIDGE_5200_SUPER_256:
case CARTRIDGE_5200_SUPER_512:
return TRUE;
default:
break;
@@ -226,6 +235,11 @@ static void set_bank_80BF(void)
}
}
static void set_bank_5200_SUPER(void)
{
MEMORY_CopyROM(0x4000, 0xbfff, active_cart->image + active_cart->state * 0x8000);
}
static void set_bank_SDX_128(void)
{
if (active_cart->state & 8)
@@ -402,7 +416,20 @@ static void MapActiveCart(void)
if (Atari800_machine_type == Atari800_MACHINE_5200) {
MEMORY_SetROM(0x4ff6, 0x4ff9); /* disable Bounty Bob bank switching */
MEMORY_SetROM(0x5ff6, 0x5ff9);
MEMORY_SetROM(0xbfc0, 0xbfff); /* disable Super Cart bank switching */
switch (active_cart->type) {
case CARTRIDGE_5200_SUPER_64:
case CARTRIDGE_5200_SUPER_128:
case CARTRIDGE_5200_SUPER_256:
case CARTRIDGE_5200_SUPER_512:
set_bank_5200_SUPER();
#ifndef PAGED_ATTRIB
MEMORY_SetHARDWARE(0xbfc0, 0xbfff);
#else
MEMORY_readmap[0xbf] = CARTRIDGE_5200SuperCartGetByte;
MEMORY_writemap[0xbf] = CARTRIDGE_5200SuperCartPutByte;
#endif
break;
case CARTRIDGE_5200_32:
MEMORY_CopyROM(0x4000, 0xbfff, active_cart->image);
break;
@@ -1151,12 +1178,10 @@ UBYTE CARTRIDGE_BountyBob2GetByte(UWORD addr, int no_side_effects)
if (Atari800_machine_type == Atari800_MACHINE_5200) {
if (addr >= 0x5ff6 && addr <= 0x5ff9) {
CARTRIDGE_BountyBob2(addr);
return 0;
}
} else {
if (addr >= 0x9ff6 && addr <= 0x9ff9) {
CARTRIDGE_BountyBob2(addr);
return 0;
}
}
}
@@ -1200,6 +1225,45 @@ int CARTRIDGE_Checksum(const UBYTE *image, int nbytes)
return checksum;
}
/* addr must be $bfxx in 5200 mode only. */
static void access_5200SuperCart(UWORD addr)
{
int old_state = active_cart->state;
int new_state = old_state;
if ((addr & 0xc0) == 0xc0) {
switch (addr & 0x30) {
case 0x00: /* $BFCx */
new_state = (new_state & 0x03) | (addr & 0x0c);
break;
case 0x10: /* $BFDx */
new_state = (new_state & 0x0c) | ((addr & 0x0c) >> 2);
break;
default: /* 0x20 or 0x30, i.e. $BFEx or $BFFx */
new_state = 0x0f;
break;
}
new_state &= ((active_cart->size >> 5) - 1);
}
if (old_state != new_state) {
active_cart->state = new_state;
set_bank_5200_SUPER();
}
}
UBYTE CARTRIDGE_5200SuperCartGetByte(UWORD addr, int no_side_effects)
{
if (!no_side_effects)
access_5200SuperCart(addr);
return MEMORY_dGetByte(addr);
}
void CARTRIDGE_5200SuperCartPutByte(UWORD addr, UBYTE value)
{
access_5200SuperCart(addr);
}
static void ResetCartState(CARTRIDGE_image_t *cart)
{
switch (cart->type) {
@@ -1371,10 +1435,16 @@ void CARTRIDGE_ColdStart(void) {
ResetCartState(&CARTRIDGE_piggyback);
MapActiveCart();
}
#ifdef __LIBRETRO__
#include "atari5200_hash.h"
extern int autorun5200;
#endif
#include "atari800_hash.h"
#include "esc.h"
#include "pokeysnd.h"
extern int autorunCartridge;
extern void retro_message(const char* text, unsigned int frames, int alt);
#endif /* __LIBRETRO __ */
/* Loads a cartridge from FILENAME. Copies FILENAME to CART_FILENAME.
Allocates a buffer with cartridge image data and puts it in *CART_IMAGE.
Sets *CART_TYPE to the cartridge type. */
@@ -1386,6 +1456,7 @@ static int InsertCartridge(const char *filename, CARTRIDGE_image_t *cart)
UBYTE header[16];
#ifdef __LIBRETRO__
ULONG crc;
static int RetroMsgShown = FALSE;
#endif
/* open file */
fp = fopen(filename, "rb");
@@ -1395,7 +1466,7 @@ static int InsertCartridge(const char *filename, CARTRIDGE_image_t *cart)
len = Util_flen(fp);
Util_rewind(fp);
#ifdef __LIBRETRO__
if(autorun5200){
if(autorunCartridge){
CRC32_FromFile(fp, &crc);
Util_rewind(fp);
}
@@ -1418,7 +1489,7 @@ static int InsertCartridge(const char *filename, CARTRIDGE_image_t *cart)
len >>= 10; /* number of kilobytes */
cart->size = len;
#ifdef __LIBRETRO__
if(autorun5200){
if (autorunCartridge == 1) {
int match = 0, i = 0;
printf("Hack Libretro:crc A5200 ON sz:%d crc:%x\n", cart->size, crc);
while (a5200_game[i].type != -1) {
@@ -1438,20 +1509,100 @@ static int InsertCartridge(const char *filename, CARTRIDGE_image_t *cart)
case 32768:
cart->type = CARTRIDGE_5200_32;
break;
}
else if(a5200_game[i].type==1)cart->type =CARTRIDGE_5200_40;
else if(a5200_game[i].type==2)cart->type =CARTRIDGE_5200_EE_16;
else if (a5200_game[i].type == a5200_40) {
/* Bounty Bob don't like stereo pokey (game locks) */
cart->type = CARTRIDGE_5200_40;
POKEYSND_stereo_enabled = FALSE;
}
else if (a5200_game[i].type == a5200_ee_16)
cart->type = CARTRIDGE_5200_EE_16;
else if (a5200_game[i].type == a5200_64)
cart->type = CARTRIDGE_5200_SUPER_64;
else if (a5200_game[i].type == a5200_128)
cart->type = CARTRIDGE_5200_SUPER_128; // I've yet to see this type
else if (a5200_game[i].type == a5200_256)
cart->type = CARTRIDGE_5200_SUPER_256; // I've yet to see this type
else if (a5200_game[i].type == a5200_512)
cart->type = CARTRIDGE_5200_SUPER_512;
printf("Hack Libretro:A5200 cart->type:%d %x\n", cart->type, crc);
break;
}
i++;
}
if(match==1)goto label_fin;
if (match == 1) {
if (!RetroMsgShown)
retro_message("5200 Cart found in DB.", 1000, 0);
goto label_fin;
}
#endif
}
else if (autorunCartridge == 2) {
int match = 0, i = 0;
printf("Hack Libretro:crc A800 ON sz:%d crc:%x\n", cart->size, crc);
while (a800_game[i].type != -1) {
if (crc == a800_game[i].crc) {
match = 1;
if (a800_game[i].type == 0)
switch (cart->size * 1024) {
case 8192:
cart->type = CARTRIDGE_STD_8;
break;
case 16384:
cart->type = CARTRIDGE_STD_16;
break;
case 32768:
cart->type = CARTRIDGE_XEGS_32;
break;
}
else if (a800_game[i].type == a800_40) {
/* Bounty Bob don't like stereo pokey (game locks) */
cart->type = CARTRIDGE_BBSB_40;
POKEYSND_stereo_enabled = FALSE;
}
else if (a800_game[i].type == a800_WILL_64)
cart->type = CARTRIDGE_WILL_64;
else if (a800_game[i].type == a800_XE_07_64)
cart->type = CARTRIDGE_XEGS_07_64;
else if (a800_game[i].type == a800_XE_128)
cart->type = CARTRIDGE_XEGS_128;
else if (a800_game[i].type == a800_MAX_128) {
/* Some ATMAX 1024 carts dislike Hi Speed SIO*/
match = 2;
cart->type = CARTRIDGE_ATMAX_128;
}
else if (a800_game[i].type == a800_MAX_1024) {
/* Some ATMAX 1024 carts dislike Hi Speed SIO*/
match = 2;
cart->type = CARTRIDGE_ATMAX_1024;
}
printf("Hack Libretro:A800 cart->type:%d %x\n", cart->type, crc);
break;
}
i++;
}
if (match == 1) {
if (!RetroMsgShown)
retro_message("800 Cart found in DB.", 1000, 0);
goto label_fin;
}
else if (match == 2) {
if (!RetroMsgShown)
retro_message("800 Cart found in DB. Some ATMAX carts need SIO Accleration disabled.", 1000, 0);
goto label_fin;
}
else if (!RetroMsgShown)
retro_message("800 Cart NOT found in DB.", 6000, 0);
}
RetroMsgShown = TRUE;
#endif /* __LIBRETRO__ */
for (type = 1; type <= CARTRIDGE_LAST_SUPPORTED; type++)
if (CARTRIDGE_kb[type] == len) {
if (cart->type == CARTRIDGE_NONE) {
@@ -1465,6 +1616,8 @@ static int InsertCartridge(const char *filename, CARTRIDGE_image_t *cart)
#ifdef __LIBRETRO__
label_fin:
#endif
RetroMsgShown = TRUE;
if (cart->type != CARTRIDGE_NONE) {
InitCartridge(cart);
return 0; /* ok */
@@ -1712,6 +1865,30 @@ void CARTRIDGE_Exit(void)
#ifndef BASIC
void CARTRIDGE_StateSave(void)
{
int cart_save = CARTRIDGE_main.type;
if (CARTRIDGE_piggyback.type != CARTRIDGE_NONE)
/* Save the cart type as negative, to indicate to CARTStateRead that there is a
second cartridge */
cart_save = -cart_save;
/* Save the cartridge type, or CARTRIDGE_NONE if there isn't one...*/
StateSav_SaveINT(&cart_save, 1);
if (CARTRIDGE_main.type != CARTRIDGE_NONE) {
StateSav_SaveFNAME(CARTRIDGE_main.filename);
StateSav_SaveINT(&CARTRIDGE_main.state, 1);
}
if (CARTRIDGE_piggyback.type != CARTRIDGE_NONE) {
/* Save the second cartridge type and name*/
StateSav_SaveINT(&CARTRIDGE_piggyback.type, 1);
StateSav_SaveFNAME(CARTRIDGE_piggyback.filename);
StateSav_SaveINT(&CARTRIDGE_piggyback.state, 1);
}
}
void CARTRIDGE_StateRead(UBYTE version)
{
int saved_type = CARTRIDGE_NONE;
@@ -1777,7 +1954,8 @@ void CARTRIDGE_StateRead(UBYTE version)
MapActiveCart();
}
void CARTRIDGE_StateSave(void)
#if defined(__LIBRETRO__)
void Retro_CARTRIDGE_StateSave(void)
{
int cart_save = CARTRIDGE_main.type;
@@ -1787,20 +1965,86 @@ void CARTRIDGE_StateSave(void)
cart_save = -cart_save;
/* Save the cartridge type, or CARTRIDGE_NONE if there isn't one...*/
StateSav_SaveINT(&cart_save, 1);
Retro_SaveINT(&cart_save, 1);
if (CARTRIDGE_main.type != CARTRIDGE_NONE) {
StateSav_SaveFNAME(CARTRIDGE_main.filename);
StateSav_SaveINT(&CARTRIDGE_main.state, 1);
Retro_SaveFNAME(CARTRIDGE_main.filename);
Retro_SaveINT(&CARTRIDGE_main.state, 1);
}
if (CARTRIDGE_piggyback.type != CARTRIDGE_NONE) {
/* Save the second cartridge type and name*/
StateSav_SaveINT(&CARTRIDGE_piggyback.type, 1);
StateSav_SaveFNAME(CARTRIDGE_piggyback.filename);
StateSav_SaveINT(&CARTRIDGE_piggyback.state, 1);
Retro_SaveINT(&CARTRIDGE_piggyback.type, 1);
Retro_SaveFNAME(CARTRIDGE_piggyback.filename);
Retro_SaveINT(&CARTRIDGE_piggyback.state, 1);
}
}
void Retro_CARTRIDGE_StateRead(UBYTE version)
{
int saved_type = CARTRIDGE_NONE;
char filename[FILENAME_MAX];
/* Read the cart type from the file. If there is no cart type, becaused we have
reached the end of the file, this will just default to CART_NONE */
Retro_ReadINT(&saved_type, 1);
if (saved_type != CARTRIDGE_NONE) {
Retro_ReadFNAME(filename);
if (filename[0]) {
/* Insert the cartridge... */
if (CARTRIDGE_Insert(filename) >= 0) {
/* And set the type to the saved type, in case it was a raw cartridge image */
CARTRIDGE_main.type = saved_type;
}
}
if (version >= 7)
/* Read the cartridge's state (current bank etc.). */
Retro_ReadINT(&CARTRIDGE_main.state, 1);
}
else
CARTRIDGE_main.type = saved_type;
if (saved_type < 0) {
/* Minus value indicates a piggyback cartridge present. */
CARTRIDGE_main.type = -saved_type;
Retro_ReadINT(&saved_type, 1);
Retro_ReadFNAME(filename);
if (filename[0]) {
/* Insert the cartridge... */
if (CARTRIDGE_Insert_Second(filename) >= 0) {
/* And set the type to the saved type, in case it was a raw cartridge image */
CARTRIDGE_piggyback.type = saved_type;
}
}
if (version >= 7)
/* Read the cartridge's state (current bank etc.). */
Retro_ReadINT(&CARTRIDGE_piggyback.state, 1);
else {
/* Savestate version 6 explicitely stored information about
the active cartridge. */
int piggyback_active;
Retro_ReadINT(&piggyback_active, 1);
if (piggyback_active)
active_cart = &CARTRIDGE_piggyback;
else
active_cart = &CARTRIDGE_main;
/* The "Determine active cartridge" code below makes no
sense when loading ver.6 savestates, because they
did not store the cartridge state. */
return;
}
}
/* Determine active cartridge (main or piggyback. */
if (CartIsPassthrough(CARTRIDGE_main.type) && (CARTRIDGE_main.state & 0x0c) == 0x08)
active_cart = &CARTRIDGE_piggyback;
else
active_cart = &CARTRIDGE_main;
MapActiveCart();
}
#endif /* __LIBRETRO__ */
#endif
/*
atari800/src/cartridge.h
+27 -2
View File
@@ -74,7 +74,14 @@ enum {
CARTRIDGE_THECART_32M = 65,
CARTRIDGE_THECART_64M = 66,
CARTRIDGE_XEGS_8F_64 = 67,
CARTRIDGE_LAST_SUPPORTED = 67
CARTRIDGE_5200_SUPER_64 = 68, // 71
CARTRIDGE_5200_SUPER_128 = 69, // 72
CARTRIDGE_5200_SUPER_256 = 70, // 73
CARTRIDGE_5200_SUPER_512 = 71, // 74
CARTRIDGE_ATMAX_NEW_1024 = 72, // 75
CARTRIDGE_LAST_SUPPORTED = 72
};
#define CARTRIDGE_MAX_SIZE (128 * 1024 * 1024)
@@ -121,7 +128,7 @@ extern int const CARTRIDGE_kb[CARTRIDGE_LAST_SUPPORTED + 1];
#define CARTRIDGE_PHOENIX_8_DESC "Phoenix 8 KB cartridge"
#define CARTRIDGE_BLIZZARD_16_DESC "Blizzard 16 KB cartridge"
#define CARTRIDGE_ATMAX_128_DESC "Atarimax 128 KB Flash cartridge"
#define CARTRIDGE_ATMAX_1024_DESC "Atarimax 1 MB Flash cartridge"
#define CARTRIDGE_ATMAX_1024_DESC "Atarimax 1 MB Flash cartridge (old)"
#define CARTRIDGE_SDX_128_DESC "SpartaDOS X 128 KB cartridge"
#define CARTRIDGE_OSS_8_DESC "OSS 8 KB cartridge"
#define CARTRIDGE_OSS_043M_16_DESC "OSS two chip 16 KB cartridge (043M)"
@@ -147,6 +154,11 @@ extern int const CARTRIDGE_kb[CARTRIDGE_LAST_SUPPORTED + 1];
#define CARTRIDGE_THECART_32M_DESC "The!Cart 32 MB cartridge"
#define CARTRIDGE_THECART_64M_DESC "The!Cart 64 MB cartridge"
#define CARTRIDGE_XEGS_8F_64_DESC "XEGS 64 KB cartridge (banks 8-15)"
#define CARTRIDGE_5200_SUPER_64_DESC "64 KB Atari 5200 Super Cart"
#define CARTRIDGE_5200_SUPER_128_DESC "128 KB Atari 5200 Super Cart"
#define CARTRIDGE_5200_SUPER_256_DESC "256 KB Atari 5200 Super Cart"
#define CARTRIDGE_5200_SUPER_512_DESC "512 KB Atari 5200 Super Cart"
#define CARTRIDGE_ATMAX_NEW_1024_DESC "Atarimax 1 MB Flash cartridge"
/* Indicates whether the emulator should automatically reboot (coldstart)
after inserting/removing a cartridge. (Doesn't affect the piggyback
@@ -203,6 +215,19 @@ void CARTRIDGE_BountyBob1(UWORD addr);
void CARTRIDGE_BountyBob2(UWORD addr);
void CARTRIDGE_StateSave(void);
void CARTRIDGE_StateRead(UBYTE version);
/* addr must be $bfxx in 5200 mode only. */
UBYTE CARTRIDGE_5200SuperCartGetByte(UWORD addr, int no_side_effects);
/* addr must be $bfxx in 5200 mode only. */
void CARTRIDGE_5200SuperCartPutByte(UWORD addr, UBYTE value);
#if defined(__LIBRETRO__)
void Retro_CARTRIDGE_StateSave(void);
void Retro_CARTRIDGE_StateRead(UBYTE version);
#endif
#ifdef PAGED_ATTRIB
UBYTE CARTRIDGE_BountyBob1GetByte(UWORD addr, int no_side_effects);
UBYTE CARTRIDGE_BountyBob2GetByte(UWORD addr, int no_side_effects);
atari800/src/cpu.c
+36
View File
@@ -2385,6 +2385,42 @@ void CPU_Reset(void)
#if !defined(BASIC) && !defined(ASAP)
#if defined(__LIBRETRO__)
void Retro_CPU_StateSave(UBYTE SaveVerbose)
{
Retro_SaveUBYTE(&CPU_regA, 1);
CPU_GetStatus(); /* Make sure flags are all updated */
Retro_SaveUBYTE(&CPU_regP, 1);
Retro_SaveUBYTE(&CPU_regS, 1);
Retro_SaveUBYTE(&CPU_regX, 1);
Retro_SaveUBYTE(&CPU_regY, 1);
Retro_SaveUBYTE(&CPU_IRQ, 1);
Retro_MEMORY_StateSave(SaveVerbose);
Retro_SaveUWORD(&CPU_regPC, 1);
}
void Retro_CPU_StateRead(UBYTE SaveVerbose, UBYTE StateVersion)
{
Retro_ReadUBYTE(&CPU_regA, 1);
Retro_ReadUBYTE(&CPU_regP, 1);
CPU_PutStatus(); /* Make sure flags are all updated */
Retro_ReadUBYTE(&CPU_regS, 1);
Retro_ReadUBYTE(&CPU_regX, 1);
Retro_ReadUBYTE(&CPU_regY, 1);
Retro_ReadUBYTE(&CPU_IRQ, 1);
Retro_MEMORY_StateRead(SaveVerbose, StateVersion);
Retro_ReadUWORD(&CPU_regPC, 1);
}
#endif /* __LIBRETRO__ */
void CPU_StateSave(UBYTE SaveVerbose)
{
StateSav_SaveUBYTE(&CPU_regA, 1);
atari800/src/cpu.h
+6
View File
@@ -22,6 +22,12 @@ void CPU_PutStatus(void);
void CPU_Reset(void);
void CPU_StateSave(UBYTE SaveVerbose);
void CPU_StateRead(UBYTE SaveVerbose, UBYTE StateVersion);
#if defined(__LIBRETRO__)
void Retro_CPU_StateSave(UBYTE SaveVerbose);
void Retro_CPU_StateRead(UBYTE SaveVerbose, UBYTE StateVersion);
#endif
void CPU_NMI(void);
void CPU_GO(int limit);
#define CPU_GenerateIRQ() (CPU_IRQ = 1)
atari800/src/gtia.c
+139
View File
@@ -1199,6 +1199,145 @@ void GTIA_PutByte(UWORD addr, UBYTE byte)
#ifndef BASIC
#if defined(__LIBRETRO__)
void Retro_GTIA_StateSave(void)
{
int next_console_value = 7;
Retro_SaveUBYTE(&GTIA_HPOSP0, 1);
Retro_SaveUBYTE(&GTIA_HPOSP1, 1);
Retro_SaveUBYTE(&GTIA_HPOSP2, 1);
Retro_SaveUBYTE(&GTIA_HPOSP3, 1);
Retro_SaveUBYTE(&GTIA_HPOSM0, 1);
Retro_SaveUBYTE(&GTIA_HPOSM1, 1);
Retro_SaveUBYTE(&GTIA_HPOSM2, 1);
Retro_SaveUBYTE(&GTIA_HPOSM3, 1);
Retro_SaveUBYTE(&PF0PM, 1);
Retro_SaveUBYTE(&PF1PM, 1);
Retro_SaveUBYTE(&PF2PM, 1);
Retro_SaveUBYTE(&PF3PM, 1);
Retro_SaveUBYTE(&GTIA_M0PL, 1);
Retro_SaveUBYTE(&GTIA_M1PL, 1);
Retro_SaveUBYTE(&GTIA_M2PL, 1);
Retro_SaveUBYTE(&GTIA_M3PL, 1);
Retro_SaveUBYTE(&GTIA_P0PL, 1);
Retro_SaveUBYTE(&GTIA_P1PL, 1);
Retro_SaveUBYTE(&GTIA_P2PL, 1);
Retro_SaveUBYTE(&GTIA_P3PL, 1);
Retro_SaveUBYTE(&GTIA_SIZEP0, 1);
Retro_SaveUBYTE(&GTIA_SIZEP1, 1);
Retro_SaveUBYTE(&GTIA_SIZEP2, 1);
Retro_SaveUBYTE(&GTIA_SIZEP3, 1);
Retro_SaveUBYTE(&GTIA_SIZEM, 1);
Retro_SaveUBYTE(&GTIA_GRAFP0, 1);
Retro_SaveUBYTE(&GTIA_GRAFP1, 1);
Retro_SaveUBYTE(&GTIA_GRAFP2, 1);
Retro_SaveUBYTE(&GTIA_GRAFP3, 1);
Retro_SaveUBYTE(&GTIA_GRAFM, 1);
Retro_SaveUBYTE(&GTIA_COLPM0, 1);
Retro_SaveUBYTE(&GTIA_COLPM1, 1);
Retro_SaveUBYTE(&GTIA_COLPM2, 1);
Retro_SaveUBYTE(&GTIA_COLPM3, 1);
Retro_SaveUBYTE(&GTIA_COLPF0, 1);
Retro_SaveUBYTE(&GTIA_COLPF1, 1);
Retro_SaveUBYTE(&GTIA_COLPF2, 1);
Retro_SaveUBYTE(&GTIA_COLPF3, 1);
Retro_SaveUBYTE(&GTIA_COLBK, 1);
Retro_SaveUBYTE(&GTIA_PRIOR, 1);
Retro_SaveUBYTE(&GTIA_VDELAY, 1);
Retro_SaveUBYTE(&GTIA_GRACTL, 1);
Retro_SaveUBYTE(&consol_mask, 1);
Retro_SaveINT(&GTIA_speaker, 1);
Retro_SaveINT(&next_console_value, 1);
Retro_SaveUBYTE(GTIA_TRIG_latch, 4);
}
void Retro_GTIA_StateRead(UBYTE version)
{
int next_console_value; /* ignored */
Retro_ReadUBYTE(&GTIA_HPOSP0, 1);
Retro_ReadUBYTE(&GTIA_HPOSP1, 1);
Retro_ReadUBYTE(&GTIA_HPOSP2, 1);
Retro_ReadUBYTE(&GTIA_HPOSP3, 1);
Retro_ReadUBYTE(&GTIA_HPOSM0, 1);
Retro_ReadUBYTE(&GTIA_HPOSM1, 1);
Retro_ReadUBYTE(&GTIA_HPOSM2, 1);
Retro_ReadUBYTE(&GTIA_HPOSM3, 1);
Retro_ReadUBYTE(&PF0PM, 1);
Retro_ReadUBYTE(&PF1PM, 1);
Retro_ReadUBYTE(&PF2PM, 1);
Retro_ReadUBYTE(&PF3PM, 1);
Retro_ReadUBYTE(&GTIA_M0PL, 1);
Retro_ReadUBYTE(&GTIA_M1PL, 1);
Retro_ReadUBYTE(&GTIA_M2PL, 1);
Retro_ReadUBYTE(&GTIA_M3PL, 1);
Retro_ReadUBYTE(&GTIA_P0PL, 1);
Retro_ReadUBYTE(&GTIA_P1PL, 1);
Retro_ReadUBYTE(&GTIA_P2PL, 1);
Retro_ReadUBYTE(&GTIA_P3PL, 1);
Retro_ReadUBYTE(&GTIA_SIZEP0, 1);
Retro_ReadUBYTE(&GTIA_SIZEP1, 1);
Retro_ReadUBYTE(&GTIA_SIZEP2, 1);
Retro_ReadUBYTE(&GTIA_SIZEP3, 1);
Retro_ReadUBYTE(&GTIA_SIZEM, 1);
Retro_ReadUBYTE(&GTIA_GRAFP0, 1);
Retro_ReadUBYTE(&GTIA_GRAFP1, 1);
Retro_ReadUBYTE(&GTIA_GRAFP2, 1);
Retro_ReadUBYTE(&GTIA_GRAFP3, 1);
Retro_ReadUBYTE(&GTIA_GRAFM, 1);
Retro_ReadUBYTE(&GTIA_COLPM0, 1);
Retro_ReadUBYTE(&GTIA_COLPM1, 1);
Retro_ReadUBYTE(&GTIA_COLPM2, 1);
Retro_ReadUBYTE(&GTIA_COLPM3, 1);
Retro_ReadUBYTE(&GTIA_COLPF0, 1);
Retro_ReadUBYTE(&GTIA_COLPF1, 1);
Retro_ReadUBYTE(&GTIA_COLPF2, 1);
Retro_ReadUBYTE(&GTIA_COLPF3, 1);
Retro_ReadUBYTE(&GTIA_COLBK, 1);
Retro_ReadUBYTE(&GTIA_PRIOR, 1);
Retro_ReadUBYTE(&GTIA_VDELAY, 1);
Retro_ReadUBYTE(&GTIA_GRACTL, 1);
Retro_ReadUBYTE(&consol_mask, 1);
Retro_ReadINT(&GTIA_speaker, 1);
Retro_ReadINT(&next_console_value, 1);
if (version >= 7)
Retro_ReadUBYTE(GTIA_TRIG_latch, 4);
GTIA_PutByte(GTIA_OFFSET_HPOSP0, GTIA_HPOSP0);
GTIA_PutByte(GTIA_OFFSET_HPOSP1, GTIA_HPOSP1);
GTIA_PutByte(GTIA_OFFSET_HPOSP2, GTIA_HPOSP2);
GTIA_PutByte(GTIA_OFFSET_HPOSP3, GTIA_HPOSP3);
GTIA_PutByte(GTIA_OFFSET_HPOSM0, GTIA_HPOSM0);
GTIA_PutByte(GTIA_OFFSET_HPOSM1, GTIA_HPOSM1);
GTIA_PutByte(GTIA_OFFSET_HPOSM2, GTIA_HPOSM2);
GTIA_PutByte(GTIA_OFFSET_HPOSM3, GTIA_HPOSM3);
GTIA_PutByte(GTIA_OFFSET_SIZEP0, GTIA_SIZEP0);
GTIA_PutByte(GTIA_OFFSET_SIZEP1, GTIA_SIZEP1);
GTIA_PutByte(GTIA_OFFSET_SIZEP2, GTIA_SIZEP2);
GTIA_PutByte(GTIA_OFFSET_SIZEP3, GTIA_SIZEP3);
GTIA_PutByte(GTIA_OFFSET_SIZEM, GTIA_SIZEM);
GTIA_PutByte(GTIA_OFFSET_GRAFP0, GTIA_GRAFP0);
GTIA_PutByte(GTIA_OFFSET_GRAFP1, GTIA_GRAFP1);
GTIA_PutByte(GTIA_OFFSET_GRAFP2, GTIA_GRAFP2);
GTIA_PutByte(GTIA_OFFSET_GRAFP3, GTIA_GRAFP3);
GTIA_PutByte(GTIA_OFFSET_GRAFM, GTIA_GRAFM);
GTIA_PutByte(GTIA_OFFSET_COLPM0, GTIA_COLPM0);
GTIA_PutByte(GTIA_OFFSET_COLPM1, GTIA_COLPM1);
GTIA_PutByte(GTIA_OFFSET_COLPM2, GTIA_COLPM2);
GTIA_PutByte(GTIA_OFFSET_COLPM3, GTIA_COLPM3);
GTIA_PutByte(GTIA_OFFSET_COLPF0, GTIA_COLPF0);
GTIA_PutByte(GTIA_OFFSET_COLPF1, GTIA_COLPF1);
GTIA_PutByte(GTIA_OFFSET_COLPF2, GTIA_COLPF2);
GTIA_PutByte(GTIA_OFFSET_COLPF3, GTIA_COLPF3);
GTIA_PutByte(GTIA_OFFSET_COLBK, GTIA_COLBK);
GTIA_PutByte(GTIA_OFFSET_PRIOR, GTIA_PRIOR);
GTIA_PutByte(GTIA_OFFSET_GRACTL, GTIA_GRACTL);
}
#endif /* __LIBRETRO__ */
void GTIA_StateSave(void)
{
int next_console_value = 7;
atari800/src/gtia.h
+5
View File
@@ -132,6 +132,11 @@ void GTIA_PutByte(UWORD addr, UBYTE byte);
void GTIA_StateSave(void);
void GTIA_StateRead(UBYTE version);
#if defined(__LIBRETRO__)
void Retro_GTIA_StateSave(void);
void Retro_GTIA_StateRead(UBYTE version);
#endif
#ifdef NEW_CYCLE_EXACT
void GTIA_UpdatePmplColls(void);
#endif
atari800/src/input.c
+33 -3
View File
@@ -48,7 +48,7 @@
#include <zlib.h>
#endif
#ifdef DREAMCAST
#if defined (DREAMCAST) || defined(__LIBRETRO__)
extern int Atari_POT(int);
#else
#define Atari_POT(x) 228
@@ -68,6 +68,12 @@ int INPUT_joy_5200_min = 6;
int INPUT_joy_5200_center = 114;
int INPUT_joy_5200_max = 220;
#if defined(__LIBRETRO__)
int INPUT_digital_5200_min = 6;
int INPUT_digital_5200_center = 114;
int INPUT_digital_5200_max = 220;
#endif
int INPUT_cx85 = 0;
int INPUT_mouse_mode = INPUT_MOUSE_OFF;
@@ -625,15 +631,38 @@ void INPUT_Frame(void)
}
else {
for (i = 0; i < 4; i++) {
#ifdef DREAMCAST
#if defined (DREAMCAST)
/* first get analog js data */
POKEY_POT_input[2 * i] = Atari_POT(2 * i); /* x */
POKEY_POT_input[2 * i + 1] = Atari_POT(2 * i + 1); /* y */
if (POKEY_POT_input[2 * i] != INPUT_joy_5200_center
|| POKEY_POT_input[2 * i + 1] != INPUT_joy_5200_center)
continue;
/* if analog js is unused, alternatively try keypad */
#endif
#if defined(__LIBRETRO__)
/* first get analog js data */
POKEY_POT_input[2 * i] = Atari_POT(2 * i); /* x */
POKEY_POT_input[2 * i + 1] = Atari_POT(2 * i + 1); /* y */
if (POKEY_POT_input[2 * i] != INPUT_joy_5200_center
|| POKEY_POT_input[2 * i + 1] != INPUT_joy_5200_center)
continue;
/* if analog js is unused, alternatively try keypad */
if ((STICK[i] & (INPUT_STICK_CENTRE ^ INPUT_STICK_LEFT)) == 0)
POKEY_POT_input[2 * i] = INPUT_digital_5200_min;
else if ((STICK[i] & (INPUT_STICK_CENTRE ^ INPUT_STICK_RIGHT)) == 0)
POKEY_POT_input[2 * i] = INPUT_digital_5200_max;
else
POKEY_POT_input[2 * i] = INPUT_digital_5200_center;
if ((STICK[i] & (INPUT_STICK_CENTRE ^ INPUT_STICK_FORWARD)) == 0)
POKEY_POT_input[2 * i + 1] = INPUT_digital_5200_min;
else if ((STICK[i] & (INPUT_STICK_CENTRE ^ INPUT_STICK_BACK)) == 0)
POKEY_POT_input[2 * i + 1] = INPUT_digital_5200_max;
else
POKEY_POT_input[2 * i + 1] = INPUT_digital_5200_center;
}
#else
/* if analog js is unused, alternatively try keypad */
if ((STICK[i] & (INPUT_STICK_CENTRE ^ INPUT_STICK_LEFT)) == 0)
POKEY_POT_input[2 * i] = INPUT_joy_5200_min;
else if ((STICK[i] & (INPUT_STICK_CENTRE ^ INPUT_STICK_RIGHT)) == 0)
@@ -647,6 +676,7 @@ void INPUT_Frame(void)
else
POKEY_POT_input[2 * i + 1] = INPUT_joy_5200_center;
}
#endif
}
/* handle mouse */
atari800/src/memory.c
+357 -2
View File
@@ -339,6 +339,351 @@ void MEMORY_InitialiseMachine(void)
#ifndef BASIC
#if defined(__LIBRETRO__)
void Retro_MEMORY_StateSave(UBYTE SaveVerbose)
{
int temp;
UBYTE byte;
/* Axlon/Mosaic for 400/800 */
if (Atari800_machine_type == Atari800_MACHINE_800) {
Retro_SaveINT(&MEMORY_axlon_num_banks, 1);
if (MEMORY_axlon_num_banks > 0) {
Retro_SaveINT(&axlon_curbank, 1);
Retro_SaveINT(&MEMORY_axlon_0f_mirror, 1);
Retro_SaveUBYTE(axlon_ram, MEMORY_axlon_num_banks * 0x4000);
}
Retro_SaveINT(&mosaic_current_num_banks, 1);
if (mosaic_current_num_banks > 0) {
Retro_SaveINT(&mosaic_curbank, 1);
Retro_SaveUBYTE(mosaic_ram, mosaic_current_num_banks * 0x1000);
}
}
/* Save amount of base RAM in kilobytes. */
temp = MEMORY_ram_size > 64 ? 64 : MEMORY_ram_size;
Retro_SaveINT(&temp, 1);
Retro_SaveUBYTE(&MEMORY_mem[0], 65536);
#ifndef PAGED_ATTRIB
Retro_SaveUBYTE(&MEMORY_attrib[0], 65536);
#else
{
/* I assume here that consecutive calls to StateSav_SaveUBYTE()
are equivalent to a single call with all the values
(i.e. StateSav_SaveUBYTE() doesn't write any headers). */
UBYTE attrib_page[256];
int i;
for (i = 0; i < 256; i++) {
if (MEMORY_writemap[i] == NULL)
memset(attrib_page, MEMORY_RAM, 256);
else if (MEMORY_writemap[i] == MEMORY_ROM_PutByte)
memset(attrib_page, MEMORY_ROM, 256);
else if (i == 0x4f || i == 0x5f || i == 0x8f || i == 0x9f) {
/* special case: Bounty Bob bank switching registers */
memset(attrib_page, MEMORY_ROM, 256);
attrib_page[0xf6] = MEMORY_HARDWARE;
attrib_page[0xf7] = MEMORY_HARDWARE;
attrib_page[0xf8] = MEMORY_HARDWARE;
attrib_page[0xf9] = MEMORY_HARDWARE;
}
else {
memset(attrib_page, MEMORY_HARDWARE, 256);
}
Retro_SaveUBYTE(&attrib_page[0], 256);
}
}
#endif
if (Atari800_machine_type == Atari800_MACHINE_XLXE) {
if (SaveVerbose != 0)
Retro_SaveUBYTE(&MEMORY_basic[0], 8192);
Retro_SaveUBYTE(&under_cartA0BF[0], 8192);
if (SaveVerbose != 0)
Retro_SaveUBYTE(&MEMORY_os[0], 16384);
Retro_SaveUBYTE(&under_atarixl_os[0], 16384);
if (SaveVerbose != 0)
Retro_SaveUBYTE(MEMORY_xegame, 0x2000);
}
/* Save amount of XE RAM in 16KB banks. */
temp = (MEMORY_ram_size - 64) / 16;
if (temp < 0)
temp = 0;
Retro_SaveINT(&temp, 1);
if (MEMORY_ram_size == MEMORY_RAM_320_RAMBO || MEMORY_ram_size == MEMORY_RAM_320_COMPY_SHOP) {
/* Save specific banking type. */
temp = MEMORY_ram_size - 320;
Retro_SaveINT(&temp, 1);
}
byte = PIA_PORTB | PIA_PORTB_mask;
Retro_SaveUBYTE(&byte, 1);
Retro_SaveINT(&MEMORY_cartA0BF_enabled, 1);
if (MEMORY_ram_size > 64) {
Retro_SaveUBYTE(&atarixe_memory[0], atarixe_memory_size);
if (ANTIC_xe_ptr != NULL && MEMORY_selftest_enabled)
Retro_SaveUBYTE(antic_bank_under_selftest, 0x800);
}
/* Simius XL/XE MapRAM expansion */
if (Atari800_machine_type == Atari800_MACHINE_XLXE && MEMORY_ram_size > 20) {
Retro_SaveINT(&MEMORY_enable_mapram, 1);
if (MEMORY_enable_mapram) {
Retro_SaveUBYTE(mapram_memory, 0x800);
}
}
}
void Retro_MEMORY_StateRead(UBYTE SaveVerbose, UBYTE StateVersion)
{
int base_ram_kb;
int num_xe_banks;
UBYTE portb;
/* Axlon/Mosaic for 400/800 */
if (Atari800_machine_type == Atari800_MACHINE_800 && StateVersion >= 5) {
Retro_ReadINT(&MEMORY_axlon_num_banks, 1);
if (MEMORY_axlon_num_banks > 0) {
Retro_ReadINT(&axlon_curbank, 1);
if (StateVersion < 7) {
/* Read bank mask, then increase by 1 to get number of banks. */
Retro_ReadINT(&MEMORY_axlon_num_banks, 1);
++MEMORY_axlon_num_banks;
}
Retro_ReadINT(&MEMORY_axlon_0f_mirror, 1);
if (StateVersion < 7) {
int temp;
/* Ignore saved RAM size - can be derived. */
Retro_ReadINT(&temp, 1);
}
alloc_axlon_memory();
Retro_ReadUBYTE(axlon_ram, MEMORY_axlon_num_banks * 0x4000);
}
Retro_ReadINT(&MEMORY_mosaic_num_banks, 1);
if (MEMORY_mosaic_num_banks > 0) {
Retro_ReadINT(&mosaic_curbank, 1);
if (StateVersion < 7) {
int temp;
/* Read max bank number, then increase by 1 to get number of banks. */
Retro_ReadINT(&MEMORY_mosaic_num_banks, 1);
++MEMORY_mosaic_num_banks;
Retro_ReadINT(&temp, 1); /* Ignore Mosaic RAM size - can be derived. */
}
alloc_mosaic_memory();
Retro_ReadUBYTE(mosaic_ram, mosaic_current_num_banks * 0x1000);
}
}
if (StateVersion >= 7)
/* Read amount of base RAM in kilobytes. */
Retro_ReadINT(&base_ram_kb, 1);
Retro_ReadUBYTE(&MEMORY_mem[0], 65536);
#ifndef PAGED_ATTRIB
Retro_ReadUBYTE(&MEMORY_attrib[0], 65536);
#else
{
UBYTE attrib_page[256];
int i;
for (i = 0; i < 256; i++) {
Retro_ReadUBYTE(&attrib_page[0], 256);
/* note: 0x40 is intentional here:
we want ROM on page 0xd1 if H: patches are enabled */
switch (attrib_page[0x40]) {
case MEMORY_RAM:
MEMORY_readmap[i] = NULL;
MEMORY_writemap[i] = NULL;
break;
case MEMORY_ROM:
if (i != 0xd1 && attrib_page[0xf6] == MEMORY_HARDWARE) {
if (i == 0x4f || i == 0x8f) {
MEMORY_readmap[i] = CARTRIDGE_BountyBob1GetByte;
MEMORY_writemap[i] = CARTRIDGE_BountyBob1PutByte;
}
else if (i == 0x5f || i == 0x9f) {
MEMORY_readmap[i] = CARTRIDGE_BountyBob2GetByte;
MEMORY_writemap[i] = CARTRIDGE_BountyBob2PutByte;
}
else if (i == 0xbf) {
MEMORY_readmap[i] = CARTRIDGE_5200SuperCartGetByte;
MEMORY_writemap[i] = CARTRIDGE_5200SuperCartPutByte;
}
/* else something's wrong, so we keep current values */
}
else {
MEMORY_readmap[i] = NULL;
MEMORY_writemap[i] = MEMORY_ROM_PutByte;
}
break;
case MEMORY_HARDWARE:
switch (i) {
case 0xc0:
case 0xd0:
MEMORY_readmap[i] = GTIA_GetByte;
MEMORY_writemap[i] = GTIA_PutByte;
break;
case 0xd1:
MEMORY_readmap[i] = PBI_D1GetByte;
MEMORY_writemap[i] = PBI_D1PutByte;
break;
case 0xd2:
case 0xe8:
case 0xeb:
MEMORY_readmap[i] = POKEY_GetByte;
MEMORY_writemap[i] = POKEY_PutByte;
break;
case 0xd3:
MEMORY_readmap[i] = PIA_GetByte;
MEMORY_writemap[i] = PIA_PutByte;
break;
case 0xd4:
MEMORY_readmap[i] = ANTIC_GetByte;
MEMORY_writemap[i] = ANTIC_PutByte;
break;
case 0xd5:
MEMORY_readmap[i] = CARTRIDGE_GetByte;
MEMORY_writemap[i] = CARTRIDGE_PutByte;
break;
case 0xd6:
MEMORY_readmap[i] = PBI_D6GetByte;
MEMORY_writemap[i] = PBI_D6PutByte;
break;
case 0xd7:
MEMORY_readmap[i] = PBI_D7GetByte;
MEMORY_writemap[i] = PBI_D7PutByte;
break;
case 0xff:
if (MEMORY_mosaic_num_banks > 0) MEMORY_writemap[0xff] = MosaicPutByte;
break;
case 0xcf:
if (MEMORY_axlon_num_banks > 0) MEMORY_writemap[0xcf] = AxlonPutByte;
break;
case 0x0f:
if (MEMORY_axlon_num_banks > 0 && MEMORY_axlon_0f_mirror) MEMORY_writemap[0x0f] = AxlonPutByte;
break;
default:
/* something's wrong, so we keep current values */
break;
}
break;
default:
/* something's wrong, so we keep current values */
break;
}
}
}
#endif
if (Atari800_machine_type == Atari800_MACHINE_XLXE) {
if (SaveVerbose)
Retro_ReadUBYTE(&MEMORY_basic[0], 8192);
Retro_ReadUBYTE(&under_cartA0BF[0], 8192);
if (SaveVerbose)
Retro_ReadUBYTE(&MEMORY_os[0], 16384);
Retro_ReadUBYTE(&under_atarixl_os[0], 16384);
if (StateVersion >= 7 && SaveVerbose)
Retro_ReadUBYTE(MEMORY_xegame, 0x2000);
}
if (StateVersion >= 7) {
/* Read amount of XE RAM in 16KB banks. */
Retro_ReadINT(&num_xe_banks, 1);
/* Compute value of MEMORY_ram_size. */
MEMORY_ram_size = base_ram_kb + num_xe_banks * 16;
if (MEMORY_ram_size == 320) {
/* There are 2 different memory mappings for 320 KB. */
/* In savestate version <= 6 this variable is read in PIA_StateRead. */
int xe_type;
Retro_ReadINT(&xe_type, 1);
MEMORY_ram_size += xe_type;
}
if (!MEMORY_SizeValid(MEMORY_ram_size)) {
MEMORY_ram_size = 64;
Log_print("Warning: Bad RAM size read in from state save, defaulting to 64 KB");
}
/* Read PORTB and set variables that are based on it. */
Retro_ReadUBYTE(&portb, 1);
MEMORY_xe_bank = 0;
if (MEMORY_ram_size > 64 && (portb & 0x30) != 0x30) {
switch (MEMORY_ram_size) {
case 128:
MEMORY_xe_bank = ((portb & 0x0c) >> 2) + 1;
break;
case 192:
MEMORY_xe_bank = (((portb & 0x0c) + ((portb & 0x40) >> 2)) >> 2) + 1;
break;
case MEMORY_RAM_320_RAMBO:
MEMORY_xe_bank = (((portb & 0x0c) + ((portb & 0x60) >> 1)) >> 2) + 1;
break;
case MEMORY_RAM_320_COMPY_SHOP:
MEMORY_xe_bank = (((portb & 0x0c) + ((portb & 0xc0) >> 2)) >> 2) + 1;
break;
case 576:
MEMORY_xe_bank = (((portb & 0x0e) + ((portb & 0x60) >> 1)) >> 1) + 1;
break;
case 1088:
MEMORY_xe_bank = (((portb & 0x0e) + ((portb & 0xe0) >> 1)) >> 1) + 1;
break;
}
}
/* In savestate version <= 6 this variable is read in PIA_StateRead. */
MEMORY_selftest_enabled = (portb & 0x81) == 0x01
&& !((portb & 0x30) != 0x30 && MEMORY_ram_size == MEMORY_RAM_320_COMPY_SHOP)
&& !((portb & 0x10) == 0 && MEMORY_ram_size == 1088);
Retro_ReadINT(&MEMORY_cartA0BF_enabled, 1);
if (Atari800_machine_type == Atari800_MACHINE_XLXE) {
GTIA_TRIG[3] = MEMORY_cartA0BF_enabled;
if (MEMORY_cartA0BF_enabled == 0 && (GTIA_GRACTL & 4))
GTIA_TRIG_latch[3] = 0;
}
}
ANTIC_xe_ptr = NULL;
AllocXEMemory();
if (MEMORY_ram_size > 64) {
Retro_ReadUBYTE(&atarixe_memory[0], atarixe_memory_size);
/* a hack that makes state files compatible with previous versions:
for 130 XE there's written 192 KB of unused data */
if (MEMORY_ram_size == 128 && StateVersion <= 6) {
UBYTE buffer[256];
int i;
for (i = 0; i < 192 * 4; i++)
Retro_ReadUBYTE(&buffer[0], 256);
}
if (StateVersion >= 7 && (MEMORY_ram_size == 128 || MEMORY_ram_size == MEMORY_RAM_320_COMPY_SHOP)) {
switch (portb & 0x30) {
case 0x20: /* ANTIC: base, CPU: extended */
ANTIC_xe_ptr = atarixe_memory;
break;
case 0x10: /* ANTIC: extended, CPU: base */
ANTIC_xe_ptr = atarixe_memory + (MEMORY_xe_bank << 14);
break;
default: /* ANTIC same as CPU */
ANTIC_xe_ptr = NULL;
break;
}
if (ANTIC_xe_ptr != NULL && MEMORY_selftest_enabled)
/* Also read ANTIC-visible memory shadowed by Self Test. */
Retro_ReadUBYTE(antic_bank_under_selftest, 0x800);
}
}
/* Simius XL/XE MapRAM expansion */
if (StateVersion >= 7 && Atari800_machine_type == Atari800_MACHINE_XLXE && MEMORY_ram_size > 20) {
Retro_ReadINT(&MEMORY_enable_mapram, 1);
AllocMapRAM();
if (mapram_memory != NULL) {
Retro_ReadUBYTE(mapram_memory, 0x800);
}
}
}
#endif /* __LIBRETRO__ */
void MEMORY_StateSave(UBYTE SaveVerbose)
{
int temp;
@@ -504,6 +849,10 @@ void MEMORY_StateRead(UBYTE SaveVerbose, UBYTE StateVersion)
MEMORY_readmap[i] = CARTRIDGE_BountyBob2GetByte;
MEMORY_writemap[i] = CARTRIDGE_BountyBob2PutByte;
}
else if (i == 0xbf) {
MEMORY_readmap[i] = CARTRIDGE_5200SuperCartGetByte;
MEMORY_writemap[i] = CARTRIDGE_5200SuperCartPutByte;
}
/* else something's wrong, so we keep current values */
}
else {
@@ -1068,13 +1417,16 @@ UBYTE MEMORY_HwGetByte(UWORD addr, int no_side_effects)
case 0x8f00:
if (!no_side_effects)
CARTRIDGE_BountyBob1(addr);
byte = 0;
byte = MEMORY_dGetByte(addr);
break;
case 0x5f00:
case 0x9f00:
if (!no_side_effects)
CARTRIDGE_BountyBob2(addr);
byte = 0;
byte = MEMORY_dGetByte(addr);
break;
case 0xbf00:
byte = CARTRIDGE_5200SuperCartGetByte(addr, no_side_effects);
break;
case 0xd000: /* GTIA */
case 0xc000: /* GTIA - 5200 */
@@ -1153,6 +1505,9 @@ void MEMORY_HwPutByte(UWORD addr, UBYTE byte)
case 0x9f00:
CARTRIDGE_BountyBob2(addr);
break;
case 0xbf00:
CARTRIDGE_5200SuperCartPutByte(addr, byte);
break;
case 0xd000: /* GTIA */
case 0xc000: /* GTIA - 5200 */
case 0xc100: /* GTIA - 5200 */
atari800/src/memory.h
+6
View File
@@ -109,6 +109,12 @@ int MEMORY_SizeValid(int size);
void MEMORY_InitialiseMachine(void);
void MEMORY_StateSave(UBYTE SaveVerbose);
void MEMORY_StateRead(UBYTE SaveVerbose, UBYTE StateVersion);
#if defined(__LIBRETRO__)
void Retro_MEMORY_StateSave(UBYTE SaveVerbose);
void Retro_MEMORY_StateRead(UBYTE SaveVerbose, UBYTE StateVersion);
#endif
void MEMORY_CopyFromMem(UWORD from, UBYTE *to, int size);
void MEMORY_CopyToMem(const UBYTE *from, UWORD to, int size);
void MEMORY_HandlePORTB(UBYTE byte, UBYTE oldval);
atari800/src/pbi.c
+16
View File
@@ -320,6 +320,22 @@ void PBI_D7PutByte(UWORD addr, UBYTE byte)
#ifndef BASIC
#if defined(__LIBRETRO__)
void Retro_PBI_StateSave(void)
{
Retro_SaveUBYTE(&D1FF_LATCH, 1);
Retro_SaveINT(&PBI_D6D7ram, 1);
Retro_SaveINT(&PBI_IRQ, 1);
}
void Retro_PBI_StateRead(void)
{
Retro_ReadUBYTE(&D1FF_LATCH, 1);
Retro_ReadINT(&PBI_D6D7ram, 1);
Retro_ReadINT(&PBI_IRQ, 1);
}
#endif
void PBI_StateSave(void)
{
StateSav_SaveUBYTE(&D1FF_LATCH, 1);
atari800/src/pbi.h
+6
View File
@@ -19,6 +19,12 @@ extern int PBI_IRQ;
extern int PBI_D6D7ram;
void PBI_StateSave(void);
void PBI_StateRead(void);
#if defined(__LIBRETRO__)
void Retro_PBI_StateSave(void);
void Retro_PBI_StateRead(void);
#endif
#define PBI_NOT_HANDLED -1
/* #define PBI_DEBUG */
#endif /* PBI_H_ */
atari800/src/pia.c
+67
View File
@@ -332,6 +332,73 @@ void PIA_PutByte(UWORD addr, UBYTE byte)
#ifndef BASIC
#if defined(__LIBRETRO__)
void Retro_PIA_StateSave(void)
{
Retro_SaveUBYTE(&PIA_PACTL, 1);
Retro_SaveUBYTE(&PIA_PBCTL, 1);
Retro_SaveUBYTE(&PIA_PORTA, 1);
Retro_SaveUBYTE(&PIA_PORTB, 1);
Retro_SaveUBYTE(&PIA_PORTA_mask, 1);
Retro_SaveUBYTE(&PIA_PORTB_mask, 1);
Retro_SaveINT(&PIA_CA2, 1);
Retro_SaveINT(&PIA_CA2_negpending, 1);
Retro_SaveINT(&PIA_CA2_pospending, 1);
Retro_SaveINT(&PIA_CB2, 1);
Retro_SaveINT(&PIA_CB2_negpending, 1);
Retro_SaveINT(&PIA_CB2_pospending, 1);
}
void Retro_PIA_StateRead(UBYTE version)
{
UBYTE byte;
int temp;
Retro_ReadUBYTE(&byte, 1);
if (version <= 7) {
PIA_PutByte(PIA_OFFSET_PACTL, byte); /* set PIA_CA2 and tape motor */
}
PIA_PACTL = byte;
Retro_ReadUBYTE(&byte, 1);
if (version <= 7) {
PIA_PutByte(PIA_OFFSET_PBCTL, byte); /* set PIA_CB2 and !command line */
}
PIA_PBCTL = byte;
Retro_ReadUBYTE(&PIA_PORTA, 1);
Retro_ReadUBYTE(&PIA_PORTB, 1);
/* In version 7 and later these variables are read in memory.c. */
if (version <= 6) {
int Ram256;
Retro_ReadINT(&MEMORY_xe_bank, 1);
Retro_ReadINT(&MEMORY_selftest_enabled, 1);
Retro_ReadINT(&Ram256, 1);
if (Atari800_machine_type == Atari800_MACHINE_XLXE) {
if (Ram256 == 1 && MEMORY_ram_size == MEMORY_RAM_320_COMPY_SHOP)
MEMORY_ram_size = MEMORY_RAM_320_RAMBO;
}
Retro_ReadINT(&MEMORY_cartA0BF_enabled, 1);
}
Retro_ReadUBYTE(&PIA_PORTA_mask, 1);
Retro_ReadUBYTE(&PIA_PORTB_mask, 1);
if (version >= 8) {
Retro_ReadINT(&temp, 1);
set_CA2(temp);
Retro_ReadINT(&PIA_CA2_negpending, 1);
Retro_ReadINT(&PIA_CA2_pospending, 1);
Retro_ReadINT(&temp, 1);
set_CB2(temp);
Retro_ReadINT(&PIA_CB2_negpending, 1);
Retro_ReadINT(&PIA_CB2_pospending, 1);
update_PIA_IRQ();
}
}
#endif /* __LIBRETRO__ */
void PIA_StateSave(void)
{
StateSav_SaveUBYTE( &PIA_PACTL, 1 );
atari800/src/pia.h
+5
View File
@@ -26,4 +26,9 @@ void PIA_PutByte(UWORD addr, UBYTE byte);
void PIA_StateSave(void);
void PIA_StateRead(UBYTE version);
#if defined(__LIBRETRO__)
void Retro_PIA_StateSave(void);
void Retro_PIA_StateRead(UBYTE version);
#endif
#endif /* PIA_H_ */
atari800/src/pokey.c
+74
View File
@@ -634,6 +634,80 @@ static void Update_Counter(int chan_mask)
#ifndef BASIC
#if defined(__LIBRETRO__)
void Retro_POKEY_StateSave(void)
{
int shift_key = 0;
int keypressed = 0;
UWORD random_scanline_counter_lo;
UWORD random_scanline_counter_hi;
Retro_SaveUBYTE(&POKEY_KBCODE, 1);
Retro_SaveUBYTE(&POKEY_IRQST, 1);
Retro_SaveUBYTE(&POKEY_IRQEN, 1);
Retro_SaveUBYTE(&POKEY_SKCTL, 1);
Retro_SaveINT(&shift_key, 1);
Retro_SaveINT(&keypressed, 1);
Retro_SaveINT(&POKEY_DELAYED_SERIN_IRQ, 1);
Retro_SaveINT(&POKEY_DELAYED_SEROUT_IRQ, 1);
Retro_SaveINT(&POKEY_DELAYED_XMTDONE_IRQ, 1);
Retro_SaveUBYTE(&POKEY_AUDF[0], 4);
Retro_SaveUBYTE(&POKEY_AUDC[0], 4);
Retro_SaveUBYTE(&POKEY_AUDCTL[0], 1);
Retro_SaveINT(&POKEY_DivNIRQ[0], 4);
Retro_SaveINT(&POKEY_DivNMax[0], 4);
Retro_SaveINT(&POKEY_Base_mult[0], 1);
// Store the random number generator for runahead and netplay. It's not seed based on the Atari like it is on other systems
random_scanline_counter_lo = random_scanline_counter & 0xFFFF;
random_scanline_counter_hi = (random_scanline_counter >> 16) & 0xFFFF;
Retro_SaveUWORD(&random_scanline_counter_lo, 1);
Retro_SaveUWORD(&random_scanline_counter_hi, 1);
}
void Retro_POKEY_StateRead(void)
{
int i, shift_key, keypressed;
UWORD random_scanline_counter_lo = 0;
UWORD random_scanline_counter_hi = 0;
Retro_ReadUBYTE(&POKEY_KBCODE, 1);
Retro_ReadUBYTE(&POKEY_IRQST, 1);
Retro_ReadUBYTE(&POKEY_IRQEN, 1);
Retro_ReadUBYTE(&POKEY_SKCTL, 1);
Retro_ReadINT(&shift_key, 1);
Retro_ReadINT(&keypressed, 1);
Retro_ReadINT(&POKEY_DELAYED_SERIN_IRQ, 1);
Retro_ReadINT(&POKEY_DELAYED_SEROUT_IRQ, 1);
Retro_ReadINT(&POKEY_DELAYED_XMTDONE_IRQ, 1);
Retro_ReadUBYTE(&POKEY_AUDF[0], 4);
Retro_ReadUBYTE(&POKEY_AUDC[0], 4);
Retro_ReadUBYTE(&POKEY_AUDCTL[0], 1);
for (i = 0; i < 4; i++) {
POKEY_PutByte((UWORD)(POKEY_OFFSET_AUDF1 + i * 2), POKEY_AUDF[i]);
POKEY_PutByte((UWORD)(POKEY_OFFSET_AUDC1 + i * 2), POKEY_AUDC[i]);
}
POKEY_PutByte(POKEY_OFFSET_AUDCTL, POKEY_AUDCTL[0]);
Retro_ReadINT(&POKEY_DivNIRQ[0], 4);
Retro_ReadINT(&POKEY_DivNMax[0], 4);
Retro_ReadINT(&POKEY_Base_mult[0], 1);
Retro_ReadUWORD(&random_scanline_counter_lo, 1);
Retro_ReadUWORD(&random_scanline_counter_hi, 1);
// Restore the random number generator for runahead and netplay. It's not seed based on the Atari like it is on other systems
random_scanline_counter = (random_scanline_counter_hi << 16) |
random_scanline_counter_lo;
}
#endif /* __LIBRETRO__ */
void POKEY_StateSave(void)
{
int shift_key = 0;
atari800/src/pokey.h
+5
View File
@@ -63,6 +63,11 @@ void POKEY_Scanline(void);
void POKEY_StateSave(void);
void POKEY_StateRead(void);
#if defined(__LIBRETRO__)
void Retro_POKEY_StateSave(void);
void Retro_POKEY_StateRead(void);
#endif
#endif
/* CONSTANT DEFINITIONS */
atari800/src/pokeysnd.c
+4
View File
@@ -165,8 +165,12 @@ int POKEYSND_bienias_fix = TRUE; /* when TRUE, high frequencies get emulated: b
#define BIENIAS_FIX POKEYSND_bienias_fix
#endif
#ifndef ASAP
#if defined(__LIBRETRO__)
int POKEYSND_stereo_enabled = TRUE;
#else /* __LIBRETRO__ */
int POKEYSND_stereo_enabled = FALSE;
#endif
#endif
int POKEYSND_volume = 0x100;
atari800/src/sio.c
+42
View File
@@ -1678,6 +1678,48 @@ int SIO_RotateDisks(void)
#ifndef BASIC
#if defined(__LIBRETRO__)
void Retro_SIO_StateSave(void)
{
int i;
for (i = 0; i < 8; i++) {
Retro_SaveINT((int*)&SIO_drive_status[i], 1);
Retro_SaveFNAME(SIO_filename[i]);
}
}
void Retro_SIO_StateRead(void)
{
int i;
for (i = 0; i < 8; i++) {
int saved_drive_status;
char filename[FILENAME_MAX];
Retro_ReadINT(&saved_drive_status, 1);
SIO_drive_status[i] = (SIO_UnitStatus)saved_drive_status;
Retro_ReadFNAME(filename);
if (filename[0] == 0)
continue;
/* If the disk drive wasn't empty or off when saved,
mount the disk */
switch (saved_drive_status) {
case SIO_READ_ONLY:
SIO_Mount(i + 1, filename, TRUE);
break;
case SIO_READ_WRITE:
SIO_Mount(i + 1, filename, FALSE);
break;
default:
break;
}
}
}
#endif /* __LIBRETRO__ */
void SIO_StateSave(void)
{
int i;
atari800/src/sio.h
+5
View File
@@ -59,4 +59,9 @@ int SIO_WriteSector(int unit, int sector, const UBYTE *buffer);
void SIO_StateSave(void);
void SIO_StateRead(void);
#if defined(__LIBRETRO__)
void Retro_SIO_StateSave(void);
void Retro_SIO_StateRead(void);
#endif
#endif /* SIO_H_ */
atari800/src/sound.c
+2
View File
@@ -231,7 +231,9 @@ int Sound_Setup(void)
return FALSE;
}
#ifndef __LIBRETRO__
POKEYSND_stereo_enabled = Sound_out.channels == 2;
#endif /* __LIBRETRO__ */
#ifndef SOUND_CALLBACK
free(process_buffer);
process_buffer_size = Sound_out.buffer_frames * Sound_out.channels * Sound_out.sample_size;
atari800/src/statesav.c
+471
View File
@@ -26,6 +26,14 @@
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#if defined(__LIBRETRO__)
#include <libretro.h>
#include <streams/memory_stream.h>
int Retro_SaveState_Size = 0;
#endif
#ifdef HAVE_ERRNO_H
#include <errno.h>
#endif
@@ -99,6 +107,12 @@ static size_t mem_write(const void *buf, size_t len, gzFile *stream);
#define Z_OK 0
#endif
#if defined(__LIBRETRO__)
static memstream_t* state_stream = NULL;
static bool state_stream_error = false;
#endif
static gzFile StateFile = NULL;
static int nFileError = Z_OK;
@@ -120,6 +134,119 @@ static void GetGZErrorText(void)
Log_print("State file I/O failed.");
}
#if defined(__LIBRETRO__)
/* Value is memory location of data, num is number of type to save */
void Retro_SaveUBYTE(const UBYTE* data, int num)
{
if (!state_stream || state_stream_error)
return;
/* Assumption is that UBYTE = 8bits and the pointer passed in refers
* directly to the active bits in a padded location. If not (unlikely)
* you'll have to redefine this to save appropriately for cross-platform
* compatibility */
if (memstream_write(state_stream, data, num) != num)
state_stream_error = true;
Retro_SaveState_Size += num;
}
void Retro_SaveINT(const int* data, int num)
{
if (!state_stream || state_stream_error)
return;
/* INTs are always saved as 32bits (4 bytes) in the file. They can be any size
* on the platform however. The sign bit is clobbered into the fourth byte saved
* for each int; on read it will be extended out to its proper position for the
* native INT size */
while (num > 0)
{
UBYTE signbit = 0;
unsigned int temp;
UBYTE byte;
int temp0 = *data++;
if (temp0 < 0)
{
temp0 = -temp0;
signbit = 0x80;
}
temp = (unsigned int)temp0;
byte = temp & 0xff;
if (memstream_write(state_stream, &byte, 1) != 1)
{
state_stream_error = true;
break;
}
temp >>= 8;
byte = temp & 0xff;
if (memstream_write(state_stream, &byte, 1) != 1)
{
state_stream_error = true;
break;
}
temp >>= 8;
byte = temp & 0xff;
if (memstream_write(state_stream, &byte, 1) != 1)
{
state_stream_error = true;
break;
}
temp >>= 8;
byte = (temp & 0x7f) | signbit;
if (memstream_write(state_stream, &byte, 1) != 1)
{
state_stream_error = true;
break;
}
num--;
Retro_SaveState_Size += 4;
}
}
/* Value is memory location of data, num is number of type to save */
void Retro_SaveUWORD(const UWORD* data, int num)
{
if (!state_stream || state_stream_error)
return;
/* UWORDS are saved as 16bits, regardless of the size on this particular
* platform. Each byte of the UWORD will be pushed out individually in
* LSB order. The shifts here and in the read routines will work for both
* LSB and MSB architectures. */
while (num > 0)
{
UWORD temp = *data++;
UBYTE byte = temp & 0xff;
if (memstream_write(state_stream, &byte, 1) != 1)
{
state_stream_error = true;
break;
}
temp >>= 8;
byte = temp & 0xff;
if (memstream_write(state_stream, &byte, 1) != 1)
{
state_stream_error = true;
break;
}
num--;
Retro_SaveState_Size += 2;
}
}
#endif
/* Value is memory location of data, num is number of type to save */
void StateSav_SaveUBYTE(const UBYTE *data, int num)
{
@@ -328,10 +455,354 @@ void StateSav_ReadFNAME(char *filename)
filename[namelen] = 0;
}
#if defined(__LIBRETRO__)
int Retro_SaveAtariState(uint8_t* data, size_t size, UBYTE SaveVerbose)
{
UBYTE StateVersion = SAVE_VERSION_NUMBER;
Retro_SaveState_Size = 0;
/* Clean up any existing memory stream */
if (state_stream)
{
memstream_close(state_stream);
memstream_set_buffer(NULL, 0);
state_stream = NULL;
}
state_stream_error = false;
if (!data || size < 1)
goto error;
/* Open memory stream */
memstream_set_buffer(data, size);
state_stream = memstream_open(1);
if (!state_stream)
goto error;
if (memstream_write(state_stream, "ATARI800", 8) != 8)
goto error;
Retro_SaveState_Size += 8;
Retro_SaveUBYTE(&StateVersion, 1);
Retro_SaveUBYTE(&SaveVerbose, 1);
/* The order here is important. Atari800_StateSave must be first because it saves the machine type, and
decisions on what to save/not save are made based off that later in the process */
Retro_Atari800_StateSave();
Retro_CARTRIDGE_StateSave();
Retro_SIO_StateSave();
Retro_ANTIC_StateSave();
Retro_CPU_StateSave(SaveVerbose);
Retro_GTIA_StateSave();
Retro_PIA_StateSave();
Retro_POKEY_StateSave();
#ifdef XEP80_EMULATION
//XEP80_StateSave();
#else
{
int local_xep80_enabled = FALSE;
Retro_SaveINT(&local_xep80_enabled, 1);
}
#endif /* XEP80_EMULATION */
PBI_StateSave();
#ifdef PBI_MIO
//PBI_MIO_StateSave();
#else
{
int local_mio_enabled = FALSE;
Retro_SaveINT(&local_mio_enabled, 1);
}
#endif /* PBI_MIO */
#ifdef PBI_BB
//PBI_BB_StateSave();
#else
{
int local_bb_enabled = FALSE;
Retro_SaveINT(&local_bb_enabled, 1);
}
#endif /* PBI_BB */
#ifdef PBI_XLD
//PBI_XLD_StateSave();
#else
{
int local_xld_enabled = FALSE;
Retro_SaveINT(&local_xld_enabled, 1);
}
#endif /* PBI_XLD */
#ifdef DREAMCAST
DCStateSave();
#endif
/* Close memory stream */
memstream_close(state_stream);
memstream_set_buffer(NULL, 0);
state_stream = NULL;
if (state_stream_error)
return FALSE;
return Retro_SaveState_Size;
error:
if (state_stream)
memstream_close(state_stream);
memstream_set_buffer(NULL, 0);
state_stream = NULL;
state_stream_error = true;
return FALSE;
}
void Retro_SaveFNAME(const char* filename)
{
UWORD namelen;
#ifdef HAVE_GETCWD
char dirname[FILENAME_MAX] = "";
/* Check to see if file is in application tree, if so, just save as
relative path....*/
if (getcwd(dirname, FILENAME_MAX) != NULL) {
if (strncmp(filename, dirname, strlen(dirname)) == 0)
/* XXX: check if '/' or '\\' follows dirname in filename? */
filename += strlen(dirname) + 1;
}
#endif
namelen = strlen(filename);
/* Save the length of the filename, followed by the filename */
Retro_SaveUWORD(&namelen, 1);
Retro_SaveUBYTE((const UBYTE*)filename, namelen);
}
int Retro_ReadAtariState(const uint8_t* data, size_t size)
{
char header_string[8];
UBYTE StateVersion = 0; /* The version of the save file */
UBYTE SaveVerbose = 0; /* Verbose mode means save basic, OS if patched */
Retro_SaveState_Size = 0;
/* Clean up any existing memory stream */
if (state_stream)
{
memstream_close(state_stream);
memstream_set_buffer(NULL, 0);
state_stream = NULL;
}
state_stream_error = false;
/* Open memory stream */
memstream_set_buffer((uint8_t*)data, size);
state_stream = memstream_open(0);
if (!state_stream)
goto error;
if (memstream_read(state_stream, header_string, 8) != 8)
goto error;
Retro_SaveState_Size += 8;
if (memcmp(header_string, "ATARI800", 8) != 0)
goto error;
if ((memstream_read(state_stream, &StateVersion, 1) != 1) ||
(memstream_read(state_stream, &SaveVerbose, 1) != 1))
goto error;
Retro_SaveState_Size += 2;
if (StateVersion > SAVE_VERSION_NUMBER || StateVersion < 3)
goto error;
Retro_Atari800_StateRead(StateVersion);
if (StateVersion >= 4) {
Retro_CARTRIDGE_StateRead(StateVersion);
Retro_SIO_StateRead();
}
Retro_ANTIC_StateRead();
Retro_CPU_StateRead(SaveVerbose, StateVersion);
Retro_GTIA_StateRead(StateVersion);
Retro_PIA_StateRead(StateVersion);
Retro_POKEY_StateRead();
if (StateVersion >= 6) {
#ifdef XEP80_EMULATION
//XEP80_StateRead();
#else
int local_xep80_enabled;
Retro_ReadINT(&local_xep80_enabled, 1);
if (local_xep80_enabled)
goto error;
#endif /* XEP80_EMULATION */
PBI_StateRead();
#ifdef PBI_MIO
//PBI_MIO_StateRead();
#else
{
int local_mio_enabled;
Retro_ReadINT(&local_mio_enabled, 1);
if (local_mio_enabled)
goto error;
}
#endif /* PBI_MIO */
#ifdef PBI_BB
//PBI_BB_StateRead();
#else
{
int local_bb_enabled;
Retro_ReadINT(&local_bb_enabled, 1);
if (local_bb_enabled)
goto error;
}
#endif /* PBI_BB */
#ifdef PBI_XLD
//PBI_XLD_StateRead();
#else
{
int local_xld_enabled;
Retro_ReadINT(&local_xld_enabled, 1);
if (local_xld_enabled)
goto error;
}
#endif /* PBI_XLD */
}
#ifdef DREAMCAST
DCStateRead();
#endif
/* Close memory stream */
memstream_close(state_stream);
memstream_set_buffer(NULL, 0);
state_stream = NULL;
if (state_stream_error)
return FALSE;
GTIA_consol_override = 0;
return Retro_SaveState_Size;
error:
if (state_stream)
memstream_close(state_stream);
memstream_set_buffer(NULL, 0);
state_stream = NULL;
state_stream_error = true;
return FALSE;
}
/* Value is memory location of data, num is number of type to save */
void Retro_ReadUBYTE(UBYTE* data, int num)
{
if (!state_stream || state_stream_error)
return;
if (memstream_read(state_stream, data, num) != num)
state_stream_error = true;
Retro_SaveState_Size += num;
}
/* Value is memory location of data, num is number of type to save */
void Retro_ReadUWORD(UWORD* data, int num)
{
if (!state_stream || state_stream_error)
return;
while (num > 0)
{
UBYTE byte1;
UBYTE byte2;
if (memstream_read(state_stream, &byte1, 1) != 1)
{
state_stream_error = true;
break;
}
if (memstream_read(state_stream, &byte2, 1) != 1)
{
state_stream_error = true;
break;
}
*data++ = (byte2 << 8) | byte1;
num--;
Retro_SaveState_Size += 2;
}
}
void Retro_ReadINT(int* data, int num)
{
if (!state_stream || state_stream_error)
return;
while (num > 0)
{
UBYTE signbit = 0;
int temp;
UBYTE byte1;
UBYTE byte2;
UBYTE byte3;
UBYTE byte4;
if (memstream_read(state_stream, &byte1, 1) != 1)
{
state_stream_error = true;
break;
}
if (memstream_read(state_stream, &byte2, 1) != 1)
{
state_stream_error = true;
break;
}
if (memstream_read(state_stream, &byte3, 1) != 1)
{
state_stream_error = true;
break;
}
if (memstream_read(state_stream, &byte4, 1) != 1)
{
state_stream_error = true;
break;
}
signbit = byte4 & 0x80;
byte4 &= 0x7f;
temp = (byte4 << 24) | (byte3 << 16) | (byte2 << 8) | byte1;
if (signbit)
temp = -temp;
*data++ = temp;
num--;
Retro_SaveState_Size += 4;
}
}
void Retro_ReadFNAME(char* filename)
{
UWORD namelen = 0;
Retro_ReadUWORD(&namelen, 1);
if (namelen >= FILENAME_MAX)
return;
Retro_ReadUBYTE((UBYTE*)filename, namelen);
filename[namelen] = 0;
}
#endif /* __RETROLIB__ */
int StateSav_SaveAtariState(const char *filename, const char *mode, UBYTE SaveVerbose)
{
UBYTE StateVersion = SAVE_VERSION_NUMBER;
if (StateFile != NULL) {
GZCLOSE(StateFile);
StateFile = NULL;
atari800/src/statesav.h
+15
View File
@@ -16,4 +16,19 @@ void StateSav_ReadUWORD(UWORD *data, int num);
void StateSav_ReadINT(int *data, int num);
void StateSav_ReadFNAME(char *filename);
#if defined(__LIBRETRO__)
int Retro_SaveAtariState(uint8_t* data, size_t size, UBYTE SaveVerbose);
int Retro_ReadAtariState(const uint8_t* data, size_t size);
void Retro_SaveUBYTE(const UBYTE* data, int num);
void Retro_SaveUWORD(const UWORD* data, int num);
void Retro_SaveINT(const int* data, int num);
void Retro_SaveFNAME(const char* filename);
void Retro_ReadUBYTE(UBYTE* data, int num);
void Retro_ReadUWORD(UWORD* data, int num);
void Retro_ReadINT(int* data, int num);
void Retro_ReadFNAME(char* filename);
#endif
#endif /* STATESAV_H_ */
atari800/src/sysrom.c
+25
View File
@@ -32,6 +32,10 @@
#include <stdio.h>
#include <string.h>
#ifdef HAVE_SYS_STAT_H
#include <sys/stat.h>
#endif
#include "sysrom.h"
#include "cfg.h"
@@ -266,6 +270,9 @@ int SYSROM_FindInDir(char const *directory, int only_if_not_set)
{
DIR *dir;
struct dirent *entry;
#ifdef HAVE_STAT
struct stat status;
#endif
if (only_if_not_set && num_unset_roms == 0)
/* No unset ROM paths left. */
@@ -281,7 +288,25 @@ int SYSROM_FindInDir(char const *directory, int only_if_not_set)
int id;
ULONG crc;
int matched_crc = FALSE;
if (entry->d_name[0] == '.') {
/* never match "." */
if (entry->d_name[1] == '\0')
continue;
/* never match ".." */
if (entry->d_name[1] == '.' && entry->d_name[2] == '\0')
continue;
}
Util_catpath(full_filename, directory, entry->d_name);
#ifdef HAVE_STAT
if (stat(full_filename, &status) == 0) {
if (S_ISDIR(status.st_mode))
continue ;
}
#endif
if ((file = fopen(full_filename, "rb")) == NULL)
/* Ignore non-readable files (e.g. directories). */
continue;
atari800/src/ui.c
+5
View File
@@ -1048,6 +1048,11 @@ int UI_SelectCartType(int k)
UI_MENU_ACTION(CARTRIDGE_THECART_32M, CARTRIDGE_THECART_32M_DESC),
UI_MENU_ACTION(CARTRIDGE_THECART_64M, CARTRIDGE_THECART_64M_DESC),
UI_MENU_ACTION(CARTRIDGE_XEGS_8F_64, CARTRIDGE_XEGS_8F_64_DESC),
UI_MENU_ACTION(CARTRIDGE_5200_SUPER_64, CARTRIDGE_5200_SUPER_64_DESC),
UI_MENU_ACTION(CARTRIDGE_5200_SUPER_128, CARTRIDGE_5200_SUPER_128_DESC),
UI_MENU_ACTION(CARTRIDGE_5200_SUPER_256, CARTRIDGE_5200_SUPER_256_DESC),
UI_MENU_ACTION(CARTRIDGE_5200_SUPER_512, CARTRIDGE_5200_SUPER_512_DESC),
UI_MENU_ACTION(CARTRIDGE_ATMAX_NEW_1024, CARTRIDGE_ATMAX_NEW_1024_DESC),
UI_MENU_END
};
atari800_libretro.info
+53
View File
@@ -0,0 +1,53 @@
# Software Information
display_name = "Atari - 5200 (Atari800)"
authors = "Petr Stehlik"
supported_extensions = "xfd|atr|dcm|cas|bin|a52|zip|atx|car|rom|com|xex|m3u"
corename = "Atari800"
categories = "Emulator"
license = "GPLv2"
permissions = ""
# Hardware Information
manufacturer = "Atari"
systemname = "Atari 5200"
systemid = "atari_5200"
database = "Atari - 5200"
display_version = "3.1.0"
# Libretro Features
supports_no_game = "false"
savestate = "true"
savestate_features = "null"
cheats = "false"
input_descriptors = "true"
memory_descriptors = "false"
libretro_saves = "false"
core_options = "true"
core_options_version = "1.0"
load_subsystem = "false"
hw_render = "false"
needs_fullpath = "true"
disk_control = "false"
is_experimental = "false"
needs_kbd_mouse_focus = "true"
# BIOS/Firmware
firmware_count = 5
firmware0_desc = "5200.rom (Atari 5200 BIOS)"
firmware0_path = "5200.rom"
firmware0_opt = "false"
firmware1_desc = "ATARIBAS.ROM (Atari BASIC)"
firmware1_path = "ATARIBAS.ROM"
firmware1_opt = "false"
firmware2_desc = "ATARIOSA.ROM (Atari 400/800 OS A)"
firmware2_path = "ATARIOSA.ROM"
firmware2_opt = "false"
firmware3_desc = "ATARIOSB.ROM (Atari 400/800 OS B)"
firmware3_path = "ATARIOSB.ROM"
firmware3_opt = "false"
firmware4_desc = "ATARIXL.ROM (Atari XL/XE OS)"
firmware4_path = "ATARIXL.ROM"
firmware4_opt = "false"
notes = "(!) 5200.rom (md5): 281f20ea4320404ec820fb7ec0693b38|(!) ATARIBAS.ROM (md5): 0bac0c6a50104045d902df4503a4c30b|(!) ATARIOSA.ROM (md5): eb1f32f5d9f382db1bbfb8d7f9cb343a|(!) ATARIOSB.ROM (md5): a3e8d617c95d08031fe1b20d541434b2|(!) ATARIXL.ROM (md5): 06daac977823773a3eea3422fd26a703"
description = "A port of the free and portable Atari800 emulator to libretro. This core supports games and programs written for the Atari 8-bit computers (400, 800, 600 XL, 800XL, 130XE) and 5200 console. When loaded, the core should boot to the Atari Computer - Memo Pad screen and will generate a .atari800.cfg config file in the frontend's home directory and will add the required BIOS files it detects in the frontend's system directory to the config file. Once that is done, users may manually select which Atari system to emulate through the Atari System core option. These and other options can also be modified through the core's own menu, accessible through the retrokeyboard's F1 key."
libretro/atari5200_hash.h
+277 -98
View File
@@ -1,6 +1,10 @@
#define a5200 0
#define a5200_40 1
#define a5200_ee_16 2
#define a5200 0 // 4, 8, NS16, 32
#define a5200_40 1 // Bounty Bob
#define a5200_ee_16 2 // 2 16k eeproms
#define a5200_64 3 // supercarts
#define a5200_128 4
#define a5200_256 5
#define a5200_512 6
typedef struct {
int type;
@@ -12,111 +16,286 @@ typedef struct {
a5200_rom a5200_game[] = {
{ a5200,"5200menu.bin",8192,0x0de2db48},
{ a5200,"aep.bin",16384,0x35484751},
{ a5200,"decathln.bin",16384,0xf43e7cd0},
{ a5200,"asteroid.bin",8192,0x38480891},
{ a5200_ee_16,"astrchse.bin",16384,0x4019ecec},
{ a5200,"ballblze.bin",32768,0x94d97d14},
{ a5200_ee_16,"bzone.bin",16384,0xb3b8e314},
{ a5200,"beamrid.bin",16384,0x9bae58dc},
{ a5200,"berzerk.bin",16384,0xbe3cd348},
{ a5200,"blckbelt.bin",32768,0xed47b0d8},
{ a5200,"blaster.bin",16384,0xc8f9c094},
{ a5200,"blueprnt.bin",16384,0x0624e6e7},
{ a5200_40,"bbstrksb.bin",40960,0x7873c6dd},
{ a5200_ee_16,"buckrog.bin",16384,0x04807705},
{ a5200_ee_16,"centiped.bin",16384,0x536a70fe},
{ a5200,"choplift.bin",16384,0x9ad53bbc},
{ a5200_ee_16,"congo.bin",16384,0xf1f42bbd},
{ a5200_ee_16,"cntrmsre.bin",16384,0xfd541c80},
{ a5200,"pitfall2.bin",16384,0x4b910461},
{ a5200_ee_16,"defender.bin",16384,0xbd52623b},
{ a5200_ee_16,"digdug.bin",16384,0x6a687f9c},
{ a5200,"dredfctr.bin",8192,0x460def2d},
{ a5200,"finalleg.bin",16384,0xd3bd3221},
{ a5200,"A.E. (Proto)",16384,0x35484751},
{ a5200,"Activision Decathlon",16384,0xf43e7cd0},
{ a5200,"Asteroids (USA) (Proto)",8192,0x38480891},
{ a5200_ee_16,"Astro Chase",16384,0x4019ecec},
{ a5200,"Ballblazer",32768,0x94d97d14},
{ a5200,"Ballblazer", 8192, 0xDEF2A207 },
{ a5200_ee_16,"Battle Zone (Proto)",16384,0xb3b8e314},
{ a5200,"Beamrider",16384,0x9bae58dc},
{ a5200,"Berzerk",16384,0xbe3cd348},
{ a5200,"Blackbelt (Proto)",32768,0xed47b0d8},
{ a5200,"Blaster (USA) (Proto)",16384,0xc8f9c094},
{ a5200,"Blue Print",16384,0x0624e6e7},
{ a5200_40,"Bounty Bob Strikes Back",40960,0x7873c6dd},
{ a5200_ee_16,"Buck Rogers - Planet of Zoom",16384,0x04807705},
{ a5200_ee_16,"Centipede",16384,0x536a70fe},
{ a5200,"Choplifter!",16384,0x9ad53bbc},
{ a5200_ee_16,"Congo Bongo",16384,0xf1f42bbd},
{ a5200_ee_16,"Counter Measure",16384,0xfd541c80},
{ a5200,"Dave Crane's Pitfall II - Lost Caverns",16384,0x4b910461},
{ a5200_ee_16,"Defender",16384,0xbd52623b},
{ a5200_ee_16,"Dig Dug",16384,0x6a687f9c},
{ a5200,"Dreadnaught Factor, The",8192,0x460def2d},
{ a5200,"Final Legacy (Proto)",16384,0xd3bd3221},
{ a5200_ee_16,"friskyt.bin",16384,0x04b299a4},
{ a5200,"frogger.bin",8192,0xae7e3444},
{ a5200_ee_16,"frogger2.bin",16384,0x0af19345},
{ a5200,"galaxian.bin",8192,0x3ef4a23f},
{ a5200,"Frisky Tom (Mouse Speed Fix)",32768,0x04b299a4},
{ a5200,"Frogger",8192,0xae7e3444},
{ a5200_ee_16,"Frogger II - Threeedeep!",16384,0x0af19345},
{ a5200,"Galaxian",8192,0x3ef4a23f},
{ a5200,"gorf.bin",8192,0xe955db74},
{ a5200,"gremlins.bin",32768,0x063ec2c4},
{ a5200_ee_16,"gyruss.bin",16384,0xcfd4a7f9},
{ a5200,"hero.bin",16384,0x18a73af3},
{ a5200_ee_16,"jamesbnd.bin",16384,0xd9ae4518},
{ a5200_ee_16,"joust.bin",16384,0xbfd30c01},
{ a5200_ee_16,"jrpacman.bin",16384,0x59983c40},
{ a5200_ee_16,"jungleh.bin",16384,0x2c676662},
{ a5200,"krazysht.bin",8192,0xee702214},
{ a5200,"kaboom.bin",4096,0x420f5d0b},
{ a5200_ee_16,"kangaroo.bin",16384,0xecfa624f},
{ a5200,"keystone.bin",8192,0x8fe3bb2c},
{ a5200,"laststar.bin",16384,0x83517703},
{ a5200_ee_16,"loontoon.bin",16384,0x84df4925},
{ a5200,"mario.bin",32768,0x873742f1},
{ a5200,"meebzork.bin",32768,0x9fb13411},
{ a5200,"megamnia.bin",8192,0x240a1e1a},
{ a5200,"meteorit.bin",16384,0xab8e035b},
{ a5200,"Gremlins",32768,0x063ec2c4},
{ a5200_ee_16,"Gyruss",16384,0xcfd4a7f9},
{ a5200,"H.E.R.O",16384,0x18a73af3},
{ a5200_ee_16,"James Bond 007",16384,0xd9ae4518},
{ a5200_ee_16,"Joust",16384,0xbfd30c01},
{ a5200_ee_16,"J.R. Pac-Man (Proto)",16384,0x59983c40},
{ a5200_ee_16,"Jungle Hunt",16384,0x2c676662},
{ a5200,"K-Razy Shoot-Out",8192,0xee702214},
{ a5200,"Kaboom!",4096,0x420f5d0b},
{ a5200_ee_16,"Kangaroo",16384,0xecfa624f},
{ a5200,"Keystone Kapers",8192,0x8fe3bb2c},
{ a5200,"Last Starfighter, The",16384,0x83517703},
{ a5200_ee_16,"Loony Tunes Hotel (Proto)",16384,0x84df4925},
{ a5200,"Mario Bros.",32768,0x873742f1},
{ a5200,"Meebzork",32768,0x9fb13411},
{ a5200,"MegaMania",8192,0x240a1e1a},
{ a5200,"Meteorites",16384,0xab8e035b},
{ a5200_ee_16,"microgam.bin",16384,0x931a454a},
{ a5200,"milliped.bin",16384,0x969cfe1a},
{ a5200,"mine2049.bin",16384,0x7df1adfb},
{ a5200_ee_16,"minigolf.bin",16384,0xc597c087},
{ a5200,"missile.bin",8192,0x44d3ff6f},
{ a5200_ee_16,"montezum.bin",16384,0x2a640143},
{ a5200,"mpatrol.bin",16384,0xd0b2f285},
{ a5200,"mntnking.bin",8192,0x0f24243c},
{ a5200,"docastle.bin",8192,0xaa55f9be},
{ a5200_ee_16,"mspacman.bin",16384,0x752f5efd},
{ a5200_ee_16,"pacman.bin",16384,0x8873ef51},
{ a5200,"pengo.bin",32768,0xe4f8ba8c},
{ a5200,"pitfall.bin",8192,0xb2887833},
{ a5200_ee_16,"polepos.bin",16384,0xabc2d1e4},
{ a5200_ee_16,"popeye.bin",16384,0xa18a9a40},
{ a5200,"Microgammon (Proto)",32768,0x960ce5e2},
{ a5200,"Millipede (Proto).bin",16384,0x969cfe1a},
{ a5200,"Miner 2049er Starring Bounty Bob",16384,0x7df1adfb},
{ a5200_ee_16,"Miniature Golf (Proto)",16384,0xc597c087},
{ a5200,"Missile Command",8192,0x44d3ff6f},
{ a5200_ee_16,"Montezuma's Revenge featuring Panama Joe",16384,0x2a640143},
{ a5200,"Moon Patrol",16384,0xd0b2f285},
{ a5200,"Mountain King",8192,0x0f24243c},
{ a5200,"Mr. Do's Castle",8192,0xaa55f9be},
{ a5200_ee_16,"Ms. Pac-Man",16384,0x752f5efd},
{ a5200_ee_16,"Pac-man",16384,0x8873ef51},
{ a5200,"Pengo",32768,0xe4f8ba8c},
{ a5200,"Pitfall.bin",8192,0xb2887833},
{ a5200_ee_16,"Pole Position",16384,0xabc2d1e4},
{ a5200_ee_16,"Popeye",16384,0xa18a9a40},
{ a5200,"qbert.bin",8192,0x3fe4a401},
{ a5200_ee_16,"qix.bin",16384,0xaea6d2c2},
{ a5200,"questroo.bin",16384,0xb5f3402b},
{ a5200,"rsbsebll.bin",32768,0x44166592},
{ a5200_ee_16,"QIX",16384,0xaea6d2c2},
{ a5200,"Quest For Quintana Roo",16384,0xb5f3402b},
{ a5200,"Realsports Baseball",32768,0x44166592},
{ a5200,"rsbktbll.bin",32768,0xdd217276},
{ a5200,"rsbktbll1.bin",32768,0xc90196fa},
{ a5200,"Realsports Basketball (Proto1)",32768,0xc90196fa},
{ a5200_ee_16,"rsbktbll2.bin",16384,0x0f996184},
{ a5200_ee_16,"rsftball.bin",16384,0x4336c2cc},
{ a5200_ee_16,"rssoccer.bin",16384,0xecbd1853},
{ a5200_ee_16,"rstennis.bin",16384,0x10f33c90},
{ a5200,"fractal.bin",32768,0x762c591b},
{ a5200,"riveraid.bin",8192,0x09fc7648},
{ a5200_ee_16,"roadrun.bin",16384,0xa97606ab},
{ a5200,"robotron.bin",16384,0x4252abd9},
{ a5200_ee_16,"spcedngn.bin",16384,0xb68d61e8},
{ a5200,"spaceinv.bin",8192,0xde5c354a},
{ a5200,"spceshut.bin",16384,0x387365dc},
{ a5200,"spitfire.bin",32768,0x3c311303},
{ a5200_ee_16,"sprtgoof.bin",16384,0x73b5b6fb},
{ a5200_ee_16,"starraid.bin",16384,0x7d819a9f},
{ a5200_ee_16,"startrek.bin",16384,0x69f23548},
{ a5200,"starwars.bin",8192,0x0675f0a5},
{ a5200_ee_16,"swa.bin",16384,0x75f566df},
{ a5200_ee_16,"stargate.bin",16384,0x1d1cee27},
{ a5200,"sprbreak.bin",4096,0xa0642110},
{ a5200,"scobra.bin",8192,0x97debcd2},
{ a5200,"spacman.bin",16384,0x0a4ddb1e},
{ a5200,"tempest.bin",16384,0x1187342f},
{ a5200,"trackfld.bin",16384,0x0ba22ece},
{ a5200,"vanguard.bin",32768,0xcaaea0a4},
{ a5200,"wow.bin",16384,0xd6f7ddfd},
{ a5200_ee_16,"xariarna.bin",16384,0xb8faaec3},
{ a5200,"xevious.bin",32768,0x382634dc},
{ a5200,"yllowsub.bin",4096,0xf47bc091},
{ a5200,"zaxxon.bin",32768,0x741746d1},
{ a5200,"zenji.bin",8192,0xda228530},
{ a5200,"znerangr.bin",16384,0x2959d827},
{ a5200_ee_16,"Realsports Football",16384,0x4336c2cc},
{ a5200_ee_16,"Realsports Soccer",16384,0xecbd1853},
{ a5200_ee_16,"RealSports Tennis",16384,0x10f33c90},
{ a5200,"Rescue on Fractalus!",32768,0x762c591b},
{ a5200,"Carol Shaw's River Raid",8192,0x09fc7648},
{ a5200_ee_16,"Road Runner (Proto)",16384,0xa97606ab},
{ a5200,"Robotron 2084",16384,0x4252abd9},
{ a5200_ee_16,"Space Dungeon",16384,0xb68d61e8},
{ a5200,"Space Invaders",8192,0xde5c354a},
{ a5200,"Space Shuttle",16384,0x387365dc},
{ a5200,"Spitfire (Proto)",32768,0x3c311303},
{ a5200_ee_16,"Sport Goofy (Proto)",16384,0x73b5b6fb},
{ a5200_ee_16,"Star Raiders",16384,0x7d819a9f},
{ a5200_ee_16,"Star Trek - Strategic Operations Simulator",16384,0x69f23548},
{ a5200,"Star Wars - Death Star Battle",8192,0x0675f0a5},
{ a5200_ee_16,"Star Wars - The Arcade Game",16384,0x75f566df},
{ a5200_ee_16,"Stargate (Proto)",16384,0x1d1cee27},
{ a5200,"Super Breakout",4096,0xa0642110},
{ a5200,"Super Cobra",8192,0x97debcd2},
{ a5200,"Super Pac-Man (USA) (Proto)",16384,0x0a4ddb1e},
{ a5200,"Tempest (Proto)",16384,0x1187342f},
{ a5200,"Track And Field",16384,0x0ba22ece},
{ a5200,"Vanguard",32768,0xcaaea0a4},
{ a5200,"Wizard Of Wor",16384,0xd6f7ddfd},
{ a5200_ee_16,"Xari Arena (Proto)",16384,0xb8faaec3},
{ a5200_ee_16,"Xari Arena (9-20-83)",16384,0x29178296},
{ a5200,"Xevious",32768,0x382634dc},
{ a5200,"Yellow Submarine (Proto)",4096,0xf47bc091},
{ a5200,"Zaxxon",32768,0x741746d1},
{ a5200,"Zenji",8192,0xda228530},
{ a5200,"Zone Ranger",16384,0x2959d827},
{ a5200,"petetest.bin",8192,0x28278cd6},
{ a5200_ee_16,"pamdiag2.bin",16384,0xe8b130c4},
{ a5200_ee_16,"pamdg23.bin",16384,0xce07d9ad},
{ a5200,"finaltst.bin",8192,0x7ea86e87},
{ a5200,"boogie.bin",4096,0x3bd5fdd6},
{ a5200,"cblast.bin",32768,0x7c988054},
{ a5200,"ccrisis.bin",32768,0xd50e4061},
{ a5200,"koffiyk.bin",32768,0x917be656},
{ a5200,"tempest (atariage).bin",32768,0xa6400e17},
{ a5200,"Boogie",16384,0x7a9d9f85},
{ a5200,"Castle Blast",32768,0x7c988054},
{ a5200,"Castle Crisis",32768,0xd50e4061},
{ a5200,"Koffi - Yellow Kopter",32768,0x917be656},
{ a5200,"Tempest (Atariage)",32768,0xa6400e17},
{ a5200,"Abracadabra",32768, 0x538a852e},
{ a5200,"3-D Tic-Tac-Toe", 32768, 0x38ec4bfe },
{ a5200,"Adventure 2 (Advanced - Special)", 32768, 0xaa600fac },
{ a5200,"Adventure 2 (Easy - Intermediate)", 32768, 0x69cc2cd6 },
{ a5200,"Alien Assault 2121 (A800)", 32768, 0x0dd8c1a0 },
{ a5200,"Analog Classics #1 (A800)", 32768, 0x3e382e45 },
{ a5200,"Ant Eater (A800)", 16384, 0x821f0d97 },
{ a5200,"Archon (A800)", 32767, 0x7bef7c2d },
{ a5200,"Asteroids (5200 Hack)", 8192, 0x28ec3d93 },
{ a5200,"Asteroids (A800)(Improved Defense-Slow Flip)", 16384, 0x0ce7a6e6 },
{ a5200,"Asteroids (A800)", 16384, 0x4e4bf0bd },
{ a5200,"Asteroids Vector Edition", 16384, 0xdd5ecbaa },
{ a5200,"Atlantis", 32768, 0xc99db95f },
{ a5200,"Attack of the Mutant Camels (A800)", 32768, 0x15cafede },
{ a5200,"Baby Berks", 32768, 0x8bc856cc },
{ a5200,"Bacterion (A800)", 8192, 0x4a2056d5 },
{ a5200,"Barnstorming", 16384, 0xf9addb80 },
{ a5200,"Basketball (A800)", 16384, 0x84acbf42 },
{ a5200,"Batty Builders (A800)", 32768, 0x67261f79 },
{ a5200,"BC's Quest For Tires (A800)", 32768, 0xa3a16596 },
{ a5200,"Beef Drop - Ultimate SD Digital Edition", 32768, 0x55545848 },
{ a5200,"Beef_Drop Demo (Fixed level 3)", 32768, 0x48a43bae },
{ a5200,"Blowsub", 16384, 0x3aa7bc0e },
{ a5200,"Boogie", 16384, 0x7a9d9f85 },
{ a5200,"BoulderDash (A800)", 32768, 0x00b9a3f4 },
{ a5200_40,"Bounty Bob Strikes Back", 40960, 0x57e7945e },
{ a5200,"Bowling", 16384, 0xd7237961 },
{ a5200,"Buried Bucks (A800)", 32768, 0x1d161671 },
{ a5200,"Captain Beeble (A800)", 32768, 0x2b760c6e },
{ a5200,"Capture The Flag (A800)", 16384, 0xd1d31e79 },
{ a5200,"Caverns Of Mars 2 (A800)", 16384, 0x2fdb70c1 },
{ a5200,"Caverns Of Mars (A800)", 32768, 0xd1b64581 },
{ a5200,"Caverns Of The Lost Miner (A800)", 32768, 0xff93b2db },
{ a5200,"Chess (Parker Brothers) (A800)", 32768, 0x0f6c1af4 },
{ a5200,"Chicken (A800)", 32768, 0xb2d018b1 },
{ a5200,"Chop Suey", 32768, 0x0244c402 }, //Atari800 improperly detects this as an ATARI Basic file.
{ a5200,"Christmas Cart", 16384, 0x38f4a6a4 },
{ a5200,"Claim Jumper (A800)", 16384, 0xb0553a77 },
{ a5200,"Cloud Burst (A800)", 16384, 0x58a0d074 },
{ a5200,"Clowns & Balloons (A800)", 32768, 0x0dafa507 },
{ a5200,"Crossfire (A800)", 32768, 0xd56be4bc },
{ a5200,"Crystal Castles (Clay) (A800)", 32768, 0xd3b10b5d },
{ a5200,"Crystal Castles (A800)", 32768, 0x596F61D1 },
{ a5200,"Curse Of The Lost Miner (A800)", 32768, 0x8cabcad2 },
{ a5200,"Curse Of The Lost Mines (A800)", 32768, 0xc15a1d9d },
{ a5200,"Deluxe Invaders (A800)", 16384, 0xaf796cfc },
{ a5200,"Demon Attack (A800)", 32768, 0x2174730e },
{ a5200,"Desmonds Dungeon (A800)", 32768, 0x1273a5d1 },
{ a5200,"Diamond Mine (A800)", 32768, 0x7882a1c0 },
{ a5200,"Dig Dug 10-9 (A800)", 32768, 0x89fde0da },
{ a5200,"Donkey Kong Arcade (Hack) (A800)", 32768, 0x8eee62a0 },
{ a5200,"Donkey Kong Jr Arcade (Hack) (A800)", 32768, 0x624cf75c },
{ a5200,"Donkey Kong Jr Enhanced (Hack) (A800)", 32768, 0x383a9157 },
{ a5200,"Donkey Kong Jr (A800)", 32768, 0xb136c3f5 },
{ a5200,"Donkey Kong (A800)", 32768, 0xe902c79e },
{ a5200,"Drelbs (A800)", 16384, 0xbce9e1c2 },
{ a5200,"Ducks Ahoy (A800)", 32768, 0x7a10c551 },
{ a5200,"Dust In The Wind", 32768, 0xf92da5f7 },
{ a5200,"Embargo (A800)", 16384, 0x803808cf },
{ a5200,"EMI Pool (A800)", 16384, 0x5b3ceac8 },
{ a5200,"Encounter (A800)", 32768, 0x6bd0efea },
{ a5200,"Enduro (5200)", 8192, 0x327633db },
{ a5200,"ET Phone Home! (A800)", 32768, 0x5e82a934 },
{ a5200,"Fast Eddie (A800)", 32768, 0xbc0d17bd },
{ a5200,"Fast Food (A800)", 16384, 0x246651b1 },
{ a5200,"Fishing Derby (A800)", 16384, 0xf8583e78 },
{ a5200,"Floyd The Droid (A800)", 8192, 0x89b2d7e5 },
{ a5200,"Forbidden Forest - Slinky (A800)", 32768, 0x219615d9 },
{ a5200,"Fort Apocalypse (A800)", 32768, 0x1b809acc },
{ a5200,"Freecell XE (A800)", 32768, 0x2d2a2807 },
{ a5200,"Freeway (A800)", 16384, 0xb506352f },
{ a5200,"Frisky Tom (Mouse speed fix) (Proto)", 32768, 0x37622411 },
{ a5200,"Frostbite 400 (A800)", 16384, 0x97e75867 },
{ a5200,"Galactic Chase (A800)", 8192, 0x4c5f1847 },
{ a5200,"Galaga (Proto) (A800)", 32768, 0xecda2354 },
{ a5200,"Gateway To Apshai (A800)", 32768, 0x59ec9114 },
{ a5200,"Gauntlet Demo", 32768, 0x3f7f9bd9 },
{ a5200,"Gebelli Compilation (A800)", 32768, 0xc05ff97c },
{ a5200,"Gorf (Digital)", 32768, 0x7f732dc9 },
{ a5200,"Gunpowder Charlie (A800)", 8192, 0x8deefa2f },
{ a5200,"Hyperblast! (A800)", 32768, 0x5ae93e04 },
{ a5200,"Intellidiscs", 32768, 0xe76a0fb6 },
{ a5200,"Ixion (A800)", 32768, 0xa84e68b9 },
{ a5200,"Jawbreaker (A800)", 32768, 0xb6150460 },
{ a5200,"Jet Boot Jack (A800)", 32768, 0xaf210f8e },
{ a5200,"Journey To The Planets (A800)", 32768, 0x31498fe6 },
{ a5200,"Jumpman Jr. (A800)", 32768, 0xfb35d43b },
{ a5200,"Juno First (A800)", 32768, 0x34928a3f },
{ a5200,"K-Star Patrol (A800)", 32768, 0xcb5355b9 },
{ a5200,"Kid Grid (A800)", 8192, 0x2ad24e49 },
{ a5200,"Kooky Diver 2021 (A800)", 32768, 0xe64eb7f1 },
{ a5200,"Kooky Klimber 2021 (A800)", 32768, 0xd0fe471b },
{ a5200,"Kooky's Quest 2021 (A800)", 32768, 0xd1425786 },
{ a5200,"Laser Gates (A800)", 32768, 0x73a3f5f4 },
{ a5200,"Magical Fairy Force (A800)", 32768, 0x2619c4f2 },
{ a5200,"Major Blink", 32768, 0xfe9abd19 },
{ a5200,"Mario Bros Arcade (A800)", 32768, 0x0d9ee13e },
{ a5200,"Missile Command Plus (A800)", 32768, 0xda25c34a },
{ a5200,"Mr. Cool (A800)", 32768, 0xb132a38d },
{ a5200,"Ms Pac-Man Encore (A800)", 32768, 0xdaeae9ad },
{ a5200,"Necromancer (A800)", 32768, 0x5b7303ed },
{ a5200,"O'Riley's Mine (A800)", 32768, 0x646bbe82 },
{ a5200,"Oil's Well (A800)", 32768, 0x0f77eb0d },
{ a5200,"Pac-man Fixed Munch", 32768, 0x21966b5c },
{ a5200,"Pac-man Plus (A800)", 32768, 0xd3363d1c },
{ a5200,"Pacman Arcade Demo V2 (A800)", 32768, 0xb3351c89 },
{ a5200,"Pacific Coast Highway (A800)", 32768, 0x4cc139d0 },
{ a5200,"Pastfinder (A800)", 32768, 0x366c9c2a },
{ a5200,"Phobos (A800)", 16384, 0x2fb8412a },
{ a5200,"Phoenix 2021 (A800)", 32768, 0x4ad9e737 },
{ a5200,"Pinhead", 16384, 0x2af2aa4b },
{ a5200,"Piracy 1621 (A800)", 32768, 0x762ec09c },
{ a5200,"Pitfall! (Classics Fix)", 32768, 0x78cd4061 },
{ a5200,"Pitstop (A800)", 32768, 0xc23d81f5 },
{ a5200,"Pooyan (A800)", 32768, 0x28210510 },
{ a5200,"Popeye Arcade (A800)", 32768, 0x87c94e0b },
{ a5200,"Preppie! II (A800)", 32768, 0x790a8be1 },
{ a5200,"Preppie! (A800)", 32768, 0x47dc1314 },
{ a5200,"Protector II (A800)", 32768, 0x2c1615d0 },
{ a5200,"Q-bert (No Button)", 8192, 0xaaf3d843 },
{ a5200,"Rainbow Walker (A800)", 16384, 0xcfe4aa0c },
{ a5200,"Rally Speedway (A800)", 32768, 0xd9e3fb4d },
{ a5200,"Rampage (A800)", 32768, 0xb3f352f2 },
{ a5200,"Ramses' Revenge 2021 BC (A800)", 32768, 0xc5aae92b },
{ a5200,"Raster Music Tracker", 32768, 0xc790a3a0 },
{ a5200,"Ratcatcher (A800)", 32768, 0x17c7708d },
{ a5200,"Realsports Curling", 32768, 0x0b5b6fbb },
{ a5200,"Rob n Banks (A800)", 32768, 0x9c34cc76 },
{ a5200,"Robot Dungeon 2121 (A800)", 32768, 0x971027bd },
{ a5200,"Rockball (A800)", 32768, 0xb975d952 },
{ a5200,"Rolltris (A800)", 32768, 0x39eb84a0 },
{ a5200,"Runner Bear (A800)", 32768, 0x9a4f1056 },
{ a5200,"Satan's Hollow (A800)", 32768, 0xfdf0f296 },
{ a5200,"Savage Pond (A800)", 16384, 0xc1f458e6 },
{ a5200,"Scramble (A800)", 32768, 0x41e48cff },
{ a5200,"Sea Chase (A800)", 16384, 0xa87c92e0 },
{ a5200,"Sea Dragon (A800)", 16384, 0x20b68254 },
{ a5200,"Shamus Case II (A800)", 32768, 0xa0e29983 },
{ a5200,"Shamus (A800)", 32768, 0x04eb6f41 },
{ a5200,"Sinistar (A800)", 32768, 0xfb1429b4 },
{ a5200,"Slime (A800)", 32768, 0x4b098ebc },
{ a5200,"Space Assailants 2121 (A800)", 32768, 0xb10338f5 },
{ a5200,"SpeedAce (A800)", 32768, 0x4e35e0fc },
{ a5200,"Spy Hunter (A800)", 32768, 0x4eff1e32 },
{ a5200,"Star Rider (A800)", 16384, 0xb9a9a96b },
{ a5200,"Tapper (A800)", 32768, 0xc18d30fa },
{ a5200,"Tempest (AtariAge)", 32768, 0x015e08b0 },
{ a5200,"Tennis (A800)", 16384, 0xd7e15040 },
{ a5200,"Thetris (A800)", 32768, 0x2f02d826 },
{ a5200,"TimeRunner (A800)", 32768, 0x6483d20c },
{ a5200,"TimeSlip (A800)", 32768, 0x97a9e3f7 },
{ a5200,"Train 1 (A800)", 32768, 0x6e32458b },
{ a5200,"Train 2 (A800)", 32768, 0x3f26a60c },
{ a5200,"Train 3 (A800)", 32768, 0x8716e7c8 },
{ a5200,"Turmoil (A800)", 32768, 0xe3ae4170 },
{ a5200,"Up'n Down (A800)", 32768, 0xb08ca999 },
{ a5200,"Yahtzee 2021 (A800)", 32768, 0x63a5dc8f },
{ a5200,"Worm War I (A800)", 32768, 0x271fdab5 },
{ a5200,"Yar's Strike (A800)", 8192, 0xd1c6f325 },
{ a5200,"Zaxxon 32k (A800)", 32768, 0xbddfd255 },
{ a5200_64,"Berks4", 65536, 0x56aca9c3 },
{ a5200_64,"Dropzone (A800)", 65536, 0x42214594 },
{ a5200_64,"ET Phone Home! (A800)", 65536, 0x0fd0ef86 },
{ a5200_64,"Laser Hawk (A800)", 65536, 0x2e2bee02 },
{ a5200_64,"Mr. Do (A800)", 65536, 0x4d66d5ab },
{ a5200_64,"M.U.L.E (A800)", 65536, 0x1f21446e },
{ a5200_64,"Oil's Well (Title) (A800)", 65536, 0x6a1ebc7d },
{ a5200_64,"Rampage 64K (A800)", 65536, 0xdf48d7d4 },
{ a5200_64,"Sea Dragon 64k (A800)", 65536, 0x66b4ea6b },
{ a5200_64,"Super Pac-man 64k (A800)", 65536, 0x93866191 },
{ a5200_512,"Bosconian (A800)", 524288, 0xbbc7d63c },
{ -1,"",0,0},
} ;
libretro/atari800_hash.h
+262
View File
@@ -0,0 +1,262 @@
#define a800 0 // STD_8, STD_16, XEGS_32
#define a800_40 1 // Bounty Bob
#define a800_WILL_64 2 // 64 KB Williams cartridge
#define a800_XE_07_64 3 // XEGS 64 KB cartridge (banks 0-7)
#define a800_XE_128 4 // XEGS 128 KB cartridge
//#define a800_XE_256 4 // XEGS 256 KB cartridge. Not sure if any exist.
//#define a800_XE_512 5 // XEGS 512 KB cartridge. Not sure if any exist.
//#define a800_XE_1024 6 // XEGS 1 MB cartridge. Not sure if any exist.
#define a800_MAX_128 5 // Atarimax 128 KB Flash cartridge
#define a800_MAX_1024 6 // Atarimax 1 MB Flash cartridge (old)
typedef struct {
int type;
char name[50];
int size;
ULONG crc;
} a800_rom;
a800_rom a800_game[] = {
{ a800,"3-D Tic-Tac-Toe",8192,0x1cf50ebe},
{ a800,"Abracadabra!",16384,0xa35c775d},
{ a800_XE_128,"Ace Of Aces",131072,0xebad3ddb},
{ a800,"Activision Decathlon",16384,0x7cc0118b},
{ a800,"Adventure Creator",16384,0x8746d9da},
{ a800_XE_128,"Airball",131072,0xa0ccb3c1},
{ a800,"Alf In Color Caves",16384,0x79df7f9d},
{ a800,"Alien Ambush",8192,0xad7bc30b},
{ a800,"Alien Garden",8192,0x3e27ed0f},
{ a800,"Alpha Shield",8192,0xa7ade454},
{ a800_MAX_1024,"Alternate Reality- The City (MF) (Proto)",1048576,0x52cbd474},
{ a800_MAX_1024,"Alternate Reality- The Dungeon (MF)v9",1048576,0x9fd8d4d3},
{ a800,"Ant Eater",8192,0xc7290722},
{ a800,"Archon- The Light And The Dark",32768,0x2636829f},
{ a800_MAX_128,"Arkanoid I, II, III (MF)",131072,0x70f7bbe5},
{ a800,"Asteroids",8192,0xf9fff4a4},
{ a800,"Astro Chase (First Star Software)",16384,0x18752991},
{ a800,"Astro Chase",16384,0x11f1c7fa},
{ a800,"Atlantis",8192,0xbe0b390c},
{ a800,"Attack At EP-CYG-4",163834,0xdca02ca0},
{ a800,"Attack Of The Mutant Camels",163834,0xc933d741},
{ a800_XE_07_64,"Ballblazer",65536,0x820e5ce5},
{ a800,"Baseball",16384,0x065c3fd2},
{ a800,"Basketball",8192,0x79934851},
{ a800_XE_07_64,"Battlezone",65536,0x692515f2},
{ a800,"BC's Quest For Tires",16384,0xdddc6e36},
{ a800,"Beamrider",16384,0x2b05b8df},
{ a800_MAX_128,"Beyond Castle Wolfenstein (MF)",131926,0xf454689b},
{ a800,"Blue Max",32768,0x003f41ac},
{ a800,"Blaster",16384,0xce1126a2},
{ a800,"Boulderdash",16384,0xaf778329},
{ a800,"Boulders And Bombs",16384,0xab2ec21c},
{ a800_40,"Bounty Bob Strikes Back!",40960,0x0d00f072},
{ a800,"Bristles",16384,0x4263d64d},
{ a800_XE_07_64,"Bruce Lee (Repro)",65536,0x255dfc59},
{ a800,"Buck Rogers - Planet Of Zoom",16384,0x84dd597c},
{ a800,"Captain Beeble",16384,0xad8400b1},
{ a800,"Carnival Massacre (CS)",16384,0xea764851},
{ a800,"Carnival Massacre",16384,0x1baf0c97},
{ a800,"Castle Crisis",32768,0x47acda14},
{ a800,"Castle Hassle",16384,0x5a9e938a},
{ a800,"Castles And Keys",16384,0xbe14c091},
{ a800,"Caverns Of Mars",16384,0x8b9b2f5e},
{ a800,"Centipede",8192,0x44bb1842},
{ a800,"Chess",8192,0x72860db1},
{ a800,"Chicken",8192,0x1ab4d8d8},
{ a800,"Choplifter! (Broderbund)",16384,0x3ebc05ff},
{ a800_XE_07_64,"Choplifter!",65536,0xd426eccc},
{ a800,"Claim Jumper",16384,0x1a333c4a},
{ a800,"Cloudburts",8192,0x259aa18b},
{ a800_XE_128,"Commando",131072,0x28288df4}, // falsely autodetected as an xex file
{ a800,"Computer Chess",8192,0x5ce06e94},
{ a800,"Computer War",16384,0x4922aac6},
{ a800_MAX_1024,"Conan (MF)",1048576,0x25feb642},
{ a800,"Congo Bongo",16384,0x7a588045},
{ a800,"Cosmic Life",16384,0x919eaaa9},
{ a800,"Cosmic Tunnels",16384,0xad56c2bf},
{ a800,"Crossfire",8192,0x4d7e0503},
{ a800,"Crystal Castles",32768,0x998fa803},
{ a800,"Dance Fantasy",8192,0xfaec94e7},
{ a800_XE_07_64,"Dark Chambers",65536,0xfa2f132c},
{ a800_XE_07_64,"David's Midnight Magic",65536,0xb7ca61a2},
{ a800,"Defender",16384,0x782a81e4},
{ a800,"Deluxe Invaders",8192,0x15dc9b31},
{ a800,"Demo Cart",16384,0x9bedcdf3},
{ a800,"Demon Attack",8192,0x91328072},
{ a800_XE_07_64,"Desert Falcon",65536,0xa8f9324d},
{ a800,"Diamond Mine",16384,0xd8f9b867},
{ a800,"Dig Dug (1983)",16384,0xfdbc57ed},
{ a800,"Dig Dug",16384,0x6d68114e},
{ a800,"Donkey Kong Jr.",16384,0xa4eb70ef},
{ a800,"Donkey Kong",16384,0xf2b76a27},
{ a800,"Dreadnaught Factor",8192,0xc26fbb5b},
{ a800,"Droids",8192,0x5bb0c159},
{ a800,"Ducks Ahoy",16384,0x4cdfceb9},
{ a800_WILL_64,"DynaKillers",65536,0xad050724},
{ a800,"Eastern Front (1941)",16384,0xccff4a03},
{ a800,"Enduro",8192,0xa538a1bb},
{ a800_MAX_128,"Eidolon- The (MF)",131072,0x46f363f7},
{ a800,"Embargo",8192,0x07b1560c},
{ a800,"Espial",16384,0x64946757},
{ a800,"E.T. Phone Home",16384,0xbce4ef51},
{ a800,"Fantastic Voyage",8192,0x7bde2593},
{ a800,"Fast Eddie",8192,0x53ac386a},
{ a800,"Fast Food",8192,0x77223249},
{ a800_XE_128,"Fight Night",131072,0x4440d167},
{ a800,"Final Legacy",16384,0x6bd0d8e4},
{ a800,"Final Orbit",8192,0x177007e9},
{ a800,"Firebird",8192,0xe3c0b5f1},
{ a800,"Flapper",16384,0x18803c52},
{ a800_XE_128,"Flight Simulator II",131072,0x10cfc489},
{ a800,"Flip And Flop",16384,0x8ae057be},
{ a800_MAX_1024,"Flob 1.0.3b",1048576,0xff236e36},
{ a800,"Food Fight",32767,0x4236f0ea},
{ a800,"Fort Apocalypse",16384,0xf79b33f0},
{ a800,"Fortune Hutner",8192,0x03255972},
{ a800,"Frogger II - Threeedeep!",16384,0xed35f49c},
{ a800,"Frogger",8192,0x40e9476c},
{ a800,"Galaxian",8192,0xd60027be},
{ a800,"Gateway To Apshai",16384,0x3a0c6eb0},
{ a800_XE_128,"G.A.T.O.",131072,0xab06a3f5},
{ a800_MAX_128,"Gauntlet (MF)",131072,0x48cface0},
{ a800,"Gold Mine",8192,0x8459b11e},
{ a800,"Gorf",8192,0x90d0c7d7},
{ a800,"Gridrunner",8192,0x752dd5fe},
{ a800,"Gyruss",16384,0x1da47d01},
{ a800,"H.E.R.O.",16384,0x6062d3ce},
{ a800,"Halftime Battlin Bands",16384,0x8d14b5d3},
{ a800_XE_07_64,"Hardball",65536,0xbf0c6df2},
{ a800,"Hypnotic Land",16384,0x4fb75909},
{ a800,"Into The Eagles Nest",32768,0xf31321c2},
{ a800,"James Bond 007",16384,0x19b4e3a1},
{ a800,"Jawbreaker II",8192,0xe2a63a2d},
{ a800_MAX_1024,"Jim Slide XL",1048576,0x5f74de4a},
{ a800,"Journey To The Planets",16384,0xdce59b65},
{ a800,"Joust",16384,0xf6ec618c},
{ a800,"Jumbo Jet Pilot",16384,0xf046332b},
{ a800_MAX_128,"Jumpman",131072,0x4b7beb03},
{ a800,"Jumpman Jr.",16384,0x6c79bbad},
{ a800,"Jungle Hunt",16384,0x1847a7d4},
{ a800,"K-Razy Antiks",8192,0x84ab21b0},
{ a800,"K-razy Kritters (K-Byte)",8192,0x50354927},
{ a800,"K-razy Kritters",8192,0xf854a3b4},
{ a800,"K-razy Shoot-Out (CBS)",8192,0x636a01f5},
{ a800,"K-razy Shoot-Out (K-Byte)",8192,0x4300f6ff},
{ a800,"K-Star Patrol",8192,0x44c71fae},
{ a800,"Kangaroo",16384,0x1ef94906},
{ a800_XE_128,"Karateka",131072,0x97646f16},
{ a800,"Keystone Kapers",8192,0x465e1763},
{ a800,"Kickback",8192,0x2480ed0a},
{ a800_MAX_128,"Koronis Rift (MF)",131072,0xd385b89c},
{ a800_XE_128,"Lode Runner",131072,0x7790f474},
{ a800_MAX_1024,"Lords Of Conquest (MF)",1048576,0x3d6c01bb},
{ a800_MAX_1024,"M.U.L.E. (MF)",1048576,0x0b84f03e},
{ a800,"Major League Hockey",8192,0x4ffbc999},
{ a800_XE_07_64,"Mario Bros. XE",65536,0x7ba07c34},
{ a800,"M.A.S.H.",8192,0xfa041093},
{ a800,"Matterhorn",16384,0xdcc308cf},
{ a800,"Megamania",8192,0xb3c5130c},
{ a800_XE_128,"Mean 18 (Proto)",131072,0x0ee74a89},
{ a800_XE_128,"Midi Maze (Proto)",131072,0x193a53f6},
{ a800,"Millipede",16384,0xfb7e45da},
{ a800,"Miner 2049er",16384,0x6b1478bf},
{ a800,"Missile Command",8192,0xd2e36392},
{ a800,"Mogul Maniac",16384,0x0c391600},
{ a800,"Monster Maze",16384,0x37049e57},
{ a800,"Moon Patrol",16384,0xb845edb8},
{ a800,"Mountain King",8192,0x79748c93},
{ a800,"Mr. Cool",8192,0x1345d10c},
{ a800,"Mr. Do's Castle",8192,0xf1b9a24a},
{ a800,"Mr. TNT",8192,0x701dbdea},
{ a800,"Mrs. Pac-Man",16384,0xf91d18cf},
{ a800_MAX_128,"Mysterious Adventures (MF)",131072,0xadd506c5},
{ a800,"Necromancer",16384,0x39250ff2},
{ a800,"Nightstrike",8192,0x61245a75},
{ a800,"Oil's Well",16384,0x030ecad6},
{ a800,"One-On-One - Dr J. Vs Larry Bird",32768,0xab060567},
{ a800_MAX_1024,"onEscape (121422) (MF)",1048576,0x083fb021},
{ a800,"Orc Attack",16384,0xfbfaefcd},
{ a800,"Ozzy's Orchard",16384,0x1554b983},
{ a800,"Pac-Man",8192,0x61cf6167},
{ a800_MAX_128,"Pac-Man Arcade",131072,0x19bc1482},
{ a800,"Pastfinder",16384,0x12694c3f},
{ a800,"Peanut Butter Panic",8192,0xcdeb7759},
{ a800,"Pengo",16384,0xd8a9fe0a},
{ a800,"Picnic Paranoia",16384,0xe386a621},
{ a800,"Pitfall! II - The Lost Caverns",16384,0x1668cf3b},
{ a800,"Pitfall!",8192,0xb58bdf1c},
{ a800,"Pitstop",16384,0xd49ebf91},
{ a800,"Plattermania",8192,0x6cef6f94},
{ a800,"Pole Position",16384,0x581570C4},
{ a800,"Pool 400",8192,0xa6c2130f},
{ a800,"Popeye",16384,0x00fce79a},
{ a800,"Porky's",16384,0x1733d3fc},
{ a800,"Powerstar",16384,0xdc0dca6e},
{ a800,"Princes And The Frog",8192,0x7ce79281},
{ a800_MAX_1024,"Prince of Persia 211206 (MF)",1048576,0x52df819c},
{ a800,"Protector II",16384,0x374f311f},
{ a800,"Q-bert",8192,0xff3f0472},
{ a800,"Qix",8192,0x967b8051},
{ a800,"Rack'em Up",16384,0x5335d935},
{ a800,"Rally Speedway",16384,0x0a0f6ea2},
{ a800,"Realsports Football",16384,0x5e8951f4},
{ a800,"Realsports Tennis",16384,0x9a34cbdc},
{ a800_XE_07_64,"Rescue On Fractalus",65536,0x1ca549ad},
{ a800,"Risk (Proto)",8192,0x688b0a0c},
{ a800,"River Raid",8192,0x6e601d81},
{ a800,"River Rescue",16384,0xc018c8a0},
{ a800,"Robotron 2084",16384,0x528fc44a},
{ a800,"Satan's Hollow",16384,0x0f7c7934},
{ a800_MAX_128,"Scott Adams Adventures (MF)",131072,0x5446bcb1},
{ a800,"Sea Chase",8192,0x99b5a1dd},
{ a800,"Sea Fox",16384,0x932cc9a8},
{ a800,"Serpentine",8192,0x1b555b41},
{ a800,"Shamus",16384,0xbd3f06ee},
{ a800,"Silicon Warrior",16384,0x0736c8ae},
{ a800,"Slime",16384,0x1babcad6},
{ a800,"Soccer",8192,0x784c7060},
{ a800_MAX_1024,"Space Harrier",1048576,0xca98abfc},
{ a800,"Space Invaders",8192,0x6c811a10},
{ a800,"Space Shuttle",16384,0x66832f68},
{ a800,"Spark Bugs",8192,0xf56eced2},
{ a800,"Speedway Blast",8192,0xf895cc47},
{ a800,"Spider City",8192,0x8f8c3841},
{ a800,"Springer",16384,0x81466b55},
{ a800,"Spy Hunter",16384,0x34df8ffc},
{ a800,"Squish Em",8192,0xe01600b8},
{ a800,"Stargate (Proto)",16384,0xf527b721},
{ a800,"Star Raiders II",32768,0x737d4196},
{ a800,"Star Raiders",8192,0x5ec023ba},
{ a800,"Star Trek - Strategic Operations Simulator",16384,0x9df169d9},
{ a800,"Star Wars - Arcade Game - The",16384,0xaea795f7},
{ a800,"Star Wars - Death Star Battle",16384,0xd9f5cac7},
{ a800,"Starion",16384,0x23faf9b3},
{ a800,"Submarine Commander",16384,0x77198b2b},
{ a800_MAX_1024,"Summer Games (MF)",1048576,0x92325dc3},
{ a800_XE_128,"Summer Games",131072,0x95e6932d},
{ a800,"Super Cobra",8192,0x2af38d2f},
{ a800,"Super Pac-Man (Early Proto)",16384,0xb985be78},
{ a800,"Super Pac-Man (Proto)",16384,0xb518dda8},
{ a800,"Super Zaxxon",16384,0x9e64e13b},
{ a800,"Survival Of The Fittest",8192,0x7f48fbc5},
{ a800_XE_07_64,"Tapper (Cart)",65536,0xeff12440},
{ a800_XE_07_64,"Thunderfox",65536,0xb15ccef2},
{ a800,"Topper",16384,0x0286eea6},
{ a800_XE_07_64,"Tower Toppler (Proto)",65536,0x6b5333bd},
{ a800,"Track And Field",16384,0x9e2484c8},
{ a800,"Turmoil",8192,0xfe48aadf},
{ a800,"Typo Attack",16384,0x89da4ff7},
{ a800,"Typo",8192,0x70585854},
{ a800_MAX_1024,"Ultima II - Revenge of the Enchantress",1048576,0xd2a6db16},
{ a800_MAX_1024,"Ultima III (MF)",1048576,0xb132a1da},
{ a800_MAX_1024,"Ultima IV (MF)",1048576,0x62b1571f},
{ a800,"Up'n Down",16384,0x53ea3bf6},
{ a800,"Wizard Of Wor",16384,0x8017e56a},
{ a800_MAX_128,"World Karate Championship (MF)",131072,0x83c87b17},
{ a800,"Worm War I",8291,0x79934b01},
{ a800_XE_128,"Xenophobe",131072,0x68466666},
{ a800,"Zaxxon",16384,0x21579706},
{ a800,"Zenji",16384,0xebc6ec2e},
{ a800,"Zone Ranger",16384,0x8f1e72e7},
{ -1,"",0,0},
} ;
libretro/cmdline.c
+1 -1
View File
@@ -22,7 +22,7 @@ void Add_Option(const char* option)
first++;
}
sprintf(XARGV[PARAMCOUNT++],"%s\0",option);
sprintf(XARGV[PARAMCOUNT++],"%s", option);
}
int pre_main(const char *argv)
libretro/core-mapper.c
+224 -78
View File
@@ -3,22 +3,17 @@
#include "retroscreen.h"
#include "platform.h"
#include "vkbd.h"
#include "input.h"
#include "pokey.h"
//CORE VAR
#ifdef _WIN32
char slash = '\\';
#else
char slash = '/';
#endif
extern const char *retro_save_directory;
extern const char *retro_system_directory;
extern const char *retro_content_directory;
char RETRO_DIR[512];
char DISKA_NAME[512]="\0";
char DISKB_NAME[512]="\0";
char TAPE_NAME[512]="\0";
extern void Screen_SetFullUpdate(int scr);
//extern void retro_message(const char* text, unsigned int frames, int alt);
long frame=0;
unsigned long Ktime=0 , LastFPSTime=0;
@@ -35,12 +30,9 @@ short signed int SNDBUF[1024*2];
int snd_sampler_pal = 44100 / 50;
int snd_sampler_ntsc = 44100 / 60;
//PATH
char RPATH[512];
//EMU FLAGS
int NPAGE = -1, KCOL = 1, BKGCOLOR = 0;
int SHOWKEY=-1;
int SHOWKEY = -1, SHOWKEYDELAY = 0;
int VKBD_OPACITY = -1;
#if defined(ANDROID) || defined(__ANDROID__)
@@ -48,35 +40,54 @@ int MOUSE_EMULATED=1;
#else
int MOUSE_EMULATED = -1;
#endif
int SHIFTON=-1,MOUSEMODE=-1,PAS=4;
int SND=1; //SOUND ON/OFF
int pauseg=0; //enter_gui
int touch=-1; // gui mouse btn
//JOY
int al[2][2];//left analog1
int ar[2][2];//right analog1
unsigned char MXjoy[4]; // joy
int16_t joypad_bits[4];
extern UBYTE consol_mask;
#define JOYRANGE_UP_VALUE -16384 /* Joystick ranges in XY */
#define JOYRANGE_DOWN_VALUE 16383
#define JOYRANGE_LEFT_VALUE -16384
#define JOYRANGE_RIGHT_VALUE 16383
extern int a5200_joyhack;
// retro core option variables
extern int atari_joyhack;
extern int keyboard_type;
extern int pot_analog_deadzone;
extern int paddle_mode;
extern int paddle_speed;
//MOUSE
extern int INPUT_joy_5200_center;
extern int INPUT_joy_5200_min;
extern int INPUT_joy_5200_max;
extern int INPUT_digital_5200_min;
extern int INPUT_digital_5200_center;
extern int INPUT_digital_5200_max;
//MOUSE Is this even tied to anything?
extern int pushi; // gui mouse btn
int gmx,gmy; //gui mouse
int mouse_wu=0,mouse_wd=0;
//KEYBOARD
char Key_Sate[512];
char Key_Sate2[512];
static char old_Key_Sate[512];
int mbt[16]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
//Atari800 EMU mouse
extern UBYTE POKEY_POT_input[8];
extern int INPUT_mouse_pot_min;
extern int INPUT_mouse_pot_max;
//KEYBOARD
char Key_State[512];
static char old_Key_State[512];
int mbt[4][16] = { {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}, { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }
, { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 } };
//STATS GUI
int BOXDEC= 32+2;
@@ -84,7 +95,6 @@ int STAT_BASEY;
/*static*/ retro_input_state_t input_state_cb;
static retro_input_poll_t input_poll_cb;
extern void retro_audio_cb( short l, short r);
extern bool libretro_supports_bitmasks;
@@ -114,13 +124,14 @@ int slowdown=0;
#define RETRO_DEVICE_ATARI_KEYBOARD RETRO_DEVICE_SUBCLASS(RETRO_DEVICE_KEYBOARD, 0)
#define RETRO_DEVICE_ATARI_JOYSTICK RETRO_DEVICE_SUBCLASS(RETRO_DEVICE_JOYPAD, 1)
#define RETRO_DEVICE_ATARI_5200_JOYSTICK RETRO_DEVICE_SUBCLASS(RETRO_DEVICE_JOYPAD, 2)
void texture_uninit(void) { }
void texture_init(void)
{
memset(Retro_Screen, 0, sizeof(Retro_Screen));
memset(old_Key_Sate ,0, sizeof(old_Key_Sate));
memset(old_Key_State ,0, sizeof(old_Key_State));
gmx=(retrow/2)-1;
gmy=(retroh/2)-1;
@@ -151,7 +162,13 @@ void retro_sound_update(void)
}
}
extern void vkbd_key(int key,int pressed);
//extern void vkbd_key(int key,int pressed);
void Screen_SetFullUpdate(int scr)
{
if (scr == 0 || scr > 1)
memset(Retro_Screen, 0, sizeof(Retro_Screen));
}
void vkbd_key(int key,int pressed)
{
@@ -159,14 +176,14 @@ void vkbd_key(int key,int pressed)
{
if(SHIFTON==1)
;
Key_Sate[key]=1;
Key_State[key]=1;
// key is being held down
}
else
{
if(SHIFTON==1)
;
Key_Sate[key]=0;
Key_State[key]=0;
// key is being RELEASE
}
}
@@ -229,7 +246,7 @@ void retro_virtualkb(void)
virtual_kdb(( char *)Retro_Screen,vkx,vky);
i=8;
i=0; // swapped Button 1 and 2 definitions ( used to be 8 )
if( (joypad_bits[0] & (1 << i)) && vkflag[4]==0 )
vkflag[4]=1;
else if( !(joypad_bits[0] & (1 << i)) && vkflag[4]==1 )
@@ -310,12 +327,6 @@ void retro_virtualkb(void)
}
}
void Screen_SetFullUpdate(int scr)
{
if(scr==0 ||scr>1)
memset(Retro_Screen, 0, sizeof(Retro_Screen));
}
void Process_key(void)
{
int i;
@@ -324,13 +335,13 @@ void Process_key(void)
return;
for(i=0;i<320;i++)
Key_Sate[i]=input_state_cb(0, RETRO_DEVICE_KEYBOARD, 0,i) ? 0x80: 0;
Key_State[i]=input_state_cb(0, RETRO_DEVICE_KEYBOARD, 0,i) ? 0x80: 0;
if(memcmp( Key_Sate,old_Key_Sate , sizeof(Key_Sate) ) )
if(memcmp( Key_State,old_Key_State , sizeof(Key_State) ) )
{
for(i=0;i<320;i++)
{
if(Key_Sate[i] && Key_Sate[i]!=old_Key_Sate[i] )
if(Key_State[i] && Key_State[i]!=old_Key_State[i] )
{
if(i==RETROK_RCTRL)
{
@@ -352,7 +363,7 @@ void Process_key(void)
//retro_key_down(i);
}
else if ( !Key_Sate[i] && Key_Sate[i]!=old_Key_Sate[i] )
else if ( !Key_State[i] && Key_State[i]!=old_Key_State[i] )
{
if(i==RETROK_RCTRL)
{
@@ -378,7 +389,52 @@ void Process_key(void)
}
}
memcpy(old_Key_Sate,Key_Sate , sizeof(Key_Sate) );
memcpy(old_Key_State,Key_State , sizeof(Key_State) );
}
int Atari_POT(int input)
{
int which = input / 2;
int xval, yval, pval, result;
//if (consol_mask == 0x0f)
// return 228;
/* account for Joystick swap enabled */
if (atari_joyhack == 2)
which = (which + 1) % 2;
xval = input_state_cb(which, RETRO_DEVICE_ANALOG, RETRO_DEVICE_INDEX_ANALOG_LEFT, RETRO_DEVICE_ID_ANALOG_X);
yval = input_state_cb(which, RETRO_DEVICE_ANALOG, RETRO_DEVICE_INDEX_ANALOG_LEFT, RETRO_DEVICE_ID_ANALOG_Y);
pval = (input & 1) ? yval : xval;
if ((pval > -pot_analog_deadzone) && (pval < pot_analog_deadzone))
return INPUT_joy_5200_center;
/* Convert to amplitude */
float amplitude = (float)((pval > pot_analog_deadzone) ?
(pval - pot_analog_deadzone) :
(pval + pot_analog_deadzone)) /
(float)(LIBRETRO_ANALOG_RANGE - pot_analog_deadzone);
/* Map to Atari 5200 values */
if (amplitude >= 0.0f)
result = (JOY_5200_CENTER + (unsigned int)(((float)(INPUT_joy_5200_max - JOY_5200_CENTER) * amplitude) + 0.5f));
else
result = (JOY_5200_CENTER - (unsigned int)(((float)(JOY_5200_CENTER - INPUT_joy_5200_min) * -amplitude) + 0.5f));
/* for debug purposes */
//if (input == 1)
//{
// char msg[256];
// //sprintf(msg, "X=%f, Y=%f, Deadzone=%f. Result- %i\n", xval / (float)LIBRETRO_ANALOG_RANGE, yval / (float)LIBRETRO_ANALOG_RANGE, (float)pot_analog_deadzone, result);
// sprintf(msg, "Joy Min=%i, Joy Max=%i. Result- %i\n", INPUT_joy_5200_max, INPUT_joy_5200_min, result);
// retro_message(msg, 60, 0);
//}
return result;
}
int Retro_PollEvent()
@@ -386,13 +442,12 @@ int Retro_PollEvent()
// RETRO B Y SLT STA UP DWN LEFT RGT A X L R L2 R2 L3 R3
// INDEX 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
int SAVPAS=PAS;
int i,j;
static int vbt[4][16]={
{0x0,0x0,0x0,0x0,0x01,0x02,0x04,0x08,0x80,0x40,0x0,0x0,0x0,0x0,0x0,0x0},
{0x0,0x0,0x0,0x0,0x01,0x02,0x04,0x08,0x80,0x40,0x0,0x0,0x0,0x0,0x0,0x0},
{0x0,0x0,0x0,0x0,0x01,0x02,0x04,0x08,0x80,0x40,0x0,0x0,0x0,0x0,0x0,0x0},
{0x0,0x0,0x0,0x0,0x01,0x02,0x04,0x08,0x80,0x40,0x0,0x0,0x0,0x0,0x0,0x0},
{0x80,0x0,0x0,0x0,0x01,0x02,0x04,0x08,0x10,0x40,0x0,0x0,0x0,0x0,0x0,0x0},
{0x80,0x0,0x0,0x0,0x01,0x02,0x04,0x08,0x10,0x40,0x0,0x0,0x0,0x0,0x0,0x0},
{0x80,0x0,0x0,0x0,0x01,0x02,0x04,0x08,0x10,0x40,0x0,0x0,0x0,0x0,0x0,0x0},
{0x80,0x0,0x0,0x0,0x01,0x02,0x04,0x08,0x10,0x40,0x0,0x0,0x0,0x0,0x0,0x0},
};
input_poll_cb();
@@ -414,12 +469,13 @@ int Retro_PollEvent()
int16_t mouse_x,mouse_y;
mouse_x=mouse_y=0;
if(SHOWKEY==-1 && pauseg==0)Process_key();
if (SHOWKEY==-1 && pauseg==0)
Process_key();
//Joy mode
for(j=0;j<4;j++)
{
for(i=4;i<10;i++)
for(i=0;i<16;i++)
{
if(joypad_bits[j] & (1 << i))
MXjoy[j] |= vbt[j][i]; // Joy press
@@ -428,21 +484,12 @@ int Retro_PollEvent()
}
}
if(a5200_joyhack) //hack for robotron right analog act as Joy1
if (atari_joyhack == 1 && !paddle_mode) //hack for robotron right analog act as Joy1
{
#if 0
int x,y;
#endif
//emulate Joy1 with joy analog right
ar[0][0] = (input_state_cb(0, RETRO_DEVICE_ANALOG, RETRO_DEVICE_INDEX_ANALOG_RIGHT, RETRO_DEVICE_ID_ANALOG_X));
ar[0][1] = (input_state_cb(0, RETRO_DEVICE_ANALOG, RETRO_DEVICE_INDEX_ANALOG_RIGHT, RETRO_DEVICE_ID_ANALOG_Y));
#if 0
x=ar[0][0];
y=ar[0][1];
#endif
/* Directions */
if (ar[0][1] <= JOYRANGE_UP_VALUE)
@@ -455,40 +502,141 @@ int Retro_PollEvent()
else if (ar[0][0] >= JOYRANGE_RIGHT_VALUE)
MXjoy[1] |= 0x08;
}
else if (atari_joyhack == 2 && !paddle_mode) //hack for Joy 1 / 2 swap.
{
//emulate Joy1 with joy analog right
al[0][0] = (input_state_cb(0, RETRO_DEVICE_ANALOG, RETRO_DEVICE_INDEX_ANALOG_LEFT, RETRO_DEVICE_ID_ANALOG_X));
al[0][1] = (input_state_cb(0, RETRO_DEVICE_ANALOG, RETRO_DEVICE_INDEX_ANALOG_LEFT, RETRO_DEVICE_ID_ANALOG_Y));
if (libretro_supports_bitmasks)
joypad_bits[1] = input_state_cb(0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_MASK);
else
{
joypad_bits[1] = 0;
joypad_bits[1] |= input_state_cb(0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_MASK) ? 1 : 0;
}
if(atari_devices[0]==RETRO_DEVICE_ATARI_JOYSTICK)
for (i = 0 ; i < 16; i++)
{
if (joypad_bits[1] & (1 << i))
MXjoy[1] |= vbt[0][i]; // Joy press
else if (MXjoy[1] & vbt[0][i])
MXjoy[1] &= ~vbt[0][i]; // Joy press
}
/* Directions */
if (al[0][1] <= JOYRANGE_UP_VALUE)
MXjoy[1] |= 0x01;
else if (al[0][1] >= JOYRANGE_DOWN_VALUE)
MXjoy[1] |= 0x02;
if (al[0][0] <= JOYRANGE_LEFT_VALUE)
MXjoy[1] |= 0x04;
else if (al[0][0] >= JOYRANGE_RIGHT_VALUE)
MXjoy[1] |= 0x08;
}
if ( atari_devices[0] != RETRO_DEVICE_ATARI_KEYBOARD)
{
//shortcut for joy mode only
//Button B Y SLT STA
// 0 1 2 3
for(i=0;i<4;i++)
for (i = 0; i < 16; i++)
{
if ( (joypad_bits[0] & (1 << i)) && mbt[i]==0 )
mbt[i]=1;
else if (mbt[i]==1 && !(joypad_bits[0] & (1 << i)) )
for (int j = 0; j < 4; j++)
{
mbt[i]=0;
if ((joypad_bits[j] & (1 << i)) && mbt[j][i] == 0)
mbt[j][i] = 1;
else if (mbt[j][i] == 1 && !(joypad_bits[j] & (1 << i)))
{
mbt[j][i] = 0;
#if defined(ANDROID) || defined(__ANDROID__)
/* apparently this is used by the ANDROID port? Keep in for now. Android only*/
if(i==2)
MOUSE_EMULATED = -MOUSE_EMULATED;
#endif
}
}
//Button L R L2 R2 L3 R3
// 10 11 12 13 14 15
for(i=10;i<16;i++)
{
if ( (joypad_bits[0] & (1 << i)) && mbt[i]==0 )
mbt[i]=1;
else if ( mbt[i]==1 && !(joypad_bits[0] & (1 << i)) )
{
mbt[i]=0;
if(i==14)
SHOWKEY = -SHOWKEY;
}
}
}//if atari_devices=joy
/* Huh? */
//for(i=0;i<4;i++)
//{
// if ( (joypad_bits[0] & (1 << i)) && mbt[i]==0 )
// mbt[i]=1;
// else if (mbt[i]==1 && !(joypad_bits[0] & (1 << i)) )
// {
// mbt[i]=0;
// //if(i==2) /* hard coded? android only? */
// // MOUSE_EMULATED = -MOUSE_EMULATED;
// }
//}
////Button L R L2 R2 L3 R3
//// 10 11 12 13 14 15
//for(i=10;i<16;i++)
//{
// if ( (joypad_bits[0] & (1 << i)) && mbt[i]==0 )
// mbt[i]=1;
// else if ( mbt[i]==1 && !(joypad_bits[0] & (1 << i)) )
// {
// mbt[i]=0;
// //if(i==14) /* removed can be defined in controller settings screen? */
// //SHOWKEY = -SHOWKEY;
// }
//}
}
else //Emulate joystick controls with keyboard/retro_keyboard only Joy 1 atm... experimental
{
// these are the same for both computer and 5200
if (Key_State[RETROK_KP8]) // up
MXjoy[0] |= 0x01;
else if (Key_State[RETROK_KP2]) // down
MXjoy[0] |= 0x02;
if (Key_State[RETROK_KP4]) // left
MXjoy[0] |= 0x04;
else if (Key_State[RETROK_KP6]) // right
MXjoy[0] |= 0x08;
if (Key_State[RETROK_RALT]) // fire 1
MXjoy[0] |= 0x80;
// 5200 fire button 2
if (Atari800_machine_type == Atari800_MACHINE_5200 && !UI_is_active)
if ( Key_State[RETROK_RCTRL])
INPUT_key_shift = 1;
}
if (paddle_mode)
{
for (int i = 0; i < 4; i++)
{
int pval = input_state_cb(i, RETRO_DEVICE_ANALOG, RETRO_DEVICE_INDEX_ANALOG_LEFT, RETRO_DEVICE_ID_ANALOG_X);
if ((pval < -pot_analog_deadzone) || (pval > pot_analog_deadzone))
{
if (pval > 0)
POKEY_POT_input[i] -= paddle_speed;
else
POKEY_POT_input[i] += paddle_speed;
}
else
{
if (joypad_bits[0] & (1 << RETRO_DEVICE_ID_JOYPAD_RIGHT))
POKEY_POT_input[i] -= paddle_speed;
if (joypad_bits[0] & (1 << RETRO_DEVICE_ID_JOYPAD_LEFT))
POKEY_POT_input[i] += paddle_speed;
}
if (POKEY_POT_input[i] < INPUT_mouse_pot_min)
POKEY_POT_input[i] = INPUT_mouse_pot_min;
if (POKEY_POT_input[i] > INPUT_mouse_pot_max)
POKEY_POT_input[i] = INPUT_mouse_pot_max;
}
}
if(MOUSE_EMULATED==1)
{
@@ -503,10 +651,8 @@ int Retro_PollEvent()
mouse_y += PAS;
if (joypad_bits[0] & (1 << RETRO_DEVICE_ID_JOYPAD_UP))
mouse_y -= PAS;
mouse_l = (joypad_bits[0] & (1 << RETRO_DEVICE_ID_JOYPAD_A)) ? 1 : 0;
mouse_r = (joypad_bits[0] & (1 << RETRO_DEVICE_ID_JOYPAD_B)) ? 1 : 0;
PAS=SAVPAS;
mouse_l = (joypad_bits[0] & (1 << RETRO_DEVICE_ID_JOYPAD_B)) ? 1 : 0;
mouse_r = (joypad_bits[0] & (1 << RETRO_DEVICE_ID_JOYPAD_A)) ? 1 : 0;
slowdown=1;
}
libretro/libretro-common/include/libretro.h
+939 -1
View File
File diff suppressed because it is too large Load Diff
libretro/libretro-common/include/streams/memory_stream.h
+63
View File
@@ -0,0 +1,63 @@
/* Copyright (C) 2010-2020 The RetroArch team
*
* ---------------------------------------------------------------------------------------
* The following license statement only applies to this file (memory_stream.h).
* ---------------------------------------------------------------------------------------
*
* Permission is hereby granted, free of charge,
* to any person obtaining a copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation the rights to
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
* and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
* INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#ifndef _LIBRETRO_SDK_FILE_MEMORY_STREAM_H
#define _LIBRETRO_SDK_FILE_MEMORY_STREAM_H
#include <stdint.h>
#include <stddef.h>
#include <retro_common_api.h>
RETRO_BEGIN_DECLS
typedef struct memstream memstream_t;
memstream_t *memstream_open(unsigned writing);
void memstream_close(memstream_t *stream);
uint64_t memstream_read(memstream_t *stream, void *data, uint64_t bytes);
uint64_t memstream_write(memstream_t *stream, const void *data, uint64_t bytes);
int memstream_getc(memstream_t *stream);
void memstream_putc(memstream_t *stream, int c);
char *memstream_gets(memstream_t *stream, char *buffer, size_t len);
uint64_t memstream_pos(memstream_t *stream);
void memstream_rewind(memstream_t *stream);
int64_t memstream_seek(memstream_t *stream, int64_t offset, int whence);
void memstream_set_buffer(uint8_t *buffer, uint64_t size);
uint64_t memstream_get_last_size(void);
uint64_t memstream_get_ptr(memstream_t *stream);
RETRO_END_DECLS
#endif
libretro/libretro-common/streams/memory_stream.c
+191
View File
@@ -0,0 +1,191 @@
/* Copyright (C) 2010-2020 The RetroArch team
*
* ---------------------------------------------------------------------------------------
* The following license statement only applies to this file (memory_stream.c).
* ---------------------------------------------------------------------------------------
*
* Permission is hereby granted, free of charge,
* to any person obtaining a copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation the rights to
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
* and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
* INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <streams/memory_stream.h>
/* TODO/FIXME - static globals */
static uint8_t* g_buffer = NULL;
static uint64_t g_size = 0;
static uint64_t last_file_size = 0;
struct memstream
{
uint64_t size;
uint64_t ptr;
uint64_t max_ptr;
uint8_t *buf;
unsigned writing;
};
void memstream_set_buffer(uint8_t *buffer, uint64_t size)
{
g_buffer = buffer;
g_size = size;
}
uint64_t memstream_get_last_size(void)
{
return last_file_size;
}
memstream_t *memstream_open(unsigned writing)
{
memstream_t *stream;
if (!g_buffer || !g_size)
return NULL;
stream = (memstream_t*)malloc(sizeof(*stream));
if (!stream)
return NULL;
stream->buf = g_buffer;
stream->size = g_size;
stream->ptr = 0;
stream->max_ptr = 0;
stream->writing = writing;
g_buffer = NULL;
g_size = 0;
return stream;
}
void memstream_close(memstream_t *stream)
{
if (!stream)
return;
last_file_size = stream->writing ? stream->max_ptr : stream->size;
free(stream);
}
uint64_t memstream_get_ptr(memstream_t *stream)
{
return stream->ptr;
}
uint64_t memstream_read(memstream_t *stream, void *data, uint64_t bytes)
{
uint64_t avail = 0;
if (!stream)
return 0;
avail = stream->size - stream->ptr;
if (bytes > avail)
bytes = avail;
memcpy(data, stream->buf + stream->ptr, (size_t)bytes);
stream->ptr += bytes;
if (stream->ptr > stream->max_ptr)
stream->max_ptr = stream->ptr;
return bytes;
}
uint64_t memstream_write(memstream_t *stream,
const void *data, uint64_t bytes)
{
uint64_t avail = 0;
if (!stream)
return 0;
avail = stream->size - stream->ptr;
if (bytes > avail)
bytes = avail;
memcpy(stream->buf + stream->ptr, data, (size_t)bytes);
stream->ptr += bytes;
if (stream->ptr > stream->max_ptr)
stream->max_ptr = stream->ptr;
return bytes;
}
int64_t memstream_seek(memstream_t *stream, int64_t offset, int whence)
{
uint64_t ptr;
switch (whence)
{
case SEEK_SET:
ptr = offset;
break;
case SEEK_CUR:
ptr = stream->ptr + offset;
break;
case SEEK_END:
ptr = (stream->writing ? stream->max_ptr : stream->size) + offset;
break;
default:
return -1;
}
if (ptr <= stream->size)
{
stream->ptr = ptr;
return 0;
}
return -1;
}
void memstream_rewind(memstream_t *stream)
{
memstream_seek(stream, 0L, SEEK_SET);
}
uint64_t memstream_pos(memstream_t *stream)
{
return stream->ptr;
}
char *memstream_gets(memstream_t *stream, char *buffer, size_t len)
{
return NULL;
}
int memstream_getc(memstream_t *stream)
{
int ret = 0;
if (stream->ptr >= stream->size)
return EOF;
ret = stream->buf[stream->ptr++];
if (stream->ptr > stream->max_ptr)
stream->max_ptr = stream->ptr;
return ret;
}
void memstream_putc(memstream_t *stream, int c)
{
if (stream->ptr < stream->size)
stream->buf[stream->ptr++] = c;
if (stream->ptr > stream->max_ptr)
stream->max_ptr = stream->ptr;
}
libretro/libretro-core.c
+712 -158
View File
File diff suppressed because it is too large Load Diff
libretro/libretro-core.h
+10 -2
View File
@@ -36,8 +36,7 @@
extern cothread_t mainThread;
extern cothread_t emuThread;
extern char Key_Sate[512];
extern char Key_Sate2[512];
extern char Key_State[512];
extern int pauseg;
@@ -76,4 +75,13 @@ extern int pauseg;
#endif
#define uint32 unsigned int
#define uint8 unsigned char
//Paddle & 5200 POT
#define LIBRETRO_ANALOG_RANGE 0x8000
#define JOY_5200_MIN 6
#define JOY_5200_MAX 220
#define JOY_5200_CENTER 114
void retro_message(const char* text, unsigned int frames, int alt);
void retro_audio_cb(short l, short r);
#endif
libretro/libretro_core_options.h
+736
View File
@@ -0,0 +1,736 @@
#ifndef LIBRETRO_CORE_OPTIONS_H__
#define LIBRETRO_CORE_OPTIONS_H__
#include <stdlib.h>
#include <string.h>
#include <libretro.h>
#include <retro_inline.h>
#ifndef HAVE_NO_LANGEXTRA
#include "libretro_core_options_intl.h"
#endif
/*
********************************
* VERSION: 1.0
********************************
*
* - 1.0: First commit. Support for cor options v2 interfaec.
* - libretro_core_options_intl.h includes BOM and utf-8
* fix for MSVC 2010-2013
* - Contains HAVE_NO_LANGEXTRA flag to disable translations
* on platforms/compilers without BOM support
* - Uses core options v1 interface when
* RETRO_ENVIRONMENT_GET_CORE_OPTIONS_VERSION is >= 1
* (previously required RETRO_ENVIRONMENT_GET_CORE_OPTIONS_VERSION == 1)
* - Support for generation of core options v0 retro_core_option_value
* arrays containing options with a single value
*/
#ifdef __cplusplus
extern "C" {
#endif
/*
********************************
* Core Option Definitions
********************************
*/
/* RETRO_LANGUAGE_ENGLISH */
/* Default language:
* - All other languages must include the same keys and values
* - Will be used as a fallback in the event that frontend language
* is not available
* - Will be used as a fallback for any missing entries in
* frontend language definition */
//struct retro_core_option_v2_category option_cats_us[] = {
// { NULL, NULL, NULL },
//};
struct retro_core_option_v2_category option_cats_us[] = {
{
"video",
"Video",
"Configure video standard (NTSC/PAL). Enable Hi-res artifacting and set artifacting mode. Set internal resolution"
},
{
"input",
"Input",
"Configure 5200 Digital and Analog Joystick sensitivity and Analog deadzone. Activate Swap or Dual Joysticks. Activate Paddle mode and set Paddle speed. Set retroarch keyboard type."
},
{ NULL, NULL, NULL },
};
struct retro_core_option_v2_definition option_defs_us[] = {
{
"atari800_ntscpal",
"Video Standard",
NULL,
"Select whether emulated system is NTSC (60hz) or PAL (50hz)",
NULL,
"video",
{
{ "NTSC", NULL },
{ "PAL", NULL },
{ NULL, NULL },
},
"disabled"
},
{
"atari800_artifacting_mode",
"Hi-Res Artifacting Mode",
NULL,
"Set Hi-Res Artifacting mode used. Typically dependant on the actual emulated system. Pick the color combination that pleases you.",
NULL,
"video",
{
{ "none", "None "},
{ "blue/brown 1", NULL },
{ "blue/brown 2", NULL },
{ "GTIA", NULL },
{ "CTIA", NULL },
{ NULL, NULL },
},
"none"
},
{
"atari800_resolution",
"Internal resolution",
NULL,
"Set emulated systems internal resolution.",
NULL,
"video",
{
{ "336x240", NULL },
{ "320x240", NULL },
{ "384x240", NULL },
{ "384x272", NULL },
{ "384x288", NULL },
{ "400x300", NULL },
{ NULL, NULL },
},
"336x240"
},
{
"atari800_opt2",
"Controller Hacks",
NULL,
"Apply gamepad input hacks required for specific games. 'Dual Stick' maps Player 2's joystick to the right analog stick of Player 1's RetroPad, enabling dual stick control in 'Robotron 2084' and 'Space Dungeon'. 'Swap Ports' maps Player 1 to port 2 and Player 2 to port 1 of the emulated console, correcting the swapped inputs of 'Wizard of Wor', 'Apple Panic' and a few other games",
NULL,
"input",
{
{ "none", NULL },
{ "enabled", "Dual Stick" },
{ "Swap Ports", "Swap Ports" },
{ NULL, NULL },
},
"none"
},
{
"paddle_active",
"Activate Paddle Mode",
NULL,
"Use analog stick and digital pad to control paddle games. Dual Stick and Swap Ports will be de-activated if this is enabled",
NULL,
"input",
{
{ "disabled", NULL },
{ "enabled", NULL },
{ NULL, NULL },
},
"disabled"
},
{
"paddle_movement_speed",
"Paddle Movement Speed",
NULL,
"Determines how fast the paddle will move.",
NULL,
"input",
{
{ "1", NULL },
{ "2", NULL },
{ "3", NULL },
{ "4", NULL },
{ "5", NULL },
{ "6", NULL },
{ "7", NULL },
{ "8", NULL },
{ "9", NULL },
{ NULL, NULL },
},
"3"
},
{
"pot_digital_sensitivity",
"Digital Joystick Sensitivity",
NULL,
"Set the effective range of the emulated analog joystick when using the gamepad's digital D-Pad for movement. Lower values equate to slower speeds. Also can be used to make games like Centipede, Kaboom, Missile Command, Pengo, Realsports Tennis, Pole Position, Xari Arena and Super Breakout more playable.",
NULL,
"input",
{
{ "5", "5%" },
{ "10", "10%" },
{ "15", "15%" },
{ "20", "20%" },
{ "25", "25%" },
{ "30", "30%" },
{ "35", "35%" },
{ "40", "40%" },
{ "45", "45%" },
{ "50", "50%" },
{ "55", "55%" },
{ "60", "60%" },
{ "65", "65%" },
{ "70", "70%" },
{ "75", "75%" },
{ "80", "80%" },
{ "85", "85%" },
{ "90", "90%" },
{ "95", "95%" },
{ "100", "100%" },
{ NULL, NULL },
},
"100"
},
{
"pot_analog_sensitivity",
"Analog Joystick Sensitivity",
NULL,
"Set the effective range of the emulated analog joystick when using the gamepad's left analog stick for movement. Lower values equate to slower speeds. Also can be used to make games like Centipede, Kaboom, Missile Command, Pengo, Realsports Tennis, Pole Position, Xari Arena and Super Breakout more playable.",
NULL,
"input",
{
{ "5", "5%" },
{ "10", "10%" },
{ "15", "15%" },
{ "20", "20%" },
{ "25", "25%" },
{ "30", "30%" },
{ "35", "35%" },
{ "40", "40%" },
{ "45", "45%" },
{ "50", "50%" },
{ "55", "55%" },
{ "60", "60%" },
{ "65", "65%" },
{ "70", "70%" },
{ "75", "75%" },
{ "80", "80%" },
{ "85", "85%" },
{ "90", "90%" },
{ "95", "95%" },
{ "100", "100%" },
{ NULL, NULL },
},
"100"
},
{
"pot_analog_deadzone",
"Analog Joystick Deadzone",
NULL,
"Set the deadzone of the gamepad's analog sticks. Use this to eliminate controller drift.",
NULL,
"input",
{
{ "0", "0%" },
{ "3", "3%" },
{ "5", "5%" },
{ "7", "7%" },
{ "10", "10%" },
{ "13", "13%" },
{ "15", "15%" },
{ "17", "17%" },
{ "20", "20%" },
{ "23", "23%" },
{ "25", "25%" },
{ "27", "27%" },
{ "30", "30%" },
{ NULL, NULL },
},
"15"
},
{
"atari800_keyboard",
"Retroarch Keyboard type",
NULL,
"Set whether keyboard is polled or used callback.",
NULL,
"input",
{
{ "poll", NULL },
{ "callback", NULL },
{ NULL, NULL },
},
"poll"
},
{
"keyboard_defines",
"Atari Keyboard Defines",
NULL,
"Joystick and Console Key mappings for\n\"Atari Keyboard\".\n \n Joystick \"Keyboard Numpad 8, 2, 4 & 6\".\n \n5200 analog joystick. Left analog stick or \"Keyboard Numpad 8, 2, 4 & 6\".\n \nFire 1 \"Right CTRL\". Fire 2 \"Right ALT\".\n \n5200 * \"Keyboard Numpad * \". # \"Keyboard =\"\n \n5200 Keypad 0-9 \"Keyboard 0-9\".\nPause \"P\", Reset \"R\".\n \n'Console' keys Option \"F2\", Select \"F3\",\nStart \"F4\".\n \nController 1 only.",
NULL,
"input",
{
{ "informational", NULL },
{ NULL, NULL },
},
"informational"
},
{
"atari800_system",
"Atari System",
NULL,
"Select system emulated. Atari 5200 for Atari 5200 console games. 400/800 (OS B) for <48K games or ones that require OS/B. 800XL (64K) works for most content. 130XE (128K), Modern XL/XE(320K Compy Shop), Modern XL/XE(576K), Modern XL/XE(1088K) for content that needs more than 64K.",
NULL,
NULL,
{
{ "400/800 (OS B)", "Atari 400/800 (OS B)" },
{ "800XL (64K)", "Atari 800XL (64K)" },
{ "130XE (128K)", "Atari 130XE (128K)" },
{ "Modern XL/XE(320K CS)", "Modern Atari XL/XE(320K Compy Shop)" },
{ "Modern XL/XE(576K)", "Modern Atari XL/XE(576K)" },
{ "Modern XL/XE(1088K)", "Modern Atari XL/XE(1088K)" },
{ "5200", "Atari 5200 Super System" },
{ NULL, NULL },
},
"400/800 (OS B)"
},
{
"atari800_internalbasic",
"Internal BASIC (hold OPTION on boot) (Restart)",
NULL,
"Enable for content that needs Atari BASIC in order to run. A proper ROM file (ATARIBAS.ROM) is needed.",
NULL,
NULL,
{
{ "disabled", NULL },
{ "enabled", NULL },
{ NULL, NULL },
},
"disabled"
},
{
"atari800_sioaccel",
"SIO Acceleration",
NULL,
"This enables ALL SIO acceleration. Enabled improves loading speed for Disk and Cassette images. Disable only for protected disk (.ATX) and protected cassette images. Reboot required if change made while loading a cassette image.",
NULL,
NULL,
{
{ "disabled", NULL },
{ "enabled", NULL },
{ NULL, NULL },
},
"enabled"
},
{
"atari800_cassboot",
"Boot from Cassette (Reboot)",
NULL,
"Forces emulated system to boot from autoboot cassette images by holding down the \"START\" key on boot.",
NULL,
NULL,
{
{ "disabled", NULL },
{ "enabled", NULL },
{ NULL, NULL },
},
"disabled"
},
{
"atari800_opt1",
"Autodetect Atari Cartridge Type (Restart)",
NULL,
"Emulator will auto detect Atari cartridge based on checksum. (requires good ROM dumps).",
NULL,
NULL,
{
{ "disabled", NULL },
{ "enabled", NULL },
{ NULL, NULL },
},
"disabled"
},
/* Not sure if I want to implement this. Only helps a small handful of games ( Kaboom, Super Breakout and Star Wars The Arcade Game
{
"pot_analog_center",
"Analog Joystick/Paddle Center",
NULL,
"Set the value for emulated analog joystick or paddle center. Use this to properly center player for some games like Kaboom, Starwars or Super Breakout. Default is 114",
NULL,
"5200",
{
{ "80", NULL },
{ "82", NULL },
{ "84", NULL },
{ "86", NULL },
{ "88", NULL },
{ "90", NULL },
{ "92", NULL },
{ "94", NULL },
{ "96", NULL },
{ "98", NULL },
{ "100", NULL },
{ "102", NULL },
{ "104", NULL },
{ "106", NULL },
{ "108", NULL },
{ "110", NULL },
{ "112", NULL },
{ "114", NULL },
{ "116", NULL },
{ "118", NULL },
{ "120", NULL },
{ "122", NULL },
{ "124", NULL },
{ "126", NULL },
{ "128", NULL },
{ "130", NULL },
{ "132", NULL },
{ "134", NULL },
{ "136", NULL },
{ "130", NULL },
{ "140", NULL },
{ "142", NULL },
{ "144", NULL },
{ "146", NULL },
{ "148", NULL },
{ "150", NULL },
{ NULL, NULL },
},
"114"
}, */
{ NULL, NULL, NULL, NULL, NULL, NULL, {{0}}, NULL },
};
struct retro_core_options_v2 options_us = {
option_cats_us,
option_defs_us
};
/*
********************************
* Language Mapping
********************************
*/
#ifndef HAVE_NO_LANGEXTRA
struct retro_core_options_v2 *options_intl[RETRO_LANGUAGE_LAST] = {
&options_us, /* RETRO_LANGUAGE_ENGLISH */
NULL, /* RETRO_LANGUAGE_JAPANESE */
NULL, /* RETRO_LANGUAGE_FRENCH */
NULL, /* RETRO_LANGUAGE_SPANISH */
NULL, /* RETRO_LANGUAGE_GERMAN */
NULL, /* RETRO_LANGUAGE_ITALIAN */
NULL, /* RETRO_LANGUAGE_DUTCH */
NULL, /* RETRO_LANGUAGE_PORTUGUESE_BRAZIL */
NULL, /* RETRO_LANGUAGE_PORTUGUESE_PORTUGAL */
NULL, /* RETRO_LANGUAGE_RUSSIAN */
NULL, /* RETRO_LANGUAGE_KOREAN */
NULL, /* RETRO_LANGUAGE_CHINESE_TRADITIONAL */
NULL, /* RETRO_LANGUAGE_CHINESE_SIMPLIFIED */
NULL, /* RETRO_LANGUAGE_ESPERANTO */
NULL, /* RETRO_LANGUAGE_POLISH */
NULL, /* RETRO_LANGUAGE_VIETNAMESE */
NULL, /* RETRO_LANGUAGE_ARABIC */
NULL, /* RETRO_LANGUAGE_GREEK */
NULL, /* RETRO_LANGUAGE_TURKISH */
NULL, /* RETRO_LANGUAGE_SLOVAK */
NULL, /* RETRO_LANGUAGE_PERSIAN */
NULL, /* RETRO_LANGUAGE_HEBREW */
NULL, /* RETRO_LANGUAGE_ASTURIAN */
NULL, /* RETRO_LANGUAGE_FINNISH */
};
#endif
/*
********************************
* Functions
********************************
*/
/* Handles configuration/setting of core options.
* Should be called as early as possible - ideally inside
* retro_set_environment(), and no later than retro_load_game()
* > We place the function body in the header to avoid the
* necessity of adding more .c files (i.e. want this to
* be as painless as possible for core devs)
*/
static INLINE void libretro_set_core_options(retro_environment_t environ_cb,
bool *categories_supported)
{
unsigned version = 0;
#ifndef HAVE_NO_LANGEXTRA
unsigned language = 0;
#endif
if (!environ_cb || !categories_supported)
return;
*categories_supported = false;
if (!environ_cb(RETRO_ENVIRONMENT_GET_CORE_OPTIONS_VERSION, &version))
version = 0;
if (version >= 2)
{
#ifndef HAVE_NO_LANGEXTRA
struct retro_core_options_v2_intl core_options_intl;
core_options_intl.us = &options_us;
core_options_intl.local = NULL;
if (environ_cb(RETRO_ENVIRONMENT_GET_LANGUAGE, &language) &&
(language < RETRO_LANGUAGE_LAST) && (language != RETRO_LANGUAGE_ENGLISH))
core_options_intl.local = options_intl[language];
*categories_supported = environ_cb(RETRO_ENVIRONMENT_SET_CORE_OPTIONS_V2_INTL,
&core_options_intl);
#else
*categories_supported = environ_cb(RETRO_ENVIRONMENT_SET_CORE_OPTIONS_V2,
&options_us);
#endif
}
else
{
size_t i, j;
size_t option_index = 0;
size_t num_options = 0;
struct retro_core_option_definition
*option_v1_defs_us = NULL;
#ifndef HAVE_NO_LANGEXTRA
size_t num_options_intl = 0;
struct retro_core_option_v2_definition
*option_defs_intl = NULL;
struct retro_core_option_definition
*option_v1_defs_intl = NULL;
struct retro_core_options_intl
core_options_v1_intl;
#endif
struct retro_variable *variables = NULL;
char **values_buf = NULL;
/* Determine total number of options */
while (true)
{
if (option_defs_us[num_options].key)
num_options++;
else
break;
}
if (version >= 1)
{
/* Allocate US array */
option_v1_defs_us = (struct retro_core_option_definition *)
calloc(num_options + 1, sizeof(struct retro_core_option_definition));
/* Copy parameters from option_defs_us array */
for (i = 0; i < num_options; i++)
{
struct retro_core_option_v2_definition *option_def_us = &option_defs_us[i];
struct retro_core_option_value *option_values = option_def_us->values;
struct retro_core_option_definition *option_v1_def_us = &option_v1_defs_us[i];
struct retro_core_option_value *option_v1_values = option_v1_def_us->values;
option_v1_def_us->key = option_def_us->key;
option_v1_def_us->desc = option_def_us->desc;
option_v1_def_us->info = option_def_us->info;
option_v1_def_us->default_value = option_def_us->default_value;
/* Values must be copied individually... */
while (option_values->value)
{
option_v1_values->value = option_values->value;
option_v1_values->label = option_values->label;
option_values++;
option_v1_values++;
}
}
#ifndef HAVE_NO_LANGEXTRA
if (environ_cb(RETRO_ENVIRONMENT_GET_LANGUAGE, &language) &&
(language < RETRO_LANGUAGE_LAST) && (language != RETRO_LANGUAGE_ENGLISH) &&
options_intl[language])
option_defs_intl = options_intl[language]->definitions;
if (option_defs_intl)
{
/* Determine number of intl options */
while (true)
{
if (option_defs_intl[num_options_intl].key)
num_options_intl++;
else
break;
}
/* Allocate intl array */
option_v1_defs_intl = (struct retro_core_option_definition *)
calloc(num_options_intl + 1, sizeof(struct retro_core_option_definition));
/* Copy parameters from option_defs_intl array */
for (i = 0; i < num_options_intl; i++)
{
struct retro_core_option_v2_definition *option_def_intl = &option_defs_intl[i];
struct retro_core_option_value *option_values = option_def_intl->values;
struct retro_core_option_definition *option_v1_def_intl = &option_v1_defs_intl[i];
struct retro_core_option_value *option_v1_values = option_v1_def_intl->values;
option_v1_def_intl->key = option_def_intl->key;
option_v1_def_intl->desc = option_def_intl->desc;
option_v1_def_intl->info = option_def_intl->info;
option_v1_def_intl->default_value = option_def_intl->default_value;
/* Values must be copied individually... */
while (option_values->value)
{
option_v1_values->value = option_values->value;
option_v1_values->label = option_values->label;
option_values++;
option_v1_values++;
}
}
}
core_options_v1_intl.us = option_v1_defs_us;
core_options_v1_intl.local = option_v1_defs_intl;
environ_cb(RETRO_ENVIRONMENT_SET_CORE_OPTIONS_INTL, &core_options_v1_intl);
#else
environ_cb(RETRO_ENVIRONMENT_SET_CORE_OPTIONS, option_v1_defs_us);
#endif
}
else
{
/* Allocate arrays */
variables = (struct retro_variable *)calloc(num_options + 1,
sizeof(struct retro_variable));
values_buf = (char **)calloc(num_options, sizeof(char *));
if (!variables || !values_buf)
goto error;
/* Copy parameters from option_defs_us array */
for (i = 0; i < num_options; i++)
{
const char *key = option_defs_us[i].key;
const char *desc = option_defs_us[i].desc;
const char *default_value = option_defs_us[i].default_value;
struct retro_core_option_value *values = option_defs_us[i].values;
size_t buf_len = 3;
size_t default_index = 0;
values_buf[i] = NULL;
if (desc)
{
size_t num_values = 0;
/* Determine number of values */
while (true)
{
if (values[num_values].value)
{
/* Check if this is the default value */
if (default_value)
if (strcmp(values[num_values].value, default_value) == 0)
default_index = num_values;
buf_len += strlen(values[num_values].value);
num_values++;
}
else
break;
}
/* Build values string */
if (num_values > 0)
{
buf_len += num_values - 1;
buf_len += strlen(desc);
values_buf[i] = (char *)calloc(buf_len, sizeof(char));
if (!values_buf[i])
goto error;
strcpy(values_buf[i], desc);
strcat(values_buf[i], "; ");
/* Default value goes first */
strcat(values_buf[i], values[default_index].value);
/* Add remaining values */
for (j = 0; j < num_values; j++)
{
if (j != default_index)
{
strcat(values_buf[i], "|");
strcat(values_buf[i], values[j].value);
}
}
}
}
variables[option_index].key = key;
variables[option_index].value = values_buf[i];
option_index++;
}
/* Set variables */
environ_cb(RETRO_ENVIRONMENT_SET_VARIABLES, variables);
}
error:
/* Clean up */
if (option_v1_defs_us)
{
free(option_v1_defs_us);
option_v1_defs_us = NULL;
}
#ifndef HAVE_NO_LANGEXTRA
if (option_v1_defs_intl)
{
free(option_v1_defs_intl);
option_v1_defs_intl = NULL;
}
#endif
if (values_buf)
{
for (i = 0; i < num_options; i++)
{
if (values_buf[i])
{
free(values_buf[i]);
values_buf[i] = NULL;
}
}
free(values_buf);
values_buf = NULL;
}
if (variables)
{
free(variables);
variables = NULL;
}
}
}
#ifdef __cplusplus
}
#endif
#endif
libretro/libretro_core_options_intl.h
+91
View File
@@ -0,0 +1,91 @@
#ifndef LIBRETRO_CORE_OPTIONS_INTL_H__
#define LIBRETRO_CORE_OPTIONS_INTL_H__
#if defined(_MSC_VER) && (_MSC_VER >= 1500 && _MSC_VER < 1900)
/* https://support.microsoft.com/en-us/kb/980263 */
#pragma execution_character_set("utf-8")
#pragma warning(disable:4566)
#endif
#include <libretro.h>
/*
********************************
* VERSION: 2.0
********************************
*
* - 2.0: Add support for core options v2 interface
* - 1.3: Move translations to libretro_core_options_intl.h
* - libretro_core_options_intl.h includes BOM and utf-8
* fix for MSVC 2010-2013
* - Added HAVE_NO_LANGEXTRA flag to disable translations
* on platforms/compilers without BOM support
* - 1.2: Use core options v1 interface when
* RETRO_ENVIRONMENT_GET_CORE_OPTIONS_VERSION is >= 1
* (previously required RETRO_ENVIRONMENT_GET_CORE_OPTIONS_VERSION == 1)
* - 1.1: Support generation of core options v0 retro_core_option_value
* arrays containing options with a single value
* - 1.0: First commit
*/
#ifdef __cplusplus
extern "C" {
#endif
/*
********************************
* Core Option Definitions
********************************
*/
/* RETRO_LANGUAGE_JAPANESE */
/* RETRO_LANGUAGE_FRENCH */
/* RETRO_LANGUAGE_SPANISH */
/* RETRO_LANGUAGE_GERMAN */
/* RETRO_LANGUAGE_ITALIAN */
/* RETRO_LANGUAGE_DUTCH */
/* RETRO_LANGUAGE_PORTUGUESE_BRAZIL */
/* RETRO_LANGUAGE_PORTUGUESE_PORTUGAL */
/* RETRO_LANGUAGE_RUSSIAN */
/* RETRO_LANGUAGE_KOREAN */
/* RETRO_LANGUAGE_CHINESE_TRADITIONAL */
/* RETRO_LANGUAGE_CHINESE_SIMPLIFIED */
/* RETRO_LANGUAGE_ESPERANTO */
/* RETRO_LANGUAGE_POLISH */
/* RETRO_LANGUAGE_VIETNAMESE */
/* RETRO_LANGUAGE_ARABIC */
/* RETRO_LANGUAGE_GREEK */
/* RETRO_LANGUAGE_TURKISH */
/* RETRO_LANGUAGE_SLOVAK */
/* RETRO_LANGUAGE_PERSIAN */
/* RETRO_LANGUAGE_HEBREW */
/* RETRO_LANGUAGE_ASTURIAN */
/* RETRO_LANGUAGE_FINNISH */
#ifdef __cplusplus
}
#endif
#endif
libretro/platform.c
+426 -298
View File
@@ -37,24 +37,31 @@
#include "screen.h"
#include "colours.h"
#include "ui.h"
extern char Key_Sate[512];
#include "libretro-core.h"
#include "libretro.h"
#include "retroscreen.h"
#define RETRO_DEVICE_ATARI_KEYBOARD RETRO_DEVICE_SUBCLASS(RETRO_DEVICE_KEYBOARD, 0)
#define RETRO_DEVICE_ATARI_JOYSTICK RETRO_DEVICE_SUBCLASS(RETRO_DEVICE_JOYPAD, 1)
#define RETRO_DEVICE_ATARI_5200_JOYSTICK RETRO_DEVICE_SUBCLASS(RETRO_DEVICE_JOYPAD, 2)
extern char Key_State[512];
extern int SHIFTON;
extern int CTRLON;
extern int UI_is_active;
extern int SHOWKEY, SHOWKEYDELAY;
static int swap_joysticks = FALSE;
int PLATFORM_kbd_joy_0_enabled = TRUE; /* enabled by default, doesn't hurt */
int PLATFORM_kbd_joy_1_enabled = TRUE;//FALSE; /* disabled, would steal normal keys */
int PLATFORM_kbd_joy_2_enabled = TRUE;//FALSE; /* disabled, would steal normal keys */
int PLATFORM_kbd_joy_3_enabled = TRUE;//FALSE; /* disabled, would steal normal keys */
extern unsigned char MXjoy[4]; // joy
extern int mbt[16];
extern int mbt[4][16];
extern unsigned atari_devices[4];
extern int paddle_mode;
extern int retro_sound_finalized;
int CURRENT_TV=Atari800_TV_PAL;
@@ -164,45 +171,46 @@ static int key_control = 0;
int PLATFORM_Keyboard(void)
{
int shiftctrl = 0;
int whichButton = 0;
UI_alt_function = -1;
if (Key_Sate[RETROK_LALT]){
if (Key_State[RETROK_LALT]){
if (Key_Sate[RETROK_r])
if (Key_State[RETROK_r])
UI_alt_function = UI_MENU_RUN;
else if (Key_Sate[RETROK_y])
else if (Key_State[RETROK_y])
UI_alt_function = UI_MENU_SYSTEM;
else if (Key_Sate[RETROK_o])
else if (Key_State[RETROK_o])
UI_alt_function = UI_MENU_SOUND;
else if (Key_Sate[RETROK_w])
else if (Key_State[RETROK_w])
UI_alt_function = UI_MENU_SOUND_RECORDING;
else if (Key_Sate[RETROK_a])
else if (Key_State[RETROK_a])
UI_alt_function = UI_MENU_ABOUT;
else if (Key_Sate[RETROK_s])
else if (Key_State[RETROK_s])
UI_alt_function = UI_MENU_SAVESTATE;
else if (Key_Sate[RETROK_d])
else if (Key_State[RETROK_d])
UI_alt_function = UI_MENU_DISK;
else if (Key_Sate[RETROK_l])
else if (Key_State[RETROK_l])
UI_alt_function = UI_MENU_LOADSTATE;
else if (Key_Sate[RETROK_c])
else if (Key_State[RETROK_c])
UI_alt_function = UI_MENU_CARTRIDGE;
else if (Key_Sate[RETROK_t])
else if (Key_State[RETROK_t])
UI_alt_function = UI_MENU_CASSETTE;
else if (Key_Sate[RETROK_BACKSLASH])
else if (Key_State[RETROK_BACKSLASH])
return AKEY_PBI_BB_MENU;
}
/* SHIFT STATE */
//if ((Key_Sate[RETROK_LSHIFT]) || (Key_Sate[RETROK_RSHIFT]))
//if ((Key_State[RETROK_LSHIFT]) || (Key_State[RETROK_RSHIFT]))
if (SHIFTON == 1)
INPUT_key_shift = 1;
else
INPUT_key_shift = 0;
/* CONTROL STATE */
//if ((Key_Sate[RETROK_LCTRL]) || (Key_Sate[RETROK_RCTRL]))
//if ((Key_State[RETROK_LCTRL]) || (Key_State[RETROK_RCTRL]))
if (CTRLON == 1)
key_control = 1;
else
@@ -212,21 +220,21 @@ int PLATFORM_Keyboard(void)
/* OPTION / SELECT / START keys */
INPUT_key_consol = INPUT_CONSOL_NONE;
if (Key_Sate[RETROK_F2])
if (Key_State[RETROK_F2])
INPUT_key_consol &= (~INPUT_CONSOL_OPTION);
if (Key_Sate[RETROK_F3])
if (Key_State[RETROK_F3])
INPUT_key_consol &= (~INPUT_CONSOL_SELECT);
if (Key_Sate[RETROK_F4])
if (Key_State[RETROK_F4])
INPUT_key_consol &= (~INPUT_CONSOL_START);
/* Handle movement and special keys. */
if (Key_Sate[RETROK_F1])return AKEY_UI;
if (Key_State[RETROK_F1]) return AKEY_UI;
if (Key_Sate[RETROK_F5])
if (Key_State[RETROK_F5] && (Atari800_machine_type != Atari800_MACHINE_5200))
return INPUT_key_shift ? AKEY_COLDSTART : AKEY_WARMSTART;
if (Key_Sate[RETROK_F12])return AKEY_TURBO;
if (Key_State[RETROK_F12]) return AKEY_TURBO;
if (UI_alt_function != -1) {
return AKEY_UI;
@@ -235,69 +243,131 @@ int PLATFORM_Keyboard(void)
if (INPUT_key_shift)
shiftctrl ^= AKEY_SHFT;
if (Atari800_machine_type == Atari800_MACHINE_5200 && !UI_is_active) {
if (MXjoy[0]&0x40) { /* 2nd action button */
INPUT_key_shift = 1;
}
else {
// Atari 5200 specific. Don't accept joypad input when UI is active. or virtual keyboard is active.
if (Atari800_machine_type == Atari800_MACHINE_5200 && !UI_is_active)
{
INPUT_key_shift = 0;
if (SHOWKEYDELAY)
SHOWKEYDELAY--;
/* Don't accept joypad input when virtual keyboard is active */
for (int i = 0; i < 4; i++)
{
if (SHOWKEY == -1)
{
//if (MXjoy[0]&0x40) {
/* 2nd action button */
if (atari_devices[i] == RETRO_DEVICE_ATARI_JOYSTICK)
whichButton = RETRO_DEVICE_ID_JOYPAD_X;
else if (atari_devices[i] == RETRO_DEVICE_ATARI_5200_JOYSTICK)
whichButton = RETRO_DEVICE_ID_JOYPAD_A;
else if (atari_devices[i] == RETRO_DEVICE_ATARI_KEYBOARD && (Key_State[RETROK_RCTRL]))
INPUT_key_shift = 1;
if (mbt[i][whichButton]) {
INPUT_key_shift = 1;
break;
}
if (mbt[RETRO_DEVICE_ID_JOYPAD_START])
/* shared between ATARI_JOYSTICK and ATARI_5200*/
if (mbt[i][RETRO_DEVICE_ID_JOYPAD_START])
return AKEY_5200_START ^ shiftctrl;
if (Key_Sate[RETROK_F4])
return AKEY_5200_START ^ shiftctrl;
/* only Hash # and Asterick * */
if (atari_devices[i] == RETRO_DEVICE_ATARI_JOYSTICK)
{
if (mbt[i][RETRO_DEVICE_ID_JOYPAD_SELECT]) return AKEY_5200_HASH ^ shiftctrl;
if (mbt[i][RETRO_DEVICE_ID_JOYPAD_L]) return AKEY_5200_ASTERISK ^ shiftctrl;
}
/* We map most all keys. Only number keys done are 0-4. This might change */
/* Not a big fan of this method. Likely creates issues on 2 or more player games. */
/* But testing seems to show otherwise. Maybe OR the values and then return the result */
else if (atari_devices[i] == RETRO_DEVICE_ATARI_5200_JOYSTICK)
{
if (mbt[i][RETRO_DEVICE_ID_JOYPAD_Y]) return AKEY_5200_HASH ^ shiftctrl;
if (mbt[i][RETRO_DEVICE_ID_JOYPAD_X]) return AKEY_5200_ASTERISK ^ shiftctrl;
if (mbt[i][RETRO_DEVICE_ID_JOYPAD_SELECT]) return AKEY_5200_PAUSE ^ shiftctrl;
if (mbt[i][RETRO_DEVICE_ID_JOYPAD_L]) return AKEY_5200_0 ^ shiftctrl;
if (mbt[i][RETRO_DEVICE_ID_JOYPAD_R]) return AKEY_5200_1 ^ shiftctrl;
if (mbt[i][RETRO_DEVICE_ID_JOYPAD_L2]) return AKEY_5200_2 ^ shiftctrl;
if (mbt[i][RETRO_DEVICE_ID_JOYPAD_R2]) return AKEY_5200_3 ^ shiftctrl;
if (mbt[i][RETRO_DEVICE_ID_JOYPAD_L3]) return AKEY_5200_7 ^ shiftctrl;
}
}
if(Key_Sate[RETROK_p])return AKEY_5200_PAUSE ^ shiftctrl;
if(Key_Sate[RETROK_r])return AKEY_5200_RESET ^ shiftctrl;
if(Key_Sate[RETROK_0])return AKEY_5200_0 ^ shiftctrl;
if(Key_Sate[RETROK_1])return AKEY_5200_1 ^ shiftctrl;
if(Key_Sate[RETROK_2])return AKEY_5200_2 ^ shiftctrl;
if(Key_Sate[RETROK_3])return AKEY_5200_3 ^ shiftctrl;
if(Key_Sate[RETROK_4])return AKEY_5200_4 ^ shiftctrl;
if(Key_Sate[RETROK_5])return AKEY_5200_5 ^ shiftctrl;
if(Key_Sate[RETROK_6])return AKEY_5200_6 ^ shiftctrl;
if(Key_Sate[RETROK_7])return AKEY_5200_7 ^ shiftctrl;
if(Key_Sate[RETROK_8])return AKEY_5200_8 ^ shiftctrl;
if(Key_Sate[RETROK_9])return AKEY_5200_9 ^ shiftctrl;
if(Key_Sate[RETROK_HASH])return AKEY_5200_HASH ^ shiftctrl;
if(Key_Sate[RETROK_EQUALS])return AKEY_5200_HASH ^ shiftctrl;
if(Key_Sate[RETROK_ASTERISK])return AKEY_5200_ASTERISK ^ shiftctrl;
if(Key_Sate[RETROK_KP_MULTIPLY])return AKEY_5200_ASTERISK ^ shiftctrl;
if (atari_devices[i] == RETRO_DEVICE_ATARI_JOYSTICK)
whichButton = RETRO_DEVICE_ID_JOYPAD_L3;
else if (atari_devices[i] == RETRO_DEVICE_ATARI_5200_JOYSTICK)
whichButton = RETRO_DEVICE_ID_JOYPAD_R3;
if (mbt[i][whichButton])
if (!SHOWKEYDELAY)
{
SHOWKEY = -SHOWKEY;
SHOWKEYDELAY = 20;
}
}
/* keyboard mapped to 5200 controls*/
if (Key_State[RETROK_F4]) return AKEY_5200_START ^ shiftctrl;
if (Key_State[RETROK_p]) return AKEY_5200_PAUSE ^ shiftctrl;
if (Key_State[RETROK_r]) return AKEY_5200_RESET ^ shiftctrl;
if (Key_State[RETROK_0]) return AKEY_5200_0 ^ shiftctrl;
if (Key_State[RETROK_1]) return AKEY_5200_1 ^ shiftctrl;
if (Key_State[RETROK_2]) return AKEY_5200_2 ^ shiftctrl;
if (Key_State[RETROK_3]) return AKEY_5200_3 ^ shiftctrl;
if (Key_State[RETROK_4]) return AKEY_5200_4 ^ shiftctrl;
if (Key_State[RETROK_5]) return AKEY_5200_5 ^ shiftctrl;
if (Key_State[RETROK_6]) return AKEY_5200_6 ^ shiftctrl;
if (Key_State[RETROK_7]) return AKEY_5200_7 ^ shiftctrl;
if (Key_State[RETROK_8]) return AKEY_5200_8 ^ shiftctrl;
if (Key_State[RETROK_9]) return AKEY_5200_9 ^ shiftctrl;
if (Key_State[RETROK_HASH]) return AKEY_5200_HASH ^ shiftctrl;
if (Key_State[RETROK_EQUALS]) return AKEY_5200_HASH ^ shiftctrl;
if (Key_State[RETROK_ASTERISK]) return AKEY_5200_ASTERISK ^ shiftctrl;
if (Key_State[RETROK_KP_MULTIPLY]) return AKEY_5200_ASTERISK ^ shiftctrl;
/* virtual keyboard mapped to 5200 controls */
if (Key_State[RETROK_F5])
return AKEY_5200_RESET ^ shiftctrl;
if (Key_State[RETROK_F7])
{
SHOWKEY = -1;
SHOWKEYDELAY = 20;
return AKEY_UI;
}
return AKEY_NONE;
}
//else if (Atari800_machine_type != Atari800_MACHINE_5200 && !UI_is_active)
{
if (key_control)
shiftctrl ^= AKEY_CTRL;
if (Key_Sate[RETROK_BACKQUOTE] || Key_Sate[RETROK_LSUPER] )
if (Key_State[RETROK_BACKQUOTE] || Key_State[RETROK_LSUPER] )
return AKEY_ATARI ^ shiftctrl;
if (Key_Sate[RETROK_RSUPER] ){
if (Key_State[RETROK_RSUPER] ){
if (INPUT_key_shift)
return AKEY_CAPSLOCK;
else
return AKEY_CAPSTOGGLE;
}
if (Key_Sate[RETROK_END] || Key_Sate[RETROK_F6] )
if (Key_State[RETROK_END] || Key_State[RETROK_F6] )
return AKEY_HELP ^ shiftctrl;
if (Key_Sate[RETROK_PAGEDOWN])
if (Key_State[RETROK_PAGEDOWN])
return AKEY_F2 | AKEY_SHFT;
if (Key_Sate[RETROK_PAGEUP])
if (Key_State[RETROK_PAGEUP])
return AKEY_F1 | AKEY_SHFT;
if (Key_Sate[RETROK_HOME])
if (Key_State[RETROK_HOME])
return key_control ? AKEY_LESS|shiftctrl : AKEY_CLEAR;
if (Key_Sate[RETROK_PAUSE])
if (Key_State[RETROK_PAUSE])
{
if (BINLOAD_wait_active) {
BINLOAD_pause_loading = TRUE;
@@ -306,17 +376,17 @@ int PLATFORM_Keyboard(void)
else
return AKEY_BREAK;
}
if (Key_Sate[RETROK_CAPSLOCK]){
if (Key_State[RETROK_CAPSLOCK]){
if (INPUT_key_shift)
return AKEY_CAPSLOCK|shiftctrl;
else
return AKEY_CAPSTOGGLE|shiftctrl;
}
if (Key_Sate[RETROK_SPACE])
if (Key_State[RETROK_SPACE])
return AKEY_SPACE ^ shiftctrl;
if (Key_Sate[RETROK_BACKSPACE]){
if (Key_State[RETROK_BACKSPACE]){
if (INPUT_key_shift)
return AKEY_DELETE_CHAR;
else if (key_control)
@@ -325,32 +395,32 @@ int PLATFORM_Keyboard(void)
return AKEY_BACKSPACE;
}
if (Key_Sate[RETROK_RETURN])
if (Key_State[RETROK_RETURN])
return AKEY_RETURN ^ shiftctrl;
if (Key_Sate[RETROK_LEFT])
if (Key_State[RETROK_LEFT])
return (!UI_is_active && Atari800_f_keys ? AKEY_F3 : (INPUT_key_shift ? AKEY_PLUS : AKEY_LEFT)) ^ shiftctrl;
if (Key_Sate[RETROK_RIGHT])
if (Key_State[RETROK_RIGHT])
return (!UI_is_active && Atari800_f_keys ? AKEY_F4 : (INPUT_key_shift ? AKEY_ASTERISK : AKEY_RIGHT)) ^ shiftctrl;
if (Key_Sate[RETROK_UP])
if (Key_State[RETROK_UP])
return (!UI_is_active && Atari800_f_keys ? AKEY_F1 : (INPUT_key_shift ? AKEY_MINUS : AKEY_UP)) ^ shiftctrl;
if (Key_Sate[RETROK_DOWN])
if (Key_State[RETROK_DOWN])
return (!UI_is_active && Atari800_f_keys ? AKEY_F2 : (INPUT_key_shift ? AKEY_EQUAL : AKEY_DOWN)) ^ shiftctrl;
if (Key_Sate[RETROK_ESCAPE])
if (Key_State[RETROK_ESCAPE])
return AKEY_ESCAPE ^ shiftctrl;
if (Key_Sate[RETROK_TAB])
if (Key_State[RETROK_TAB])
return AKEY_TAB ^ shiftctrl;
if (Key_Sate[RETROK_DELETE]){
if (Key_State[RETROK_DELETE]){
if (INPUT_key_shift)
return AKEY_DELETE_LINE|shiftctrl;
else
return AKEY_DELETE_CHAR;
}
if (Key_Sate[RETROK_INSERT]){
if (Key_State[RETROK_INSERT]){
if (INPUT_key_shift)
return AKEY_INSERT_LINE|shiftctrl;
else
@@ -358,269 +428,261 @@ int PLATFORM_Keyboard(void)
}
if (INPUT_cx85){
if (Key_Sate[RETROK_KP1])
return AKEY_CX85_1;
else if (Key_Sate[RETROK_KP2])
return AKEY_CX85_2;
else if (Key_Sate[RETROK_KP2])
return AKEY_CX85_3;
else if (Key_Sate[RETROK_KP3])
return AKEY_CX85_4;
else if (Key_Sate[RETROK_KP4])
return AKEY_CX85_5;
else if (Key_Sate[RETROK_KP5])
return AKEY_CX85_6;
else if (Key_Sate[RETROK_KP6])
return AKEY_CX85_7;
else if (Key_Sate[RETROK_KP7])
return AKEY_CX85_8;
else if (Key_Sate[RETROK_KP8])
return AKEY_CX85_9;
else if (Key_Sate[RETROK_KP9])
return AKEY_CX85_0;
else if (Key_Sate[RETROK_KP0])
return AKEY_CX85_2;
else if (Key_Sate[RETROK_KP_PERIOD])
return AKEY_CX85_PERIOD;
else if (Key_Sate[RETROK_KP_MINUS])
return AKEY_CX85_MINUS;
else if (Key_Sate[RETROK_KP_ENTER])
return AKEY_CX85_PLUS_ENTER;
else if (Key_Sate[RETROK_KP_DIVIDE])
return (key_control ? AKEY_CX85_ESCAPE : AKEY_CX85_NO);
else if (Key_Sate[RETROK_KP_MULTIPLY])
return AKEY_CX85_DELETE;
else if (Key_Sate[RETROK_KP_PLUS])
return AKEY_CX85_YES;
if (Key_State[RETROK_KP1]) return AKEY_CX85_1;
else if (Key_State[RETROK_KP2]) return AKEY_CX85_2;
else if (Key_State[RETROK_KP2]) return AKEY_CX85_3;
else if (Key_State[RETROK_KP3]) return AKEY_CX85_4;
else if (Key_State[RETROK_KP4]) return AKEY_CX85_5;
else if (Key_State[RETROK_KP5]) return AKEY_CX85_6;
else if (Key_State[RETROK_KP6]) return AKEY_CX85_7;
else if (Key_State[RETROK_KP7]) return AKEY_CX85_8;
else if (Key_State[RETROK_KP8]) return AKEY_CX85_9;
else if (Key_State[RETROK_KP9]) return AKEY_CX85_0;
else if (Key_State[RETROK_KP0]) return AKEY_CX85_2;
else if (Key_State[RETROK_KP_PERIOD]) return AKEY_CX85_PERIOD;
else if (Key_State[RETROK_KP_MINUS]) return AKEY_CX85_MINUS;
else if (Key_State[RETROK_KP_ENTER]) return AKEY_CX85_PLUS_ENTER;
else if (Key_State[RETROK_KP_DIVIDE]) return (key_control ? AKEY_CX85_ESCAPE : AKEY_CX85_NO);
else if (Key_State[RETROK_KP_MULTIPLY]) return AKEY_CX85_DELETE;
else if (Key_State[RETROK_KP_PLUS]) return AKEY_CX85_YES;
}
/* Handle CTRL-0 to CTRL-9 and other control characters */
if (key_control) {
if (Key_Sate[RETROK_PERIOD])
return AKEY_FULLSTOP|shiftctrl;
if (Key_Sate[RETROK_COMMA])
return AKEY_COMMA|shiftctrl;
if (Key_Sate[RETROK_SEMICOLON])
return AKEY_SEMICOLON|shiftctrl;
if (Key_Sate[RETROK_SLASH])
return AKEY_SLASH|shiftctrl;
if (Key_Sate[RETROK_BACKSLASH])
return AKEY_ESCAPE|shiftctrl;
if (Key_Sate[RETROK_0])
return AKEY_CTRL_0|shiftctrl;
if (Key_Sate[RETROK_1])
return AKEY_CTRL_1|shiftctrl;
if (Key_Sate[RETROK_2])
return AKEY_CTRL_2|shiftctrl;
if (Key_Sate[RETROK_3])
return AKEY_CTRL_3|shiftctrl;
if (Key_Sate[RETROK_4])
return AKEY_CTRL_4|shiftctrl;
if (Key_Sate[RETROK_5])
return AKEY_CTRL_5|shiftctrl;
if (Key_Sate[RETROK_6])
return AKEY_CTRL_6|shiftctrl;
if (Key_Sate[RETROK_7])
return AKEY_CTRL_7|shiftctrl;
if (Key_Sate[RETROK_8])
return AKEY_CTRL_8|shiftctrl;
if (Key_Sate[RETROK_9])
return AKEY_CTRL_9|shiftctrl;
if (Key_State[RETROK_PERIOD]) return AKEY_FULLSTOP|shiftctrl;
if (Key_State[RETROK_COMMA]) return AKEY_COMMA|shiftctrl;
if (Key_State[RETROK_SEMICOLON]) return AKEY_SEMICOLON|shiftctrl;
if (Key_State[RETROK_SLASH]) return AKEY_SLASH|shiftctrl;
if (Key_State[RETROK_BACKSLASH]) return AKEY_ESCAPE|shiftctrl;
if (Key_State[RETROK_0]) return AKEY_CTRL_0|shiftctrl;
if (Key_State[RETROK_1]) return AKEY_CTRL_1|shiftctrl;
if (Key_State[RETROK_2]) return AKEY_CTRL_2|shiftctrl;
if (Key_State[RETROK_3]) return AKEY_CTRL_3|shiftctrl;
if (Key_State[RETROK_4]) return AKEY_CTRL_4|shiftctrl;
if (Key_State[RETROK_5]) return AKEY_CTRL_5|shiftctrl;
if (Key_State[RETROK_6]) return AKEY_CTRL_6|shiftctrl;
if (Key_State[RETROK_7]) return AKEY_CTRL_7|shiftctrl;
if (Key_State[RETROK_8]) return AKEY_CTRL_8|shiftctrl;
if (Key_State[RETROK_9]) return AKEY_CTRL_9|shiftctrl;
if (Key_Sate[RETROK_a])return AKEY_CTRL_a;
if (Key_Sate[RETROK_b])return AKEY_CTRL_b;
if (Key_Sate[RETROK_c])return AKEY_CTRL_c;
if (Key_Sate[RETROK_d])return AKEY_CTRL_d;
if (Key_Sate[RETROK_e])return AKEY_CTRL_e;
if (Key_Sate[RETROK_f])return AKEY_CTRL_f;
if (Key_Sate[RETROK_g])return AKEY_CTRL_g;
if (Key_Sate[RETROK_h])return AKEY_CTRL_h;
if (Key_Sate[RETROK_i])return AKEY_CTRL_i;
if (Key_Sate[RETROK_j])return AKEY_CTRL_j;
if (Key_Sate[RETROK_k])return AKEY_CTRL_k;
if (Key_Sate[RETROK_l])return AKEY_CTRL_l;
if (Key_Sate[RETROK_m])return AKEY_CTRL_m;
if (Key_Sate[RETROK_n])return AKEY_CTRL_n;
if (Key_Sate[RETROK_o])return AKEY_CTRL_o;
if (Key_Sate[RETROK_p])return AKEY_CTRL_p;
if (Key_Sate[RETROK_q])return AKEY_CTRL_q;
if (Key_Sate[RETROK_r])return AKEY_CTRL_r;
if (Key_Sate[RETROK_s])return AKEY_CTRL_s;
if (Key_Sate[RETROK_t])return AKEY_CTRL_t;
if (Key_Sate[RETROK_u])return AKEY_CTRL_u;
if (Key_Sate[RETROK_v])return AKEY_CTRL_v;
if (Key_Sate[RETROK_w])return AKEY_CTRL_w;
if (Key_Sate[RETROK_x])return AKEY_CTRL_x;
if (Key_Sate[RETROK_y])return AKEY_CTRL_y;
if (Key_Sate[RETROK_z])return AKEY_CTRL_z;
if (Key_State[RETROK_a]) return AKEY_CTRL_a;
if (Key_State[RETROK_b]) return AKEY_CTRL_b;
if (Key_State[RETROK_c]) return AKEY_CTRL_c;
if (Key_State[RETROK_d]) return AKEY_CTRL_d;
if (Key_State[RETROK_e]) return AKEY_CTRL_e;
if (Key_State[RETROK_f]) return AKEY_CTRL_f;
if (Key_State[RETROK_g]) return AKEY_CTRL_g;
if (Key_State[RETROK_h]) return AKEY_CTRL_h;
if (Key_State[RETROK_i]) return AKEY_CTRL_i;
if (Key_State[RETROK_j]) return AKEY_CTRL_j;
if (Key_State[RETROK_k]) return AKEY_CTRL_k;
if (Key_State[RETROK_l]) return AKEY_CTRL_l;
if (Key_State[RETROK_m]) return AKEY_CTRL_m;
if (Key_State[RETROK_n]) return AKEY_CTRL_n;
if (Key_State[RETROK_o]) return AKEY_CTRL_o;
if (Key_State[RETROK_p]) return AKEY_CTRL_p;
if (Key_State[RETROK_q]) return AKEY_CTRL_q;
if (Key_State[RETROK_r]) return AKEY_CTRL_r;
if (Key_State[RETROK_s]) return AKEY_CTRL_s;
if (Key_State[RETROK_t]) return AKEY_CTRL_t;
if (Key_State[RETROK_u]) return AKEY_CTRL_u;
if (Key_State[RETROK_v]) return AKEY_CTRL_v;
if (Key_State[RETROK_w]) return AKEY_CTRL_w;
if (Key_State[RETROK_x]) return AKEY_CTRL_x;
if (Key_State[RETROK_y]) return AKEY_CTRL_y;
if (Key_State[RETROK_z]) return AKEY_CTRL_z;
/* these three keys also type control-graphics characters, but
there don't seem to be AKEY_ values for them! */
if (Key_Sate[RETROK_COMMA])return (AKEY_CTRL | AKEY_COMMA);
if (Key_Sate[RETROK_PERIOD])return (AKEY_CTRL | AKEY_FULLSTOP);
if (Key_Sate[RETROK_SEMICOLON])return (AKEY_CTRL | AKEY_SEMICOLON);
if (Key_State[RETROK_COMMA]) return (AKEY_CTRL | AKEY_COMMA);
if (Key_State[RETROK_PERIOD]) return (AKEY_CTRL | AKEY_FULLSTOP);
if (Key_State[RETROK_SEMICOLON]) return (AKEY_CTRL | AKEY_SEMICOLON);
if (Key_Sate[RETROK_F7])return (AKEY_CTRL | AKEY_F1);
if (Key_Sate[RETROK_F8])return (AKEY_CTRL | AKEY_F2);
if (Key_Sate[RETROK_F9])return (AKEY_CTRL | AKEY_F3);
if (Key_Sate[RETROK_F10])return (AKEY_CTRL | AKEY_F4);
if (Key_State[RETROK_F7]) return (AKEY_CTRL | AKEY_F1);
if (Key_State[RETROK_F8]) return (AKEY_CTRL | AKEY_F2);
if (Key_State[RETROK_F9]) return (AKEY_CTRL | AKEY_F3);
if (Key_State[RETROK_F10]) return (AKEY_CTRL | AKEY_F4);
// cursor keys
if (Key_Sate[RETROK_PLUS])return AKEY_LEFT;
if (Key_Sate[RETROK_ASTERISK])return AKEY_RIGHT;
if (Key_Sate[RETROK_EQUALS])return AKEY_DOWN;
if (Key_Sate[RETROK_UNDERSCORE])return AKEY_UP;
if (Key_State[RETROK_PLUS]) return AKEY_LEFT;
if (Key_State[RETROK_ASTERISK]) return AKEY_RIGHT;
if (Key_State[RETROK_EQUALS]) return AKEY_DOWN;
if (Key_State[RETROK_UNDERSCORE]) return AKEY_UP;
}
/* handle all keys */
if (INPUT_key_shift) {
if (Key_Sate[RETROK_a])return AKEY_A;
if (Key_Sate[RETROK_b])return AKEY_B;
if (Key_Sate[RETROK_c])return AKEY_C;
if (Key_Sate[RETROK_d])return AKEY_D;
if (Key_Sate[RETROK_e])return AKEY_E;
if (Key_Sate[RETROK_f])return AKEY_F;
if (Key_Sate[RETROK_g])return AKEY_G;
if (Key_Sate[RETROK_h])return AKEY_H;
if (Key_Sate[RETROK_i])return AKEY_I;
if (Key_Sate[RETROK_j])return AKEY_J;
if (Key_Sate[RETROK_k])return AKEY_K;
if (Key_Sate[RETROK_l])return AKEY_L;
if (Key_Sate[RETROK_m])return AKEY_M;
if (Key_Sate[RETROK_n])return AKEY_N;
if (Key_Sate[RETROK_o])return AKEY_O;
if (Key_Sate[RETROK_p])return AKEY_P;
if (Key_Sate[RETROK_q])return AKEY_Q;
if (Key_Sate[RETROK_r])return AKEY_R;
if (Key_Sate[RETROK_s])return AKEY_S;
if (Key_Sate[RETROK_t])return AKEY_T;
if (Key_Sate[RETROK_u])return AKEY_U;
if (Key_Sate[RETROK_v])return AKEY_V;
if (Key_Sate[RETROK_w])return AKEY_W;
if (Key_Sate[RETROK_x])return AKEY_X;
if (Key_Sate[RETROK_y])return AKEY_Y;
if (Key_Sate[RETROK_z])return AKEY_Z;
if (Key_State[RETROK_a]) return AKEY_A;
if (Key_State[RETROK_b]) return AKEY_B;
if (Key_State[RETROK_c]) return AKEY_C;
if (Key_State[RETROK_d]) return AKEY_D;
if (Key_State[RETROK_e]) return AKEY_E;
if (Key_State[RETROK_f]) return AKEY_F;
if (Key_State[RETROK_g]) return AKEY_G;
if (Key_State[RETROK_h]) return AKEY_H;
if (Key_State[RETROK_i]) return AKEY_I;
if (Key_State[RETROK_j]) return AKEY_J;
if (Key_State[RETROK_k]) return AKEY_K;
if (Key_State[RETROK_l]) return AKEY_L;
if (Key_State[RETROK_m]) return AKEY_M;
if (Key_State[RETROK_n]) return AKEY_N;
if (Key_State[RETROK_o]) return AKEY_O;
if (Key_State[RETROK_p]) return AKEY_P;
if (Key_State[RETROK_q]) return AKEY_Q;
if (Key_State[RETROK_r]) return AKEY_R;
if (Key_State[RETROK_s]) return AKEY_S;
if (Key_State[RETROK_t]) return AKEY_T;
if (Key_State[RETROK_u]) return AKEY_U;
if (Key_State[RETROK_v]) return AKEY_V;
if (Key_State[RETROK_w]) return AKEY_W;
if (Key_State[RETROK_x]) return AKEY_X;
if (Key_State[RETROK_y]) return AKEY_Y;
if (Key_State[RETROK_z]) return AKEY_Z;
if (Key_Sate[RETROK_1])return AKEY_EXCLAMATION;
if (Key_Sate[RETROK_2])return AKEY_DBLQUOTE;
if (Key_Sate[RETROK_3])return AKEY_HASH;
if (Key_Sate[RETROK_4])return AKEY_DOLLAR;
if (Key_Sate[RETROK_5])return AKEY_PERCENT;
if (Key_Sate[RETROK_6])return AKEY_AMPERSAND;
if (Key_Sate[RETROK_7])return AKEY_QUOTE;
if (Key_Sate[RETROK_8])return AKEY_AT;
if (Key_Sate[RETROK_9])return AKEY_PARENLEFT;
if (Key_Sate[RETROK_0])return AKEY_PARENRIGHT;
if (Key_State[RETROK_1]) return AKEY_EXCLAMATION;
if (Key_State[RETROK_2]) return AKEY_DBLQUOTE;
if (Key_State[RETROK_3]) return AKEY_HASH;
if (Key_State[RETROK_4]) return AKEY_DOLLAR;
if (Key_State[RETROK_5]) return AKEY_PERCENT;
if (Key_State[RETROK_6]) return AKEY_AMPERSAND;
if (Key_State[RETROK_7]) return AKEY_QUOTE;
if (Key_State[RETROK_8]) return AKEY_AT;
if (Key_State[RETROK_9]) return AKEY_PARENLEFT;
if (Key_State[RETROK_0]) return AKEY_PARENRIGHT;
if (Key_Sate[RETROK_BACKSLASH])return AKEY_BAR;
if (Key_Sate[RETROK_COMMA])return AKEY_BRACKETLEFT;
if (Key_Sate[RETROK_PERIOD])return AKEY_BRACKETRIGHT;
if (Key_Sate[RETROK_UNDERSCORE])return AKEY_MINUS;
if (Key_Sate[RETROK_PLUS])return AKEY_BACKSLASH;
if (Key_Sate[RETROK_EQUALS])return AKEY_BAR;
if (Key_Sate[RETROK_LEFTBRACKET])return AKEY_BRACKETLEFT; // no curly braces on Atari
if (Key_Sate[RETROK_RIGHTBRACKET])return AKEY_BRACKETRIGHT; // no curly braces on Atari
if (Key_Sate[RETROK_SEMICOLON])return AKEY_COLON;
if (Key_Sate[RETROK_QUOTE])return AKEY_DBLQUOTE;
if (Key_Sate[RETROK_SLASH])return AKEY_QUESTION;
if (Key_Sate[RETROK_ASTERISK])return AKEY_CIRCUMFLEX;
if (Key_Sate[RETROK_LESS])return AKEY_LESS;
if (Key_Sate[RETROK_GREATER])return AKEY_GREATER;
if (Key_State[RETROK_BACKSLASH]) return AKEY_BAR;
if (Key_State[RETROK_COMMA]) return AKEY_BRACKETLEFT;
if (Key_State[RETROK_PERIOD]) return AKEY_BRACKETRIGHT;
if (Key_State[RETROK_UNDERSCORE]) return AKEY_MINUS;
if (Key_State[RETROK_PLUS]) return AKEY_BACKSLASH;
if (Key_State[RETROK_EQUALS]) return AKEY_BAR;
if (Key_State[RETROK_LEFTBRACKET]) return AKEY_BRACKETLEFT; // no curly braces on Atari
if (Key_State[RETROK_RIGHTBRACKET]) return AKEY_BRACKETRIGHT; // no curly braces on Atari
if (Key_State[RETROK_SEMICOLON]) return AKEY_COLON;
if (Key_State[RETROK_QUOTE]) return AKEY_DBLQUOTE;
if (Key_State[RETROK_SLASH]) return AKEY_QUESTION;
if (Key_State[RETROK_ASTERISK]) return AKEY_CIRCUMFLEX;
if (Key_State[RETROK_LESS]) return AKEY_LESS;
if (Key_State[RETROK_GREATER]) return AKEY_GREATER;
if (Key_Sate[RETROK_F7])return (AKEY_SHFT | AKEY_F1);
if (Key_Sate[RETROK_F8])return (AKEY_SHFT | AKEY_F2);
if (Key_Sate[RETROK_F9])return (AKEY_SHFT | AKEY_F3);
if (Key_Sate[RETROK_F10])return (AKEY_SHFT | AKEY_F4);
if (Key_State[RETROK_F7]) return (AKEY_SHFT | AKEY_F1);
if (Key_State[RETROK_F8]) return (AKEY_SHFT | AKEY_F2);
if (Key_State[RETROK_F9]) return (AKEY_SHFT | AKEY_F3);
if (Key_State[RETROK_F10]) return (AKEY_SHFT | AKEY_F4);
} else {
if (Key_Sate[RETROK_a])return AKEY_a;
if (Key_Sate[RETROK_b])return AKEY_b;
if (Key_Sate[RETROK_c])return AKEY_c;
if (Key_Sate[RETROK_d])return AKEY_d;
if (Key_Sate[RETROK_e])return AKEY_e;
if (Key_Sate[RETROK_f])return AKEY_f;
if (Key_Sate[RETROK_g])return AKEY_g;
if (Key_Sate[RETROK_h])return AKEY_h;
if (Key_Sate[RETROK_i])return AKEY_i;
if (Key_Sate[RETROK_j])return AKEY_j;
if (Key_Sate[RETROK_k])return AKEY_k;
if (Key_Sate[RETROK_l])return AKEY_l;
if (Key_Sate[RETROK_m])return AKEY_m;
if (Key_Sate[RETROK_n])return AKEY_n;
if (Key_Sate[RETROK_o])return AKEY_o;
if (Key_Sate[RETROK_p])return AKEY_p;
if (Key_Sate[RETROK_q])return AKEY_q;
if (Key_Sate[RETROK_r])return AKEY_r;
if (Key_Sate[RETROK_s])return AKEY_s;
if (Key_Sate[RETROK_t])return AKEY_t;
if (Key_Sate[RETROK_u])return AKEY_u;
if (Key_Sate[RETROK_v])return AKEY_v;
if (Key_Sate[RETROK_w])return AKEY_w;
if (Key_Sate[RETROK_x])return AKEY_x;
if (Key_Sate[RETROK_y])return AKEY_y;
if (Key_Sate[RETROK_z])return AKEY_z;
if (Key_State[RETROK_a]) return AKEY_a;
if (Key_State[RETROK_b]) return AKEY_b;
if (Key_State[RETROK_c]) return AKEY_c;
if (Key_State[RETROK_d]) return AKEY_d;
if (Key_State[RETROK_e]) return AKEY_e;
if (Key_State[RETROK_f]) return AKEY_f;
if (Key_State[RETROK_g]) return AKEY_g;
if (Key_State[RETROK_h]) return AKEY_h;
if (Key_State[RETROK_i]) return AKEY_i;
if (Key_State[RETROK_j]) return AKEY_j;
if (Key_State[RETROK_k]) return AKEY_k;
if (Key_State[RETROK_l]) return AKEY_l;
if (Key_State[RETROK_m]) return AKEY_m;
if (Key_State[RETROK_n]) return AKEY_n;
if (Key_State[RETROK_o]) return AKEY_o;
if (Key_State[RETROK_p]) return AKEY_p;
if (Key_State[RETROK_q]) return AKEY_q;
if (Key_State[RETROK_r]) return AKEY_r;
if (Key_State[RETROK_s]) return AKEY_s;
if (Key_State[RETROK_t]) return AKEY_t;
if (Key_State[RETROK_u]) return AKEY_u;
if (Key_State[RETROK_v]) return AKEY_v;
if (Key_State[RETROK_w]) return AKEY_w;
if (Key_State[RETROK_x]) return AKEY_x;
if (Key_State[RETROK_y]) return AKEY_y;
if (Key_State[RETROK_z]) return AKEY_z;
if (Key_Sate[RETROK_0])return AKEY_0;
if (Key_Sate[RETROK_1])return AKEY_1;
if (Key_Sate[RETROK_2])return AKEY_2;
if (Key_Sate[RETROK_3])return AKEY_3;
if (Key_Sate[RETROK_4])return AKEY_4;
if (Key_Sate[RETROK_5])return AKEY_5;
if (Key_Sate[RETROK_6])return AKEY_6;
if (Key_Sate[RETROK_7])return AKEY_7;
if (Key_Sate[RETROK_8])return AKEY_8;
if (Key_Sate[RETROK_9])return AKEY_9;
if (Key_State[RETROK_0]) return AKEY_0;
if (Key_State[RETROK_1]) return AKEY_1;
if (Key_State[RETROK_2]) return AKEY_2;
if (Key_State[RETROK_3]) return AKEY_3;
if (Key_State[RETROK_4]) return AKEY_4;
if (Key_State[RETROK_5]) return AKEY_5;
if (Key_State[RETROK_6]) return AKEY_6;
if (Key_State[RETROK_7]) return AKEY_7;
if (Key_State[RETROK_8]) return AKEY_8;
if (Key_State[RETROK_9]) return AKEY_9;
if (Key_Sate[RETROK_BACKSLASH])return AKEY_BACKSLASH;
if (Key_Sate[RETROK_COMMA])return AKEY_COMMA;
if (Key_Sate[RETROK_PERIOD])return AKEY_FULLSTOP;
if (Key_Sate[RETROK_MINUS])return AKEY_MINUS;
if (Key_Sate[RETROK_PLUS])return AKEY_PLUS;
if (Key_Sate[RETROK_EQUALS])return AKEY_EQUAL;
if (Key_Sate[RETROK_LEFTBRACKET])return AKEY_BRACKETLEFT;
if (Key_Sate[RETROK_RIGHTBRACKET])return AKEY_BRACKETRIGHT;
if (Key_Sate[RETROK_SEMICOLON])return AKEY_SEMICOLON;
if (Key_Sate[RETROK_QUOTE])return AKEY_QUOTE;
if (Key_Sate[RETROK_SLASH])return AKEY_SLASH;
if (Key_Sate[RETROK_ASTERISK])return AKEY_ASTERISK;
if (Key_Sate[RETROK_LESS])return AKEY_LESS;
if (Key_Sate[RETROK_GREATER])return AKEY_GREATER;
if (Key_Sate[RETROK_UNDERSCORE])return AKEY_UNDERSCORE;
if (Key_Sate[RETROK_F7])return AKEY_F1;
if (Key_Sate[RETROK_F8])return AKEY_F2;
if (Key_Sate[RETROK_F9])return AKEY_F3;
if (Key_Sate[RETROK_F10])return AKEY_F4;
if (Key_State[RETROK_BACKSLASH]) return AKEY_BACKSLASH;
if (Key_State[RETROK_COMMA]) return AKEY_COMMA;
if (Key_State[RETROK_PERIOD]) return AKEY_FULLSTOP;
if (Key_State[RETROK_MINUS]) return AKEY_MINUS;
if (Key_State[RETROK_PLUS]) return AKEY_PLUS;
if (Key_State[RETROK_EQUALS]) return AKEY_EQUAL;
if (Key_State[RETROK_LEFTBRACKET]) return AKEY_BRACKETLEFT;
if (Key_State[RETROK_RIGHTBRACKET]) return AKEY_BRACKETRIGHT;
if (Key_State[RETROK_SEMICOLON]) return AKEY_SEMICOLON;
if (Key_State[RETROK_QUOTE]) return AKEY_QUOTE;
if (Key_State[RETROK_SLASH]) return AKEY_SLASH;
if (Key_State[RETROK_ASTERISK]) return AKEY_ASTERISK;
if (Key_State[RETROK_LESS]) return AKEY_LESS;
if (Key_State[RETROK_GREATER]) return AKEY_GREATER;
if (Key_State[RETROK_UNDERSCORE]) return AKEY_UNDERSCORE;
if (Key_State[RETROK_F7]) return AKEY_F1;
if (Key_State[RETROK_F8]) return AKEY_F2;
if (Key_State[RETROK_F9]) return AKEY_F3;
if (Key_State[RETROK_F10]) return AKEY_F4;
}
/* FIXME joy bind */
if (!UI_is_active)
{
if (SHOWKEYDELAY)
SHOWKEYDELAY--;
if (mbt[RETRO_DEVICE_ID_JOYPAD_SELECT])
for (int i = 0; i < 4; i++)
{
if (SHOWKEY == -1)
{
if (mbt[i][RETRO_DEVICE_ID_JOYPAD_SELECT])
INPUT_key_consol &= (~INPUT_CONSOL_SELECT);
if (mbt[RETRO_DEVICE_ID_JOYPAD_START])
if (mbt[i][RETRO_DEVICE_ID_JOYPAD_START])
INPUT_key_consol &= (~INPUT_CONSOL_START);
if (mbt[RETRO_DEVICE_ID_JOYPAD_L])
if (mbt[i][RETRO_DEVICE_ID_JOYPAD_L])
INPUT_key_consol &= (~INPUT_CONSOL_OPTION);
if (mbt[RETRO_DEVICE_ID_JOYPAD_R])
if (mbt[i][RETRO_DEVICE_ID_JOYPAD_R])
return AKEY_UI;
if (mbt[RETRO_DEVICE_ID_JOYPAD_L2])
if (mbt[i][RETRO_DEVICE_ID_JOYPAD_Y])
return AKEY_SPACE;
if (mbt[RETRO_DEVICE_ID_JOYPAD_R2])
if (mbt[i][RETRO_DEVICE_ID_JOYPAD_L2])
return AKEY_ESCAPE;
if (mbt[RETRO_DEVICE_ID_JOYPAD_B])
if (mbt[i][RETRO_DEVICE_ID_JOYPAD_X])
return AKEY_RETURN;
if (mbt[RETRO_DEVICE_ID_JOYPAD_Y])
if (mbt[i][RETRO_DEVICE_ID_JOYPAD_R2])
return AKEY_HELP;
}
if (mbt[i][RETRO_DEVICE_ID_JOYPAD_L3])
if (!SHOWKEYDELAY)
{
SHOWKEY = -SHOWKEY;
SHOWKEYDELAY = 20;
}
}
/* not quite working when controller Device Type is ATARI Keyboard.. FIXME!*/
//if (atari_devices[0] == RETRO_DEVICE_ATARI_KEYBOARD && (Key_State[RETROK_F11]))
// if (!SHOWKEYDELAY)
// {
// SHOWKEY = -SHOWKEY;
// SHOWKEYDELAY = 20;
// Key_State[RETROK_F11] = 0;
// }
}
/* not a big fan of hard coding input.. but it helps in a pinch of one accidently unmaps the controls
and this code is only used when the UI is active */
if (UI_is_active){
// whitout kbd in GUI
// whithout kbd in GUI
if (MXjoy[0] & 0x04)
return AKEY_LEFT;
if (MXjoy[0] & 0x08)
@@ -629,25 +691,52 @@ int PLATFORM_Keyboard(void)
return AKEY_UP;
if (MXjoy[0] & 0x02)
return AKEY_DOWN;
if (MXjoy[0]&0x80)
if (MXjoy[0] & 0x10)
return AKEY_RETURN;
if (MXjoy[0]&0x40)
if (MXjoy[0] & 0x80)
return AKEY_ESCAPE;
}
return AKEY_NONE;
/* This is my alternate internal UI controls... mapped based on players controller mapping. I can't decide which is the best to use
Maybe give the player the option? */
//if (UI_is_active) {
// for (int i = 0; i < 4; i++)
// {
// if (mbt[i][RETRO_DEVICE_ID_JOYPAD_LEFT])
// return AKEY_LEFT;
// if (mbt[i][RETRO_DEVICE_ID_JOYPAD_RIGHT])
// return AKEY_RIGHT;
// if (mbt[i][RETRO_DEVICE_ID_JOYPAD_UP])
// return AKEY_UP;
// if (mbt[i][RETRO_DEVICE_ID_JOYPAD_DOWN])
// return AKEY_DOWN;
// if (atari_devices[i] == RETRO_DEVICE_ATARI_JOYSTICK)
// whichButton = RETRO_DEVICE_ID_JOYPAD_A;
// else if (atari_devices[i] == RETRO_DEVICE_ATARI_5200_JOYSTICK)
// whichButton = RETRO_DEVICE_ID_JOYPAD_B;
// if (mbt[i][whichButton])
// return AKEY_RETURN;
// if (atari_devices[i] == RETRO_DEVICE_ATARI_JOYSTICK)
// whichButton = RETRO_DEVICE_ID_JOYPAD_R2;
// else if (atari_devices[i] == RETRO_DEVICE_ATARI_5200_JOYSTICK)
// whichButton = RETRO_DEVICE_ID_JOYPAD_A;
// if (mbt[i][whichButton])
// return AKEY_ESCAPE;
// }
//}
return AKEY_NONE;
}
/*
int PLATFORM_GetRawKey(void)
{
input_poll_cb();
for(i=0;i<320;i++)
Key_Sate[i]=input_state_cb(0, RETRO_DEVICE_KEYBOARD, 0,i) ? 0x80: 0;
Key_State[i]=input_state_cb(0, RETRO_DEVICE_KEYBOARD, 0,i) ? 0x80: 0;
}
*/
@@ -701,6 +790,38 @@ static void get_platform_PORT(unsigned char *s0, unsigned char *s1, unsigned cha
int stick0, stick1, stick2, stick3;
stick0 = stick1 = stick2 = stick3 = INPUT_STICK_CENTRE;
/* only send trigger (joyleft) if paddle mode is active and trigger button pressed*/
if (!UI_is_active && paddle_mode)
{
if (PLATFORM_kbd_joy_0_enabled) {
if ((MXjoy[0] & 0x80))
stick0 &= INPUT_STICK_LEFT;
}
if (PLATFORM_kbd_joy_1_enabled) {
if ((MXjoy[1] & 0x80))
stick1 &= INPUT_STICK_LEFT;
}
if (PLATFORM_kbd_joy_2_enabled) {
if ((MXjoy[2] & 0x80))
stick2 &= INPUT_STICK_LEFT;
}
if (PLATFORM_kbd_joy_3_enabled) {
if ((MXjoy[3] & 0x80))
stick3 &= INPUT_STICK_LEFT;
}
*s0 = stick0;
*s1 = stick1;
*s2 = stick2;
*s3 = stick3;
/* trig is all we care about */
return;
}
if (PLATFORM_kbd_joy_0_enabled) {
if (MXjoy[0] & 0x04)
stick0 &= INPUT_STICK_LEFT;
@@ -796,6 +917,9 @@ static void get_platform_TRIG(unsigned char *t0, unsigned char *t1, unsigned cha
int PLATFORM_PORT(int num)
{
if (SHOWKEY == 1 )
return 0xff;
if (num == 0) {
UBYTE a, b, c, d;
get_platform_PORT(&a, &b, &c, &d);
@@ -815,6 +939,10 @@ int PLATFORM_PORT(int num)
int PLATFORM_TRIG(int num)
{
UBYTE a, b, c, d;
if (SHOWKEY == 1)
return 0x01;
get_platform_TRIG(&a, &b, &c, &d);
switch (num) {
libretro/retro_disk_control.c
+428
View File
@@ -0,0 +1,428 @@
/* Copyright (C) 2018
*
* Permission is hereby granted, free of charge,
* to any person obtaining a copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation the rights to
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
* and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
* INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#include <stdarg.h>
#include "libretro.h"
#include "retro_disk_control.h"
#include "retro_strings.h"
#include "retro_utils.h"
#include "file/file_path.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string/stdstring.h>
/*#include <sys/types.h>
#include <sys/stat.h>
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>*/
static void fallback_log(enum retro_log_level level, const char* fmt, ...);
static retro_log_printf_t log_cb = fallback_log;
static void fallback_log(enum retro_log_level level, const char* fmt, ...)
{
va_list va;
(void)level;
va_start(va, fmt);
vfprintf(stderr, fmt, va);
va_end(va);
}
#define COMMENT "#"
#define M3U_SPECIAL_COMMAND "#COMMAND:"
// Return the directory name of filename 'filename'.
static char* dirname_int(const char* filename)
{
if (filename == NULL)
return NULL;
// Find last separator
char* right = find_last_slash(filename);
if (right)
return strleft(filename, right - filename);
// Not found
return NULL;
}
static char* m3u_search_file(const char* basedir, const char* dskName)
{
// If basedir was provided
if (basedir != NULL && !path_is_absolute(dskName))
{
// Join basedir and dskName
char* dskPath = path_join_dup(basedir, dskName);
// Verify if this item is a relative filename (append it to the m3u path)
if (file_exists(dskPath))
{
// Return
return dskPath;
}
free(dskPath);
}
// Verify if this item is an absolute pathname (or the file is in working dir)
if (file_exists(dskName))
{
// Copy and return
return strdup(dskName);
}
// File not found
return NULL;
}
void dc_reset(dc_storage* dc)
{
unsigned i;
// Verify
if (dc == NULL)
return;
// Clean the command
if (dc->command)
{
free(dc->command);
dc->command = NULL;
}
// Clean the struct
for (i = 0; i < dc->count; i++)
{
free(dc->files[i]);
dc->files[i] = NULL;
free(dc->names[i]);
dc->names[i] = NULL;
dc->types[i] = DC_IMAGE_TYPE_NONE;
}
dc->unit = DC_IMAGE_TYPE_NONE;
dc->count = 0;
dc->index = 0;
dc->index_prev = 0;
dc->eject_state = true;
dc->replace = false;
}
dc_storage* dc_create(void)
{
int i;
// Initialize the struct
dc_storage* dc = NULL;
if ((dc = (dc_storage*)malloc(sizeof(dc_storage))) != NULL)
{
dc->unit = DC_IMAGE_TYPE_NONE;
dc->count = 0;
dc->index = 0;
dc->eject_state = true;
dc->replace = false;
dc->command = NULL;
for (i = 0; i < DC_MAX_SIZE; i++)
{
dc->files[i] = NULL;
dc->names[i] = NULL;
dc->types[i] = DC_IMAGE_TYPE_NONE;
}
}
return dc;
}
bool dc_add_file_int(dc_storage* dc, char* filename, char* name)
{
/* Verify */
if (dc == NULL)
return false;
if (!filename || (*filename == '\0'))
return false;
/* If max size is not exceeded */
if (dc->count < DC_MAX_SIZE)
{
/* Add the file */
dc->count++;
dc->files[dc->count - 1] = strdup(filename);
dc->names[dc->count - 1] = !string_is_empty(name) ? strdup(name) : NULL;
dc->types[dc->count - 1] = dc_get_image_type(filename);
log_cb(RETRO_LOG_INFO, ">>> dc added int %s - [%s]\n", filename, name);
return true;
}
return false;
}
bool dc_add_file(dc_storage* dc, const char* filename)
{
unsigned index = 0;
/* Verify */
if (dc == NULL || !filename || (*filename == '\0'))
return false;
/* Dupecheck */
for (index = 0; index < dc->count; index++)
{
if (!strcmp(dc->files[index], filename))
{
log_cb(RETRO_LOG_INFO,"File '%s' ignored as duplicate!\n", filename);
return true;
}
}
// Get 'name' - just the filename without extension
char name[512];
name[0] = '\0';
fill_pathname(name, path_basename(filename), "", sizeof(name));
if (!dc_add_file_int(dc, strdup(filename), strdup(name)))
return false;
// if dc unit-type is none, get type from first image
if (dc->unit == DC_IMAGE_TYPE_NONE)
{
if (dc_get_image_type(dc->files[0]) == DC_IMAGE_TYPE_TAPE)
dc->unit = DC_IMAGE_TYPE_TAPE;
else if (dc_get_image_type(dc->files[0]) == DC_IMAGE_TYPE_FLOPPY)
dc->unit = DC_IMAGE_TYPE_FLOPPY;
else if (dc_get_image_type(dc->files[0]) == DC_IMAGE_TYPE_MEM)
dc->unit = DC_IMAGE_TYPE_MEM;
else
dc->unit = DC_IMAGE_TYPE_FLOPPY;
}
log_cb(RETRO_LOG_INFO,">>> dc added %s - [%s] [unit %i]\n", filename, name, dc->unit);
return true;
}
bool dc_remove_file(dc_storage* dc, int index)
{
if (dc == NULL)
return false;
if (index < 0 || index >= dc->count)
return false;
// "If ptr is a null pointer, no action occurs"
free(dc->files[index]);
dc->files[index] = NULL;
free(dc->names[index]);
dc->names[index] = NULL;
dc->types[index] = DC_IMAGE_TYPE_NONE;
// Shift all entries after index one slot up
if (index != dc->count - 1)
{
memmove(dc->files + index, dc->files + index + 1, (dc->count - 1 - index) * sizeof(dc->files[0]));
memmove(dc->names + index, dc->names + index + 1, (dc->count - 1 - index) * sizeof(dc->names[0]));
}
dc->count--;
// Reset fliplist unit after removing last entry
if (dc->count == 0)
{
dc->unit = DC_IMAGE_TYPE_NONE;
}
return true;
}
int dc_replace_file(dc_storage* dc, int index, const char* filename)
{
if (dc == NULL)
return false;
if (index < 0 || index >= dc->count)
return false;
// "If ptr is a null pointer, no action occurs"
free(dc->files[index]);
dc->files[index] = NULL;
free(dc->names[index]);
dc->names[index] = NULL;
dc->types[index] = DC_IMAGE_TYPE_NONE;
if (filename == NULL)
{
dc_remove_file(dc, index);
}
else
{
dc->replace = false;
char full_path_replace[RETRO_PATH_MAX] = { 0 };
strncpy(full_path_replace, (char*)filename, sizeof(full_path_replace));
/* ZIP/M3U not implemented internally */
if (
strendswith(full_path_replace, "m3u") ||
strendswith(full_path_replace, "zip") ||
strendswith(full_path_replace, "7z")
)
{
log_cb(RETRO_LOG_INFO,">>> dc replace %s unsupported type.\n", filename);
return false;
}
/* Single append */
else
{
// Get 'name' - just the filename without extension
char name[512];
name[0] = '\0';
fill_pathname(name, path_basename(filename), "", sizeof(name));
/* Dupecheck */
for (unsigned i = 0; i < dc->count - 1; i++)
{
if (!strcmp(dc->files[i], full_path_replace))
{
dc_remove_file(dc, index);
return 2; // 2 = duplicate found
}
}
dc->files[index] = strdup(filename);
dc->names[index] = !string_is_empty(name) ? strdup(name) : NULL;
dc->types[index] = dc_get_image_type(filename);
log_cb(RETRO_LOG_INFO,">>> dc replace %s - %s [%u].\n", filename, name , dc->types[index] );
}
}
return true;
}
void dc_parse_m3u(dc_storage* dc, const char* m3u_file)
{
// Verify
if (dc == NULL)
return;
if (m3u_file == NULL)
return;
FILE* fp = NULL;
// Try to open the file
if ((fp = fopen(m3u_file, "r")) == NULL)
return;
// Reset
dc_reset(dc);
// Get the m3u base dir for resolving relative path
char* basedir = dirname_int(m3u_file);
// Disk control interface 'name' for the following file
char* image_name = NULL;
// Read the lines while there is line to read and we have enough space
char buffer[2048];
while ((dc->count <= DC_MAX_SIZE) && (fgets(buffer, sizeof(buffer), fp) != NULL))
{
char* string = trimwhitespace(buffer);
// If it's a m3u special key or a file
if (strstartswith(string, M3U_SPECIAL_COMMAND))
{
dc->command = strright(string, strlen(string) - strlen(M3U_SPECIAL_COMMAND));
}
else if (!strstartswith(string, COMMENT))
{
// Search the file (absolute, relative to m3u)
char* filename;
if ((filename = m3u_search_file(basedir, string)) != NULL)
{
char tmp[512];
tmp[0] = '\0';
fill_pathname(tmp, path_basename(filename), "", sizeof(tmp));
image_name = strdup(tmp);
// Add the file to the struct
dc_add_file_int(dc, filename, image_name);
image_name = NULL;
}
}
}
// If basedir was provided
if (basedir != NULL)
free(basedir);
// Close the file
fclose(fp);
if (dc->count != 0)
{
if (dc_get_image_type(dc->files[0]) == DC_IMAGE_TYPE_TAPE)
dc->unit = DC_IMAGE_TYPE_TAPE;
else if (dc_get_image_type(dc->files[0]) == DC_IMAGE_TYPE_FLOPPY)
dc->unit = DC_IMAGE_TYPE_FLOPPY;
else
dc->unit = DC_IMAGE_TYPE_FLOPPY;
log_cb(RETRO_LOG_INFO,">>> dc (m3u) unit type: %i\n", dc->unit);
}
}
void dc_free(dc_storage* dc)
{
// Clean the struct
dc_reset(dc);
free(dc);
dc = NULL;
return;
}
enum dc_image_type dc_get_image_type(const char* filename)
{
// Missing file
if (!filename || (*filename == '\0'))
return DC_IMAGE_TYPE_NONE;
// Floppy image
if (strendswith(filename, "atr") ||
strendswith(filename, "atx") ||
strendswith(filename, "xfd") ||
strendswith(filename, "dcm"))
return DC_IMAGE_TYPE_FLOPPY;
// Tape image. Removed "cdt" since it is not an Atari800 file type
if (strendswith(filename, "cas"))
return DC_IMAGE_TYPE_TAPE;
// Fallback
return DC_IMAGE_TYPE_UNKNOWN;
}
libretro/retro_disk_control.h
+86
View File
@@ -0,0 +1,86 @@
/****************************************************************************
* Caprice32 libretro port
*
* Copyright not6 - r-type (2015-2018)
* Copyright David Colmenero - D_Skywalk (2019-2021)
* Copyright Daniel De Matteis (2012-2021)
*
* Redistribution and use of this code or any derivative works are permitted
* provided that the following conditions are met:
*
* - Redistributions may not be sold, nor may they be used in a commercial
* product or activity.
*
* - Redistributions that are modified from the original source must include the
* complete source code, including the source code for all components used by a
* binary built from the modified sources. However, as a special exception, the
* source code distributed need not include anything that is normally distributed
* (in either source or binary form) with the major components (compiler, kernel,
* and so on) of the operating system on which the executable runs, unless that
* component itself accompanies the executable.
*
* - Redistributions must reproduce the above copyright notice, this list of
* conditions and the following disclaimer in the documentation and/or other
* materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
****************************************************************************************/
#ifndef RETRO_DISK_CONTROL_H__
#define RETRO_DISK_CONTROL_H__
#include <stdbool.h>
//*****************************************************************************
// Disk control structure and functions
#define DC_MAX_SIZE 20
//static INLINE bool string_is_empty(const char* data)
//{
// return !data || (*data == '\0');
//}
enum dc_image_type {
DC_IMAGE_TYPE_NONE = 0,
DC_IMAGE_TYPE_FLOPPY,
DC_IMAGE_TYPE_TAPE,
DC_IMAGE_TYPE_MEM,
DC_IMAGE_TYPE_UNKNOWN
};
struct dc_storage{
char* command;
char* files[DC_MAX_SIZE];
char* names[DC_MAX_SIZE];
enum dc_image_type types[DC_MAX_SIZE];
unsigned unit;
unsigned count;
int index;
bool eject_state;
bool replace;
unsigned index_prev;
};
typedef struct dc_storage dc_storage;
dc_storage* dc_create(void);
void dc_parse_m3u(dc_storage* dc, const char* m3u_file);
bool dc_add_file(dc_storage* dc, const char* filename);
void dc_free(dc_storage* dc);
void dc_reset(dc_storage* dc);
int dc_replace_file(dc_storage* dc, int index, const char* filename);
bool dc_remove_file(dc_storage* dc, int index);
enum dc_image_type dc_get_image_type(const char* filename);
#endif
libretro/retro_files.c
+28
View File
@@ -0,0 +1,28 @@
/* Copyright (C) 2018
*
* Permission is hereby granted, free of charge,
* to any person obtaining a copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation the rights to
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
* and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
* INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#include "retro_files.h"
#include <sys/stat.h>
#include <stdio.h>
#include <string.h>
void path_join(char* out, const char* basedir, const char* filename)
{
snprintf(out, RETRO_PATH_MAX, "%s%s%s", basedir, RETRO_PATH_SEPARATOR, filename);
}
libretro/retro_files.h
+38
View File
@@ -0,0 +1,38 @@
/* Copyright (C) 2018
*
* Permission is hereby granted, free of charge,
* to any person obtaining a copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation the rights to
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
* and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
* INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#ifndef RETRO_FILES_H__
#define RETRO_FILES_H__
#include <stdbool.h>
//*****************************************************************************
// File helpers functions
#define RETRO_PATH_MAX 512
#ifdef _WIN32
#define RETRO_PATH_SEPARATOR "\\"
// Windows also support the unix path separator
#define RETRO_PATH_SEPARATOR_ALT "/"
#else
#define RETRO_PATH_SEPARATOR "/"
#endif
void path_join(char* out, const char* basedir, const char* filename);
#endif
libretro/retro_strings.c
+86
View File
@@ -0,0 +1,86 @@
/* Copyright (C) 2018
*
* Permission is hereby granted, free of charge,
* to any person obtaining a copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation the rights to
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
* and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
* INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#include "retro_strings.h"
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// Note: This function returns a pointer to a substring_left of the original string.
// If the given string was allocated dynamically, the caller must not overwrite
// that pointer with the returned value, since the original pointer must be
// deallocated using the same allocator with which it was allocated. The return
// value must NOT be deallocated using free() etc.
char* trimwhitespace(char *str)
{
char *end;
// Trim leading space
while(isspace((unsigned char)*str)) str++;
if(*str == 0) // All spaces?
return str;
// Trim trailing space
end = str + strlen(str) - 1;
while(end > str && isspace((unsigned char)*end)) end--;
// Write new null terminator character
end[1] = '\0';
return str;
}
// Returns a substring of 'str' that contains the 'len' leftmost characters of 'str'.
char* strleft(const char* str, int len)
{
char* result = calloc(len + 1, sizeof(char));
strncpy(result, str, len);
return result;
}
// Returns a substring of 'str' that contains the 'len' rightmost characters of 'str'.
char* strright(const char* str, int len)
{
int pos = strlen(str) - len;
char* result = calloc(len + 1, sizeof(char));
strncpy(result, str + pos, len);
return result;
}
// Returns true if 'str' starts with 'start'
bool strstartswith(const char* str, const char* start)
{
if (strlen(str) >= strlen(start))
if(!strncasecmp(str, start, strlen(start)))
return true;
return false;
}
// Returns true if 'str' ends with 'end'
bool strendswith(const char* str, const char* end)
{
if (strlen(str) >= strlen(end))
if(!strcasecmp((char*)&str[strlen(str)-strlen(end)], end))
return true;
return false;
}
libretro/retro_strings.h
+32
View File
@@ -0,0 +1,32 @@
/* Copyright (C) 2018
*
* Permission is hereby granted, free of charge,
* to any person obtaining a copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation the rights to
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
* and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
* INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#ifndef RETRO_STRINGS_H__
#define RETRO_STRINGS_H__
#include <stdbool.h>
//*****************************************************************************
// String helpers functions
char* trimwhitespace(char *str);
char* strleft(const char* str, int len);
char* strright(const char* str, int len);
bool strstartswith(const char* str, const char* start);
bool strendswith(const char* str, const char* end);
#endif
libretro/retro_utils.c
+185
View File
@@ -0,0 +1,185 @@
/****************************************************************************
* Caprice32 libretro port
*
* Copyright not6 - r-type (2015-2018)
* Copyright David Colmenero - D_Skywalk (2019-2021)
* Copyright Daniel De Matteis (2012-2021)
*
* Redistribution and use of this code or any derivative works are permitted
* provided that the following conditions are met:
*
* - Redistributions may not be sold, nor may they be used in a commercial
* product or activity.
*
* - Redistributions that are modified from the original source must include the
* complete source code, including the source code for all components used by a
* binary built from the modified sources. However, as a special exception, the
* source code distributed need not include anything that is normally distributed
* (in either source or binary form) with the major components (compiler, kernel,
* and so on) of the operating system on which the executable runs, unless that
* component itself accompanies the executable.
*
* - Redistributions must reproduce the above copyright notice, this list of
* conditions and the following disclaimer in the documentation and/or other
* materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
****************************************************************************************/
#include <sys/stat.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "retro_utils.h"
#ifdef VITA
#include "file/file_path.h"
#endif
extern uint8_t* pbGPBuffer;
// Verify file extension
bool file_check_extension(const char *filename, const size_t filename_size, const char *ext, const size_t ext_size)
{
#ifndef __PS3__
size_t file_len = strnlen(filename, filename_size);
size_t ext_len = strnlen(ext, ext_size);
#else
size_t file_len = strlen(filename) > filename_size ? filename_size : strlen(filename);
size_t ext_len = strlen(ext) > ext_size ? ext_size : strlen(ext);
#endif
if( ext_len > file_len || file_len >= filename_size - 1)
return false;
const char * file_ext = &filename[file_len - ext_len];
return (strncasecmp(file_ext, ext, filename_size) == 0);
}
bool file_check_flag(const char *filename, const size_t filename_size, const char *flag, const size_t flag_size)
{
#ifndef __PS3__
size_t file_len = strnlen(filename, filename_size);
size_t flag_len = strnlen(flag, flag_size);
#else
size_t file_len = strlen(filename) > filename_size ? filename_size : strlen(filename);
size_t flag_len = strlen(flag) > flag_size ? flag_size : strlen(flag);
#endif
for (int i = 0; i < file_len; i++) {
if (i + flag_len > file_len)
return false;
if (strncasecmp(&filename[i], flag, flag_len) == 0)
return true;
}
return false;
}
// Verify if file exists
bool file_exists(const char *filename)
{
#ifdef VITA
if (path_is_valid(filename) && !path_is_directory(filename))
#else
struct stat buf;
if (stat(filename, &buf) == 0 &&
(buf.st_mode & (S_IRUSR|S_IWUSR)) && !(buf.st_mode & S_IFDIR))
#endif
{
/* file points to user readable regular file */
return true;
}
return false;
}
int file_size (int file_num)
{
struct stat s;
if (!fstat(file_num, &s)) {
return s.st_size;
} else {
return 0;
}
}
void path_join(char* out, const char* basedir, const char* filename)
{
snprintf(out, RETRO_PATH_MAX, "%s%s%s", basedir, RETRO_PATH_SEPARATOR, filename);
}
char* path_join_dup(const char* basedir, const char* filename)
{
size_t dirlen = strlen(basedir);
size_t seplen = strlen(RETRO_PATH_SEPARATOR);
size_t filelen = strlen(filename);
char* result = (char*)malloc(dirlen + seplen + filelen + 1);
strcpy(result, basedir);
strcpy(result + dirlen, RETRO_PATH_SEPARATOR);
strcpy(result + dirlen + seplen, filename);
return result;
}
/**
* D_Skywalk: Imported from my 3DS pituka implementation
* http://david.dantoine.org/proyecto/26/
*/
#ifdef _3DS
void* linearMemAlign(size_t size, size_t alignment);
void linearFree(void* mem);
#endif
void *retro_malloc(size_t size) {
#ifdef _3DS
return linearMemAlign(size, 0x80);
#else
return malloc(size);
#endif
}
void retro_free(void * mem) {
#ifdef _3DS
linearFree(mem);
#else
free(mem);
#endif
}
// ----------------------------- crc32b --------------------------------
/* This is the basic CRC-32 calculation with some optimization but no
table lookup. The the byte reversal is avoided by shifting the crc reg
right instead of left and by using a reversed 32-bit word to represent
the polynomial. */
uint32_t crc32_calculate(uint8_t * data, uint32_t size) {
uint32_t byte, crc, mask;
crc = 0xFFFFFFFF;
for (int i = 0; i < size; i++) {
byte = data[i];
crc = crc ^ byte;
for (int j = 7; j >= 0; j--) {
mask = -(crc & 1);
crc = (crc >> 1) ^ (0xedb88320 & mask);
}
}
return ~crc;
}
libretro/retro_utils.h
+72
View File
@@ -0,0 +1,72 @@
/****************************************************************************
* Caprice32 libretro port
*
* Copyright not6 - r-type (2015-2018)
* Copyright David Colmenero - D_Skywalk (2019-2021)
* Copyright Daniel De Matteis (2012-2021)
*
* Redistribution and use of this code or any derivative works are permitted
* provided that the following conditions are met:
*
* - Redistributions may not be sold, nor may they be used in a commercial
* product or activity.
*
* - Redistributions that are modified from the original source must include the
* complete source code, including the source code for all components used by a
* binary built from the modified sources. However, as a special exception, the
* source code distributed need not include anything that is normally distributed
* (in either source or binary form) with the major components (compiler, kernel,
* and so on) of the operating system on which the executable runs, unless that
* component itself accompanies the executable.
*
* - Redistributions must reproduce the above copyright notice, this list of
* conditions and the following disclaimer in the documentation and/or other
* materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
****************************************************************************************/
#ifndef RETRO_UTILS_H__
#define RETRO_UTILS_H__
#include <stdio.h>
#include <stdint.h>
#include <stdbool.h>
//*****************************************************************************
// File helpers functions
#define RETRO_PATH_MAX 512
#ifdef _WIN32
#define RETRO_PATH_SEPARATOR "\\"
// Windows also support the unix path separator
#define RETRO_PATH_SEPARATOR_ALT "/"
#else
#define RETRO_PATH_SEPARATOR "/"
#endif
bool file_check_extension(const char *filename, const size_t filename_size, const char *ext, const size_t ext_size);
bool file_check_flag(const char *filename, const size_t filename_size, const char *flag, const size_t flag_size);
void path_join(char* out, const char* basedir, const char* filename);
char* path_join_dup(const char* basedir, const char* filename);
bool file_exists(const char *filename);
int file_size (int file_num);
uint32_t get_hash(const char *filename);
void *retro_malloc(size_t size);
void retro_free(void * mem);
#endif