mirror of
https://github.com/SourMesen/Mesen2.git
synced 2025-04-02 10:21:44 -04:00
671 lines
17 KiB
C#
671 lines
17 KiB
C#
using Avalonia.Controls;
|
|
using Mesen.Debugger.Utilities;
|
|
using Mesen.Interop;
|
|
using Mesen.Utilities;
|
|
using Mesen.ViewModels;
|
|
using ReactiveUI;
|
|
using ReactiveUI.Fody.Helpers;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Threading.Tasks;
|
|
|
|
namespace Mesen.Debugger.ViewModels;
|
|
|
|
public class NesHeaderEditViewModel : DisposableViewModel
|
|
{
|
|
public NesHeader Header { get; }
|
|
|
|
[Reactive] public bool IsBatteryCheckboxEnabled { get; private set; }
|
|
[Reactive] public bool IsVsSystemVisible { get; private set; }
|
|
[Reactive] public bool IsNes20 { get; private set; }
|
|
|
|
[Reactive] public Enum[]? AvailableSystemTypes { get; private set; } = null;
|
|
[Reactive] public Enum[]? AvailableTimings { get; private set; } = null;
|
|
|
|
[Reactive] public string HeaderBytes { get; private set; } = "";
|
|
[Reactive] public string ErrorMessage { get; private set; } = "";
|
|
|
|
private RomInfo _romInfo;
|
|
|
|
public NesHeaderEditViewModel()
|
|
{
|
|
byte[] headerBytes = new byte[16];
|
|
_romInfo = EmuApi.GetRomInfo();
|
|
string romPath = _romInfo.RomPath;
|
|
try {
|
|
//TODOv2, get header from core (to support for patches, etc.)
|
|
using(FileStream? fileStream = FileHelper.OpenRead(romPath)) {
|
|
if(fileStream != null) {
|
|
fileStream.Read(headerBytes, 0, 16);
|
|
}
|
|
}
|
|
} catch { }
|
|
|
|
Header = NesHeader.FromBytes(headerBytes);
|
|
|
|
AddDisposable(this.WhenAnyValue(x => x.Header.SaveRam, x => x.Header.ChrRamBattery).Subscribe(x => {
|
|
IsBatteryCheckboxEnabled = Header.SaveRam == MemorySizes.None && Header.ChrRamBattery == MemorySizes.None;
|
|
if(!IsBatteryCheckboxEnabled) {
|
|
Header.HasBattery = true;
|
|
}
|
|
}));
|
|
|
|
AddDisposable(this.WhenAnyValue(x => x.Header.System, x => x.Header.FileType).Subscribe(x => {
|
|
bool isVsSystem = Header.System == TvSystem.VsSystem;
|
|
IsVsSystemVisible = isVsSystem && Header.FileType == NesFileType.Nes2_0;
|
|
if(!IsVsSystemVisible) {
|
|
Header.VsPpu = VsPpuType.RP2C03B;
|
|
Header.VsSystem = VsSystemType.Default;
|
|
}
|
|
}));
|
|
|
|
AddDisposable(this.WhenAnyValue(x => x.Header.FileType).Subscribe(x => {
|
|
IsNes20 = Header.FileType == NesFileType.Nes2_0;
|
|
|
|
if(IsNes20) {
|
|
AvailableSystemTypes = null;
|
|
AvailableTimings = null;
|
|
} else {
|
|
AvailableSystemTypes = new Enum[] { TvSystem.NesFamicomDendy, TvSystem.VsSystem, TvSystem.Playchoice };
|
|
AvailableTimings = new Enum[] { FrameTiming.Ntsc, FrameTiming.Pal, FrameTiming.NtscAndPal };
|
|
|
|
Header.SubmapperId = 0;
|
|
Header.ChrRam = MemorySizes.None;
|
|
Header.ChrRamBattery = MemorySizes.None;
|
|
Header.SaveRam = MemorySizes.None;
|
|
Header.WorkRam = MemorySizes.None;
|
|
}
|
|
}));
|
|
|
|
Header.PropertyChanged += Header_PropertyChanged;
|
|
UpdateHeaderPreview();
|
|
}
|
|
|
|
protected override void DisposeView()
|
|
{
|
|
base.DisposeView();
|
|
Header.PropertyChanged -= Header_PropertyChanged;
|
|
}
|
|
|
|
private void Header_PropertyChanged(object? sender, System.ComponentModel.PropertyChangedEventArgs e)
|
|
{
|
|
UpdateHeaderPreview();
|
|
ErrorMessage = GetErrorMessage();
|
|
}
|
|
|
|
private void UpdateHeaderPreview()
|
|
{
|
|
byte[] headerBytes = Header.ToBytes();
|
|
StringBuilder sb = new();
|
|
for(int i = 0; i < 16; i++) {
|
|
sb.Append(headerBytes[i].ToString("X2") + " ");
|
|
}
|
|
HeaderBytes = sb.ToString().Trim();
|
|
}
|
|
|
|
private string GetErrorMessage()
|
|
{
|
|
bool isValidPrgSize = Header.FileType == NesFileType.Nes2_0 && NesHeader.IsValidSize(Header.PrgRom);
|
|
bool isValidChrSize = Header.FileType == NesFileType.Nes2_0 && NesHeader.IsValidSize(Header.ChrRom);
|
|
if(!isValidPrgSize && (Header.PrgRom % 16) != 0) {
|
|
return "Error: PRG ROM size must be a multiple of 16 KB";
|
|
} if(!isValidChrSize && (Header.ChrRom % 8) != 0) {
|
|
return "Error: CHR ROM size must be a multiple of 8 KB";
|
|
}
|
|
|
|
if(Header.FileType == NesFileType.Nes2_0) {
|
|
if(Header.MapperId >= 4096) {
|
|
return "Error: Mapper ID must be lower than 4096";
|
|
}
|
|
if(Header.SubmapperId >= 16) {
|
|
return "Error: Submapper ID must be lower than 16";
|
|
}
|
|
if(!isValidChrSize && Header.ChrRom >= 16384) {
|
|
return "Error: CHR ROM size must be lower than 16384 KB";
|
|
}
|
|
if(!isValidPrgSize && Header.PrgRom >= 32768) {
|
|
return "Error: PRG ROM size must be lower than 32768 KB";
|
|
}
|
|
} else {
|
|
if(Header.MapperId >= 256) {
|
|
return "Error: Mapper ID must be lower than 256 ";
|
|
}
|
|
if(Header.ChrRom >= 2048) {
|
|
return "Error: CHR ROM size must be lower than 2048 KB";
|
|
}
|
|
if(Header.PrgRom >= 4096) {
|
|
return "Error: PRG ROM size must be lower than 4096 KB";
|
|
}
|
|
}
|
|
|
|
return "";
|
|
}
|
|
|
|
public async Task<bool> Save(Window wnd)
|
|
{
|
|
string? filepath = await FileDialogHelper.SaveFile(Path.GetDirectoryName(_romInfo.RomPath), Path.GetFileName(_romInfo.RomPath), wnd, FileDialogHelper.NesExt);
|
|
if(filepath != null) {
|
|
byte[]? data = FileHelper.ReadAllBytes(_romInfo.RomPath);
|
|
if(data != null) {
|
|
byte[] header = Header.ToBytes();
|
|
for(int i = 0; i < 16; i++) {
|
|
data[i] = header[i];
|
|
}
|
|
return FileHelper.WriteAllBytes(filepath, data);
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public class NesHeader : ViewModelBase
|
|
{
|
|
private static Dictionary<UInt64, int> _validSizeValues = new Dictionary<UInt64, int>();
|
|
|
|
[Reactive] public NesFileType FileType { get; set; }
|
|
|
|
[Reactive] public uint MapperId { get; set; }
|
|
[Reactive] public uint SubmapperId { get; set; }
|
|
|
|
[Reactive] public UInt64 PrgRom { get; set; }
|
|
[Reactive] public UInt64 ChrRom { get; set; }
|
|
|
|
[Reactive] public iNesMirroringType Mirroring { get; set; }
|
|
|
|
[Reactive] public FrameTiming Timing { get; set; }
|
|
[Reactive] public TvSystem System { get; set; }
|
|
[Reactive] public bool HasTrainer { get; set; }
|
|
[Reactive] public bool HasBattery { get; set; }
|
|
[Reactive] public VsPpuType VsPpu { get; set; }
|
|
[Reactive] public VsSystemType VsSystem { get; set; }
|
|
[Reactive] public GameInputType InputType { get; set; }
|
|
|
|
[Reactive] public MemorySizes WorkRam { get; set; } = MemorySizes.None;
|
|
[Reactive] public MemorySizes SaveRam { get; set; } = MemorySizes.None;
|
|
[Reactive] public MemorySizes ChrRam { get; set; } = MemorySizes.None;
|
|
[Reactive] public MemorySizes ChrRamBattery { get; set; } = MemorySizes.None;
|
|
|
|
static NesHeader()
|
|
{
|
|
_validSizeValues = new Dictionary<UInt64, int>();
|
|
for(int i = 0; i < 256; i++) {
|
|
int multiplier = (i & 0x03) * 2 + 1;
|
|
UInt64 value = ((UInt64)1 << (i >> 2)) / 1024;
|
|
_validSizeValues[(UInt64)multiplier * value] = i;
|
|
}
|
|
}
|
|
|
|
public byte[] ToBytes()
|
|
{
|
|
byte[] header = new byte[16];
|
|
header[0] = 0x4E;
|
|
header[1] = 0x45;
|
|
header[2] = 0x53;
|
|
header[3] = 0x1A;
|
|
|
|
UInt64 prgRomValue = PrgRom / 16;
|
|
UInt64 chrRomValue = ChrRom / 8;
|
|
|
|
if(FileType == NesFileType.Nes2_0) {
|
|
if((PrgRom % 16) != 0 || PrgRom >= 32768) {
|
|
if(_validSizeValues.ContainsKey(PrgRom)) {
|
|
//This value is a valid exponent+multiplier combo (NES 2.0 only)
|
|
prgRomValue = ((uint)_validSizeValues[PrgRom] & 0xFF) | 0xF00;
|
|
}
|
|
}
|
|
|
|
if((ChrRom % 8) != 0 || ChrRom >= 16384) {
|
|
if(_validSizeValues.ContainsKey(ChrRom)) {
|
|
//This value is a valid exponent+multiplier combo (NES 2.0 only)
|
|
chrRomValue = ((uint)_validSizeValues[ChrRom] & 0xFF) | 0xF00;
|
|
}
|
|
}
|
|
|
|
//NES 2.0
|
|
header[4] = (byte)(prgRomValue);
|
|
header[5] = (byte)(chrRomValue);
|
|
|
|
header[6] = (byte)(
|
|
((byte)(MapperId & 0x0F) << 4) |
|
|
(byte)Mirroring | (HasTrainer ? 0x04 : 0x00) | (HasBattery ? 0x02 : 0x00)
|
|
);
|
|
|
|
header[7] = (byte)(MapperId & 0xF0);
|
|
|
|
switch(System) {
|
|
case TvSystem.NesFamicomDendy: header[7] |= 0x00; break;
|
|
case TvSystem.VsSystem: header[7] |= 0x01; break;
|
|
case TvSystem.Playchoice: header[7] |= 0x02; break;
|
|
default: header[7] |= 0x03; break;
|
|
}
|
|
|
|
//Enable NES 2.0 header
|
|
header[7] |= 0x08;
|
|
|
|
header[8] = (byte)(((SubmapperId & 0x0F) << 4) | ((MapperId & 0xF00) >> 8));
|
|
header[9] = (byte)(((prgRomValue & 0xF00) >> 8) | ((chrRomValue & 0xF00) >> 4));
|
|
|
|
header[10] = (byte)((byte)WorkRam | ((byte)SaveRam) << 4);
|
|
header[11] = (byte)((byte)ChrRam | ((byte)ChrRamBattery) << 4);
|
|
|
|
header[12] = (byte)Timing;
|
|
|
|
if(System == TvSystem.VsSystem) {
|
|
header[13] = (byte)(((byte)VsPpu & 0x0F) | ((((byte)VsSystem) & 0x0F) << 4));
|
|
} else {
|
|
header[13] = (byte)System;
|
|
}
|
|
header[14] = 0;
|
|
header[15] = (byte)InputType;
|
|
} else {
|
|
//iNES
|
|
if(prgRomValue == 0x100) {
|
|
header[4] = 0;
|
|
} else {
|
|
header[4] = (byte)(prgRomValue);
|
|
}
|
|
header[5] = (byte)(chrRomValue);
|
|
|
|
header[6] = (byte)(
|
|
((byte)(MapperId & 0x0F) << 4) |
|
|
(byte)Mirroring | (HasTrainer ? 0x04 : 0x00) | (HasBattery ? 0x02 : 0x00)
|
|
);
|
|
header[7] = (byte)(
|
|
((byte)MapperId & 0xF0) |
|
|
(byte)(System == TvSystem.VsSystem ? 0x01 : 0x00) | (System == TvSystem.Playchoice ? 0x02 : 0x00)
|
|
);
|
|
|
|
header[8] = 0;
|
|
header[9] = (byte)(Timing == FrameTiming.Pal ? 0x01 : 0x00);
|
|
header[10] = 0;
|
|
header[11] = 0;
|
|
header[12] = 0;
|
|
header[13] = 0;
|
|
header[14] = 0;
|
|
header[15] = 0;
|
|
}
|
|
|
|
return header;
|
|
}
|
|
|
|
public static NesHeader FromBytes(byte[] bytes)
|
|
{
|
|
BinaryHeader binHeader = new BinaryHeader(bytes);
|
|
|
|
NesHeader header = new NesHeader();
|
|
header.FileType = binHeader.GetRomHeaderVersion() == RomHeaderVersion.Nes2_0 ? NesFileType.Nes2_0 : NesFileType.iNes;
|
|
header.PrgRom = (uint)(binHeader.GetPrgSize());
|
|
header.ChrRom = (uint)(binHeader.GetChrSize());
|
|
header.HasTrainer = binHeader.HasTrainer();
|
|
header.HasBattery = binHeader.HasBattery();
|
|
|
|
header.System = binHeader.GetTvSystem();
|
|
header.Timing = binHeader.GetFrameTiming();
|
|
|
|
header.Mirroring = binHeader.GetMirroringType();
|
|
header.MapperId = (uint)binHeader.GetMapperID();
|
|
header.SubmapperId = (uint)binHeader.GetSubMapper();
|
|
header.WorkRam = (MemorySizes)binHeader.GetWorkRamSize();
|
|
header.SaveRam = (MemorySizes)binHeader.GetSaveRamSize();
|
|
header.ChrRam = (MemorySizes)binHeader.GetChrRamSize();
|
|
header.ChrRamBattery = (MemorySizes)binHeader.GetSaveChrRamSize();
|
|
header.InputType = binHeader.GetInputType();
|
|
header.VsPpu = (VsPpuType)bytes[13];
|
|
header.VsSystem = binHeader.GetVsSystemType();
|
|
|
|
return header;
|
|
}
|
|
|
|
public static bool IsValidSize(ulong size)
|
|
{
|
|
return _validSizeValues.ContainsKey(size);
|
|
}
|
|
}
|
|
|
|
private class BinaryHeader
|
|
{
|
|
private byte[] _bytes;
|
|
private byte PrgCount;
|
|
private byte ChrCount;
|
|
|
|
public BinaryHeader(byte[] bytes)
|
|
{
|
|
_bytes = bytes;
|
|
PrgCount = bytes[4];
|
|
ChrCount = bytes[5];
|
|
}
|
|
|
|
public RomHeaderVersion GetRomHeaderVersion()
|
|
{
|
|
if((_bytes[7] & 0x0C) == 0x08) {
|
|
return RomHeaderVersion.Nes2_0;
|
|
} else if((_bytes[7] & 0x0C) == 0x00) {
|
|
return RomHeaderVersion.iNes;
|
|
} else {
|
|
return RomHeaderVersion.OldiNes;
|
|
}
|
|
}
|
|
|
|
public int GetMapperID()
|
|
{
|
|
switch(GetRomHeaderVersion()) {
|
|
case RomHeaderVersion.Nes2_0:
|
|
return ((_bytes[8] & 0x0F) << 8) | (_bytes[7] & 0xF0) | (_bytes[6] >> 4);
|
|
default:
|
|
case RomHeaderVersion.iNes:
|
|
return (_bytes[7] & 0xF0) | (_bytes[6] >> 4);
|
|
case RomHeaderVersion.OldiNes:
|
|
return (_bytes[6] >> 4);
|
|
}
|
|
}
|
|
|
|
public bool HasBattery()
|
|
{
|
|
return (_bytes[6] & 0x02) == 0x02;
|
|
}
|
|
|
|
public bool HasTrainer()
|
|
{
|
|
return (_bytes[6] & 0x04) == 0x04;
|
|
}
|
|
|
|
public FrameTiming GetFrameTiming()
|
|
{
|
|
if(GetRomHeaderVersion() == RomHeaderVersion.Nes2_0) {
|
|
return (FrameTiming)(_bytes[12] & 0x03);
|
|
} else if(GetRomHeaderVersion() == RomHeaderVersion.iNes) {
|
|
return (_bytes[9] & 0x01) == 0x01 ? FrameTiming.Pal : FrameTiming.Ntsc;
|
|
}
|
|
return FrameTiming.Ntsc;
|
|
}
|
|
|
|
public TvSystem GetTvSystem()
|
|
{
|
|
if(GetRomHeaderVersion() == RomHeaderVersion.Nes2_0) {
|
|
switch(_bytes[7] & 0x03) {
|
|
case 0: return TvSystem.NesFamicomDendy;
|
|
case 1: return TvSystem.VsSystem;
|
|
case 2: return TvSystem.Playchoice;
|
|
case 3: return (TvSystem)_bytes[13];
|
|
}
|
|
} else if(GetRomHeaderVersion() == RomHeaderVersion.iNes) {
|
|
if((_bytes[7] & 0x01) == 0x01) {
|
|
return TvSystem.VsSystem;
|
|
} else if((_bytes[7] & 0x02) == 0x02) {
|
|
return TvSystem.Playchoice;
|
|
}
|
|
}
|
|
return TvSystem.NesFamicomDendy;
|
|
}
|
|
|
|
private UInt64 GetSizeValue(int exponent, int multiplier)
|
|
{
|
|
multiplier = multiplier * 2 + 1;
|
|
return (UInt64)multiplier * (((UInt64)1 << exponent) / 1024);
|
|
}
|
|
|
|
public UInt64 GetPrgSize()
|
|
{
|
|
if(GetRomHeaderVersion() == RomHeaderVersion.Nes2_0) {
|
|
if((_bytes[9] & 0x0F) == 0x0F) {
|
|
return GetSizeValue(PrgCount >> 2, PrgCount & 0x03);
|
|
} else {
|
|
return (UInt64)(((_bytes[9] & 0x0F) << 8) | PrgCount) * 16;
|
|
}
|
|
} else {
|
|
if(PrgCount == 0) {
|
|
return 256 * 16; //0 is a special value and means 256
|
|
} else {
|
|
return (UInt64)PrgCount * 16;
|
|
}
|
|
}
|
|
}
|
|
|
|
public UInt64 GetChrSize()
|
|
{
|
|
if(GetRomHeaderVersion() == RomHeaderVersion.Nes2_0) {
|
|
if((_bytes[9] & 0xF0) == 0xF0) {
|
|
return GetSizeValue(ChrCount >> 2, ChrCount & 0x03);
|
|
} else {
|
|
return (UInt64)(((_bytes[9] & 0xF0) << 4) | ChrCount) * 8;
|
|
}
|
|
} else {
|
|
return (UInt64)ChrCount * 8;
|
|
}
|
|
}
|
|
|
|
public int GetWorkRamSize()
|
|
{
|
|
if(GetRomHeaderVersion() == RomHeaderVersion.Nes2_0) {
|
|
return _bytes[10] & 0x0F;
|
|
} else {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
public int GetSaveRamSize()
|
|
{
|
|
if(GetRomHeaderVersion() == RomHeaderVersion.Nes2_0) {
|
|
return (_bytes[10] & 0xF0) >> 4;
|
|
} else {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
public int GetChrRamSize()
|
|
{
|
|
if(GetRomHeaderVersion() == RomHeaderVersion.Nes2_0) {
|
|
return _bytes[11] & 0x0F;
|
|
} else {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
public int GetSaveChrRamSize()
|
|
{
|
|
if(GetRomHeaderVersion() == RomHeaderVersion.Nes2_0) {
|
|
return (_bytes[11] & 0xF0) >> 4;
|
|
} else {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
public int GetSubMapper()
|
|
{
|
|
if(GetRomHeaderVersion() == RomHeaderVersion.Nes2_0) {
|
|
return (_bytes[8] & 0xF0) >> 4;
|
|
} else {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
public iNesMirroringType GetMirroringType()
|
|
{
|
|
if((_bytes[6] & 0x08) != 0) {
|
|
return iNesMirroringType.FourScreens;
|
|
} else {
|
|
return (_bytes[6] & 0x01) != 0 ? iNesMirroringType.Vertical : iNesMirroringType.Horizontal;
|
|
}
|
|
}
|
|
|
|
public GameInputType GetInputType()
|
|
{
|
|
if(GetRomHeaderVersion() == RomHeaderVersion.Nes2_0) {
|
|
if(_bytes[15] < Enum.GetValues<GameInputType>().Length) {
|
|
return (GameInputType)_bytes[15];
|
|
}
|
|
return GameInputType.Unspecified;
|
|
} else {
|
|
return GameInputType.Unspecified;
|
|
}
|
|
}
|
|
|
|
public VsSystemType GetVsSystemType()
|
|
{
|
|
if(GetRomHeaderVersion() == RomHeaderVersion.Nes2_0) {
|
|
if((_bytes[13] >> 4) <= 0x06) {
|
|
return (VsSystemType)(_bytes[13] >> 4);
|
|
}
|
|
}
|
|
return VsSystemType.Default;
|
|
}
|
|
}
|
|
|
|
public enum RomHeaderVersion
|
|
{
|
|
iNes = 0,
|
|
Nes2_0 = 1,
|
|
OldiNes = 2
|
|
}
|
|
|
|
public enum NesFileType
|
|
{
|
|
iNes = 0,
|
|
Nes2_0 = 1
|
|
}
|
|
|
|
public enum iNesMirroringType
|
|
{
|
|
Horizontal = 0,
|
|
Vertical = 1,
|
|
FourScreens = 8
|
|
}
|
|
|
|
public enum FrameTiming
|
|
{
|
|
Ntsc = 0,
|
|
Pal = 1,
|
|
NtscAndPal = 2,
|
|
Dendy = 3
|
|
}
|
|
|
|
public enum TvSystem
|
|
{
|
|
NesFamicomDendy,
|
|
VsSystem,
|
|
Playchoice,
|
|
CloneWithDecimal,
|
|
EpsmModule,
|
|
Vt01RedCyan,
|
|
Vt02,
|
|
Vt03,
|
|
Vt09,
|
|
Vt32,
|
|
Vt369,
|
|
UmcUm6578,
|
|
FamicomNetworkSystem,
|
|
ReservedD,
|
|
ReservedE,
|
|
ReservedF
|
|
}
|
|
|
|
public enum MemorySizes
|
|
{
|
|
None = 0,
|
|
_128Bytes = 1,
|
|
_256Bytes = 2,
|
|
_512Bytes = 3,
|
|
_1KB = 4,
|
|
_2KB = 5,
|
|
_4KB = 6,
|
|
_8KB = 7,
|
|
_16KB = 8,
|
|
_32KB = 9,
|
|
_64KB = 10,
|
|
_128KB = 11,
|
|
_256KB = 12,
|
|
_512KB = 13,
|
|
_1024KB = 14,
|
|
Reserved = 15
|
|
}
|
|
|
|
public enum VsPpuType
|
|
{
|
|
RP2C03B = 0,
|
|
RP2C03G = 1,
|
|
RP2C040001 = 2,
|
|
RP2C040002 = 3,
|
|
RP2C040003 = 4,
|
|
RP2C040004 = 5,
|
|
RC2C03B = 6,
|
|
RC2C03C = 7,
|
|
RC2C0501 = 8,
|
|
RC2C0502 = 9,
|
|
RC2C0503 = 10,
|
|
RC2C0504 = 11,
|
|
RC2C0505 = 12,
|
|
ReservedD = 13,
|
|
ReservedE = 14,
|
|
ReservedF = 15
|
|
}
|
|
|
|
public enum VsSystemType
|
|
{
|
|
Default = 0,
|
|
RbiBaseballProtection = 1,
|
|
TkoBoxingProtection = 2,
|
|
SuperXeviousProtection = 3,
|
|
IceClimberProtection = 4,
|
|
VsDualSystem = 5,
|
|
RaidOnBungelingBayProtection = 6,
|
|
}
|
|
|
|
public enum GameInputType
|
|
{
|
|
Unspecified = 0,
|
|
StandardControllers = 1,
|
|
FourScore = 2,
|
|
FourPlayerAdapter = 3,
|
|
VsSystem = 4,
|
|
VsSystemSwapped = 5,
|
|
VsSystemSwapAB = 6,
|
|
VsZapper = 7,
|
|
Zapper = 8,
|
|
TwoZappers = 9,
|
|
BandaiHypershot = 0x0A,
|
|
PowerPadSideA = 0x0B,
|
|
PowerPadSideB = 0x0C,
|
|
FamilyTrainerSideA = 0x0D,
|
|
FamilyTrainerSideB = 0x0E,
|
|
ArkanoidControllerNes = 0x0F,
|
|
ArkanoidControllerFamicom = 0x10,
|
|
DoubleArkanoidController = 0x11,
|
|
KonamiHyperShot = 0x12,
|
|
PachinkoController = 0x13,
|
|
ExcitingBoxing = 0x14,
|
|
JissenMahjong = 0x15,
|
|
PartyTap = 0x16,
|
|
OekaKidsTablet = 0x17,
|
|
BarcodeBattler = 0x18,
|
|
MiraclePiano = 0x19, //not supported yet
|
|
PokkunMoguraa = 0x1A, //not supported yet
|
|
TopRider = 0x1B, //not supported yet
|
|
DoubleFisted = 0x1C, //not supported yet
|
|
Famicom3dSystem = 0x1D, //not supported yet
|
|
DoremikkoKeyboard = 0x1E, //not supported yet
|
|
ROB = 0x1F, //not supported yet
|
|
FamicomDataRecorder = 0x20,
|
|
TurboFile = 0x21,
|
|
BattleBox = 0x22,
|
|
FamilyBasicKeyboard = 0x23,
|
|
Pec586Keyboard = 0x24, //not supported yet
|
|
Bit79Keyboard = 0x25, //not supported yet
|
|
SuborKeyboard = 0x26,
|
|
SuborKeyboardMouse1 = 0x27,
|
|
SuborKeyboardMouse2 = 0x28,
|
|
SnesMouse = 0x29,
|
|
GenericMulticart = 0x2A, //not supported yet
|
|
SnesControllers = 0x2B,
|
|
RacerMateBicycle = 0x2C, //not supported yet
|
|
UForce = 0x2D, //not supported yet
|
|
RobStackUp = 0x2E, //not supported yet
|
|
CityPatrolmanLightgun = 0x2F, //not supported yet
|
|
SharpC1CassetteInterface = 0x30, //not supported yet
|
|
StandardControllerWithSwappedButtons = 0x31, //not supported yet
|
|
ExcaliborSudokuPad = 0x32, //not supported yet
|
|
AblPinball = 0x33, //not supported yet
|
|
GoldenNuggetCasino = 0x34 //not supported yet
|
|
}
|
|
}
|