public IEnumerable <GameRom> ImportGame(string gamelistpath, Emulator emulator)
{
var plateforme = dbService.GetSysteme(emulator.SystemeID);
string imgfolder = Path.Combine(FileJSONService.appSettings.AppSettingsFolder, "media", plateforme.Shortname);
var xmlgamelist = File.ReadAllText(gamelistpath);
var folderpath = Path.GetDirectoryName(gamelistpath);
XmlSerializer serializer = new XmlSerializer(typeof(GameList));
using (StringReader reader = new StringReader(xmlgamelist))
{
var gamelistfile = (GameList)serializer.Deserialize(reader);
var gamelist = gamelistfile.Game;
foreach (var gamedata in gamelist)
{
if (File.Exists(Path.Combine(folderpath, gamedata.Path.Substring(2))))
{
var newgame = new GameRom();
newgame.Name = Path.GetFileNameWithoutExtension(gamedata.Path);
newgame.Path = Path.Combine(folderpath, gamedata.Path.Substring(2));
newgame.EmulatorID = emulator.EmulatorID;
newgame.Boxart = Path.Combine(imgfolder, "box2dfront", $"{newgame.Name}.png");
newgame.Fanart = Path.Combine(imgfolder, "steamgrid", $"{newgame.Name}.jpg");
newgame.Screenshoot = Path.Combine(imgfolder, "fanart", $"{newgame.Name}.png");
newgame.Logo = Path.Combine(imgfolder, "wheel", $"{newgame.Name}.png");
newgame.TitleScreen = Path.Combine(imgfolder, "screentitle", $"{newgame.Name}.png");
newgame.RecalView = Path.Combine(imgfolder, "recalview", $"{newgame.Name}.png");
newgame.Video = Path.Combine(imgfolder, "videos", $"{newgame.Name}.mp4");
newgame = ScrapeGamefromGamelist(newgame, folderpath, gamedata);
newgame.IsDuplicate = false;
yield return(newgame);
}
}
}
}
public static void Main(string[] args)
{
if (args.Length < 1)
{
Console.Error.WriteLine("Missing level ID argument");
return;
}
if (!int.TryParse(args[0], out int levelId) || levelId < 0 || levelId > 12)
{
Console.Error.WriteLine("Invalid level ID given");
return;
}
Console.WriteLine("Parsing level data");
var rom = GameRom.FromFile("Micro Mages.nes");
var colorMapping = NesColorMapping.FromFile("ntscpalette.pal");
var level = new LevelDataParser().Run(rom, levelId);
Directory.CreateDirectory(OUTPUT_DIRECTORY);
Console.WriteLine("Saving level image data");
SaveLevel(OUTPUT_DIRECTORY + "level.bmp", level, colorMapping);
Console.WriteLine("Saving tile image data");
SaveAllTiles(level, colorMapping);
Console.WriteLine("Completed");
Console.ReadKey();
return;
}
public bool DetectIsRomInstalled(GameRom rom, string installDirectory)
{
if (string.IsNullOrEmpty(rom.Path))
{
return(false);
}
if (driveRegex.IsMatch(rom.Path))
{
return(File.Exists(rom.Path));
}
string romFullPath = rom.Path;
if (!string.IsNullOrEmpty(installDirectory))
{
if (installDirVarRegex.IsMatch(rom.Path))
{
romFullPath = rom.Path.Replace("{InstallDir}", installDirectory);
}
else
{
romFullPath = Path.Combine(installDirectory, rom.Path);
}
}
return(File.Exists(romFullPath));
}
public GameRom DuplicateGame(GameRom game)
{
GameRom duplicate = new GameRom();
duplicate.Path = game.Path;
duplicate.Name = game.Name;
duplicate.Boxart = game.Boxart;
duplicate.Fanart = game.Fanart;
duplicate.Screenshoot = game.Screenshoot;
duplicate.Logo = game.Logo;
duplicate.TitleScreen = game.TitleScreen;
duplicate.RecalView = game.RecalView;
duplicate.Video = game.Video;
duplicate.Desc = game.Desc;
duplicate.Dev = game.Dev;
duplicate.Editeur = game.Editeur;
duplicate.Year = game.Year;
duplicate.Genre = game.Genre;
duplicate.Name = game.Name;
duplicate.IsDuplicate = true;
duplicate.IsFavorite = game.IsFavorite;
duplicate.LastStart = game.LastStart;
duplicate.NbTimeStarted = game.NbTimeStarted;
duplicate.SGDBID = game.SGDBID;
duplicate.SteamID = game.SteamID;
duplicate.IGDBID = game.IGDBID;
duplicate.RAWGID = game.RAWGID;
return(duplicate);
}
public void LoadingProposal(GameRom game)
{
Search searchedGame = new Search();
if (CurrentScrapeSource == ScraperSource.IGDB)
{
if (game.IGDBID < 1)
{
searchedGame = dialogService.SearchSteamGridDBByName(game.Name, CurrentScrapeSource);
if (searchedGame != null)
{
game.IGDBID = searchedGame.id;
}
}
}
if (searchedGame != null)
{
ResultVideos = new ObservableCollection <KeyValuePair <String, String> >();
if (CurrentScrapeSource == ScraperSource.IGDB)
{
var detailvideo = iGDBService.GetVideosByGameId(game.IGDBID);
if (detailvideo != null)
{
foreach (var video in detailvideo)
{
ResultVideos.Add(new KeyValuePair <String, String>(video.name, string.Format("https://www.youtube.com/embed/{0}", video.video_id)));
}
}
}
NBVideo = ResultVideos.Count;
SelectedVideoIndex = 0;
}
}
public List <GameRom> GetSteamGame(Emulator emu)
{
string steamfolder;
var key64 = @"HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Valve\Steam";
var key32 = @"HKEY_LOCAL_MACHINE\SOFTWARE\Valve\Steam";
if (Environment.Is64BitOperatingSystem)
{
steamfolder = (string)Microsoft.Win32.Registry.GetValue(key64, "InstallPath", string.Empty);
}
else
{
steamfolder = (string)Microsoft.Win32.Registry.GetValue(key32, "InstallPath", string.Empty);
}
if (steamfolder != null)
{
List <string> foldersTosearch = new List <string>();
foldersTosearch.Add(Path.Combine(steamfolder, "steamapps"));
VProperty volvo = VdfConvert.Deserialize(File.ReadAllText(Path.Combine(steamfolder, "steamapps", "libraryfolders.vdf")));
var childs = volvo.Value.Children();
foreach (var child in childs)
{
var childKV = (VProperty)child;
var childValueKV = childKV.Value;
var pathchildKV = childValueKV.FirstOrDefault();
if (pathchildKV != null)
{
//if (Directory.Exists(((VProperty)child).Value.ToString()))
if (Directory.Exists(((VProperty)pathchildKV).Value.ToString()))
{
foldersTosearch.Add(Path.Combine(((VProperty)pathchildKV).Value.ToString(), "steamapps"));
}
}
}
List <GameRom> gamesfind = new List <GameRom>();
List <String> appmanifestfiles = new List <string>();
foreach (string foldertoSeek in foldersTosearch)
{
appmanifestfiles.AddRange(Directory.GetFiles(foldertoSeek, "appmanifest_*.acf").ToList());
}
foreach (var file in appmanifestfiles)
{
dynamic appfile = VdfConvert.Deserialize(File.ReadAllText(file));
GameRom game = new GameRom();
game.EmulatorID = emu.EmulatorID;
game.SteamID = int.Parse(appfile.Value.appid.Value);
game.Name = appfile.Value.name.Value;
gamesfind.Add(game);
}
return(gamesfind);
}
else
{
return(null);
}
}
public GameDetailViewModel(GameRom game)
{
_gameService = App.ServiceProvider.GetRequiredService <IGameService>();
dialogService = App.ServiceProvider.GetRequiredService <IDialogService>();
databaseService = App.ServiceProvider.GetRequiredService <IDatabaseService>();
_screenScraperService = App.ServiceProvider.GetRequiredService <IScreenScraperService>();
LoadingGame(game);
}
public string GetImgPathForGame(GameRom game, ScraperType sGDBType)
{
var emulator = dbService.GetEmulator(game.EmulatorID);
var plateforme = dbService.GetSysteme(emulator.SystemeID);
string imgfolder = Path.Combine(FileJSONService.appSettings.AppSettingsFolder, "media", plateforme.Shortname);
if (sGDBType == ScraperType.ArtWork)
{
//if(game.SteamID > 0)
// return Path.Combine(imgfolder, "fanart", $"{game.SteamID}");
//else
// return Path.Combine(imgfolder, "fanart", $"{game.Name}");
Directory.CreateDirectory(Path.Combine(imgfolder, "fanart"));
return(Path.Combine(imgfolder, "fanart", $"{Guid.NewGuid().ToString()}"));
}
else if (sGDBType == ScraperType.Boxart)
{
//if (game.SteamID > 0)
// return Path.Combine(imgfolder, "box2dfront", $"{game.SteamID}");
//else
// return Path.Combine(imgfolder, "box2dfront", $"{game.Name}");
Directory.CreateDirectory(Path.Combine(imgfolder, "box2dfront"));
return(Path.Combine(imgfolder, "box2dfront", $"{Guid.NewGuid().ToString()}"));
}
else if (sGDBType == ScraperType.Banner)
{
//if (game.SteamID > 0)
// return Path.Combine(imgfolder, "steamgrid", $"{game.SteamID}");
//else
// return Path.Combine(imgfolder, "steamgrid", $"{game.Name}");
Directory.CreateDirectory(Path.Combine(imgfolder, "steamgrid"));
return(Path.Combine(imgfolder, "steamgrid", $"{Guid.NewGuid().ToString()}"));
}
else if (sGDBType == ScraperType.Logo)
{
//if (game.SteamID > 0)
// return Path.Combine(imgfolder, "wheel", $"{game.SteamID}");
//else
// return Path.Combine(imgfolder, "wheel", $"{game.Name}");
Directory.CreateDirectory(Path.Combine(imgfolder, "wheel"));
return(Path.Combine(imgfolder, "wheel", $"{Guid.NewGuid().ToString()}"));
}
else if (sGDBType == ScraperType.Video)
{
//if (game.SteamID > 0)
// return Path.Combine(imgfolder, "wheel", $"{game.SteamID}");
//else
// return Path.Combine(imgfolder, "wheel", $"{game.Name}");
Directory.CreateDirectory(Path.Combine(imgfolder, "videos"));
return(Path.Combine(imgfolder, "videos", $"{Guid.NewGuid().ToString()}"));
}
else
{
return(string.Empty);
}
}
public ImgFinderSearchViewModel(GameRom game, ScraperSource currentScrapeSource, ScraperType currentScraperType)
{
steamGridDBService = App.ServiceProvider.GetRequiredService <ISteamGridDBService>();
iGDBService = App.ServiceProvider.GetRequiredService <IIGDBService>();
dialogService = App.ServiceProvider.GetRequiredService <IDialogService>();
Title = $"Recherche de {CurrentScraperType.ToString()} pour {game.Name}";
ResultImgs = new ObservableCollection <string>();
CurrentScrapeSource = currentScrapeSource;
CurrentScraperType = currentScraperType;
LoadingProposal(game);
}
public GameRom GetSteamInfos(GameRom game, Emulator emu)
{
var urlinfos = @"https://store.steampowered.com/api/appdetails?appids=" + game.SteamID + "&l=french";
var plateforme = dbService.GetSysteme(emu.SystemeID);
string imgfolder = Path.Combine(FileJSONService.appSettings.AppSettingsFolder, "media", plateforme.Shortname);
var newgame = game;
try
{
string jsoninfos;
using (WebClient wc = new WebClient())
{
jsoninfos = wc.DownloadString(urlinfos);
}
JObject json = JObject.Parse(jsoninfos);
var datajson = json[newgame.SteamID.ToString()]["data"];
if (datajson != null)
{
var data = JsonConvert.DeserializeObject <Data>(datajson.ToString());
newgame.Path = $"steam://rungameid/{newgame.SteamID.ToString()}";
newgame.Genre = string.Join(", ", data.genres.Select(x => x.description));
newgame.Editeur = string.Join(", ", data.publishers);
newgame.Dev = string.Join(", ", data.developers);
newgame.Desc = data.short_description;
newgame.Year = DateTime.Parse(data.release_date.date).Year.ToString();
Directory.CreateDirectory(Path.Combine(imgfolder, "box2dfront"));
Directory.CreateDirectory(Path.Combine(imgfolder, "fanart"));
Directory.CreateDirectory(Path.Combine(imgfolder, "images"));
Directory.CreateDirectory(Path.Combine(imgfolder, "wheel"));
Directory.CreateDirectory(Path.Combine(imgfolder, "videos"));
newgame.Boxart = Path.Combine(imgfolder, "box2dfront", $"{newgame.SteamID.ToString()}.jpg");
newgame.Fanart = Path.Combine(imgfolder, "steamgrid", $"{newgame.SteamID.ToString()}.jpg");
newgame.Screenshoot = Path.Combine(imgfolder, "fanart", $"{newgame.SteamID.ToString()}.jpg");
newgame.Logo = Path.Combine(imgfolder, "wheel", $"{newgame.SteamID.ToString()}.png");
newgame.Video = Path.Combine(imgfolder, "videos", $"{newgame.SteamID.ToString()}.mp4");
DownloadSteamData(data.header_image, newgame.Fanart);
DownloadSteamData(data.screenshots.First().path_full, newgame.Screenshoot);
DownloadSteamData(LogoPath.Replace("%STEAMID%", newgame.SteamID.ToString()), newgame.Logo);
DownloadSteamData(BoxPath.Replace("%STEAMID%", newgame.SteamID.ToString()), newgame.Boxart);
DownloadSteamData(data.movies.First().mp4.max, newgame.Video);
game = newgame;
}
}
catch (Exception ex)
{
//throw;
}
return(game);
}
public string SearchVideo(GameRom game, ScraperType type, ScraperSource source)
{
ModalWindow modalWindow = new ModalWindow();
var vm = new VideoFinderSearchViewModel(game, source, type);
modalWindow.DataContext = vm;
if (modalWindow.ShowDialog().Value)
{
return(vm.ResultPath);
}
return(null);
}
public GameRom ShowGameDetail(GameRom game)
{
ModalWindow modalWindow = new ModalWindow();
var vm = new GameDetailViewModel(game);
modalWindow.DataContext = vm;
if (modalWindow.ShowDialog().Value)
{
return(vm.GameCurrent);
}
return(null);
}
public List <GameRom> GetOriginGame(Emulator emu)
{
var originPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData), "Origin", "LocalContent");
if (Directory.Exists(originPath))
{
var manifests = Directory.GetFiles(originPath, "*.mfst", SearchOption.AllDirectories);
List <GameRom> gamesfind = new List <GameRom>();
foreach (var files in manifests)
{
//string gameName;
string gameId;
try
{
gameId = Path.GetFileNameWithoutExtension(files);
if (!gameId.StartsWith("Origin"))
{
var match = Regex.Match(gameId, @"^(.*?)(\d+)$");
if (!match.Success)
{
continue;
}
gameId = match.Groups[1].Value + ":" + match.Groups[2].Value;
}
if (gameId.Contains("@"))
{
gameId = gameId.Substring(0, gameId.IndexOf("@"));
}
var origindata = GetGameLocalData(gameId);
if (origindata != null)
{
GameRom game = new GameRom();
game.EmulatorID = emu.EmulatorID;
game.Name = origindata.localizableAttributes.displayName;
game.Desc = origindata.localizableAttributes.longDescription;
game.OriginID = gameId;
game.Path = $"origin://launchgame/{gameId}";
gamesfind.Add(game);
}
}
catch (Exception ex)
{
continue;
}
}
return(gamesfind);
}
else
{
return(null);
}
}
private GameRom ScrapeGamefromGamelist(GameRom game, string filefolder, Game gamedata)
{
game.Desc = gamedata.Desc;
game.Dev = gamedata.Developer;
game.Editeur = gamedata.Publisher;
if (!string.IsNullOrEmpty(gamedata.Releasedate) && !string.IsNullOrWhiteSpace(gamedata.Releasedate))
{
game.Year = gamedata.Releasedate.Substring(0, 4);
}
game.Genre = gamedata.Genre;
game.Name = gamedata.Name;
return(game);
}
public GameViewModel(GameRom game)
{
Game = game;
Name = game.Name;
Path = game.Path;
Desc = game.Desc;
Year = game.Year;
Editeur = game.Editeur;
Dev = game.Dev;
Genre = game.Genre;
Boxart = game.Boxart;
Sxreenshoot = game.Screenshoot;
Logo = game.Logo;
RecalView = game.RecalView;
TitleScreen = game.TitleScreen;
Banner = game.Fanart;
Video = game.Video;
if (game.Fanart != null)
{
if (File.Exists(game.Fanart) == false)
{
if (File.Exists(game.Fanart.Replace(".jpg", ".png")))
{
Banner = game.Fanart.Replace(".jpg", ".png");
}
}
}
if (File.Exists(game.Screenshoot) == false)
{
if (game.Screenshoot != null && File.Exists(game.Screenshoot.Replace(".png", ".jpg")))
{
Sxreenshoot = game.Screenshoot.Replace(".png", ".jpg");
}
else
{
Sxreenshoot = TitleScreen;
if (File.Exists(game.TitleScreen) == false)
{
Sxreenshoot = RecalView;
}
}
}
else
{
Sxreenshoot = game.Screenshoot;
}
}
public Level Run(GameRom gameRom, int levelId)
{
this.gameRom = gameRom;
level = new Level(levelId);
level.Tile8s = GetTile8s();
level.Tile16Palettes = GetTile16Palettes(level);
level.Tile16s = GetTile16s(level);
level.Tile32s = GetTile32s(level);
level.Tile32Rows = GetTile32Rows(level);
level.SpriteTiles = GetSpriteTiles(level);
level.SpritePalettes = GetSpritePalettes(level);
level.GameObjects = GetGameObjects(level);
level.LevelObjects = GetLevelObjects(level);
return(level);
}
public GameRom CreateGame(string gamefile, Emulator emulator)
{
GameRom game = new GameRom();
var plateforme = dbService.GetSysteme(emulator.SystemeID);
string imgfolder = Path.Combine(FileJSONService.appSettings.AppSettingsFolder, "media", plateforme.Shortname);
game.Path = gamefile;
game.Name = System.IO.Path.GetFileNameWithoutExtension(gamefile);
game.EmulatorID = emulator.EmulatorID;
game.Boxart = Path.Combine(imgfolder, "box2dfront", $"{game.Name}.png");
game.Fanart = Path.Combine(imgfolder, "steamgrid", $"{game.Name}.jpg");
game.Screenshoot = Path.Combine(imgfolder, "fanart", $"{game.Name}.png");
game.Logo = Path.Combine(imgfolder, "wheel", $"{game.Name}.png");
game.TitleScreen = Path.Combine(imgfolder, "screentitle", $"{game.Name}.png");
game.RecalView = Path.Combine(imgfolder, "recalview", $"{game.Name}.png");
game.Video = Path.Combine(imgfolder, "videos", $"{game.Name}.mp4");
game.IsDuplicate = false;
return(LookForData(game));
}
public List <GameRom> GetEpicGame(Emulator emu)
{
var originPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData), "Epic", "EpicGamesLauncher", "Data", "Manifests");
var manifestsFiles = Directory.GetFiles(originPath, "*.item", SearchOption.TopDirectoryOnly);
List <GameRom> gamesfind = new List <GameRom>();
foreach (var manifestsFile in manifestsFiles)
{
var manifestObject = JObject.Parse(File.ReadAllText(manifestsFile));
var name = (string)manifestObject["DisplayName"];
var appId = (string)manifestObject["AppName"];
GameRom game = new GameRom();
game.Name = name;
game.EpicID = appId;
game.EmulatorID = emu.EmulatorID;
game.Path = $"com.epicgames.launcher://apps/{appId}?action=launch&silent=true";
gamesfind.Add(game);
}
return(gamesfind);
}
public GameRom LookForData(GameRom game)
{
var filefolder = Path.GetDirectoryName(game.Path);
if (File.Exists(Path.Combine(filefolder, "gamelist.xml")))
{
var xmlgamelist = File.ReadAllText(Path.Combine(filefolder, "gamelist.xml"));
XmlSerializer serializer = new XmlSerializer(typeof(GameList));
using (StringReader reader = new StringReader(xmlgamelist))
{
var gamelistfile = (GameList)serializer.Deserialize(reader);
var gamelist = gamelistfile.Game;
foreach (var gamedata in gamelist)
{
var gamedatapath = Path.Combine(filefolder, gamedata.Path.Substring(2));
if (gamedatapath == game.Path)
{
game = ScrapeGamefromGamelist(game, filefolder, gamedata);
}
}
}
}
return(game);
}
public byte ReadByte(ushort address)
{
if (address <= 0xFF)
{
// When the system boots, the bootrom (scrolling Nintendo logo) is executed starting from address 0.
// Bootrom is 256 bytes. At the end of the boot sequence, it writes to a special register to disable the boot rom page and
// this makes the first 256 bytes of the cart rom readable
if (bootRomMask == 0)
{
return(BootstrapRom.ReadByte(address));
}
else
{
return(GameRom.ReadByte(address));
}
}
// ROM space is 0x0000 - 0x7FFFF. To access anything over that requires bank switching (which most games use)
// The lower half of the ROM is fixed and always available 0 - 0x3FFF (16K)
// The upper half of ROM can be bank switched
if (address <= 0x7fff)
{
// Bank switching is done inside the ROM code
return(GameRom.ReadByte(address));
}
else if ((address >= 0xA000) && (address <= 0xBFFF))
{
return(GameRom.ReadRamBankByte((ushort)(address - 0xA000)));
}
else if (address >= 0xC000 && address <= 0xDFFF)
{
return(Ram[address - 0xC000]);
}
else if (address >= 0xE000 && address <= 0xFDFF)
{
return(Ram[address - 0xE000]);
}
else if (address >= 0x8000 && address <= 0x9FFF)
{
// CPU cannot access vram during Pixel Transfer and if it does it gets 0xFF
if (ppu.Mode == PpuMode.PixelTransfer &&
ppu.PpuAccessingVram == false)
{
return(0xFF);
}
return(VRam[address - 0x8000]);
}
else if (address >= 0xFE00 && address <= 0xFEFF)
{
// CPU cannot access OAM during OAM Search or Pixel Transfer and if it does it gets 0xFF
if ((ppu.Mode == PpuMode.OamSearch || ppu.Mode == PpuMode.PixelTransfer) &&
ppu.PpuAccessingVram == false)
{
return(0xFF);
}
// OAM table read. Should only be accessed by PPU.
return(OamRam[address - 0xFE00]);
}
else if (address >= 0xFF80 && address <= 0xFFFE)
{
return(HRam[address - 0xFF80]);
}
else if (address == 0xFF00)
{
// Joypad
return(dmg.pad.Register);
}
else if (address == 0xFF04)
{
// Divider register (RNG)
return(dmg.timer.DividerRegister);
}
else if (address == 0xFF07)
{
// Timer Controller register
return(dmg.timer.TimerControllerRegister);
}
else if (address == 0xFF40)
{
return(ppu.MemoryRegisters.LCDC.Register);
}
else if (address == 0xFF41)
{
return(ppu.MemoryRegisters.STAT.Register);
}
else if (address == 0xFF42)
{
return(ppu.MemoryRegisters.BgScrollY);
}
else if (address == 0xFF43)
{
return(ppu.MemoryRegisters.BgScrollX);
}
else if (address == 0xFF44)
{
// Read only
return(ppu.CurrentScanline);
}
else if (address == 0xFF45)
{
return(ppu.MemoryRegisters.STAT.LYC);
}
else if (address == 0xFF47)
{
return(ppu.Palettes.BackgroundGbPalette);
}
else if (address == 0xFF48)
{
return(ppu.Palettes.ObjGbPalette0);
}
else if (address == 0xFF49)
{
return(ppu.Palettes.ObjGbPalette1);
}
else if (address == 0xFF4A)
{
return(ppu.MemoryRegisters.WindowY);
}
else if (address == 0xFF4B)
{
return(ppu.MemoryRegisters.WindowX);
}
else if (address == 0xFF0F)
{
return(interrupts.InterruptFlags);
}
else if (address == 0xFFFF)
{
return(interrupts.InterruptEnableRegister);
}
else if (address >= 0xFF10 && address < 0xFF40)
{
return(dmg.spu.ReadRegister(address));
}
else if (address >= 0xFF00 && address <= 0xFF7F)
{
return(Io[address - 0xFF00]);
}
throw new ArgumentException("Invalid memory read");
}
public void WriteByte(ushort address, byte value)
{
if (address < 0x8000)
{
// Rom Banking is triggered by 'writing' to the Rom
GameRom.BankSwitch(address, value);
}
else if ((address >= 0xA000) && (address < 0xC000))
{
// Ram Bank on cart
GameRom.WriteRamBankByte((ushort)(address - 0xA000), value);
}
else if (address >= 0xC000 && address <= 0xDFFF)
{
Ram[address - 0xc000] = value;
}
else if (address >= 0xE000 && address <= 0xFDFF)
{
Ram[address - 0xe000] = value;
}
else if (address >= 0x8000 && address <= 0x9fff)
{
// CPU cannot access vram during Pixel Transfer and if it does it gets 0xFF
if (ppu.Mode == PpuMode.PixelTransfer)
{
return;
}
VRam[address - 0x8000] = value;
// Whenever we write to a tile in vram, update the rendering data. (Remember tile maps start at 0x9800)
if (address <= 0x97ff)
{
// Calculate the start address of the tile
int tileAddress = (address - (address % 16));
Tile tile = ppu.GetTileByVRamAdrressFast((ushort)tileAddress);
tile.Parse(VRam, tileAddress - 0x8000);
}
}
else if (address >= 0xFE00 && address <= 0xFEFF)
{
// CPU cannot access OAM during OAM Search or Pixel Transfer and if it does it gets 0xFF
if ((ppu.Mode == PpuMode.OamSearch || ppu.Mode == PpuMode.PixelTransfer) &&
ppu.PpuAccessingVram == false)
{
return;
}
// Writing to OAM Table
OamRam[address - 0xFE00] = value;
}
else if (address >= 0xFF80 && address <= 0xFFFE)
{
HRam[address - 0xFF80] = value;
}
else if (address == 0xFF00)
{
// Joypad writes 2 bits to select if it is reading pad or buttons
dmg.pad.Register = value;
}
// Serial Port output
else if (address == 0xFF01)
{
dmg.Tty.Append(Encoding.ASCII.GetString(new[] { value }));
}
// Serial Port clock
else if (address == 0xFF02)
{
}
else if (address == 0xFF04)
{
// When writing to DIV, the whole counter is reset so the timer is also affected.
// Writing any value to the divider register restes it
dmg.timer.DividerRegister = 0;
}
else if (address == 0xFF07)
{
// Timer Controller register, update if the value is changing
value &= 0x07;
if ((dmg.timer.TimerControllerRegister & 0x03) != (value & 0x03))
{
dmg.timer.ResetTIMACycles();
}
dmg.timer.TimerControllerRegister = value;
}
else if (address == 0xFF40)
{
ppu.MemoryRegisters.LCDC.Register = value;
}
else if (address == 0xFF41)
{
ppu.MemoryRegisters.STAT.Register = value;
}
else if (address == 0xFF42)
{
ppu.MemoryRegisters.BgScrollY = value;
}
else if (address == 0xFF43)
{
ppu.MemoryRegisters.BgScrollX = value;
}
else if (address == 0xFF44)
{
// reset scanline if the program tries to write to it
//ppu.CurrentScanline = 0;
}
else if (address == 0xFF45)
{
ppu.MemoryRegisters.STAT.LYC = value;
}
else if (address == 0xFF46)
{
// OAM DMA
DmaCopy(0xfe00, (ushort)(value << 8), 160);
}
else if (address == 0xFF47)
{
ppu.Palettes.BackgroundGbPalette = value;
}
else if (address == 0xFF48)
{
ppu.Palettes.ObjGbPalette0 = value;
}
else if (address == 0xFF49)
{
ppu.Palettes.ObjGbPalette1 = value;
}
else if (address == 0xFF4A)
{
ppu.MemoryRegisters.WindowY = value;
}
else if (address == 0xFF4B)
{
ppu.MemoryRegisters.WindowX = value;
}
else if (address == 0xFF50)
{
bootRomMask = value;
}
else if (address == 0xFF0F)
{
interrupts.InterruptFlags = value;
}
else if (address == 0xFFFF)
{
interrupts.InterruptEnableRegister = value;
}
else if (address >= 0xFF10 && address < 0xFF40)
{
dmg.spu.WriteRegister(address, value);
}
else if (address >= 0xFF00 && address <= 0xFF7F)
{
// TODO: Move all the specific IO calls FF40 etc etc into this else if
Io[address - 0xFF00] = value;
}
else
{
Console.WriteLine(String.Format("Invalid memory write addr 0x{0:X4} val 0x{1:X2}", address, value));
throw new ArgumentException(String.Format("Invalid memory write addr 0x{0:X4} val 0x{1:X2}", address, value));
}
}
public GameRom ScrapeGame(GameRom game)
{
return(game);
}
public void LoadingProposal(GameRom game)
{
Search searchedGame = new Search();
if (CurrentScrapeSource == ScraperSource.IGDB)
{
if (game.IGDBID < 1)
{
searchedGame = dialogService.SearchSteamGridDBByName(game.Name, CurrentScrapeSource);
if (searchedGame != null)
{
game.IGDBID = searchedGame.id;
}
}
}
else if (CurrentScrapeSource == ScraperSource.SGDB)
{
if (game.SGDBID < 1)
{
searchedGame = dialogService.SearchSteamGridDBByName(game.Name, CurrentScrapeSource);
if (searchedGame != null)
{
game.SGDBID = searchedGame.id;
}
}
}
if (searchedGame != null)
{
ResultImgs = new ObservableCollection <string>();
if (CurrentScraperType == ScraperType.Logo)
{
var result = steamGridDBService.GetLogoForId(game.SGDBID);
if (result != null)
{
foreach (var img in result)
{
ResultImgs.Add(img.url);
}
}
}
else if (CurrentScraperType == ScraperType.ArtWork)
{
IEnumerable <ImgResult> result;
if (CurrentScrapeSource == ScraperSource.SGDB)
{
result = steamGridDBService.GetHeroesForId(game.SGDBID);
if (result != null)
{
foreach (var img in result)
{
ResultImgs.Add(img.url);
}
}
}
else if (CurrentScrapeSource == ScraperSource.IGDB)
{
var detailart = iGDBService.GetArtworksByGameId(game.IGDBID);
var detailsch = iGDBService.GetScreenshotsByGameId(game.IGDBID);
if (detailart != null)
{
var resultartigdb = detailart.Select(x => iGDBService.GetArtWorkLink(x.image_id));
foreach (var img in resultartigdb)
{
ResultImgs.Add(img);
}
}
if (detailsch != null)
{
var resultschigdb = detailsch.Select(x => iGDBService.GetArtWorkLink(x.image_id));
foreach (var img in resultschigdb)
{
ResultImgs.Add(img);
}
}
}
}
else if (CurrentScraperType == ScraperType.Banner)
{
var result = steamGridDBService.GetGridBannerForId(game.SGDBID);
if (result != null)
{
foreach (var img in result)
{
ResultImgs.Add(img.url);
}
}
}
else if (CurrentScraperType == ScraperType.Boxart)
{
if (CurrentScrapeSource == ScraperSource.SGDB)
{
var result = steamGridDBService.GetGridBoxartForId(game.SGDBID);
if (result != null)
{
foreach (var img in result)
{
ResultImgs.Add(img.url);
}
}
}
else if (CurrentScrapeSource == ScraperSource.IGDB)
{
var detail = iGDBService.GetDetailsGame(game.IGDBID);
ResultImgs.Add(iGDBService.GetCoverLink(detail.cover.image_id));
}
}
NBImg = ResultImgs.Count;
SelectedImgIndex = 0;
}
}
private void LoadingGame(GameRom game = null)
{
if (game != null)
{
GameCurrent = game;
}
Name = GameCurrent.Name;
Path = GameCurrent.Path;
Desc = GameCurrent.Desc;
Year = GameCurrent.Year;
Editeur = GameCurrent.Editeur;
Dev = GameCurrent.Dev;
Genre = GameCurrent.Genre;
Boxart = GameCurrent.Boxart;
Screenshoot = GameCurrent.Screenshoot;
Logo = GameCurrent.Logo;
RecalView = GameCurrent.RecalView;
TitleScreen = GameCurrent.TitleScreen;
Fanart = GameCurrent.Fanart;
Video = GameCurrent.Video;
IsResolveIGDB = GameCurrent.IGDBID;
IsResolveSCSP = GameCurrent.ScreenScraperID;
IsResolveSGDB = GameCurrent.SGDBID;
if (GameCurrent.Fanart != null)
{
if (File.Exists(GameCurrent.Fanart) == false)
{
if (File.Exists(GameCurrent.Fanart.Replace(".jpg", ".png")))
{
Fanart = GameCurrent.Fanart.Replace(".jpg", ".png");
}
// Fanart = TitleScreen;
// if (File.Exists(game.TitleScreen) == false)
// {
// Fanart = RecalView;
// }
}
}
if (GameCurrent.Screenshoot != null)
{
if (File.Exists(GameCurrent.Screenshoot) == false)
{
if (File.Exists(GameCurrent.Screenshoot.Replace(".png", ".jpg")))
{
Screenshoot = GameCurrent.Screenshoot.Replace(".png", ".jpg");
}
else
{
Screenshoot = TitleScreen;
if (File.Exists(GameCurrent.TitleScreen) == false)
{
Screenshoot = RecalView;
}
}
}
else
{
Screenshoot = GameCurrent.Screenshoot;
}
}
}