-Save/Load preferences are now on Preferences menu

-Save/Load Method set to Auto - will automatically determine method (NOT YET IMPLEMENTED - defaults to SD for the moment)
-All ROM, SRAM, Freeze, and preferences are saved/loaded according to these preferences
-new cheats menu! Loads .CHT file from /cheats folder, must match file name of ROM
-combined SRAM / Freeze Managers into new "Game Option" menu
-SRAM / Freeze - game (re)loaded automatically after loading a SRAM or Freeze from Game Options
-SRAM load/save defaults to ON
-Game Options, Return to Game, Reload Game do not show up until a game has been loaded
-added ROM Information page to Game Option menu
-licence/credits moved to Credits page
-menu code tweaks
-USB support
-added future support for Wii DVD / Network loading
-MultiTap & SuperScope moved to controller configuration
-combined/rewrote SRAM/preferences/freeze code - this is now much cleaner and less repetitve - a few steps closer to being workable
-a lot of function parameters have been changed and standardized
-if preferences can't be loaded at the start and/or are reset, preferences menu pops up
-if Home button is pressed when a game is running, Game Menu pops up
-a bunch of misc. bug fixes
-probably some more things
This commit is contained in:
dborth 2008-08-07 03:25:02 +00:00
parent 1478cee2a3
commit 17d6488545
23 changed files with 2096 additions and 2151 deletions

48
source/ngc/cheatmgr.cpp Normal file
View File

@ -0,0 +1,48 @@
/****************************************************************************
* Snes9x 1.51
*
* Nintendo Wii/Gamecube Port
* Tantric August 2008
*
* cheatmgr.cpp
*
* Cheat handling
****************************************************************************/
#include "snes9xGx.h"
#include "memmap.h"
#include "sdload.h"
#include "cheats.h"
extern SCheatData Cheat;
/****************************************************************************
* SetupCheats
*
* Erases any prexisting cheats, loads cheats from a cheat file
* Called when a ROM is first loaded
****************************************************************************/
void
SetupCheats()
{
S9xInitCheatData ();
S9xDeleteCheats ();
char cheatFile[150] = { '\0' };
if(GCSettings.SaveMethod == METHOD_SD)
sprintf (cheatFile, "%s/snes9x/cheats/%s.cht", ROOTSDDIR, Memory.ROMFilename);
else if(GCSettings.SaveMethod == METHOD_USB)
sprintf (cheatFile, "%s/snes9x/cheats/%s.cht", ROOTUSBDIR, Memory.ROMFilename);
// load cheat file if present
if(strlen(cheatFile) > 0)
{
if(S9xLoadCheatFile (cheatFile))
{
// disable all cheats loaded from the file
for (uint16 i = 0; i < Cheat.num_cheats; i++)
S9xDisableCheat(i);
}
}
}

12
source/ngc/cheatmgr.h Normal file
View File

@ -0,0 +1,12 @@
/****************************************************************************
* Snes9x 1.51
*
* Nintendo Wii/Gamecube Port
* Tantric August 2008
*
* cheatmgr.h
*
* Cheat handling
****************************************************************************/
void SetupCheats();

View File

@ -15,7 +15,6 @@
#include <fat.h>
#include <sys/dir.h>
#include "snes9x.h"
#include "memmap.h"
#include "debug.h"
@ -44,95 +43,84 @@
int maxfiles;
int havedir = 0;
int hasloaded = 0;
int loadtype = 0;
int LoadDVDFile (unsigned char *buffer);
bool haveSDdir = 0;
bool haveUSBdir = 0;
int haveFATdir = 0;
extern unsigned long ARAM_ROMSIZE;
extern int screenheight;
extern FILEENTRIES filelist[MAXFILES];
/**
* Showfile screen
/****************************************************************************
* Auto-determines the load method
* THIS CODE STILL NEEDS WORK
****************************************************************************/
int autoLoadMethod()
{
return METHOD_SD;
}
/****************************************************************************
* Auto-determines the save method
* THIS CODE STILL NEEDS WORK
****************************************************************************/
int autoSaveMethod()
{
return METHOD_SD;
int method = -1;
while(method < 0)
{
WaitPrompt((char*) "Checking SD");
if(diropen(ROOTSDDIR))
{
WaitPrompt((char*) "Found SD!");
method = METHOD_SD;
break;
}
WaitPrompt((char*) "Checking USB");
if(diropen(ROOTUSBDIR))
{
WaitPrompt((char*) "Found USB!");
method = METHOD_USB;
break;
}
WaitPrompt((char*) "Checking Slot A");
// check Memory Card Slot A
if(MountCard(CARD_SLOTA, SILENT) == 0)
{
WaitPrompt((char*) "Found Memory Card A!");
method = METHOD_MC_SLOTA;
break;
}
WaitPrompt((char*) "Checking Slot B");
// check Memory Card Slot B
if(MountCard(CARD_SLOTB, SILENT) == 0)
{
WaitPrompt((char*) "Found Memory Card B!");
method = METHOD_MC_SLOTB;
break;
}
// no method found
WaitPrompt((char*) "Error: Could not determine save method.");
method = 0;
}
return method;
}
/****************************************************************************
* StripExt
*
* Display the file selection to the user
*/
static void
ShowFiles (int offset, int selection)
{
int i, j;
char text[MAXPATHLEN];
int ypos;
int w;
* Strips an extension from a filename
****************************************************************************/
setfontsize(18);
clearscreen ();
ypos = (screenheight - ((PAGESIZE - 1) * 20)) >> 1;
if (screenheight == 480)
ypos += 24;
else
ypos += 10;
j = 0;
for (i = offset; i < (offset + PAGESIZE) && (i < maxfiles); i++)
{
if (filelist[i].flags) // if a dir
{
strcpy (text, "[");
strcat (text, filelist[i].displayname);
strcat (text, "]");
}
else
strcpy (text, filelist[i].displayname);
if (j == (selection - offset))
{
/*** Highlighted text entry ***/
for ( w = 0; w < 20; w++ )
DrawLineFast( 30, 610, ( j * 20 ) + (ypos-16) + w, 0x80, 0x80, 0x80 );
setfontcolour (0x00, 0x00, 0xe0);
DrawText (-1, (j * 20) + ypos, text);
setfontcolour (0x00, 0x00, 0x00);
}
else
{
/*** Normal entry ***/
DrawText (-1, (j * 20) + ypos, text);
}
j++;
}
showscreen ();
}
/**
* SNESROMSOffset
*
* Function to check for and return offset to a directory called SNESROMS, if
* any
*/
int SNESROMSOffset()
{
int i;
for ( i = 0; i < maxfiles; i++ )
if (strcmp(filelist[i].filename, "SNESROMS") == 0)
return i;
return 0;
}
void strip_ext(char* inputstring, char* returnstring)
void StripExt(char* returnstring, char * inputstring)
{
char* loc_dot;
@ -144,31 +132,108 @@ void strip_ext(char* inputstring, char* returnstring)
return;
}
/**
/****************************************************************************
* Showfile screen
*
* Display the file selection to the user
****************************************************************************/
static void
ShowFiles (int offset, int selection)
{
int i, j;
char text[MAXPATHLEN];
int ypos;
int w;
clearscreen ();
setfontsize (28);
DrawText (-1, 60, (char*)"Choose Game");
setfontsize(18);
ypos = (screenheight - ((PAGESIZE - 1) * 20)) >> 1;
if (screenheight == 480)
ypos += 24;
else
ypos += 10;
j = 0;
for (i = offset; i < (offset + PAGESIZE) && (i < maxfiles); i++)
{
if (filelist[i].flags) // if a dir
{
strcpy (text, "[");
strcat (text, filelist[i].displayname);
strcat (text, "]");
}
else
{
// hide file extension on listing (.7z, .fig, .smc)
StripExt(text, filelist[i].displayname);
}
if (j == (selection - offset))
{
/*** Highlighted text entry ***/
for ( w = 0; w < 20; w++ )
DrawLineFast( 30, 610, ( j * 20 ) + (ypos-16) + w, 0x80, 0x80, 0x80 );
setfontcolour (0x00, 0x00, 0xe0);
DrawText (50, (j * 20) + ypos, text);
setfontcolour (0x00, 0x00, 0x00);
}
else
{
/*** Normal entry ***/
DrawText (50, (j * 20) + ypos, text);
}
j++;
}
showscreen ();
}
/****************************************************************************
* SNESROMSOffset
*
* Function to check for and return offset to a directory called SNESROMS, if
* any
****************************************************************************/
int SNESROMSOffset()
{
int i;
for ( i = 0; i < maxfiles; i++ )
if (strcmp(filelist[i].filename, "SNESROMS") == 0)
return i;
return 0;
}
/****************************************************************************
* FileSelector
*
* Let user select a file from the DVD listing
*/
* Let user select a file from the listing
****************************************************************************/
int offset = 0;
int selection = 0;
#define PADCAL 40
int
FileSelector ()
FileSelector (int method)
{
u32 p, wp, ph, wh;
signed char a, c;
int haverom = 0;
int redraw = 1;
int selectit = 0;
float mag = 0;
float mag2 = 0;
u16 ang = 0;
u16 ang2 = 0;
float mag, mag2 = 0;
u16 ang, ang2 = 0;
int scroll_delay = 0;
bool move_selection = 0;
#define SCROLL_INITIAL_DELAY 15
#define SCROLL_LOOP_DELAY 4
#define SCROLL_LOOP_DELAY 2
while (haverom == 0)
{
@ -201,36 +266,27 @@ FileSelector ()
selectit = 0;
if (filelist[selection].flags) /*** This is directory ***/
{
if (loadtype == LOAD_SDC || loadtype == LOAD_USB)
if (method == METHOD_SD || method == METHOD_USB)
{
/* memorize last entries list, actual root directory and selection for next access */
if (loadtype == LOAD_SDC)
haveSDdir = 1;
else
haveUSBdir = 1;
/* memorize last entries list, actual root directory and selection for next access */
haveFATdir = 1;
/* update current directory and set new entry list if directory has changed */
int status = updateFATdirname();
int status = updateFATdirname(method);
if (status == 1) // ok, open directory
{
maxfiles = parseFATdirectory();
maxfiles = parseFATdirectory(method);
if (!maxfiles)
{
WaitPrompt ((char*) "Error reading directory !");
haverom = 1; // quit SD menu
if (loadtype == LOAD_SDC) // reset everything at next access
haveSDdir = 0;
else
haveUSBdir = 0;
haverom = 1; // quit FAT menu
haveFATdir = 0; // reset everything at next access
}
}
else if (status == -1) // directory name too long
{
haverom = 1; // quit SD menu
if (loadtype == LOAD_SDC) // reset everything at next access
haveSDdir = 0;
else
haveUSBdir = 0;
haverom = 1; // quit FAT menu
haveFATdir = 0; // reset everything at next access
}
}
else
@ -249,32 +305,33 @@ FileSelector ()
}
else // this is a file
{
rootdir = filelist[selection].offset;
rootdir = filelist[selection].offset;
rootdirlength = filelist[selection].length;
/*** store the filename (used for sram/freeze naming) ***/
strip_ext(filelist[selection].filename, Memory.ROMFilename); // store stripped filename in Memory.ROMFilename
// store the filename (used for sram/freeze naming)
StripExt(Memory.ROMFilename, filelist[selection].filename); // store stripped filename in Memory.ROMFilename
switch (loadtype)
switch (method)
{
case LOAD_DVD:
case METHOD_SD:
case METHOD_USB:
/*** Load from FAT ***/
/* memorize last entries list, actual root directory and selection for next access */
haveFATdir = 1;
ARAM_ROMSIZE = LoadFATFile (filelist[selection].filename,
filelist[selection].length);
break;
case METHOD_DVD:
/*** Now load the DVD file to it's offset ***/
ARAM_ROMSIZE = LoadDVDFile (Memory.ROM);
break;
case LOAD_SMB:
case METHOD_SMB:
/*** Load from SMB ***/
ARAM_ROMSIZE = LoadSMBFile (filelist[selection].filename,
ARAM_ROMSIZE =
LoadSMBFile (filelist[selection].filename,
filelist[selection].length);
break;
case LOAD_USB:
case LOAD_SDC:
/*** Load from SD Card ***/
/* memorize last entries list, actual root directory and selection for next access */
haveSDdir = 1;
ARAM_ROMSIZE = LoadSDFile (filelist[selection].filename,
filelist[selection].length);
break;
}
@ -397,18 +454,16 @@ FileSelector ()
return 0;
}
/**
/****************************************************************************
* OpenDVD
*
* Function to load a DVD directory and display to user.
*/
****************************************************************************/
int
OpenDVD ()
OpenDVD (int method)
{
int romsdiroffset = 0;
loadtype = LOAD_DVD;
if (!getpvd())
{
ShowAction((char*) "Mounting DVD ... Wait");
@ -421,8 +476,7 @@ OpenDVD ()
if (havedir == 0)
{
offset = selection = 0; /* reset file selector */
haveSDdir = 0; /* prevent conflicts with SDCARD, USB file selector */
haveUSBdir = 0;
haveFATdir = 0; /* prevent conflicts with FAT file selector */
if ((maxfiles = parsedirectory ()))
{
@ -434,209 +488,119 @@ OpenDVD ()
maxfiles = parsedirectory ();
}
int ret = FileSelector ();
int ret = FileSelector (method);
havedir = 1;
return ret;
}
}
else
return FileSelector ();
return FileSelector (method);
return 0;
}
/**
/****************************************************************************
* OpenSMB
*
* Function to load from an SMB share
*/
****************************************************************************/
int
OpenSMB ()
OpenSMB (int method)
{
loadtype = LOAD_SMB;
if ((maxfiles = parseSMBDirectory ()))
if ((maxfiles = parseSMBDirectory ()))
{
char txt[80];
sprintf(txt,"maxfiles = %d", maxfiles);
return FileSelector ();
return FileSelector (method);
}
return 0;
}
/****************************************************************************
* OpenFAT
*
* Function to load from FAT
****************************************************************************/
int
OpenFAT (int method)
{
char msg[80];
// is_mounted
//
// to check whether FAT media are detected.
bool fat_is_mounted(PARTITION_INTERFACE partition) {
char prefix[] = "fatX:/";
prefix[3] = partition + '0';
DIR_ITER *dir = diropen(prefix);
if (dir) {
dirclose(dir);
return true;
}
return false;
}
//if (haveFATdir == 0)
//{
/* don't mess with DVD entries */
havedir = 0; // gamecube only
void fat_enable_readahead_all() {
int i;
for (i=1; i <= 4; ++i) {
if (fat_is_mounted((PARTITION_INTERFACE)i)) fatEnableReadAhead((PARTITION_INTERFACE)i, 64, 128);
}
}
/* change current dir to snes roms directory */
if(method == METHOD_SD)
sprintf ( currFATdir, "%s/%s", ROOTSDDIR, GCSettings.LoadFolder );
else
sprintf ( currFATdir, "%s/%s", ROOTUSBDIR, GCSettings.LoadFolder );
bool fat_remount(PARTITION_INTERFACE partition) {
//ShowAction("remounting...");
/* // removed to make usb work...
if (fat_is_mounted(partition))
/* Parse initial root directory and get entries list */
if ((maxfiles = parseFATdirectory (method)))
{
fatUnmount(partition);
/* Select an entry */
return FileSelector (method);
}
*/
fatMountNormalInterface(partition, 8);
fatSetDefaultInterface(partition);
//fatEnableReadAhead(partition, 64, 128);
if (fat_is_mounted(partition))
else
{
//ShowAction("remount successful.");
sleep(1);
return 1;
} else {
ShowAction("FAT mount failed.");
sleep(1);
/* no entries found */
sprintf (msg, "No Files Found!");
WaitPrompt (msg);
return 0;
}
//}
/* Retrieve previous entries list and made a new selection */
//else
// return FileSelector (method);
return 0;
}
/**
* OpenSD
*
* Function to load from an SD Card
*/
/****************************************************************************
* OpenROM
* Opens device specified by method, displays a list of ROMS
****************************************************************************/
int
OpenSD ()
OpenROM (int method)
{
char msg[80];
char buf[50] = "";
int loadROM = 0;
loadtype = LOAD_SDC;
if(method == METHOD_AUTO)
method = autoLoadMethod();
/*
fatUnmount(PI_INTERNAL_SD);
fatMountNormalInterface(PI_INTERNAL_SD,8);
//fatEnableReadAhead(PI_INTERNAL_SD, 64, 128);
fatSetDefaultInterface(PI_INTERNAL_SD);
//chdir("fat0:/");
*/
#ifdef HW_RVL
// only remount on wii
if (!fat_remount (PI_INTERNAL_SD))
return 0;
#endif
switch (method)
{
case METHOD_SD:
case METHOD_USB:
loadROM = OpenFAT (method);
break;
case METHOD_DVD:
// Load from DVD
loadROM = OpenDVD (method);
break;
case METHOD_SMB:
// Load from Network (SMB)
loadROM = OpenSMB (method);
break;
}
if (haveSDdir == 0)
{
/* don't mess with DVD entries */
havedir = 0;
haveUSBdir = 0;
/* change current dir to snes roms directory */
sprintf ( currSDdir, "%s/%s", ROOTSDDIR, SNESROMDIR );
/* Parse initial root directory and get entries list */
if ((maxfiles = parseFATdirectory ()))
{
/* Select an entry */
return FileSelector ();
}
else
{
/* no entries found */
sprintf (msg, "No Files Found!");
WaitPrompt (msg);
return 0;
}
}
/* Retrieve previous entries list and made a new selection */
else
return FileSelector ();
return 0;
return loadROM;
}
/**
* OpenUSB
*
* Function to load from a USB device (wii only)
*/
int
OpenUSB ()
{
char msg[80];
char buf[50] = "";
/*
//fatUnmount(PI_USBSTORAGE);
fatUnmount(PI_INTERNAL_SD);
//if(!fatMountNormalInterface(PI_USBSTORAGE,8))
// return 0;
//fatEnableReadAhead(PI_USBSTORAGE, 64, 128);
fatSetDefaultInterface(PI_USBSTORAGE);
*/
#ifdef HW_RVL
// make compiler happy
if (!fat_remount (PI_USBSTORAGE))
return 0;
#endif
loadtype = LOAD_USB;
if (haveUSBdir == 0)
{
/* don't mess with DVD, SDCARD entries */
havedir = 0;
haveSDdir = 0;
/* change current dir to snes roms directory */
sprintf ( currSDdir, "%s/%s", ROOTSDDIR, SNESROMDIR );
/* Parse initial root directory and get entries list */
if ((maxfiles = parseFATdirectory ()))
{
/* Select an entry */
return FileSelector ();
}
else
{
/* no entries found */
sprintf (msg, "No Files Found!");
WaitPrompt (msg);
return 0;
}
}
/* Retrieve previous entries list and made a new selection */
else
return FileSelector ();
return 0;
}
/**
/****************************************************************************
* LoadDVDFile
*
* This function will load a file from DVD, in BIN, SMD or ZIP format.
* The values for offset and length are inherited from rootdir and
* rootdirlength.
*
* The buffer parameter should re-use the initial ROM buffer.
*/
****************************************************************************/
int
LoadDVDFile (unsigned char *buffer)
{

View File

@ -10,17 +10,8 @@
#ifndef _NGCFILESEL_
#define _NGCFILESEL_
int OpenDVD ();
int OpenSMB ();
int OpenSD ();
int OpenUSB ();
#define LOAD_DVD 1
#define LOAD_SMB 2
#define LOAD_SDC 4
#define LOAD_USB 8
#define ROOTSDDIR "fat3:/"
#define SNESROMDIR "snes9x/roms"
#define SNESSAVEDIR "snes9x/saves"
int OpenROM (int method);
int autoLoadMethod();
int autoSaveMethod();
#endif

View File

@ -31,6 +31,7 @@
#include "dkpro.h"
#include "snes9xGX.h"
#include "memmap.h"
#include "aram.h"
#include <zlib.h>
@ -49,9 +50,9 @@ extern int screenheight;
extern unsigned int *xfb[2];
extern int whichfb;
/**
/****************************************************************************
* Unpack the devkit pro logo
*/
****************************************************************************/
static u32 *dkproraw;
/*** Permanent backdrop ***/
#ifdef HW_RVL
@ -59,14 +60,13 @@ u32 *backdrop;
#else
static u32 *backdrop;
#endif
static void unpackbackdrop ();
unsigned int getcolour (u8 r1, u8 g1, u8 b1);
void DrawLineFast( int startx, int endx, int y, u8 r, u8 g, u8 b );
u32 getrgb( u32 ycbr, u32 low );
/**
/****************************************************************************
* Initialisation of libfreetype
*/
****************************************************************************/
int
FT_Init ()
{
@ -91,11 +91,11 @@ FT_Init ()
}
/**
/****************************************************************************
* setfontsize
*
* Set the screen font size in pixels
*/
****************************************************************************/
void
setfontsize (int pixelsize)
{
@ -107,6 +107,10 @@ setfontsize (int pixelsize)
printf ("Error setting pixel sizes!");
}
/****************************************************************************
* DrawCharacter
* Draws a single character on the screen
****************************************************************************/
static void
DrawCharacter (FT_Bitmap * bmp, FT_Int x, FT_Int y)
{
@ -144,11 +148,11 @@ DrawCharacter (FT_Bitmap * bmp, FT_Int x, FT_Int y)
}
}
/**
/****************************************************************************
* DrawText
*
* Place the font bitmap on the screen
*/
****************************************************************************/
void
DrawText (int x, int y, char *text)
{
@ -161,6 +165,8 @@ DrawText (int x, int y, char *text)
if (n == 0)
return;
setfontcolour (0x00, 0x00, 0x00);
/*** x == -1, auto centre ***/
if (x == -1)
{
@ -198,11 +204,11 @@ DrawText (int x, int y, char *text)
}
}
/**
/****************************************************************************
* setfontcolour
*
* Uses RGB triple values.
*/
****************************************************************************/
void
setfontcolour (u8 r, u8 g, u8 b)
{
@ -213,47 +219,11 @@ setfontcolour (u8 r, u8 g, u8 b)
fontlo = fontcolour & 0xffff;
}
/**
* Licence Information
*
* THIS MUST NOT BE REMOVED IN ANY DERIVATIVE WORK.
*/
void
licence ()
{
int ypos = ((screenheight - (282 + dkpro_HEIGHT)) >> 1);
if (screenheight == 480)
ypos += 42;
else
ypos += 24;
setfontsize (16);
setfontcolour (0x00, 0x00, 0x00);
DrawText (-1, ypos += 40, (char*)"Snes9x - Copyright (c) Snes9x Team 1996 - 2006");
DrawText (-1, ypos += 40, (char*)"This is free software, and you are welcome to");
DrawText (-1, ypos += 20, (char*)"redistribute it under the conditions of the");
DrawText (-1, ypos += 20, (char*)"GNU GENERAL PUBLIC LICENSE Version 2");
DrawText (-1, ypos +=
20, (char*)"Additionally, the developers of this port disclaim");
DrawText (-1, ypos +=
20, (char*)"all copyright interests in the Nintendo GameCube");
DrawText (-1, ypos +=
20, (char*)"porting code. You are free to use it as you wish");
DrawText (-1, ypos += 40, (char*)"Developed with DevkitPPC and libOGC");
DrawText (-1, ypos += 20, (char*)"http://www.devkitpro.org");
}
/**
/****************************************************************************
* dkunpack
*
* Support function to expand the DevkitPro logo
*/
****************************************************************************/
int
dkunpack ()
{
@ -271,11 +241,11 @@ dkunpack ()
return 0;
}
/**
/****************************************************************************
* showdklogo
*
* Display the DevkitPro logo
*/
****************************************************************************/
void
showdklogo ()
{
@ -302,13 +272,69 @@ showdklogo ()
free (dkproraw);
}
/**
/****************************************************************************
* Display credits, legal copyright and licence
*
* THIS MUST NOT BE REMOVED IN ANY DERIVATIVE WORK.
****************************************************************************/
void
Credits ()
{
clearscreen ();
setfontcolour (0x00, 0x00, 0x00);
setfontsize (28);
DrawText (-1, 60, (char*)"Credits");
int ypos = 25;
if (screenheight == 480)
ypos += 52;
else
ypos += 32;
setfontsize (18);
DrawText (-1, ypos += 30, (char*)"Technical");
setfontsize (14);
DrawText (-1, ypos += 22, (char*)"Snes9x v1.5.1 - Snes9x Team");
DrawText (-1, ypos += 18, (char*)"GameCube Port 2.0 WIP6 and earlier - SoftDev");
DrawText (-1, ypos += 18, (char*)"Additional improvements to 2.0 WIP6 - eke-eke");
DrawText (-1, ypos += 18, (char*)"GameCube 2.0.1bx enhancements - crunchy2");
DrawText (-1, ypos += 18, (char*)"v00x updates - michniewski & Tantric");
DrawText (-1, ypos += 18, (char*)"GX - http://www.gc-linux.org");
DrawText (-1, ypos += 18, (char*)"libogc - Shagkur & wintermute");
setfontsize (18);
DrawText (-1, ypos += 30, (char*)"Testing");
setfontsize (14);
DrawText (-1, ypos += 22, (char*)"crunchy2 / tehskeen users / others");
setfontsize (18);
DrawText (-1, ypos += 30, (char*)"Documentation");
setfontsize (14);
DrawText (-1, ypos += 22, (char*)"brakken, crunchy2, michniewski");
setfontsize (12);
DrawText (-1, ypos += 50, (char*)"Snes9x - Copyright (c) Snes9x Team 1996 - 2006");
DrawText (-1, ypos += 15, (char*)"This software is open source and may be copied, distributed, or modified");
DrawText (-1, ypos += 15, (char*)"under the terms of the GNU General Public License (GPL) Version 2.");
showscreen ();
}
/****************************************************************************
* getcolour
*
* Simply converts RGB to Y1CbY2Cr format
*
* I got this from a pastebin, so thanks to whoever originally wrote it!
*/
****************************************************************************/
unsigned int
getcolour (u8 r1, u8 g1, u8 b1)
@ -334,9 +360,9 @@ getcolour (u8 r1, u8 g1, u8 b1)
return ((y1 << 24) | (cb << 16) | (y2 << 8) | cr);
}
/**
/****************************************************************************
* Unpackbackdrop
*/
****************************************************************************/
void
unpackbackdrop ()
{
@ -371,22 +397,9 @@ unpackbackdrop ()
}
/**
* Display legal copyright and licence
*/
void
legal ()
{
unpackbackdrop ();
clearscreen ();
licence ();
showdklogo ();
showscreen ();
}
/**
/****************************************************************************
* Wait for user to press A
*/
****************************************************************************/
void
WaitButtonA ()
{
@ -399,9 +412,9 @@ WaitButtonA ()
#endif
}
/**
/****************************************************************************
* Wait for user to press A or B. Returns 0 = B; 1 = A
*/
****************************************************************************/
int
WaitButtonAB ()
@ -438,9 +451,9 @@ WaitButtonAB ()
#endif
}
/**
/****************************************************************************
* Show a prompt
*/
****************************************************************************/
void
WaitPrompt (char *msg)
{
@ -459,10 +472,10 @@ WaitPrompt (char *msg)
WaitButtonA ();
}
/**
/****************************************************************************
* Show a prompt with choice of two options. Returns 1 if A button was pressed
and 0 if B button was pressed.
*/
****************************************************************************/
int
WaitPromptChoice (char *msg, char *bmsg, char *amsg)
{
@ -483,9 +496,9 @@ WaitPromptChoice (char *msg, char *bmsg, char *amsg)
return WaitButtonAB ();
}
/**
/****************************************************************************
* Show an action in progress
*/
****************************************************************************/
void
ShowAction (char *msg)
{
@ -505,62 +518,81 @@ ShowAction (char *msg)
* Generic Menu Routines
****************************************************************************/
void
DrawMenu (char items[][20], char *title, int maxitems, int selected, int fontsize)
DrawMenu (char items[][50], char *title, int maxitems, int selected, int fontsize, int x)
{
int i, w;
int ypos;
int i, w = 0;
int ypos = 0;
int n = 1;
#if 0
int bounding[] = { 80, 40, 600, 40, 560, 94, 40, 94 };
int base[] = { 80, screenheight - 90, 600, screenheight - 90,
560, screenheight - 40, 40, screenheight - 40
};
#endif
ypos = 65;
//ypos = (screenheight - (maxitems * 32)) >> 1; previous
ypos = (screenheight - (maxitems * (fontsize + 8))) >> 1;
if (screenheight == 480)
ypos += 52;
else
ypos += 32;
if (screenheight == 480)
ypos += 52;
else
ypos += 32;
clearscreen ();
clearscreen ();
setfontcolour (0, 0, 0);
//#if 0
// DrawPolygon (4, bounding, 0x00, 0x00, 0xc0);
// DrawPolygon (4, base, 0x00, 0x00, 0xc0);
setfontsize (30);
if (title != NULL)
DrawText (-1, 60, title);
setfontsize (12);
DrawText (510, screenheight - 20, "Snes9x GX 004");
//#endif
setfontsize (fontsize); // set font size
setfontcolour (0, 0, 0);
for (i = 0; i < maxitems; i++)
{
if (i == selected)
if (title != NULL)
{
//for( w = 0; w < 32; w++ )
for( w = 0; w < (fontsize + 8); w++ )
//DrawLineFast( 30, 610, (i << 5) + (ypos-26) + w, 0x80, 0x80, 0x80 ); previous
DrawLineFast( 30, 610, i * (fontsize + 8) + (ypos-(fontsize + 2)) + w, 0x80, 0x80, 0x80 );
setfontcolour (0xff, 0xff, 0xff);
//DrawText (-1, (i << 5) + ypos, items[i]); previous
DrawText (-1, i * (fontsize + 8) + ypos, items[i]);
setfontcolour (0x00, 0x00, 0x00);
setfontsize (28);
DrawText (-1, 60, title);
}
else
DrawText (-1, i * (fontsize + 8) + ypos, items[i]);
//DrawText (-1, i * 32 + ypos, items[i]); previous
}
showscreen ();
setfontsize (12);
DrawText (510, screenheight - 20, (char *)"Snes9x GX 005");
// Draw menu items
setfontsize (fontsize); // set font size
for (i = 0; i < maxitems; i++)
{
if(strlen(items[i]) > 0)
{
if (i == selected)
{
for( w = 0; w < (fontsize + 8); w++ )
DrawLineFast( 30, 610, n * (fontsize + 8) + (ypos-(fontsize + 2)) + w, 0x80, 0x80, 0x80 );
setfontcolour (0xff, 0xff, 0xff);
DrawText (x, n * (fontsize + 8) + ypos, items[i]);
setfontcolour (0x00, 0x00, 0x00);
}
else
{
DrawText (x, n * (fontsize + 8) + ypos, items[i]);
}
n++;
}
}
showscreen ();
}
/****************************************************************************
* FindMenuItem
*
* Help function to find the next visible menu item on the list
* Supports menu wrap-around
****************************************************************************/
int FindMenuItem(char items[][50], int maxitems, int currentItem, int direction)
{
int nextItem = currentItem + direction;
if(nextItem < 0)
nextItem = maxitems-1;
else if(nextItem >= maxitems)
nextItem = 0;
if(strlen(items[nextItem]) > 0)
return nextItem;
else
return FindMenuItem(&items[0], maxitems, nextItem, direction);
}
/****************************************************************************
@ -570,8 +602,9 @@ DrawMenu (char items[][20], char *title, int maxitems, int selected, int fontsiz
* It's here to keep all the font / interface stuff together.
****************************************************************************/
int menu = 0;
int
RunMenu (char items[][20], int maxitems, char *title, int fontsize)
RunMenu (char items[][50], int maxitems, char *title, int fontsize, int x)
{
int redraw = 1;
int quit = 0;
@ -583,7 +616,6 @@ RunMenu (char items[][20], int maxitems, char *title, int fontsize)
u16 ang = 0;
u16 ang2 = 0;
//while (!(PAD_ButtonsDown (0) & PAD_BUTTON_B) && (quit == 0))
while (quit == 0)
{
if (redraw)
@ -607,14 +639,14 @@ RunMenu (char items[][20], int maxitems, char *title, int fontsize)
if ( (p & PAD_BUTTON_UP) || (wp & (WPAD_BUTTON_UP | WPAD_CLASSIC_BUTTON_UP)) || (a > 70) || (mag>JOY_THRESHOLD && (ang>300 || ang<50)) )
{
redraw = 1;
menu--;
menu = FindMenuItem(&items[0], maxitems, menu, -1);
}
/*** Look for down ***/
if ( (p & PAD_BUTTON_DOWN) || (wp & (WPAD_BUTTON_DOWN | WPAD_CLASSIC_BUTTON_DOWN)) || (a < -70) || (mag>JOY_THRESHOLD && (ang>130 && ang<230)) )
{
redraw = 1;
menu++;
menu = FindMenuItem(&items[0], maxitems, menu, +1);
}
if ((p & PAD_BUTTON_A) || (wp & (WPAD_BUTTON_A | WPAD_CLASSIC_BUTTON_A)))
@ -628,12 +660,6 @@ RunMenu (char items[][20], int maxitems, char *title, int fontsize)
quit = -1;
ret = -1;
}
if (menu == maxitems)
menu = 0;
if (menu < 0)
menu = maxitems - 1;
}
/*** Wait for B button to be released before proceeding ***/
@ -651,6 +677,92 @@ RunMenu (char items[][20], int maxitems, char *title, int fontsize)
}
/****************************************************************************
* ROM Information Screen
****************************************************************************/
void RomInfo()
{
clearscreen ();
int ypos = 65;
if (screenheight == 480)
ypos += 52;
else
ypos += 32;
setfontsize (28);
DrawText (-1, 60, (char*)"Rom Information");
setfontsize (16);
setfontcolour (0x00, 0x00, 0x00);
#define MENU_INFO_ROM "ROM"
#define MENU_INFO_ROMID "ROMID"
#define MENU_INFO_COMPANY "Company"
#define MENU_INFO_SIZE "Size"
#define MENU_INFO_SRAM "SRAM"
#define MENU_INFO_TYPE "Type"
#define MENU_INFO_CHECKSUM "Checksum"
#define MENU_INFO_TVTYPE "TV Type"
#define MENU_INFO_FRAMES "Frames"
#define MENU_INFO_CRC32 "CRC32"
char fmtString[1024];
ypos += 20;
DrawText (150, ypos, (char *)MENU_INFO_ROM);
DrawText (300, ypos, Memory.ROMName);
ypos += 20;
DrawText (150, ypos, (char *)MENU_INFO_ROMID);
DrawText (300, ypos, Memory.ROMId);
ypos += 20;
DrawText (150, ypos, (char *)MENU_INFO_COMPANY);
DrawText (300, ypos, Memory.CompanyId);
ypos += 20;
DrawText (150, ypos, (char *)MENU_INFO_SIZE);
sprintf(fmtString, "%d", Memory.ROMSize);
DrawText (300, ypos, fmtString);
ypos += 20;
DrawText (150, ypos, (char *)MENU_INFO_SRAM);
sprintf(fmtString, "%d", Memory.SRAMSize);
DrawText (300, ypos, fmtString);
ypos += 20;
DrawText (150, ypos, (char *)MENU_INFO_TYPE);
sprintf(fmtString, "%d", Memory.ROMType);
DrawText (300, ypos, fmtString);
ypos += 20;
DrawText (150, ypos, (char *)MENU_INFO_CHECKSUM);
sprintf(fmtString, "%04x / %04x", Memory.ROMChecksum, Memory.ROMComplementChecksum);
DrawText (300, ypos, fmtString);
ypos += 20;
DrawText (150, ypos, (char *)MENU_INFO_TVTYPE);
sprintf(fmtString, "%s", Settings.PAL ? "PAL" : "NTSC");
DrawText (300, ypos, fmtString);
ypos += 20;
DrawText (150, ypos, (char *)MENU_INFO_FRAMES);
sprintf(fmtString, "%d", Memory.ROMFramesPerSecond);
DrawText (300, ypos, fmtString);
ypos += 20;
DrawText (150, ypos, (char *)MENU_INFO_CRC32);
sprintf(fmtString, "%08X", Memory.ROMCRC32);
DrawText (300, ypos, fmtString);
showscreen ();
}
/****************************************************************************
* DrawLine
*
@ -845,10 +957,10 @@ void DrawLineFast( int startx, int endx, int y, u8 r, u8 g, u8 b )
}
}
/**
/*****************************************************************************
* Ok, I'm useless with Y1CBY2CR colour.
* So convert back to RGB so I can work with it -;)
*/
****************************************************************************/
u32 getrgb( u32 ycbr, u32 low )
{
u8 r,g,b;
@ -873,5 +985,3 @@ u32 getrgb( u32 ycbr, u32 low )
return (u32)( r << 16 | g << 8 | b );
}

View File

@ -22,13 +22,14 @@
int FT_Init ();
void setfontsize (int pixelsize);
void DrawText (int x, int y, char *text);
void legal ();
void highlight (int on);
void WaitButtonA ();
void setfontcolour (u8 r, u8 g, u8 b);
int RunMenu (char items[][20], int maxitems, char *title, int fontsize = 24);
void DrawMenu (char items[][20], char *title, int maxitems, int selected, int fontsize = 24);
void DrawText (int x, int y, char *text);
void unpackbackdrop ();
void Credits ();
void RomInfo ();
void WaitButtonA ();
int RunMenu (char items[][50], int maxitems, char *title, int fontsize = 20, int x = -1);
void DrawMenu (char items[][50], char *title, int maxitems, int selected, int fontsize = 20, int x = -1);
void WaitPrompt (char *msg);
int WaitPromptChoice (char *msg, char* bmsg, char* amsg);
void ShowAction (char *msg);

View File

@ -46,8 +46,6 @@ card_dir CardDir;
card_file CardFile;
card_stat CardStatus;
extern void uselessinquiry();
/****************************************************************************
* Clear the savebuffer
@ -89,15 +87,14 @@ CardFileExists (char *filename, int slot)
* workarounds implemented for when the mount fails.
* Returns the result of the last attempted CARD_Mount command.
****************************************************************************/
int MountCard(int cslot)
int MountCard(int cslot, bool8 silent)
{
int ret;
int tries;
EXI_ProbeReset();
//Mount the card
// Mount the card
ret = CARD_Mount (cslot, SysArea, NULL);
tries = 0;
@ -118,7 +115,9 @@ int MountCard(int cslot)
while ( tries < 5 && ret == CARD_ERROR_NOCARD )
{
EXI_ProbeReset ();
ShowAction ((char*) "Mounting card...");
if(!silent)
ShowAction ((char*) "Mounting card...");
CARD_Unmount (cslot);
usleep(500000); // wait half second
ShowAction ((char*) "");
@ -131,9 +130,12 @@ int MountCard(int cslot)
while ( tries < 5 && ret == CARD_ERROR_UNLOCKED )
{
EXI_ProbeReset ();
ShowAction ((char*) "Waiting for unlock...");
if(!silent)
ShowAction ((char*) "Waiting for unlock...");
usleep(500000); // wait half second
ShowAction ((char*) "");
if(!silent)
ShowAction ((char*) "");
usleep(500000); // wait half second
ret = CARD_Probe(cslot);
tries++;
@ -161,7 +163,7 @@ VerifyMCFile (unsigned char *buf, int slot, char *filename, int datasize)
CARD_Init ("SNES", "00");
/*** Try to mount the card ***/
CardError = MountCard(slot);
CardError = MountCard(slot, NOTSILENT);
if (CardError == 0)
{
@ -242,7 +244,7 @@ LoadBufferFromMC (unsigned char *buf, int slot, char *filename, bool8 silent)
CARD_Init ("SNES", "00");
/*** Try to mount the card ***/
CardError = MountCard(slot);
CardError = MountCard(slot, NOTSILENT);
if (CardError == 0)
{
@ -251,8 +253,7 @@ LoadBufferFromMC (unsigned char *buf, int slot, char *filename, bool8 silent)
if (!CardFileExists (filename, slot))
{
if ( !silent )
WaitPrompt((char*) "Unable to open file");
WaitPrompt((char*) "Unable to open file");
return 0;
}
@ -277,8 +278,11 @@ LoadBufferFromMC (unsigned char *buf, int slot, char *filename, bool8 silent)
bytesleft -= SectorSize;
bytesread += SectorSize;
sprintf (msg, "Read %d of %d bytes", bytesread, blocks);
ShowProgress (msg, bytesread, blocks);
if ( !silent )
{
sprintf (msg, "Read %d of %d bytes", bytesread, blocks);
ShowProgress (msg, bytesread, blocks);
}
}
CARD_Close (&CardFile);
CARD_Unmount (slot);
@ -309,7 +313,7 @@ SaveBufferToMC (unsigned char *buf, int slot, char *filename, int datasize, bool
CARD_Init ("SNES", "00");
/*** Try to mount the card ***/
CardError = MountCard(slot);
CardError = MountCard(slot, NOTSILENT);
if (CardError == 0)
{
@ -409,7 +413,7 @@ SaveBufferToMC (unsigned char *buf, int slot, char *filename, int datasize, bool
if (CardError)
{
CARD_Unmount (slot);
if ( CardError = CARD_ERROR_INSSPACE )
if ( CardError == CARD_ERROR_INSSPACE )
WaitPrompt((char*) "Not enough space to create file!");
else
WaitPrompt((char*) "Unable to create card file!");
@ -468,124 +472,4 @@ SaveBufferToMC (unsigned char *buf, int slot, char *filename, int datasize, bool
}
/****************************************************************************
* Memory Card SRAM Load
****************************************************************************/
void
LoadSRAMFromMC (int slot, int silent)
{
char filename[MAXPATHLEN];
int offset = 0;
ShowAction ((char*) "Loading SRAM from MC...");
// check for 'old' version of sram
sprintf (filename, "%s.srm", Memory.ROMName); // Build old SRAM filename
offset = LoadBufferFromMC (savebuffer, slot, filename, silent); // load file
if (offset > 0) // old sram found
{
if (WaitPromptChoice ((char*)"Old SRAM found. Convert and delete?", (char*)"Cancel", (char*)"Do it"))
{
decodesavedata (offset);
CARD_Delete (slot, filename); // delete old sram
SaveSRAMToMC (slot, silent);
}
}
//
/*** Build SRAM filename ***/
sprintf (filename, "%s.srm", Memory.ROMFilename);
offset = LoadBufferFromMC (savebuffer, slot, filename, silent);
if ( offset > 0 )
{
decodesavedata (offset);
if ( !silent )
{
sprintf (filename, "Loaded %d bytes", offset);
WaitPrompt (filename);
}
S9xSoftReset();
}
}
/****************************************************************************
* Memory Card SRAM Save
****************************************************************************/
void
SaveSRAMToMC (int slot, int silent)
{
char filename[128];
int datasize;
int offset;
if (!silent)
ShowAction ((char*) "Saving SRAM to MC...");
/*** Build SRAM filename ***/
sprintf (filename, "%s.srm", Memory.ROMFilename);
datasize = prepareMCsavedata ();
offset = SaveBufferToMC (savebuffer, slot, filename, datasize, silent);
if ( (offset > 0) && (!silent))
{
sprintf (filename, "Wrote %d bytes", offset);
WaitPrompt (filename);
}
}
/****************************************************************************
* Memory Card Preferences Load
****************************************************************************/
void
LoadPrefsFromMC (int slot, int silent)
{
int offset;
char msg[80];
ShowAction ((char*) "Loading Prefs from MC...");
offset = LoadBufferFromMC (savebuffer, slot, PREFS_FILE_NAME, silent);
if ( offset > 0 )
{
decodePrefsData ();
if ( !silent )
{
sprintf (msg, "Loaded %d bytes", offset);
WaitPrompt (msg);
}
}
}
/****************************************************************************
* Memory Card Preferences Save
****************************************************************************/
void
SavePrefsToMC (int slot, int silent)
{
int datasize;
int offset;
char msg[80];
if (!silent)
ShowAction ((char*) "Saving Prefs to MC...");
datasize = preparePrefsData ();
offset = SaveBufferToMC (savebuffer, slot, PREFS_FILE_NAME, datasize, silent);
if ( offset > 0 && !silent)
{
sprintf (msg, "Wrote %d bytes", offset);
WaitPrompt (msg);
}
}

View File

@ -21,11 +21,6 @@ int VerifyMCFile (unsigned char *buf, int slot, char *filename, int datasize);
int LoadBufferFromMC (unsigned char *buf, int slot, char *filename, bool8 silent);
int SaveBufferToMC (unsigned char *buf, int slot, char *filename, int datasize, bool8 silent);
void LoadSRAMFromMC (int slot, int silent);
void SaveSRAMToMC (int slot, int silent);
void LoadPrefsFromMC (int slot, int silent);
void SavePrefsToMC (int slot, int silent);
int MountCard(int cslot, bool8 silent);
#endif

View File

@ -30,6 +30,7 @@
#include "filesel.h"
#include "ftfont.h"
#include "smbload.h"
#include "sdload.h"
#include "mcsave.h"
extern "C"
@ -131,162 +132,167 @@ NGCFreezeMemBuffer ()
* Do freeze game for Nintendo Gamecube
*/
int
NGCFreezeGame (int where, bool8 silent)
NGCFreezeGame (int method, bool8 silent)
{
char filename[1024];
SMBFILE smbfile;
FILE *handle;
int len = 0;
int wrote = 0;
int offset = 0;
char msg[100];
if(method == METHOD_AUTO)
method = autoSaveMethod();
if (where == 4)
{
/*** Freeze to SMB ***/
sprintf (filename, "/%s/%s.frz", SNESSAVEDIR, Memory.ROMFilename);
}
else if (where == 2 || where == 3)
{
/*** Freeze to SDCard in slot A or slot B ***/
char filename[1024];
SMBFILE smbfile;
FILE *handle;
int len = 0;
int wrote = 0;
int offset = 0;
char msg[100];
#ifdef SDUSE_LFN
sprintf (filename, "%s/%s/%s.frz", ROOTSDDIR, SNESSAVEDIR, Memory.ROMFilename);
#else
/*** Until we have LFN on SD ... ***/
sprintf (filename, "%s/%s/%08x.frz", ROOTSDDIR, SNESSAVEDIR, Memory.ROMCRC32);
#endif
}
else
{
/*** Freeze to MC in slot A or slot B ***/
sprintf (filename, "%s.snz", Memory.ROMFilename);
}
if (method == METHOD_SD) // SD
{
sprintf (filename, "%s/%s/%s.frz", ROOTSDDIR, GCSettings.SaveFolder, Memory.ROMFilename);
}
if (method == METHOD_USB) // USB
{
sprintf (filename, "%s/%s/%s.frz", ROOTUSBDIR, GCSettings.SaveFolder, Memory.ROMFilename);
}
else if(method == METHOD_MC_SLOTA || method == METHOD_MC_SLOTB) // MC Slot A or B
{
sprintf (filename, "%s.snz", Memory.ROMFilename);
}
else if (method == METHOD_SMB) // SMB
{
sprintf (filename, "/%s/%s.frz", GCSettings.SaveFolder, Memory.ROMFilename);
}
S9xSetSoundMute (TRUE);
S9xPrepareSoundForSnapshotSave (FALSE);
S9xSetSoundMute (TRUE);
S9xPrepareSoundForSnapshotSave (FALSE);
NGCFreezeMemBuffer ();
NGCFreezeMemBuffer ();
S9xPrepareSoundForSnapshotSave (TRUE);
S9xSetSoundMute (FALSE);
S9xPrepareSoundForSnapshotSave (TRUE);
S9xSetSoundMute (FALSE);
if (where == 4) /*** SMB ***/
{
ConnectSMB ();
if (method == METHOD_SD || method == METHOD_USB) // FAT devices
{
handle = fopen (filename, "wb");
smbfile = SMB_Open (filename, SMB_OPEN_WRITING | SMB_DENY_NONE,
SMB_OF_CREATE | SMB_OF_TRUNCATE);
if (smbfile)
{
if (handle > 0)
{
if (!silent)
ShowAction ((char*) "Saving freeze game...");
len = bufoffset;
offset = 0;
while (len > 0)
{
if (len > 1024)
wrote =
SMB_Write ((char *) membuffer + offset, 1024, offset,
smbfile);
else
wrote =
SMB_Write ((char *) membuffer + offset, len, offset,
smbfile);
len = fwrite (membuffer, 1, bufoffset, handle);
fclose (handle);
offset += wrote;
len -= wrote;
}
SMB_Close (smbfile);
if ( !silent )
{
sprintf (filename, "Written %d bytes", bufoffset);
WaitPrompt (filename);
}
}
else
{
char msg[100];
sprintf(msg, "Couldn't save to SMB:\\%s\\", SNESSAVEDIR);
WaitPrompt (msg);
}
}
else if (where == 2 || where == 3) /*** SDCard slot A or slot B ***/
{
handle = fopen (filename, "wb");
if (handle > 0)
{
if (!silent)
ShowAction ((char*) "Saving freeze game...");
len = fwrite (membuffer, 1, bufoffset, handle);
fclose (handle);
if (len != bufoffset)
WaitPrompt((char*) "Error writing freeze file");
else if ( !silent )
{
sprintf (filename, "Written %d bytes", bufoffset);
WaitPrompt (filename);
}
}
else
{
sprintf(msg, "Couldn't save to %s/%s/", ROOTSDDIR, SNESSAVEDIR);
WaitPrompt (msg);
}
}
else /*** MC in slot A or slot B ***/
{
if (len != bufoffset)
WaitPrompt((char*) "Error writing freeze file");
else if ( !silent )
{
sprintf (filename, "Written %d bytes", bufoffset);
WaitPrompt (filename);
}
}
else
{
if(method == METHOD_SD)
sprintf(msg, "Couldn't save to %s/%s/", ROOTSDDIR, GCSettings.SaveFolder);
else
sprintf(msg, "Couldn't save to %s/%s/", ROOTUSBDIR, GCSettings.SaveFolder);
WaitPrompt (msg);
}
}
else if(method == METHOD_MC_SLOTA || method == METHOD_MC_SLOTA) // MC Slot A or B
{
if (!silent)
ShowAction ((char*) "Saving freeze game...");
ClearSaveBuffer ();
ClearSaveBuffer ();
/*** Copy in save icon ***/
int offset = sizeof (saveicon);
memcpy (savebuffer, saveicon, offset);
/*** Copy in save icon ***/
int offset = sizeof (saveicon);
memcpy (savebuffer, saveicon, offset);
/*** And the freezecomment ***/
sprintf (freezecomment[1], "%s", Memory.ROMName);
memcpy (savebuffer + offset, freezecomment, 64);
offset += 64;
/*** And the freezecomment ***/
sprintf (freezecomment[1], "%s", Memory.ROMFilename);
memcpy (savebuffer + offset, freezecomment, 64);
offset += 64;
/*** Zip and copy in the freeze ***/
uLongf DestBuffSize = (uLongf) SAVEBUFFERSIZE;
int err= compress2((Bytef*)(savebuffer+offset+8), (uLongf*)&DestBuffSize, (const Bytef*)membuffer, (uLongf)bufoffset, Z_BEST_COMPRESSION);
/*** Zip and copy in the freeze ***/
uLongf DestBuffSize = (uLongf) SAVEBUFFERSIZE;
int err= compress2((Bytef*)(savebuffer+offset+8), (uLongf*)&DestBuffSize, (const Bytef*)membuffer, (uLongf)bufoffset, Z_BEST_COMPRESSION);
if(err!=Z_OK)
{
sprintf (msg, "zip error %s ",zError(err));
WaitPrompt (msg);
return 0;
}
if(err!=Z_OK)
{
sprintf (msg, "zip error %s ",zError(err));
WaitPrompt (msg);
return 0;
}
int zippedsize = (int)DestBuffSize;
memcpy (savebuffer + offset, &zippedsize, 4);
offset += 4;
offset += 4;
int decompressedsize = (int)bufoffset;
memcpy (savebuffer + offset, &decompressedsize, 4);
offset += 4;
offset += 4;
offset += zippedsize;
offset += zippedsize;
int ret = SaveBufferToMC ( savebuffer, where, filename, offset, SILENT );
if ( ret && !silent )
{
sprintf (filename, "Written %d bytes", ret);
WaitPrompt (filename);
}
}
int ret;
if(method == METHOD_MC_SLOTA)
ret = SaveBufferToMC ( savebuffer, CARD_SLOTA, filename, offset, SILENT );
else
ret = SaveBufferToMC ( savebuffer, CARD_SLOTB, filename, offset, SILENT );
if ( ret && !silent )
{
sprintf (filename, "Written %d bytes", ret);
WaitPrompt (filename);
}
}
else if (method == METHOD_SMB) // SMB
{
ConnectSMB ();
smbfile = SMB_Open (filename, SMB_OPEN_WRITING | SMB_DENY_NONE,
SMB_OF_CREATE | SMB_OF_TRUNCATE);
if (smbfile)
{
if (!silent)
ShowAction ((char*) "Saving freeze game...");
len = bufoffset;
offset = 0;
while (len > 0)
{
if (len > 1024)
wrote =
SMB_Write ((char *) membuffer + offset, 1024, offset,
smbfile);
else
wrote =
SMB_Write ((char *) membuffer + offset, len, offset,
smbfile);
offset += wrote;
len -= wrote;
}
SMB_Close (smbfile);
if ( !silent )
{
sprintf (filename, "Written %d bytes", bufoffset);
WaitPrompt (filename);
}
}
else
{
char msg[100];
sprintf(msg, "Couldn't save to SMB:\\%s\\", GCSettings.SaveFolder);
WaitPrompt (msg);
}
}
return 0;
}
@ -331,7 +337,7 @@ NGCUnFreezeBlock (char *name, uint8 * block, int size)
* NGCUnfreezeGame
*/
int
NGCUnfreezeGame (int from, bool8 silent)
NGCUnfreezeGame (int method, bool8 silent)
{
char filename[1024];
SMBFILE smbfile;
@ -342,148 +348,153 @@ NGCUnfreezeGame (int from, bool8 silent)
bufoffset = 0;
if (from == 4)
{
/*** From SMB ***/
sprintf (filename, "\\%s\\%s.frz", SNESSAVEDIR, Memory.ROMFilename);
ConnectSMB ();
if(method == METHOD_AUTO)
method = autoLoadMethod();
/*** Read the file into memory ***/
smbfile =
SMB_Open (filename, SMB_OPEN_READING | SMB_DENY_NONE, SMB_OF_OPEN);
if (method == METHOD_SD || method == METHOD_USB) // SD & USB
{
if(method == METHOD_SD)
sprintf (filename, "%s/%s/%s.frz", ROOTSDDIR, GCSettings.SaveFolder, Memory.ROMFilename);
else
sprintf (filename, "%s/%s/%s.frz", ROOTUSBDIR, GCSettings.SaveFolder, Memory.ROMFilename);
if (smbfile)
{
ShowAction ((char*) "Loading freeze file...");
while ((read =
SMB_Read ((char *) membuffer + offset, 1024, offset,
smbfile)) > 0)
offset += read;
handle = fopen (filename, "rb");
SMB_Close (smbfile);
if (handle > 0)
{
if ( !silent )
ShowAction ((char*) "Loading freeze file...");
ShowAction ((char*) "Unpacking freeze file");
if (S9xUnfreezeGame ("AGAME") != SUCCESS)
{
WaitPrompt((char*) "Error thawing");
return 0;
}
}
else if ( !silent )
{
WaitPrompt((char*) "No freeze file found");
return 0;
}
}
else if (from == 2 || from == 3) /*** From SD slot A or slot B ***/
{
offset = 0;
/*** Usual chunks into memory ***/
while ((read = fread (membuffer + offset, 1, 2048, handle)) > 0)
offset += read;
#ifdef SDUSE_LFN
sprintf (filename, "%s/%s/%s.frz", ROOTSDDIR, SNESSAVEDIR, Memory.ROMFilename);
#else
/*** From SDCard ***/
sprintf (filename, "%s/%s/%08x.frz", ROOTSDDIR, SNESSAVEDIR, Memory.ROMCRC32);
#endif
fclose (handle);
handle = fopen (filename, "rb");
if (handle > 0)
{
ShowAction ((char*) "Loading freeze file...");
offset = 0;
/*** Usual chunks into memory ***/
while ((read = fread (membuffer + offset, 1, 2048, handle)) >
0)
offset += read;
fclose (handle);
ShowAction ((char*) "Unpacking freeze file");
if (S9xUnfreezeGame ("AGAME") != SUCCESS)
{
WaitPrompt((char*) "Error thawing");
return 0;
}
}
else if ( !silent )
{
WaitPrompt((char*) "No freeze file found");
return 0;
}
}
else /*** From MC in slot A or slot B ***/
{
ShowAction ((char*) "Loading freeze file...");
sprintf (filename, "%s.snz", Memory.ROMFilename);
int ret = LoadBufferFromMC ( savebuffer, from, filename, silent );
if ( ret )
{
ShowAction ((char*) "Unpacking freeze file");
// skip the saveicon and comment
offset = (sizeof(saveicon) + 64);
uLongf zipsize = 0;
uLongf decompressedsize = 0;
memcpy (&zipsize, savebuffer+offset, 4);
offset += 4;
memcpy (&decompressedsize, savebuffer+offset, 4);
offset += 4;
memset(membuffer, 0, MEMBUFFER);
uLongf DestBuffSize = MEMBUFFER;
int err= uncompress((Bytef*)membuffer, (uLongf*)&DestBuffSize, (const Bytef*)(savebuffer + offset), zipsize);
if ( err!=Z_OK )
{
sprintf (msg, "unzip error %s ",zError(err));
WaitPrompt (msg);
return 0;
}
if ( DestBuffSize != decompressedsize )
{
WaitPrompt((char*) "Unzipped size doesn't match expected size!");
return 0;
}
if (S9xUnfreezeGame ("AGAME") != SUCCESS)
{
WaitPrompt((char*) "Error thawing");
return 0;
}
}
else if ( !silent )
{
sprintf(msg, "Couldn't load from MC slot %s", (from ? "B" : "A"));
WaitPrompt (msg);
return 0;
}
if ( !silent )
ShowAction ((char*) "Unpacking freeze file");
if (S9xUnfreezeGame ("AGAME") != SUCCESS)
{
WaitPrompt((char*) "Error thawing");
return 0;
}
}
else
{
WaitPrompt((char*) "No freeze file found");
return 0;
}
return 1;
}
return 1;
else if(method == METHOD_MC_SLOTA || method == METHOD_MC_SLOTB) // MC in slot A or slot B
{
if ( !silent )
ShowAction ((char*) "Loading freeze file...");
sprintf (filename, "%s.snz", Memory.ROMFilename);
int ret = 0;
if(method == METHOD_MC_SLOTA)
LoadBufferFromMC ( savebuffer, CARD_SLOTA, filename, silent );
else
LoadBufferFromMC ( savebuffer, CARD_SLOTB, filename, silent );
if ( ret )
{
if ( !silent )
ShowAction ((char*) "Unpacking freeze file");
// skip the saveicon and comment
offset = (sizeof(saveicon) + 64);
uLongf zipsize = 0;
uLongf decompressedsize = 0;
memcpy (&zipsize, savebuffer+offset, 4);
offset += 4;
memcpy (&decompressedsize, savebuffer+offset, 4);
offset += 4;
memset(membuffer, 0, MEMBUFFER);
uLongf DestBuffSize = MEMBUFFER;
int err= uncompress((Bytef*)membuffer, (uLongf*)&DestBuffSize, (const Bytef*)(savebuffer + offset), zipsize);
if ( err!=Z_OK )
{
sprintf (msg, "unzip error %s ",zError(err));
WaitPrompt (msg);
return 0;
}
if ( DestBuffSize != decompressedsize )
{
WaitPrompt((char*) "Unzipped size doesn't match expected size!");
return 0;
}
if (S9xUnfreezeGame ("AGAME") != SUCCESS)
{
WaitPrompt((char*) "Error thawing");
return 0;
}
}
else
{
return 0;
}
return 1;
}
else if (method == METHOD_SMB) // Network (SMB)
{
sprintf (filename, "\\%s\\%s.frz", GCSettings.SaveFolder, Memory.ROMFilename);
ConnectSMB ();
/*** Read the file into memory ***/
smbfile =
SMB_Open (filename, SMB_OPEN_READING | SMB_DENY_NONE, SMB_OF_OPEN);
if (smbfile)
{
if ( !silent )
ShowAction ((char*) "Loading freeze file...");
while ((read =
SMB_Read ((char *) membuffer + offset, 1024, offset,
smbfile)) > 0)
offset += read;
SMB_Close (smbfile);
if ( !silent )
ShowAction ((char*) "Unpacking freeze file");
if (S9xUnfreezeGame ("AGAME") != SUCCESS)
{
WaitPrompt((char*) "Error thawing");
return 0;
}
}
else if ( !silent )
{
WaitPrompt((char*) "No freeze file found");
return 0;
}
return 1;
}
return 0; // if we reached here, nothing was done!
}
void quickLoadFreeze (bool8 silent)
{
if ( QUICK_SAVE_SLOT >= 0 )
NGCUnfreezeGame ( QUICK_SAVE_SLOT, silent );
NGCUnfreezeGame ( GCSettings.SaveMethod, silent );
}
void quickSaveFreeze (bool8 silent)
{
if ( QUICK_SAVE_SLOT >= 0 )
NGCFreezeGame ( QUICK_SAVE_SLOT, silent );
NGCFreezeGame ( GCSettings.SaveMethod, silent );
}

View File

@ -25,8 +25,8 @@ typedef struct
}
MEMFILE;
int NGCFreezeGame (int where, bool8 silent);
int NGCUnfreezeGame (int from, bool8 silent);
int NGCFreezeGame (int method, bool8 silent);
int NGCUnfreezeGame (int method, bool8 silent);
void quickLoadFreeze (bool8 silent);
void quickSaveFreeze (bool8 silent);

File diff suppressed because it is too large Load Diff

View File

@ -10,6 +10,6 @@
#define _NGCMENU_
void mainmenu ();
void mainmenu (int selectedMenu);
#endif

View File

@ -21,6 +21,7 @@
#include "mcsave.h"
#include "sdload.h"
#include "smbload.h"
#include "filesel.h"
extern unsigned char savebuffer[];
extern int currconfig[4];
@ -31,14 +32,15 @@ extern unsigned int wmpadmap[];
extern unsigned int ccpadmap[];
extern unsigned int ncpadmap[];
#define PREFSVERSTRING "Snes9x GX 004a Prefs"
#define PREFS_FILE_NAME "snes9xGx.prf"
#define PREFSVERSTRING "Snes9x GX 005 Prefs"
char prefscomment[2][32] = { {PREFSVERSTRING}, {"Preferences"} };
/****************************************************************************
* Prepare Preferences Data
*
* This sets up the save buffer for saving to a memory card.
* This sets up the save buffer for saving.
****************************************************************************/
int
preparePrefsData ()
@ -83,71 +85,157 @@ preparePrefsData ()
/****************************************************************************
* Decode Preferences Data
****************************************************************************/
void
bool
decodePrefsData ()
{
int offset;
char prefscomment[32];
int size;
int offset;
char prefscomment[32];
int size;
offset = sizeof (saveicon);
memcpy (prefscomment, savebuffer + offset, 32);
offset = sizeof (saveicon);
memcpy (prefscomment, savebuffer + offset, 32);
if ( strcmp (prefscomment, PREFSVERSTRING) == 0 )
{
offset += 64;
memcpy (&Settings, savebuffer + offset, sizeof (Settings));
offset += sizeof (Settings);
memcpy (&GCSettings, savebuffer + offset, sizeof (GCSettings));
offset += sizeof (GCSettings);
// load padmaps (order important)
size = sizeof (unsigned int) *12;
memcpy (&gcpadmap, savebuffer + offset, size);
offset += size;
memcpy (&wmpadmap, savebuffer + offset, size);
offset += size;
memcpy (&ccpadmap, savebuffer + offset, size);
offset += size;
memcpy (&ncpadmap, savebuffer + offset, size);
offset += 64;
memcpy (&Settings, savebuffer + offset, sizeof (Settings));
offset += sizeof (Settings);
memcpy (&GCSettings, savebuffer + offset, sizeof (GCSettings));
offset += sizeof (GCSettings);
// load padmaps (order important)
size = sizeof (unsigned int) *12;
memcpy (&gcpadmap, savebuffer + offset, size);
offset += size;
memcpy (&wmpadmap, savebuffer + offset, size);
offset += size;
memcpy (&ccpadmap, savebuffer + offset, size);
offset += size;
memcpy (&ncpadmap, savebuffer + offset, size);
return true;
}
else
WaitPrompt((char*) "Preferences reset - check settings!");
else
return false;
}
void quickLoadPrefs (bool8 silent)
/****************************************************************************
* Save Preferences
****************************************************************************/
bool
SavePrefs (int method, bool silent)
{
switch ( QUICK_SAVE_SLOT )
if(method == METHOD_AUTO)
method = autoSaveMethod();
bool retval = false;
char filepath[1024];
int datasize;
int offset = 0;
datasize = preparePrefsData ();
if (!silent)
ShowAction ((char*) "Saving preferences...");
if(method == METHOD_SD || method == METHOD_USB)
{
case CARD_SLOTA:
case CARD_SLOTB:
LoadPrefsFromMC(QUICK_SAVE_SLOT, silent);
break;
case CARD_SLOTA+2:
case CARD_SLOTB+2:
LoadPrefsFromSD(silent);
break;
case CARD_SLOTA+4:
LoadPrefsFromSMB(silent);
break;
if(method == METHOD_SD)
sprintf (filepath, "%s/%s/%s", ROOTSDDIR, GCSettings.SaveFolder, PREFS_FILE_NAME);
else
sprintf (filepath, "%s/%s/%s", ROOTUSBDIR, GCSettings.SaveFolder, PREFS_FILE_NAME);
offset = SaveBufferToFAT (filepath, datasize, silent);
}
else if(method == METHOD_SMB)
{
sprintf (filepath, "%s\\%s", GCSettings.SaveFolder, PREFS_FILE_NAME);
offset = SaveBufferToSMB (filepath, datasize, silent);
}
else if(method == METHOD_MC_SLOTA)
{
offset = SaveBufferToMC (savebuffer, CARD_SLOTA, PREFS_FILE_NAME, datasize, silent);
}
else if(method == METHOD_MC_SLOTB)
{
offset = SaveBufferToMC (savebuffer, CARD_SLOTB, PREFS_FILE_NAME, datasize, silent);
}
if (offset > 0)
{
retval = decodePrefsData ();
if ( !silent )
{
sprintf (filepath, "Wrote %d bytes", offset);
WaitPrompt (filepath);
}
}
return retval;
}
void quickSavePrefs (bool8 silent)
/****************************************************************************
* Load Preferences
****************************************************************************/
bool
LoadPrefs (int method, bool silent)
{
switch ( QUICK_SAVE_SLOT )
if(method == METHOD_AUTO)
method = autoSaveMethod(); // we use 'Save' folder because preferences need R/W
bool retval = false;
char filepath[1024];
int offset = 0;
if ( !silent )
ShowAction ((char*) "Loading preferences...");
if(method == METHOD_SD || method == METHOD_USB)
{
case CARD_SLOTA:
case CARD_SLOTB:
SavePrefsToMC(QUICK_SAVE_SLOT, silent);
break;
case CARD_SLOTA+2:
case CARD_SLOTB+2:
SavePrefsToSD(silent);
break;
case CARD_SLOTA+4:
SavePrefsToSMB(silent);
break;
if(method == METHOD_SD)
sprintf (filepath, "%s/%s/%s", ROOTSDDIR, GCSettings.SaveFolder, PREFS_FILE_NAME);
else
sprintf (filepath, "%s/%s/%s", ROOTUSBDIR, GCSettings.SaveFolder, PREFS_FILE_NAME);
offset = LoadBufferFromFAT (filepath, silent);
}
else if(method == METHOD_SMB)
{
sprintf (filepath, "%s\\%s", GCSettings.SaveFolder, PREFS_FILE_NAME);
LoadBufferFromSMB (filepath, silent);
}
else if(method == METHOD_MC_SLOTA)
{
offset = LoadBufferFromMC (savebuffer, CARD_SLOTA, PREFS_FILE_NAME, silent);
}
else if(method == METHOD_MC_SLOTB)
{
offset = LoadBufferFromMC (savebuffer, CARD_SLOTB, PREFS_FILE_NAME, silent);
}
if (offset > 0)
{
retval = decodePrefsData ();
if ( !silent )
{
sprintf (filepath, "Loaded %d bytes", offset);
WaitPrompt(filepath);
}
}
return retval;
}
/****************************************************************************
* Quick Load Preferences
****************************************************************************/
bool quickLoadPrefs (bool8 silent)
{
return LoadPrefs(GCSettings.SaveMethod, silent);
}
/****************************************************************************
* Quick Save Preferences
****************************************************************************/
bool quickSavePrefs (bool8 silent)
{
return SavePrefs(GCSettings.SaveMethod, silent);
}

View File

@ -9,10 +9,9 @@
* Preferences save/load preferences utilities
****************************************************************************/
#define PREFS_FILE_NAME "snes9xGx.prf"
int preparePrefsData ();
void decodePrefsData ();
void quickLoadPrefs (bool8 silent);
void quickSavePrefs (bool8 silent);
bool decodePrefsData ();
bool SavePrefs (int method, bool silent);
bool LoadPrefs (int method, bool silent);
bool quickLoadPrefs (bool8 silent);
bool quickSavePrefs (bool8 silent);

View File

@ -162,81 +162,90 @@
void
DefaultSettings ()
{
/*** Default ALL to false ***/
memset (&Settings, 0, sizeof (Settings));
/************** GameCube/Wii Settings *********************/
GCSettings.LoadMethod = METHOD_AUTO; // Auto, SD, DVD, USB, Network (SMB)
sprintf (GCSettings.LoadFolder,"snes9x/roms"); // Path to game files
GCSettings.SaveMethod = METHOD_AUTO; // Auto, SD, Memory Card Slot A, Memory Card Slot B, USB, Network (SMB)
sprintf (GCSettings.SaveFolder,"snes9x/saves"); // Path to save files
GCSettings.AutoLoad = 1;
GCSettings.AutoSave = 1;
strncpy (GCSettings.gcip, GC_IP, 15);
strncpy (GCSettings.gwip, GW_IP, 15);
strncpy (GCSettings.mask, MASK, 15);
strncpy (GCSettings.smbip, SMB_IP, 15);
strncpy (GCSettings.smbuser, SMB_USER, 19);
strncpy (GCSettings.smbpwd, SMB_PWD, 19);
strncpy (GCSettings.smbgcid, SMB_GCID, 19);
strncpy (GCSettings.smbsvid, SMB_SVID, 19);
strncpy (GCSettings.smbshare, SMB_SHARE, 19);
GCSettings.NGCZoom = 0;
GCSettings.VerifySaves = 0;
GCSettings.render = 0;
GCSettings.Superscope = 0;
GCSettings.Mouse = 0;
/****************** SNES9x Settings ***********************/
/*** Default ALL to false ***/
memset (&Settings, 0, sizeof (Settings));
/*** General ***/
Settings.MouseMaster = false;
Settings.SuperScopeMaster = false;
Settings.MultiPlayer5Master = false;
Settings.JustifierMaster = true;
Settings.ShutdownMaster = false;
Settings.CyclesPercentage = 100; // snes9x 1.50 and earlier
/* Eke-Eke: specific to snes9x 1.51 */
// Settings.BlockInvalidVRAMAccess = true;
// Settings.HDMATimingHack = 100;
Settings.MouseMaster = false;
Settings.SuperScopeMaster = false;
Settings.MultiPlayer5Master = false;
Settings.JustifierMaster = true;
Settings.ShutdownMaster = false;
Settings.CyclesPercentage = 100; // snes9x 1.50 and earlier
Settings.ApplyCheats = true;
/* Eke-Eke: specific to snes9x 1.51 */
// Settings.BlockInvalidVRAMAccess = true;
// Settings.HDMATimingHack = 100;
/*** Sound defaults. On GC this is 32Khz/16bit/Stereo/InterpolatedSound ***/
Settings.APUEnabled = true;
Settings.NextAPUEnabled = true;
Settings.SoundPlaybackRate = 32000;
Settings.Stereo = true;
Settings.SixteenBitSound = true;
Settings.SoundEnvelopeHeightReading = true;
Settings.DisableSampleCaching = true;
Settings.InterpolatedSound = true;
Settings.ReverseStereo = false;
Settings.APUEnabled = true;
Settings.NextAPUEnabled = true;
Settings.SoundPlaybackRate = 32000;
Settings.Stereo = true;
Settings.SixteenBitSound = true;
Settings.SoundEnvelopeHeightReading = true;
Settings.DisableSampleCaching = true;
Settings.InterpolatedSound = true;
Settings.ReverseStereo = false;
/*** Graphics ***/
Settings.Transparency = true;
Settings.SupportHiRes = true;
Settings.SkipFrames = 10;
Settings.TurboSkipFrames = 19;
Settings.DisplayFrameRate = false;
// Settings.AutoDisplayMessages = 1; /*** eke-eke snes9x 1.51 ***/
Settings.Transparency = true;
Settings.SupportHiRes = true;
Settings.SkipFrames = 10;
Settings.TurboSkipFrames = 19;
Settings.DisplayFrameRate = false;
// Settings.AutoDisplayMessages = 1; /*** eke-eke snes9x 1.51 ***/
/* Eke-Eke: frame timings in 50hz and 60hz cpu mode */
Settings.FrameTimePAL = 20000;
Settings.FrameTimeNTSC = 16667;
/* Eke-Eke: frame timings in 50hz and 60hz cpu mode */
Settings.FrameTimePAL = 20000;
Settings.FrameTimeNTSC = 16667;
/*** SDD1 - Star Ocean Returns -;) ***/
Settings.SDD1Pack = true;
GCSettings.AutoLoad = 1;
GCSettings.AutoSave = 1;
strncpy (GCSettings.gcip, GC_IP, 15);
strncpy (GCSettings.gwip, GW_IP, 15);
strncpy (GCSettings.mask, MASK, 15);
strncpy (GCSettings.smbip, SMB_IP, 15);
strncpy (GCSettings.smbuser, SMB_USER, 19);
strncpy (GCSettings.smbpwd, SMB_PWD, 19);
strncpy (GCSettings.smbgcid, SMB_GCID, 19);
strncpy (GCSettings.smbsvid, SMB_SVID, 19);
strncpy (GCSettings.smbshare, SMB_SHARE, 19);
GCSettings.NGCZoom = 0;
GCSettings.VerifySaves = 0;
GCSettings.render = 0;
GCSettings.Superscope = 0;
GCSettings.Mouse = 0;
Settings.ForceNTSC = 0;
Settings.ForcePAL = 0;
Settings.ForceHiROM = 0;
Settings.ForceLoROM = 0;
Settings.ForceHeader = 0;
Settings.ForceNoHeader = 0;
Settings.ForceTransparency = 0;
Settings.ForceInterleaved = 0;
Settings.ForceInterleaved2 = 0;
Settings.ForceInterleaveGD24 = 0;
Settings.ForceNotInterleaved = 0;
Settings.ForceNoSuperFX = 0;
Settings.ForceSuperFX = 0;
Settings.ForceDSP1 = 0;
Settings.ForceNoDSP1 = 0;
Settings.SDD1Pack = true;
Settings.ForceNTSC = 0;
Settings.ForcePAL = 0;
Settings.ForceHiROM = 0;
Settings.ForceLoROM = 0;
Settings.ForceHeader = 0;
Settings.ForceNoHeader = 0;
Settings.ForceTransparency = 0;
Settings.ForceInterleaved = 0;
Settings.ForceInterleaved2 = 0;
Settings.ForceInterleaveGD24 = 0;
Settings.ForceNotInterleaved = 0;
Settings.ForceNoSuperFX = 0;
Settings.ForceSuperFX = 0;
Settings.ForceDSP1 = 0;
Settings.ForceNoDSP1 = 0;
}

View File

@ -7,7 +7,7 @@
*
* sdload.cpp
*
* Load ROMS from SD Card
* Load ROMS from FAT
****************************************************************************/
#include <gccore.h>
#include <stdio.h>
@ -22,20 +22,75 @@
#include "filesel.h"
#include "sram.h"
#include "preferences.h"
#include "snes9xGx.h"
#include <zlib.h>
extern unsigned char savebuffer[];
extern char output[16384];
FILE * filehandle;
char currSDdir[MAXPATHLEN];
char currFATdir[MAXPATHLEN];
extern int offset;
extern int selection;
extern int loadtype;
extern FILEENTRIES filelist[MAXFILES];
/****************************************************************************
* fat_is_mounted
* to check whether FAT media are detected.
****************************************************************************/
bool fat_is_mounted(PARTITION_INTERFACE partition) {
char prefix[] = "fatX:/";
prefix[3] = partition + '0';
DIR_ITER *dir = diropen(prefix);
if (dir) {
dirclose(dir);
return true;
}
return false;
}
/****************************************************************************
* fat_enable_readahead_all
****************************************************************************/
void fat_enable_readahead_all() {
int i;
for (i=1; i <= 4; ++i) {
if (fat_is_mounted((PARTITION_INTERFACE)i)) fatEnableReadAhead((PARTITION_INTERFACE)i, 64, 128);
}
}
/****************************************************************************
* fat_remount
****************************************************************************/
bool fat_remount(PARTITION_INTERFACE partition) {
//ShowAction("remounting...");
/* // removed to make usb work...
if (fat_is_mounted(partition))
{
fatUnmount(partition);
}
*/
fatMountNormalInterface(partition, 8);
fatSetDefaultInterface(partition);
//fatEnableReadAhead(partition, 64, 128);
if (fat_is_mounted(partition))
{
//ShowAction("remount successful.");
sleep(1);
return 1;
} else {
ShowAction("FAT mount failed.");
sleep(1);
return 0;
}
}
/***************************************************************************
* FileSortCallback
*
@ -64,64 +119,72 @@ static int FileSortCallback(const void *f1, const void *f2)
}
/***************************************************************************
* Update FAT (sdcard, usb) curent directory name
* Update FATCARD curent directory name
***************************************************************************/
int updateFATdirname()
int updateFATdirname(int method)
{
int size=0;
char *test;
char temp[1024];
int size=0;
char *test;
char temp[1024];
/* current directory doesn't change */
if (strcmp(filelist[selection].filename,".") == 0) return 0;
/* current directory doesn't change */
if (strcmp(filelist[selection].filename,".") == 0)
{
return 0;
}
/* go up to parent directory */
else if (strcmp(filelist[selection].filename,"..") == 0)
{
/* determine last subdirectory namelength */
sprintf(temp,"%s",currFATdir);
test = strtok(temp,"/");
while (test != NULL)
{
size = strlen(test);
test = strtok(NULL,"/");
}
/* go up to parent directory */
else if (strcmp(filelist[selection].filename,"..") == 0)
{
/* determine last subdirectory namelength */
sprintf(temp,"%s",currSDdir);
test = strtok(temp,"/");
while (test != NULL) {
size = strlen(test);
test = strtok(NULL,"/");
}
/* remove last subdirectory name */
size = strlen(currFATdir) - size - 1;
currFATdir[size] = 0;
/* remove last subdirectory name */
size = strlen(currSDdir) - size - 1;
currSDdir[size] = 0;
/* handles root name */
if (strcmp(currSDdir, "/") == 0)
return 1;
}
else /* Open a directory */
{
/* test new directory namelength */
if ((strlen(currSDdir)+1+strlen(filelist[selection].filename)) < MAXPATHLEN)
return 1;
}
/* Open a directory */
else
{
/* test new directory namelength */
if ((strlen(currFATdir)+1+strlen(filelist[selection].filename)) < MAXPATHLEN)
{
/* handles root name */
sprintf(temp, "/%s/..", SNESROMDIR);
if (strcmp(currSDdir, temp) == 0)
sprintf(currSDdir,"%s",ROOTSDDIR);
sprintf(temp, "/%s/..", GCSettings.LoadFolder);
if (strcmp(currFATdir, temp) == 0)
{
if(method == METHOD_SD)
sprintf(currFATdir,"%s",ROOTSDDIR);
else
sprintf(currFATdir,"%s",ROOTUSBDIR);
}
/* update current directory name */
sprintf(currSDdir, "%s/%s",currSDdir, filelist[selection].filename);
sprintf(currFATdir, "%s/%s",currFATdir, filelist[selection].filename);
return 1;
} else {
}
else
{
WaitPrompt((char*)"Dirname is too long !");
return -1;
}
}
}
}
/***************************************************************************
* Browse FAT (sdcard, usb) subdirectories
* Browse FAT subdirectories
***************************************************************************/
int parseFATdirectory() {
int parseFATdirectory(int method)
{
int nbfiles = 0;
DIR_ITER *sddir;
DIR_ITER *fatdir;
char filename[MAXPATHLEN];
struct stat filestat;
char msg[128];
@ -130,26 +193,30 @@ int parseFATdirectory() {
selection = offset = 0;
/* open the directory */
sddir = diropen(currSDdir);
if (sddir == NULL) {
/*** if we can't open the previous dir, open root dir ***/
if (loadtype == LOAD_USB)
sprintf(currSDdir,"fat4:/");
else // LOAD_SDC
//sprintf(currSDdir,"%s",ROOTSDDIR);
sprintf(currSDdir,"fat3:/");
sddir = diropen(currSDdir);
fatdir = diropen(currFATdir);
if (fatdir == NULL)
{
sprintf(msg, "Error opening %s", currFATdir);
WaitPrompt(msg);
if (sddir == NULL) {
sprintf(msg, "Error opening %s", currSDdir);
// if we can't open the previous dir, open root dir
if(method == METHOD_SD)
sprintf(currFATdir,"%s",ROOTSDDIR);
else
sprintf(currFATdir,"%s",ROOTUSBDIR);
fatdir = diropen(currFATdir);
if (fatdir == NULL)
{
sprintf(msg, "Error opening %s", currFATdir);
WaitPrompt(msg);
return 0;
}
}
/* Move to DVD structure - this is required for the file selector */
while(dirnext(sddir,filename,&filestat) == 0) {
while(dirnext(fatdir,filename,&filestat) == 0) {
if(strcmp(filename,".") != 0) {
memset(&filelist[nbfiles], 0, sizeof(FILEENTRIES));
strncpy(filelist[nbfiles].filename, filename, MAXPATHLEN);
@ -161,7 +228,7 @@ int parseFATdirectory() {
}
/*** close directory ***/
dirclose(sddir);
dirclose(fatdir);
/* Sort the file list */
qsort(filelist, nbfiles, sizeof(FILEENTRIES), FileSortCallback);
@ -170,12 +237,11 @@ int parseFATdirectory() {
}
/****************************************************************************
* LoadSDFile
* LoadFATFile
****************************************************************************/
extern bool haveSDdir;
extern bool haveUSBdir;
extern int haveFATdir;
int
LoadSDFile (char *filename, int length)
LoadFATFile (char *filename, int length)
{
char zipbuffer[2048];
char filepath[MAXPATHLEN];
@ -186,13 +252,12 @@ LoadSDFile (char *filename, int length)
rbuffer = (unsigned char *) Memory.ROM;
/* Check filename length */
if ((strlen(currSDdir)+1+strlen(filelist[selection].filename)) < MAXPATHLEN)
sprintf(filepath, "%s/%s",currSDdir,filelist[selection].filename);
if ((strlen(currFATdir)+1+strlen(filelist[selection].filename)) < MAXPATHLEN)
sprintf(filepath, "%s/%s",currFATdir,filelist[selection].filename);
else
{
WaitPrompt((char*) "Maximum Filename Length reached !");
haveSDdir = 0; // reset everything before next access
haveUSBdir = 0;
haveFATdir = 0; // reset everything before next access
return -1;
}
@ -204,7 +269,7 @@ LoadSDFile (char *filename, int length)
if (IsZipFile (zipbuffer))
{
/*** Unzip the ROM ***/
size = UnZipBuffer (rbuffer, 0, 0, handle); // unzip from SD
size = UnZipBuffer (rbuffer, 0, 0, handle); // unzip from FAT
fclose (handle);
return size;
@ -236,15 +301,13 @@ LoadSDFile (char *filename, int length)
return 0;
}
/****************************************************************************
* Load savebuffer from SD card file
* Load savebuffer from FAT file
****************************************************************************/
int
LoadBufferFromSD (char *filepath, bool silent)
LoadBufferFromFAT (char *filepath, bool silent)
{
FILE *handle;
FILE *handle;
int offset = 0;
int read = 0;
@ -274,14 +337,13 @@ LoadBufferFromSD (char *filepath, bool silent)
return offset;
}
/****************************************************************************
* Write savebuffer to SD card file
* Write savebuffer to FAT card file
****************************************************************************/
int
SaveBufferToSD (char *filepath, int datasize, bool silent)
SaveBufferToFAT (char *filepath, int datasize, bool silent)
{
FILE *handle;
FILE *handle;
if (datasize)
{
@ -301,145 +363,3 @@ SaveBufferToSD (char *filepath, int datasize, bool silent)
return datasize;
}
/****************************************************************************
* Save SRAM to SD Card
****************************************************************************/
void SaveSRAMToSD (bool silent)
{
char filepath[1024];
int datasize;
int offset;
if (!silent)
ShowAction ((char*) "Saving SRAM to SD...");
#ifdef SDUSE_LFN
sprintf (filepath, "%s/%s/%s.srm", ROOTSDDIR, SNESSAVEDIR, Memory.ROMFilename);
#else
sprintf (filepath, "%s/%s/%08x.srm", ROOTSDDIR, SNESSAVEDIR, Memory.ROMCRC32);
#endif
datasize = prepareEXPORTsavedata ();
if ( datasize )
{
offset = SaveBufferToSD (filepath, datasize, silent);
if ( (offset > 0) && (!silent) )
{
sprintf (filepath, "Wrote %d bytes", offset);
WaitPrompt (filepath);
}
}
}
/****************************************************************************
* Load SRAM From SD Card
****************************************************************************/
void
LoadSRAMFromSD (bool silent)
{
char filepath[MAXPATHLEN];
int offset = 0;
ShowAction ((char*) "Loading SRAM from SD...");
// check for 'old' version of sram
sprintf (filepath, "%s/%s/%s.srm", ROOTSDDIR, SNESSAVEDIR, Memory.ROMName); // Build old SRAM filename
offset = LoadBufferFromSD (filepath, silent); // load file
if (offset > 0) // old sram found
{
if (WaitPromptChoice ((char*)"Old SRAM found. Convert and delete?", (char*)"Cancel", (char*)"Do it"))
{
decodesavedata (offset);
remove (filepath); // delete old sram
SaveSRAMToSD (silent);
}
}
//
#ifdef SDUSE_LFN
sprintf (filepath, "%s/%s/%s.srm", ROOTSDDIR, SNESSAVEDIR, Memory.ROMFilename);
#else
sprintf (filepath, "%s/%s/%08x.srm", ROOTSDDIR, SNESSAVEDIR, Memory.ROMCRC32);
#endif
offset = LoadBufferFromSD (filepath, silent);
if (offset > 0)
{
decodesavedata (offset);
if ( !silent )
{
sprintf (filepath, "Loaded %d bytes", offset);
WaitPrompt(filepath);
}
S9xSoftReset();
}
}
/****************************************************************************
* Save Preferences to SD Card
****************************************************************************/
void
SavePrefsToSD (bool silent)
{
char filepath[1024];
int datasize;
int offset;
if (!silent)
ShowAction ((char*) "Saving prefs to SD...");
#ifdef SDUSE_LFN
sprintf (filepath, "%s/%s/%s", ROOTSDDIR, SNESSAVEDIR, PREFS_FILE_NAME);
#else
sprintf (filepath, "%s/%s/%s", ROOTSDDIR, SNESSAVEDIR, PREFS_FILE_NAME);
#endif
datasize = preparePrefsData ();
offset = SaveBufferToSD (filepath, datasize, silent);
if ( (offset > 0) && (!silent) )
{
sprintf (filepath, "Wrote %d bytes", offset);
WaitPrompt (filepath);
}
}
/****************************************************************************
* Load Preferences from SD Card
****************************************************************************/
void
LoadPrefsFromSD (bool silent)
{
char filepath[1024];
int offset = 0;
ShowAction ((char*) "Loading prefs from SD...");
#ifdef SDUSE_LFN
sprintf (filepath, "%s/%s/%s", ROOTSDDIR, SNESSAVEDIR, PREFS_FILE_NAME);
#else
sprintf (filepath, "%s/%s/%s", ROOTSDDIR, SNESSAVEDIR, PREFS_FILE_NAME);
#endif
offset = LoadBufferFromSD (filepath, silent);
if (offset > 0)
{
decodePrefsData ();
if ( !silent )
{
sprintf (filepath, "Loaded %d bytes", offset);
WaitPrompt(filepath);
}
}
}

View File

@ -21,15 +21,17 @@
#include <sys/stat.h>
#include <unistd.h>
static int FileSortCallback(const void *f1, const void *f2);
int updateFATdirname();
int parseFATdirectory();
int LoadSDFile (char *filename, int length);
void SaveSRAMToSD (bool silent);
void LoadSRAMFromSD (bool silent);
void SavePrefsToSD (bool silent);
void LoadPrefsFromSD (bool silent);
#define ROOTSDDIR "fat3:/"
#define ROOTUSBDIR "fat4:/"
extern char currSDdir[MAXPATHLEN];
bool fat_remount(PARTITION_INTERFACE partition);
static int FileSortCallback(const void *f1, const void *f2);
int updateFATdirname(int method);
int parseFATdirectory(int method);
int LoadFATFile (char *filename, int length);
int SaveBufferToFAT (char *filepath, int datasize, bool silent);
int LoadBufferFromFAT (char *filepath, bool silent);
extern char currFATdir[MAXPATHLEN];
#endif

View File

@ -101,7 +101,7 @@ parseSMBDirectory ()
ConnectSMB ();
strcpy (searchpath, SNESROMDIR);
strcpy (searchpath, GCSettings.LoadFolder);
strcat (searchpath, "\\*.*");
if (SMB_FindFirst
@ -152,7 +152,7 @@ LoadSMBFile (char *filename, int length)
z_stream zs;
int res, outbytes;
strcpy (filepath, SNESROMDIR);
strcpy (filepath, GCSettings.LoadFolder);
strcat (filepath, "\\");
strcat (filepath, filename);
rbuffer = (char *) Memory.ROM;
@ -332,6 +332,7 @@ SaveBufferToSMB (char *filepath, int datasize, bool8 silent)
****************************************************************************/
int
LoadBufferFromSMB (char *filepath, bool8 silent)
{
SMBFILE smbfile;
int ret;
@ -369,116 +370,3 @@ LoadBufferFromSMB (char *filepath, bool8 silent)
return 0;
}
/****************************************************************************
* Save SRAM to SMB
****************************************************************************/
void
SaveSRAMToSMB (bool8 silent)
{
char filepath[1024];
int datasize;
int offset;
sprintf (filepath, "%s\\%s.srm", SNESSAVEDIR, Memory.ROMFilename);
if (!silent)
ShowAction ((char*) "Saving SRAM to SMB...");
datasize = prepareEXPORTsavedata ();
if ( datasize )
{
offset = SaveBufferToSMB (filepath, datasize, silent);
if ( (offset > 0) && (!silent) )
{
sprintf (filepath, "Wrote %d bytes", offset);
WaitPrompt (filepath);
}
}
}
/****************************************************************************
* Load SRAM from SMB
****************************************************************************/
void
LoadSRAMFromSMB (bool8 silent)
{
char filepath[1024];
int offset;
sprintf (filepath, "%s\\%s.srm", SNESSAVEDIR, Memory.ROMFilename);
ShowAction ((char*) "Loading SRAM from SMB...");
offset = LoadBufferFromSMB (filepath, silent);
if (offset > 0)
{
decodesavedata (offset);
if ( !silent )
{
sprintf (filepath, "Loaded %d bytes", offset);
WaitPrompt(filepath);
}
S9xSoftReset();
}
}
/****************************************************************************
* Save Preferences to SMB
****************************************************************************/
void
SavePrefsToSMB (bool8 silent)
{
char filepath[1024];
int datasize;
int offset;
sprintf (filepath, "%s\\%s", SNESSAVEDIR, PREFS_FILE_NAME);
if (!silent)
ShowAction ((char*) "Saving preferences to SMB...");
datasize = preparePrefsData ();
if ( datasize )
{
offset = SaveBufferToSMB (filepath, datasize, silent);
if ( (offset > 0) && (!silent) )
{
sprintf (filepath, "Wrote %d bytes", offset);
WaitPrompt (filepath);
}
}
}
/****************************************************************************
* Load Preferences from SMB
****************************************************************************/
void
LoadPrefsFromSMB (bool8 silent)
{
char filepath[1024];
int offset;
ShowAction ((char*) "Loading preferences from SMB...");
sprintf (filepath, "%s\\%s", SNESSAVEDIR, PREFS_FILE_NAME);
offset = LoadBufferFromSMB (filepath, silent);
if (offset > 0)
{
decodePrefsData ();
if ( !silent )
{
sprintf (filepath, "Loaded %d bytes", offset);
WaitPrompt(filepath);
}
}
}

View File

@ -11,15 +11,14 @@
****************************************************************************/
#ifndef _NGCSMB_
#define _NGCSMB_
void ConnectSMB ();
int parseSMBDirectory ();
int LoadSMBFile (char *filename, int length);
void SaveSRAMToSMB (bool8 silent);
void LoadSRAMFromSMB (bool8 silent);
void SavePrefsToSMB (bool8 silent);
void LoadPrefsFromSMB (bool8 silent);
int LoadBufferFromSMB (char *filepath, bool8 silent);
int SaveBufferToSMB (char *filepath, int datasize, bool8 silent);
typedef struct
{
@ -35,4 +34,5 @@ typedef struct
}
SMBINFO;
#endif

View File

@ -159,11 +159,11 @@
#include <ogcsys.h>
#include <unistd.h>
#include <fat.h>
#include <wiiuse/wpad.h>
#include <sdcard/card_cmn.h>
#include <sdcard/wiisd_io.h>
#include <sdcard/card_io.h>
#include <fat.h>
#include "snes9x.h"
#include "memmap.h"
@ -190,6 +190,7 @@
#include "preferences.h"
#include "gctime.h"
#include "button_mapping.h"
#include "sdload.h"
unsigned long ARAM_ROMSIZE = 0;
int ConfigRequested = 0;
@ -523,8 +524,7 @@ NGCReportButtons ()
if ( GCSettings.AutoSave == 1 )
{
//if ( WaitPromptChoice ((char*)"Save SRAM?", (char*)"Don't Save", (char*)"Save") )
quickSaveSRAM ( SILENT );
quickSaveSRAM ( SILENT );
}
else if ( GCSettings.AutoSave == 2 )
{
@ -540,7 +540,7 @@ NGCReportButtons ()
}
}
mainmenu ();
mainmenu (3); // go to game menu
FrameTimer = 0;
ConfigRequested = 0;
@ -613,6 +613,7 @@ void SetControllers ()
}
}
/****************************************************************************
* Set the default mapping for NGC
****************************************************************************/
@ -747,16 +748,16 @@ int
main ()
{
unsigned int save_flags;
int selectedMenu = -1;
/*** Initialise GC ***/
InitGCVideo (); /*** Get the ball rolling ***/
/*** Initialize libFAT and SD cards ***/
/*** Initialize libFAT for SD and USB ***/
fatInitDefault();
//fatInit(8192, false);
//fat_enable_readahead_all();
/*** Initialize DVD subsystem ***/
DVD_Init ();
@ -784,7 +785,6 @@ main ()
printf ("Cannot initialise font subsystem!\n");
while (1);
}
setfontsize (16);/***sets the font size.***/
/*** Set defaults ***/
DefaultSettings ();
@ -814,11 +814,14 @@ main ()
if (!S9xGraphicsInit ())
while (1);
legal ();
WaitButtonA ();
unpackbackdrop ();
// Load preferences
quickLoadPrefs(SILENT);
if(!quickLoadPrefs(SILENT))
{
WaitPrompt((char*) "Preferences reset - check settings!");
selectedMenu = 2; // change to preferences menu
}
// Correct any relevant saved settings that are invalid
Settings.FrameTimeNTSC = 16667;
@ -831,7 +834,7 @@ main ()
{
while (ARAM_ROMSIZE == 0)
{
mainmenu ();
mainmenu (selectedMenu);
}
}
else

View File

@ -166,9 +166,23 @@
#define NOTSILENT 0
#define SILENT 1
enum {
METHOD_AUTO,
METHOD_SD,
METHOD_USB,
METHOD_DVD,
METHOD_SMB,
METHOD_MC_SLOTA,
METHOD_MC_SLOTB
};
struct SGCSettings{
uint8 AutoLoad;
uint8 AutoSave;
uint8 LoadMethod; // For ROMS: Auto, SD, DVD, USB, Network (SMB)
char LoadFolder[200]; // Path to game files
uint8 SaveMethod; // For SRAM, Freeze, Prefs: Auto, SD, Memory Card Slot A, Memory Card Slot B, USB, SMB
char SaveFolder[200]; // Path to save files
char gcip[16];
char gwip[16];
char mask[16];
@ -181,9 +195,8 @@ struct SGCSettings{
bool8 NGCZoom;
uint8 VerifySaves;
u16 render; // 0 - original, 1 - no AA
u32 QuickSaveSlot; // -1 Disabled - no prefs are loaded, 0 Memory card in slot A, 1 Memory card in slot B, 2 SD card in slot A, 3 SD card in slot B, 4 SMB share, 5 USB
u16 Superscope;
u16 Mouse;
u16 Superscope;
u16 Mouse;
};
START_EXTERN_C
@ -197,21 +210,6 @@ END_EXTERN_C
#define JOY_THRESHOLD 0.70 // for wii (expansion) analogues
#endif
/*** QUICK_SAVE_SLOT defines where preferences are loaded and saved, and also
where SRAM and Freezes are auto loaded or saved if enabled:
-1 Disabled - no prefs are loaded
0 Memory card in slot A
1 Memory card in slot B
2 SD card in slot A
3 SD card in slot B
4 SMB share ***/
#ifndef QUICK_SAVE_SLOT
#define QUICK_SAVE_SLOT 2 // save to SD
#endif
/*** default SMB settings ***/
#ifndef GC_IP
#define GC_IP "192.168.1.32" /*** IP to assign the GameCube ***/
@ -240,3 +238,5 @@ END_EXTERN_C
#ifndef SMB_IP
#define SMB_IP "192.168.1.100" /*** IP Address of share server ***/
#endif
#endif

View File

@ -21,14 +21,13 @@
#include "mcsave.h"
#include "sdload.h"
#include "smbload.h"
#include "filesel.h"
extern unsigned char savebuffer[];
//extern int currconfig[4];
extern int padcal;
extern unsigned short gcpadmap[];
//extern unsigned short padmap[4];
char sramcomment[2][32] = { {"Snes9x GX 004 SRAM"}, {"Savegame"} };
char sramcomment[2][32] = { {"Snes9x GX 005 SRAM"}, {"Savegame"} };
/****************************************************************************
* Prepare Memory Card SRAM Save Data
@ -47,7 +46,7 @@ prepareMCsavedata ()
memcpy (savebuffer, saveicon, offset);
/*** And the sramcomments ***/
sprintf (sramcomment[1], "%s", Memory.ROMName);
sprintf (sramcomment[1], "%s", Memory.ROMFilename);
memcpy (savebuffer + offset, sramcomment, 64);
offset += 64;
@ -91,7 +90,7 @@ prepareEXPORTsavedata ()
ClearSaveBuffer ();
/*** Copy in the sramcomments ***/
sprintf (sramcomment[1], "%s", Memory.ROMName);
sprintf (sramcomment[1], "%s", Memory.ROMFilename);
memcpy (savebuffer + offset, sramcomment, 64);
offset += 64;
@ -233,39 +232,136 @@ decodesavedata (int readsize)
}
}
void quickLoadSRAM (bool8 silent)
/****************************************************************************
* Load SRAM
****************************************************************************/
bool
LoadSRAM (int method, bool silent)
{
switch ( QUICK_SAVE_SLOT )
{
case CARD_SLOTA:
case CARD_SLOTB:
LoadSRAMFromMC(QUICK_SAVE_SLOT, silent);
break;
case CARD_SLOTA+2:
case CARD_SLOTB+2:
LoadSRAMFromSD(silent);
break;
case CARD_SLOTA+4:
LoadSRAMFromSMB(SILENT);
break;
}
if(method == METHOD_AUTO)
method = autoLoadMethod();
bool retval = false;
char filepath[1024];
int offset = 0;
if(!silent)
ShowAction ((char*) "Loading SRAM...");
if(method == METHOD_SD || method == METHOD_USB)
{
if(method == METHOD_SD)
sprintf (filepath, "%s/%s/%s.srm", ROOTSDDIR, GCSettings.SaveFolder, Memory.ROMFilename);
else
sprintf (filepath, "%s/%s/%s.srm", ROOTUSBDIR, GCSettings.SaveFolder, Memory.ROMFilename);
offset = LoadBufferFromFAT (filepath, silent);
}
else if(method == METHOD_SMB)
{
sprintf (filepath, "%s\\%s.srm", GCSettings.SaveFolder, Memory.ROMFilename);
offset = LoadBufferFromSMB (filepath, silent);
}
else if(method == METHOD_MC_SLOTA)
{
sprintf (filepath, "%s.srm", Memory.ROMFilename);
offset = LoadBufferFromMC (savebuffer, CARD_SLOTA, filepath, silent);
}
else if(method == METHOD_MC_SLOTB)
{
sprintf (filepath, "%s.srm", Memory.ROMFilename);
offset = LoadBufferFromMC (savebuffer, CARD_SLOTB, filepath, silent);
}
if (offset > 0)
{
decodesavedata (offset);
if ( !silent )
{
sprintf (filepath, "Loaded %d bytes", offset);
WaitPrompt(filepath);
}
S9xSoftReset();
retval = true;
}
return retval;
}
void quickSaveSRAM (bool8 silent)
/****************************************************************************
* Save SRAM
****************************************************************************/
bool
SaveSRAM (int method, bool silent)
{
switch ( QUICK_SAVE_SLOT )
{
case CARD_SLOTA:
case CARD_SLOTB:
SaveSRAMToMC(QUICK_SAVE_SLOT, silent);
break;
case CARD_SLOTA+2:
case CARD_SLOTB+2:
SaveSRAMToSD(silent);
break;
case CARD_SLOTA+4:
SaveSRAMToSMB(SILENT);
break;
}
if(method == METHOD_AUTO)
method = autoSaveMethod();
bool retval = false;
char filepath[1024];
int datasize;
int offset = 0;
if (!silent)
ShowAction ((char*) "Saving SRAM...");
if(method == METHOD_MC_SLOTA || method == METHOD_MC_SLOTB)
datasize = prepareMCsavedata ();
else
datasize = prepareEXPORTsavedata ();
if ( datasize )
{
if(method == METHOD_SD || method == METHOD_USB)
{
if(method == METHOD_SD)
sprintf (filepath, "%s/%s/%s.srm", ROOTSDDIR, GCSettings.SaveFolder, Memory.ROMFilename);
else
sprintf (filepath, "%s/%s/%s.srm", ROOTUSBDIR, GCSettings.SaveFolder, Memory.ROMFilename);
offset = SaveBufferToFAT (filepath, datasize, silent);
}
else if(method == METHOD_SMB)
{
sprintf (filepath, "%s\\%s.srm", GCSettings.SaveFolder, Memory.ROMFilename);
offset = SaveBufferToSMB (filepath, datasize, silent);
}
else if(method == METHOD_MC_SLOTA)
{
sprintf (filepath, "%s.srm", Memory.ROMFilename);
offset = SaveBufferToMC (savebuffer, CARD_SLOTA, filepath, datasize, silent);
}
else if(method == METHOD_MC_SLOTB)
{
sprintf (filepath, "%s.srm", Memory.ROMFilename);
offset = SaveBufferToMC (savebuffer, CARD_SLOTB, filepath, datasize, silent);
}
if (offset > 0)
{
if ( !silent )
{
sprintf (filepath, "Wrote %d bytes", offset);
WaitPrompt(filepath);
}
retval = true;
}
}
return retval;
}
/****************************************************************************
* Quick Load SRAM
****************************************************************************/
bool quickLoadSRAM (bool silent)
{
return LoadSRAM(GCSettings.SaveMethod, silent);
}
/****************************************************************************
* Quick Save SRAM
****************************************************************************/
bool quickSaveSRAM (bool silent)
{
return SaveSRAM(GCSettings.SaveMethod, silent);
}

View File

@ -13,5 +13,7 @@ int prepareMCsavedata ();
int prepareEXPORTsavedata ();
void decodesavedata (int readsize);
void quickLoadSRAM (bool8 silent);
void quickSaveSRAM (bool8 silent);
bool SaveSRAM (int method, bool silent);
bool LoadSRAM (int method, bool silent);
bool quickLoadSRAM (bool silent);
bool quickSaveSRAM (bool silent);