mirror of
https://github.com/coderkei/akmenu-next.git
synced 2025-06-18 08:55:46 -04:00
106 lines
2.7 KiB
C++
106 lines
2.7 KiB
C++
/*
|
|
save64m.cpp
|
|
Copyright (C) 2008 somebody
|
|
Copyright (C) 2009 yellow wood goblin
|
|
|
|
This program is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#if defined(_STORAGE_rpg) || defined(_STORAGE_r4)
|
|
|
|
#include "save64m.h"
|
|
#include <fcntl.h>
|
|
#include <unistd.h>
|
|
#include "dbgtool.h"
|
|
#include "../../share/memtool.h"
|
|
#if defined(_STORAGE_rpg)
|
|
#include "savemngr.h"
|
|
#include <iorpg.h>
|
|
#elif defined(_STORAGE_r4)
|
|
#include <ior4.h>
|
|
#endif
|
|
|
|
void cSave64m::IterateFileCluster(int aFileDes,u32* aFatMap)
|
|
{
|
|
u32 sectorsPerCluster;
|
|
u32 shift=isSDHC()?0:9;
|
|
if(ELM_SectorsPerClusterFromHandle(aFileDes,§orsPerCluster))
|
|
{
|
|
u32 cluster=1;
|
|
while(true)
|
|
{
|
|
u32 sector;
|
|
cluster=ELM_GetFAT(aFileDes,cluster,§or);
|
|
if(!cluster) break;
|
|
for(u32 ii=0;ii<sectorsPerCluster;ii++)
|
|
*aFatMap++=(sector+ii)<<shift;
|
|
}
|
|
}
|
|
}
|
|
|
|
bool cSave64m::GenerateSaveMapInternal(const char* aPath,u32* aFatMap)
|
|
{
|
|
int fd=open(aPath,O_RDONLY);
|
|
if(fd<0) return false;
|
|
IterateFileCluster(fd,aFatMap);
|
|
close(fd);
|
|
return true;
|
|
}
|
|
|
|
#if defined(_STORAGE_rpg)
|
|
bool cSave64m::GenerateSaveMap(const std::string& aRomFilename,u8 aSlot)
|
|
{
|
|
bool res=false;
|
|
u32* buffer=new u32[KMaxSave];
|
|
fillMemory(buffer,KMaxSave*sizeof(u32),0xffffffff);
|
|
std::string saveFilename=cSaveManager::generateSaveName(aRomFilename,aSlot);
|
|
if(GenerateSaveMapInternal(saveFilename.c_str(),buffer))
|
|
{
|
|
u32 saveMapAddress=SRAM_SAVEDATA_START;
|
|
for(u32 ii=0;ii<KMaxSave;++ii)
|
|
{
|
|
ioRpgWriteSram(saveMapAddress+ii*4,buffer+ii,sizeof(u32));
|
|
}
|
|
res=true;
|
|
}
|
|
delete[] buffer;
|
|
return res;
|
|
}
|
|
#elif defined(_STORAGE_r4)
|
|
bool cSave64m::GenerateSaveMap(std::string& aSaveName)
|
|
{
|
|
bool success=false;
|
|
std::string result=aSaveName;
|
|
u32* buffer=new u32[KMaxSave];
|
|
fillMemory(buffer,KMaxSave*sizeof(u32),0xffffffff);
|
|
if(GenerateSaveMapInternal(aSaveName.c_str(),buffer))
|
|
{
|
|
result+=".fix";
|
|
int f=open(result.c_str(),O_WRONLY|O_CREAT|O_TRUNC);
|
|
if(f>=0)
|
|
{
|
|
if(write(f,buffer,KMaxSave*sizeof(u32))==KMaxSave*sizeof(u32))
|
|
{
|
|
success=true;
|
|
aSaveName=result;
|
|
}
|
|
close(f);
|
|
}
|
|
}
|
|
return success;
|
|
}
|
|
#endif
|
|
|
|
#endif
|