ShuriZma
/
BizHawk
mirror of https://github.com/TASEmulators/BizHawk.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Atari 2600 - add in unimplemented mappers and throw not implemented exceptions. Throw these on a 4IN1 and F8SC instead of wrongly using F8. Implement heuristics for Rom detection when rom isn't found in gamedb. Heuristics logic based on Stella findings.

This commit is contained in:
adelikat 2014-04-04 19:46:41 +00:00
parent 58732cf627
commit af0cd39742
12 changed files with 738 additions and 42 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
BizHawk.Common/Util.cs
View File

@ -16,6 +16,18 @@ namespace BizHawk.Common
HexConvPtr = (char*)HexConvHandle.AddrOfPinnedObject().ToPointer();
}
public static bool FindBytes(byte[] array, byte[] pattern)
{
int fidx = 0;
int result = Array.FindIndex(array, 0, array.Length, (byte b) =>
{
fidx = (b == pattern[fidx]) ? fidx + 1 : 0;
return (fidx == pattern.Length);
});
return (result >= pattern.Length - 1);
}
public static char* HexConvPtr { get; set; }
public static string Hash_MD5(byte[] data, int offset, int len)

10
BizHawk.Emulation.Cores/BizHawk.Emulation.Cores.csproj
View File

@ -176,25 +176,35 @@
<Compile Include="Computers\Commodore64\Tape\VIC1530.cs" />
<Compile Include="Consoles\Atari\2600\Atari2600.cs" />
<Compile Include="Consoles\Atari\2600\Atari2600.Core.cs" />
<Compile Include="Consoles\Atari\2600\Atari2600.RomHeuristics.cs" />
<Compile Include="Consoles\Atari\2600\Mappers\m0840.cs" />
<Compile Include="Consoles\Atari\2600\Mappers\m3E.cs" />
<Compile Include="Consoles\Atari\2600\Mappers\m3F.cs" />
<Compile Include="Consoles\Atari\2600\Mappers\m4A50.cs" />
<Compile Include="Consoles\Atari\2600\Mappers\mAR.cs" />
<Compile Include="Consoles\Atari\2600\Mappers\mDPC.cs" />
<Compile Include="Consoles\Atari\2600\Mappers\mDPCPlus.cs" />
<Compile Include="Consoles\Atari\2600\Mappers\mE0.cs" />
<Compile Include="Consoles\Atari\2600\Mappers\mE7.cs" />
<Compile Include="Consoles\Atari\2600\Mappers\mEF.cs" />
<Compile Include="Consoles\Atari\2600\Mappers\mEFSC.cs" />
<Compile Include="Consoles\Atari\2600\Mappers\mF0.cs" />
<Compile Include="Consoles\Atari\2600\Mappers\mF4.cs" />
<Compile Include="Consoles\Atari\2600\Mappers\mCV.cs" />
<Compile Include="Consoles\Atari\2600\Mappers\m2K.cs" />
<Compile Include="Consoles\Atari\2600\Mappers\m4K.cs" />
<Compile Include="Consoles\Atari\2600\Mappers\mF4SC.cs" />
<Compile Include="Consoles\Atari\2600\Mappers\mF6.cs" />
<Compile Include="Consoles\Atari\2600\Mappers\mF6SC.cs" />
<Compile Include="Consoles\Atari\2600\Mappers\mF8.cs" />
<Compile Include="Consoles\Atari\2600\Mappers\mF8SC.cs" />
<Compile Include="Consoles\Atari\2600\Mappers\mFA.cs" />
<Compile Include="Consoles\Atari\2600\Mappers\mFA2.cs" />
<Compile Include="Consoles\Atari\2600\Mappers\mFE.cs" />
<Compile Include="Consoles\Atari\2600\Mappers\mMC.cs" />
<Compile Include="Consoles\Atari\2600\Mappers\mSB.cs" />
<Compile Include="Consoles\Atari\2600\Mappers\mUA.cs" />
<Compile Include="Consoles\Atari\2600\Mappers\Multicart.cs" />
<Compile Include="Consoles\Atari\2600\Mappers\mX07.cs" />
<Compile Include="Consoles\Atari\2600\oldTIA.cs" />
<Compile Include="Consoles\Atari\2600\M6532.cs" />

108
BizHawk.Emulation.Cores/Consoles/Atari/2600/Atari2600.Core.cs
View File

@ -142,30 +142,96 @@ namespace BizHawk.Emulation.Cores.Atari.Atari2600
//regenerate mapper here to make sure its state is entirely clean
switch (game.GetOptionsDict()["m"])
{
case "4K": mapper = new m4K(); break;
case "2K": mapper = new m2K(); break;
case "CV": mapper = new mCV(); break;
case "F8": mapper = new mF8(); break;
case "F6":
case "2IN1":
case "4IN1":
case "F6SC": mapper = new mF6(); break;
case "8IN1":
case "16IN1":
case "32IN1":
mapper = new Multicart();
break;
case "AR":
mapper = new mAR();
break;
case "4K":
mapper = new m4K();
break;
case "2K":
mapper = new m2K();
break;
case "CV":
mapper = new mCV();
break;
case "DPC":
mapper = new mDPC();
break;
case "DPC+":
mapper = new mDPCPlus();
break;
case "F8":
mapper = new mF8();
break;
case "F6":
mapper = new mF6();
break;
case "F6SC":
mapper = new mF6SC();
break;
case "F4":
case "F4SC": mapper = new mF4(); break;
case "FE": mapper = new mFE(); break;
case "E0": mapper = new mE0(); break;
case "3F": mapper = new m3F(); break;
case "FA": mapper = new mFA(); break;
case "E7": mapper = new mE7(); break;
case "F0": mapper = new mF0(); break;
case "UA": mapper = new mUA(); break;
mapper = new mF4();
break;
case "F4SC":
mapper = new mF4SC();
break;
case "FE":
mapper = new mFE();
break;
case "E0":
mapper = new mE0();
break;
case "3F":
mapper = new m3F();
break;
case "FA":
mapper = new mFA();
break;
case "FA2":
mapper = new mFA2();
break;
case "E7":
mapper = new mE7();
break;
case "F0":
mapper = new mF0();
break;
case "UA":
mapper = new mUA();
break;
//Homebrew mappers
case "3E": mapper = new m3E(); break;
case "0840": mapper = new m0840(); break;
case "MC": mapper = new mMC(); break;
case "EF": mapper = new mEF(); break;
case "X07": mapper = new mX07(); break;
case "4A50": mapper = new m4A50(); break;
case "DPC": mapper = new mDPC(); break;
case "3E":
mapper = new m3E();
break;
case "0840":
mapper = new m0840();
break;
case "MC":
mapper = new mMC();
break;
case "EF":
mapper = new mEF();
break;
case "EFSC":
mapper = new mEFSC();
break;
case "X07":
mapper = new mX07();
break;
case "4A50":
mapper = new m4A50();
break;
case "SB":
mapper = new mSB();
break;
default: throw new InvalidOperationException("mapper not supported: " + game.GetOptionsDict()["m"]);
}

460
BizHawk.Emulation.Cores/Consoles/Atari/2600/Atari2600.RomHeuristics.cs Normal file
View File

@ -0,0 +1,460 @@
using System.Collections.Generic;
using System.Linq;
using BizHawk.Common;
namespace BizHawk.Emulation.Cores.Atari.Atari2600
{
public partial class Atari2600
{
// Heuristics logic based on Stella's logic
private static string DetectMapper(byte[] rom)
{
if (rom.Length % 8448 == 0 || rom.Length == 6114) // Only AR could be these odd numbers
{
return "AR";
}
if (rom.Length < 2048) // Less than 2k, then no bank switching needed
{
return "2K";
}
if (rom.Length == 2048 || // If 2k or the same 2k twice...Why would a rom be that way? Overdump?
(rom.Length == 4096
&& rom.Take(2048).SequenceEqual(rom.Skip(2048).Take(2048))))
{
return IsProablyCV(rom) ? "CV" : "2K";
}
if (rom.Length == 4096)
{
return IsProablyCV(rom) ? "CV" : "4K";
}
if (rom.Length == 8192) // Several 8K Options
{
if (IsProbablySC(rom))
{
return "F8SC";
}
if (rom.Take(4096).SequenceEqual(rom.Skip(4096).Take(4096)))
{
return "4K"; // Again if it is simply the same 4k twice. Got this scenario from Stella logic. Will assume a good reason for it
}
if (IsProbablyE0(rom))
{
return "E0";
}
if (IsProbably3E(rom))
{
return "3E";
}
if (IsProbably3F(rom))
{
return "3F";
}
if (IsProbablyUA(rom))
{
return "UA";
}
if (IsProbablyFE(rom))
{
return "FE";
}
if (IsProbably0840(rom))
{
return "0840";
}
return "F8";
}
if (rom.Length >= 10240 && rom.Length <= 10496) // ~10K - Pitfall2
{
return "DPC";
}
if (rom.Length == 12 * 1024) // 12K
{
return "FA";
}
if (rom.Length == 16 * 1024) // 16K
{
if (IsProbablySC(rom))
{
return "F6SC";
}
if (IsProbablyE7(rom))
{
return "E7";
}
if (IsProbably3E(rom))
{
return "3E";
}
if (IsProbably3F(rom))
{
return "3F";
}
return "F6";
}
if (rom.Length == 24 * 1024 || rom.Length == 28 * 1024) // 24K & 28K
{
return "FA2";
}
if (rom.Length == 29 * 1024) // 29K
{
return "DPC+";
}
if (rom.Length == 32 * 1024) // 32K
{
if (IsProbablySC(rom))
{
return "F4SC";
}
if (IsProbably3E(rom))
{
return "3E";
}
if (IsProbably3F(rom))
{
return "3F";
}
if (IsProbablyDpcPlus(rom))
{
return "DPC+";
}
return "F4";
}
if (rom.Length == 64 * 1064) // 64K
{
if (IsProbably3E(rom))
{
return "3E";
}
if (IsProbably3F(rom))
{
return "3F";
}
if (IsProbably4A50(rom))
{
return "4A50";
}
if (IsProbablyEF(rom))
{
return IsProbablySC(rom) ? "EFSC" : "EF";
}
if (IsProbablyX07(rom))
{
return "X07";
}
return "F0";
}
if (rom.Length == 128 * 1024) // 128K
{
if (IsProbably3E(rom))
{
return "3E";
}
if (IsProbably3F(rom))
{
return "3F";
}
if (IsProbably4A50(rom))
{
return "4A50";
}
if (IsProbablySB(rom))
{
return "SB";
}
return "MC";
}
if (rom.Length == 256 * 1024) // 256K
{
if (IsProbably3E(rom))
{
return "3E";
}
if (IsProbably3F(rom))
{
return "3F";
}
return "SB";
}
// What else could it be? Try 3E or 3F
if (IsProbably3E(rom))
{
return "3E";
}
if (IsProbably3F(rom))
{
return "3F";
}
return "UNKNOWN";
}
private static bool IsProbablySC(IList<byte> rom)
{
// We assume a Superchip cart contains the same bytes for its entire
// RAM area; obviously this test will fail if it doesn't
// The RAM area will be the first 256 bytes of each 4K bank
var numBanks = rom.Count / 4096;
for (var i = 0; i < numBanks; i++)
{
var first = rom[i * 4096];
for (var j = 0; j < 256; j++)
{
if (rom[(i * 4096) + j] != first)
{
return false;
}
}
}
return false;
}
private static bool IsProbably3E(byte[] rom)
{
// 3E cart bankswitching is triggered by storing the bank number
// in address 3E using 'STA $3E', commonly followed by an
// immediate mode LDA
return Util.FindBytes(rom, new byte[] { 0x85, 0x3E, 0xA9, 0x00 }); // STA $3E; LDA #$00
}
private static bool IsProbably3F(byte[] rom)
{
// 3F cart bankswitching is triggered by storing the bank number
// in address 3F using 'STA $3F'
// We expect it will be present at least 2 times, since there are at least two banks
return ContainsAll(rom, new List<byte[]>
{
new byte[] { 0x85, 0x3F },
new byte[] { 0x85, 0x3F }
});
}
private static bool IsProbably4A50(IList<byte> rom)
{
// 4A50 carts store address $4A50 at the NMI vector, which
// in this scheme is always in the last page of ROM at
// $1FFA - $1FFB (at least this is true in rev 1 of the format)
if (rom[rom.Count - 6] == 0x50 && rom[rom.Count - 5] == 0x4A)
{
return true;
}
// Program starts at $1Fxx with NOP $6Exx or NOP $6Fxx?
if (((rom[0xFFFD] & 0x1F) == 0x1F) &&
(rom[rom[0xFFFD] * 256 + rom[0xFFFC]] == 0x0C) &&
((rom[rom[0xFFFD] * 256 + rom[0xFFFC] + 2] & 0xFE) == 0x6E))
{
return true;
}
return false;
}
private static bool IsProbablyUA(byte[] rom)
{
// UA cart bankswitching switches to bank 1 by accessing address 0x240
// using 'STA $240' or 'LDA $240'
return ContainsAny(rom, new List<byte[]>
{
new byte[] { 0x8D, 0x40, 0x02 }, // STA $240
new byte[] { 0xAD, 0x40, 0x02 }, // LDA $240
new byte[] { 0xBD, 0x1F, 0x02 } // LDA $21F,X
});
}
private static bool IsProbablyE0(byte[] rom)
{
// E0 cart bankswitching is triggered by accessing addresses
// $FE0 to $FF9 using absolute non-indexed addressing
// To eliminate false positives (and speed up processing), we
// search for only certain known signatures
// Thanks to "stella@casperkitty.com" for this advice
// These signatures are attributed to the MESS project
return ContainsAny(rom, new List<byte[]>
{
new byte[] { 0x8D, 0xE0, 0x1F }, // STA $1FE0
new byte[] { 0x8D, 0xE0, 0x5F }, // STA $5FE0
new byte[] { 0x8D, 0xE9, 0xFF }, // STA $FFE9
new byte[] { 0x0C, 0xE0, 0x1F }, // NOP $1FE0
new byte[] { 0xAD, 0xE0, 0x1F }, // LDA $1FE0
new byte[] { 0xAD, 0xE9, 0xFF }, // LDA $FFE9
new byte[] { 0xAD, 0xED, 0xFF }, // LDA $FFED
new byte[] { 0xAD, 0xF3, 0xBF } // LDA $BFF3
});
}
private static bool IsProablyCV(byte[] rom)
{
// According to Stella: CV RAM access occurs at addresses $f3ff and $f400
// These signatures are attributed to the MESS project
return ContainsAny(rom, new List<byte[]>
{
new byte[] { 0x9D, 0xFF, 0xF3 },
new byte[] { 0x99, 0x00, 0xF4 }
});
}
private static bool IsProbablyFE(byte[] rom)
{
// FE bankswitching is very weird, but always seems to include a
// 'JSR $xxxx'
// These signatures are attributed to the MESS project
return ContainsAny(rom, new List<byte[]>
{
new byte[] { 0x20, 0x00, 0xD0, 0xC6, 0xC5 }, // JSR $D000; DEC $C5
new byte[] { 0x20, 0xC3, 0xF8, 0xA5, 0x82 }, // JSR $F8C3; LDA $82
new byte[] { 0xD0, 0xFB, 0x20, 0x73, 0xFE }, // BNE $FB; JSR $FE73
new byte[] { 0x20, 0x00, 0xF0, 0x84, 0xD6 } // JSR $F000; STY $D6
});
}
private static bool IsProbably0840(byte[] rom)
{
// 0840 cart bankswitching is triggered by accessing addresses 0x0800
// or 0x0840
if (ContainsAny(rom, new List<byte[]>
{
new byte[] { 0xAD, 0x00, 0x08 }, // LDA $0800
new byte[] { 0xAD, 0x40, 0x08 } // LDA $0840
}))
{
return true;
}
return ContainsAny(rom, new List<byte[]>
{
new byte[] { 0x0C, 0x00, 0x08, 0x4C }, // NOP $0800; JMP ...
new byte[] { 0x0C, 0xFF, 0x0F, 0x4C } // NOP $0FFF; JMP ...
});
}
private static bool IsProbablyE7(byte[] rom)
{
// E7 cart bankswitching is triggered by accessing addresses
// $FE0 to $FE6 using absolute non-indexed addressing
// To eliminate false positives (and speed up processing), we
// search for only certain known signatures
// Thanks to "stella@casperkitty.com" for this advice
// These signatures are attributed to the MESS project
return ContainsAny(rom, new List<byte[]>
{
new byte[] { 0xAD, 0xE2, 0xFF }, // LDA $FFE2
new byte[] { 0xAD, 0xE5, 0xFF }, // LDA $FFE5
new byte[] { 0xAD, 0xE5, 0x1F }, // LDA $1FE5
new byte[] { 0xAD, 0xE7, 0x1F }, // LDA $1FE7
new byte[] { 0x0C, 0xE7, 0x1F }, // NOP $1FE7
new byte[] { 0x8D, 0xE7, 0xFF }, // STA $FFE7
new byte[] { 0x8D, 0xE7, 0x1F } // STA $1FE7
});
}
private static bool IsProbablyDpcPlus(byte[] rom)
{
// E0 cart bankswitching is triggered by accessing addresses
// $FE0 to $FF9 using absolute non-indexed addressing
// To eliminate false positives (and speed up processing), we
// search for only certain known signatures
// Thanks to "stella@casperkitty.com" for this advice
// These signatures are attributed to the MESS project
return ContainsAny(rom, new List<byte[]>
{
new byte[] { 0x8D, 0xE0, 0x1F }, // STA $1FE0
new byte[] { 0x8D, 0xE0, 0x5F }, // STA $5FE0
new byte[] { 0x8D, 0xE9, 0xFF }, // STA $FFE9
new byte[] { 0x0C, 0xE0, 0x1F }, // NOP $1FE0
new byte[] { 0xAD, 0xE0, 0x1F }, // LDA $1FE0
new byte[] { 0xAD, 0xE9, 0xFF }, // LDA $FFE9
new byte[] { 0xAD, 0xED, 0xFF }, // LDA $FFED
new byte[] { 0xAD, 0xF3, 0xBF } // LDA $BFF3
});
}
private static bool IsProbablyEF(byte[] rom)
{
// EF cart bankswitching switches banks by accessing addresses 0xFE0
// to 0xFEF, usually with either a NOP or LDA
// It's likely that the code will switch to bank 0, so that's what is tested
return ContainsAny(rom, new List<byte[]>
{
new byte[] { 0x0C, 0xE0, 0xFF }, // NOP $FFE0
new byte[] { 0xAD, 0xE0, 0xFF }, // LDA $FFE0
new byte[] { 0x0C, 0xE0, 0x1F }, // NOP $1FE0
new byte[] { 0xAD, 0xE0, 0x1F } // LDA $1FE0
});
}
private static bool IsProbablyX07(byte[] rom)
{
// X07 bankswitching switches to bank 0, 1, 2, etc by accessing address 0x08xd
return ContainsAny(rom, new List<byte[]>
{
new byte[] { 0xAD, 0x0D, 0x08 }, // LDA $080D
new byte[] { 0xAD, 0x1D, 0x08 }, // LDA $081D
new byte[] { 0xAD, 0x2D, 0x08 } // LDA $082D
});
}
private static bool IsProbablySB(byte[] rom)
{
// SB cart bankswitching switches banks by accessing address 0x0800
return ContainsAny(rom, new List<byte[]>
{
new byte[] { 0xBD, 0x00, 0x08 }, // LDA $0800,x
new byte[] { 0xAD, 0x00, 0x08 } // LDA $0800
});
}
private static bool ContainsAny(byte[] rom, IEnumerable<byte[]> signatures)
{
return signatures.Any(signature => Util.FindBytes(rom, signature));
}
private static bool ContainsAll(byte[] rom, IEnumerable<byte[]> signatures)
{
return signatures.All(signature => Util.FindBytes(rom, signature));
}
}
}

22
BizHawk.Emulation.Cores/Consoles/Atari/2600/Atari2600.cs
View File

@ -44,33 +44,13 @@ namespace BizHawk.Emulation.Cores.Atari.Atari2600
if (!game.GetOptionsDict().ContainsKey("m"))
{
DetectMapper();
game.AddOption("m", DetectMapper(rom));
}
Console.WriteLine("Game uses mapper " + game.GetOptionsDict()["m"]);
HardReset();
}
void DetectMapper()
{
string m = "UNKNOWN";
switch (rom.Length)
{
case 2048: m = "2K"; break;
case 4096: m = "4K"; break;
case 8192: m = "F8"; break;
case 16384: m = "F6"; break;
case 12288: m = "FA"; break;
case 32768: m = "F4"; break;
case 65536: m = "EF"; break;
case 131072: m = "MC"; break;
case 262144: m = "3F"; break;
case 524288: m = "3F"; break;
}
game.AddOption("m", m);
}
public List<KeyValuePair<string, int>> GetCpuFlagsAndRegisters()
{
return new List<KeyValuePair<string, int>>

68
BizHawk.Emulation.Cores/Consoles/Atari/2600/Mappers/mAR.cs Normal file
View File

@ -0,0 +1,68 @@
using System;
using BizHawk.Common;
/**
This is the cartridge class for Arcadia (aka Starpath) Supercharger
games. Christopher Salomon provided most of the technical details
used in creating this class. A good description of the Supercharger
is provided in the Cuttle Cart's manual.
The Supercharger has four 2K banks. There are three banks of RAM
and one bank of ROM. All 6K of the RAM can be read and written.
*/
namespace BizHawk.Emulation.Cores.Atari.Atari2600
{
internal class mAR : MapperBase
{
private int _bank4k;
private ByteBuffer _ram = new ByteBuffer(6144);
public mAR()
{
throw new NotImplementedException();
}
private byte ReadMem(ushort addr, bool peek)
{
if (!peek)
{
Address(addr);
}
if (addr < 0x1000)
{
return base.ReadMemory(addr);
}
return core.rom[(_bank4k << 12) + (addr & 0xFFF)];
}
public override byte ReadMemory(ushort addr)
{
return ReadMem(addr, false);
}
public override byte PeekMemory(ushort addr)
{
return ReadMem(addr, true);
}
public override void SyncState(Serializer ser)
{
base.SyncState(ser);
ser.Sync("bank4k", ref _bank4k);
ser.Sync("ram", ref _ram);
}
private void Address(ushort addr)
{
if (addr == 0x1FF8)
{
_bank4k = 0;
}
else if (addr == 0x1FF9)
{
_bank4k = 1;
}
}
}
}

17
BizHawk.Emulation.Cores/Consoles/Atari/2600/Mappers/mDPCPlus.cs Normal file
View File

@ -0,0 +1,17 @@
using System;
namespace BizHawk.Emulation.Cores.Atari.Atari2600
{
/**
Cartridge class used for DPC+. There are six 4K program banks, a 4K
display bank, 1K frequency table and the DPC chip. For complete details on
the DPC chip see David P. Crane's United States Patent Number 4,644,495.
*/
internal class mDPCPlus : MapperBase
{
public mDPCPlus()
{
throw new NotImplementedException();
}
}
}

17
BizHawk.Emulation.Cores/Consoles/Atari/2600/Mappers/mEFSC.cs Normal file
View File

@ -0,0 +1,17 @@
using System;
namespace BizHawk.Emulation.Cores.Atari.Atari2600
{
/**
Cartridge class used for Homestar Runner by Paul Slocum.
There are 16 4K banks (total of 64K ROM) with 128 bytes of RAM.
Accessing $1FE0 - $1FEF switches to each bank.
*/
internal class mEFSC : MapperBase
{
public mEFSC()
{
throw new NotImplementedException();
}
}
}

16
BizHawk.Emulation.Cores/Consoles/Atari/2600/Mappers/mF4SC.cs Normal file
View File

@ -0,0 +1,16 @@
using System;
namespace BizHawk.Emulation.Cores.Atari.Atari2600
{
/**
Cartridge class used for Atari's 16K bankswitched games with
128 bytes of RAM. There are four 4K banks.
*/
internal class mF4SC : MapperBase
{
public mF4SC()
{
throw new NotImplementedException();
}
}
}

16
BizHawk.Emulation.Cores/Consoles/Atari/2600/Mappers/mF6SC.cs Normal file
View File

@ -0,0 +1,16 @@
using System;
namespace BizHawk.Emulation.Cores.Atari.Atari2600
{
/**
Cartridge class used for Atari's 32K bankswitched games with
128 bytes of RAM. There are eight 4K banks.
*/
internal class mF6SC : MapperBase
{
public mF6SC()
{
throw new NotImplementedException();
}
}
}

16
BizHawk.Emulation.Cores/Consoles/Atari/2600/Mappers/mF8SC.cs Normal file
View File

@ -0,0 +1,16 @@
using System;
namespace BizHawk.Emulation.Cores.Atari.Atari2600
{
/**
Cartridge class used for Atari's 8K bankswitched games with
128 bytes of RAM. There are two 4K banks.
*/
internal class mF8SC : MapperBase
{
public mF8SC()
{
throw new NotImplementedException();
}
}
}

18
BizHawk.Emulation.Cores/Consoles/Atari/2600/Mappers/mFA2.cs Normal file
View File

@ -0,0 +1,18 @@
using System;
namespace BizHawk.Emulation.Cores.Atari.Atari2600
{
/**
This is an extended version of the CBS RAM Plus bankswitching scheme
supported by the Harmony cartridge.
There are six (or seven) 4K banks and 256 bytes of RAM.
*/
internal class mFA2 : MapperBase
{
public mFA2()
{
throw new NotImplementedException();
}
}
}