sin365/AxibugEmuOnline
1
0
Fork 1
Code Issues Pull Requests Projects Releases Wiki Activity
3913595b18
AxibugEmuOnline/AxibugEmuOnline.Client/Assets/VirtualNes.Core/NES.cs

2108 lines
75 KiB
C#
Raw Normal View History

NEScore StateSave机制 实现
2024-08-29 17:20:01 +08:00
using Codice.CM.Client.Differences;
VirtuaNesCore翻译中
2024-07-23 18:31:59 +08:00
using System;
using System.Collections.Generic;
using System.IO;
NEScore StateSave机制 实现
2024-08-29 17:20:01 +08:00
using System.Runtime.ConstrainedExecution;
using System.Runtime.InteropServices.ComTypes;
using System.Security.Cryptography;
翻译中
2024-07-25 11:03:58 +08:00
using System.Text;
NEScore StateSave机制 实现
2024-08-29 17:20:01 +08:00
using UnityEngine;
VirtuaNesCore翻译中
2024-07-23 18:31:59 +08:00
using VirtualNes.Core.Debug;
namespace VirtualNes.Core
{
public class NES
{
123
2024-07-29 09:25:19 +08:00
public const int FETCH_CYCLES = 8;
VirtuaNesCore翻译中
2024-07-23 18:31:59 +08:00
public CPU cpu;
public PPU ppu;
public APU apu;
public ROM rom;
public PAD pad;
public Mapper mapper;
翻译中
2024-07-25 11:03:58 +08:00
public NesConfig nescfg;
VirtuaNesCore翻译中
2024-07-23 18:31:59 +08:00
翻译中
2024-07-25 11:03:58 +08:00
private List<CHEATCODE> m_CheatCode = new List<CHEATCODE>();
迭代
2024-07-26 17:52:33 +08:00
private List<GENIECODE> m_GenieCode = new List<GENIECODE>();
VirtuaNesCore翻译中
2024-07-23 18:31:59 +08:00
private bool m_bDiskThrottle;
private int m_nSnapNo;
private bool m_bNsfPlaying;
迭代
2024-07-26 17:52:33 +08:00
private bool m_bNsfInit;
private int m_nNsfSongNo;
private int m_nNsfSongMode;
VirtuaNesCore翻译中
2024-07-23 18:31:59 +08:00
private bool m_bMoviePlay;
private bool m_bMovieRec;
private Stream m_fpMovie;
迭代中
2024-07-30 11:57:09 +08:00
private uint m_MovieControl;
private int m_MovieStepTotal;
private int m_MovieStep;
VirtuaNesCore翻译中
2024-07-23 18:31:59 +08:00
private bool m_bTapePlay;
private bool m_bTapeRec;
private Stream m_fpTape;
private double m_TapeCycles;
private byte m_TapeIn;
private byte m_TapeOut;
翻译中
2024-07-25 11:03:58 +08:00
// For Barcode
private bool m_bBarcode;
private byte m_BarcodeOut;
private byte m_BarcodePtr;
private int m_BarcodeCycles;
private byte[] m_BarcodeData = new byte[256];
// For Barcode
VirtuaNesCore翻译中
2024-07-23 18:31:59 +08:00
private bool m_bBarcode2;
翻译中
2024-07-25 11:03:58 +08:00
private int m_Barcode2seq;
private int m_Barcode2ptr;
private int m_Barcode2cnt;
private byte m_Barcode2bit;
private byte[] m_Barcode2data = new byte[32];
VirtuaNesCore翻译中
2024-07-23 18:31:59 +08:00
private int m_TurboFileBank;
private int SAVERAM_SIZE;
private int nIRQtype;
private bool bFrameIRQ;
private bool bVideoMode;
翻译中
2024-07-25 11:03:58 +08:00
private int NES_scanline;
private EnumRenderMethod RenderMethod;
private bool bZapper;
迭代中
2024-07-30 11:57:09 +08:00
private int ZapperX;
private int ZapperY;
翻译中
2024-07-25 11:03:58 +08:00
private long base_cycles;
private long emul_cycles;
VirtuaNesCore翻译中
2024-07-23 18:31:59 +08:00
123
2024-07-30 18:53:36 +08:00
// For VS-Unisystem
byte m_VSDipValue;
VSDIPSWITCH[] m_VSDipTable;
迭代中
2024-07-30 11:57:09 +08:00
private byte[] m_PadImg = new byte[226]
{
28, 8,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x0F, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x0F, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x0F, 0x0F, 0x00, 0x00, 0x00, 0x0F, 0x0F, 0x00, 0x00,
0x00, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x0F, 0x0F, 0x0F, 0x0F, 0x00, 0x0F, 0x0F, 0x0F, 0x0F, 0x00,
0x00, 0x00, 0x00, 0x0F, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x0F, 0x0F, 0x0F, 0x00, 0x0F,
0x0F, 0x0F, 0x00, 0x00, 0x0F, 0x0F, 0x0F, 0x0F, 0x00, 0x0F, 0x0F, 0x0F, 0x0F, 0x00,
0x00, 0x00, 0x00, 0x0F, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x0F, 0x0F, 0x0F, 0x00, 0x0F,
0x0F, 0x0F, 0x00, 0x00, 0x00, 0x0F, 0x0F, 0x00, 0x00, 0x00, 0x0F, 0x0F, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
};
private byte[] m_KeyImg0 = new byte[6]
{
2, 2,
0x2A, 0x2A,
0x2A, 0x2A,
};
private byte[] m_KeyImg1 = new byte[8]
{
3, 3,
0x2A, 0x2A, 0x2A,
0x2A, 0x2A, 0x2A,
};
private byte[] m_KeyImg2 = new byte[18]
{
4, 4,
0xFF, 0x2A, 0x2A, 0xFF,
0x2A, 0x2A, 0x2A, 0x2A,
0x2A, 0x2A, 0x2A, 0x2A,
0xFF, 0x2A, 0x2A, 0xFF,
};
private byte[] Font6x8 = new byte[768]
{
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x20,0x20,0x20,0x20,0x20,0x00,0x20,0x00,
0x50,0x50,0x00,0x00,0x00,0x00,0x00,0x00,0x50,0x50,0xF8,0x50,0xF8,0x50,0x50,0x00,
0x20,0x78,0xA0,0x70,0x28,0xF0,0x20,0x00,0x48,0xB0,0x50,0x20,0x50,0x68,0x90,0x00,
0x40,0xA0,0xA8,0x68,0x90,0x90,0x68,0x00,0x30,0x20,0x00,0x00,0x00,0x00,0x00,0x00,
0x10,0x20,0x40,0x40,0x40,0x20,0x10,0x00,0x40,0x20,0x10,0x10,0x10,0x20,0x40,0x00,
0x00,0x88,0x50,0x20,0x50,0x88,0x00,0x00,0x00,0x20,0x20,0xF8,0x20,0x20,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x20,0x40,0x00,0x00,0x00,0x00,0xF8,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x20,0x00,0x08,0x10,0x10,0x20,0x40,0x40,0x80,0x00,
0x70,0x88,0x98,0xA8,0xC8,0x88,0x70,0x00,0x20,0x60,0x20,0x20,0x20,0x20,0xF8,0x00,
0x70,0x88,0x08,0x30,0x40,0x80,0xF8,0x00,0x70,0x88,0x08,0x30,0x08,0x88,0x70,0x00,
0x30,0x50,0x90,0x90,0xF8,0x10,0x10,0x00,0xF8,0x80,0x80,0xF0,0x08,0x08,0xF0,0x00,
0x70,0x88,0x80,0xF0,0x88,0x88,0x70,0x00,0xF8,0x08,0x10,0x10,0x20,0x20,0x20,0x00,
0x70,0x88,0x88,0x70,0x88,0x88,0x70,0x00,0x70,0x88,0x88,0x78,0x08,0x88,0x70,0x00,
0x00,0x20,0x00,0x00,0x00,0x20,0x00,0x00,0x00,0x20,0x00,0x00,0x00,0x20,0x40,0x00,
0x10,0x20,0x40,0x80,0x40,0x20,0x10,0x00,0x00,0x00,0xF8,0x00,0xF8,0x00,0x00,0x00,
0x40,0x20,0x10,0x08,0x10,0x20,0x40,0x00,0x70,0x88,0x08,0x10,0x20,0x00,0x20,0x00,
0x30,0x48,0x88,0x98,0xA8,0xA8,0x78,0x00,0x20,0x50,0x50,0x88,0xF8,0x88,0x88,0x00,
0xF0,0x88,0x88,0xF0,0x88,0x88,0xF0,0x00,0x70,0x88,0x80,0x80,0x80,0x88,0x70,0x00,
0xF0,0x88,0x88,0x88,0x88,0x88,0xF0,0x00,0xF8,0x80,0x80,0xF0,0x80,0x80,0xF8,0x00,
0xF8,0x80,0x80,0xF0,0x80,0x80,0x80,0x00,0x70,0x88,0x80,0xB8,0x88,0x88,0x70,0x00,
0x88,0x88,0x88,0xF8,0x88,0x88,0x88,0x00,0xF8,0x20,0x20,0x20,0x20,0x20,0xF8,0x00,
0x38,0x08,0x08,0x08,0x08,0x88,0x70,0x00,0x88,0x88,0x90,0xE0,0x90,0x88,0x88,0x00,
0x80,0x80,0x80,0x80,0x80,0x80,0xF8,0x00,0x88,0xD8,0xA8,0xA8,0xA8,0xA8,0xA8,0x00,
0x88,0xC8,0xA8,0xA8,0xA8,0x98,0x88,0x00,0x70,0x88,0x88,0x88,0x88,0x88,0x70,0x00,
0xF0,0x88,0x88,0xF0,0x80,0x80,0x80,0x00,0x70,0x88,0x88,0x88,0xA8,0x90,0x68,0x00,
0xF0,0x88,0x88,0xF0,0x88,0x88,0x88,0x00,0x70,0x88,0x80,0x70,0x08,0x88,0x70,0x00,
0xF8,0x20,0x20,0x20,0x20,0x20,0x20,0x00,0x88,0x88,0x88,0x88,0x88,0x88,0x70,0x00,
0x88,0x88,0x88,0x50,0x50,0x50,0x20,0x00,0x88,0xA8,0xA8,0xA8,0xA8,0xD8,0x88,0x00,
0x88,0x88,0x50,0x20,0x50,0x88,0x88,0x00,0x88,0x88,0x88,0x70,0x20,0x20,0x20,0x00,
0xF8,0x08,0x10,0x20,0x40,0x80,0xF8,0x00,0x70,0x40,0x40,0x40,0x40,0x40,0x70,0x00,
0x88,0x50,0xF8,0x20,0xF8,0x20,0x20,0x00,0x70,0x10,0x10,0x10,0x10,0x10,0x70,0x00,
0x20,0x50,0x88,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xF8,0x00,
0x80,0xC0,0xE0,0xF0,0xE0,0xC0,0x80,0x00,0x00,0x00,0x70,0x08,0x78,0x88,0xF8,0x00,
0x80,0x80,0x80,0xF0,0x88,0x88,0xF0,0x00,0x00,0x00,0x78,0x80,0x80,0x80,0x78,0x00,
0x08,0x08,0x08,0x78,0x88,0x88,0x78,0x00,0x00,0x00,0x70,0x88,0xF8,0x80,0x78,0x00,
0x18,0x20,0xF8,0x20,0x20,0x20,0x20,0x00,0x00,0x00,0x78,0x88,0x78,0x08,0xF0,0x00,
0x80,0x80,0x80,0xF0,0x88,0x88,0x88,0x00,0x20,0x00,0x20,0x20,0x20,0x20,0x20,0x00,
0x20,0x00,0x20,0x20,0x20,0x20,0xC0,0x00,0x80,0x80,0x88,0x90,0xE0,0x90,0x88,0x00,
0x20,0x20,0x20,0x20,0x20,0x20,0x30,0x00,0x00,0x00,0xF0,0xA8,0xA8,0xA8,0xA8,0x00,
0x00,0x00,0xF0,0x88,0x88,0x88,0x88,0x00,0x00,0x00,0x70,0x88,0x88,0x88,0x70,0x00,
0x00,0x00,0xF0,0x88,0xF0,0x80,0x80,0x00,0x00,0x00,0x78,0x88,0x78,0x08,0x08,0x00,
0x00,0x00,0xB8,0xC0,0x80,0x80,0x80,0x00,0x00,0x00,0x78,0x80,0x70,0x08,0xF0,0x00,
0x20,0x20,0xF8,0x20,0x20,0x20,0x20,0x00,0x00,0x00,0x88,0x88,0x88,0x88,0x70,0x00,
0x00,0x00,0x88,0x88,0x50,0x50,0x20,0x00,0x00,0x00,0x88,0xA8,0xA8,0xD8,0x88,0x00,
0x00,0x00,0x88,0x50,0x20,0x50,0x88,0x00,0x00,0x00,0x88,0x88,0x78,0x08,0xF0,0x00,
0x00,0x00,0xF8,0x08,0x70,0x80,0xF8,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
};
VirtuaNesCore翻译中
2024-07-23 18:31:59 +08:00
public NES(string fname)
{
Debuger.Log("VirtuaNES - CSharpCore\n");
m_bDiskThrottle = false;
m_nSnapNo = 0;
m_bNsfPlaying = false;
m_bMoviePlay = m_bMovieRec = false;
m_fpMovie = null;
m_bTapePlay = m_bTapeRec = false;
m_fpTape = null;
m_TapeCycles = 0d;
m_TapeIn = m_TapeOut = 0;
m_bBarcode2 = false;
m_TurboFileBank = 0;
cpu = null;
ppu = null;
apu = null;
rom = null;
pad = null;
mapper = null;
SAVERAM_SIZE = 8 * 1024;
nIRQtype = 0;
bFrameIRQ = true;
bVideoMode = false;
迭代
2024-07-26 17:52:33 +08:00
nescfg = NesConfig.NESCONFIG_NTSC;
VirtuaNesCore翻译中
2024-07-23 18:31:59 +08:00
CheatInitial();
try
{
Debuger.Log("Allocating CPU...");
cpu = new CPU(this);
Debuger.Log("Allocating PPU...");
ppu = new PPU(this);
virtuaNES core 产生的屏幕数据现在使用Shader进行转换
2024-08-09 15:47:44 +08:00
var screenBuffer = new uint[PPU.SCREEN_WIDTH * PPU.SCREEN_HEIGHT];
迭代中
2024-07-30 11:57:09 +08:00
var colormode = new byte[PPU.SCREEN_HEIGHT];
ppu.SetScreenPtr(screenBuffer, colormode);
VirtuaNesCore翻译中
2024-07-23 18:31:59 +08:00
Debuger.Log("Allocating APU...");
apu = new APU(this);
Debuger.Log("Allocating PAD...");
pad = new PAD(this);
Debuger.Log("Loading ROM Image...");
rom = new ROM(fname);
迭代中
2024-07-30 11:57:09 +08:00
mapper = Mapper.CreateMapper(this, rom.GetMapperNo());
Debuger.Log("OK");
Debuger.Log($"{rom.GetRomName()}");
Debuger.Log($"Mapper : #{rom.GetMapperNo():D3}");
Mapper199修改
2024-08-05 17:46:33 +08:00
Debuger.Log($"PROM-CRC : #{rom.GetPROM_CRC():X2}");
Debuger.Log($"VROM-CRC : #{rom.GetVROM_CRC():X2}");
移除RenderTexutre,调整Resources和StreamAssets目录结构,加上"NES"父目录,以区分不同模拟器,加入ROMDB机制,修改ROM Mapper信息
2024-08-05 18:42:58 +08:00
Debuger.Log($"PRG SIZE : {16 * rom.GetPROM_SIZE():0000}K");
Debuger.Log($"CHR SIZE : {8 * rom.GetVROM_SIZE():0000}K");
迭代中
2024-07-30 11:57:09 +08:00
Debuger.Log($"V MIRROR :{rom.IsVMIRROR()}");
Debuger.Log($"4 SCREEN :{rom.Is4SCREEN()}");
Debuger.Log($"SAVE RAM :{rom.IsSAVERAM()}");
Debuger.Log($"TRAINER :{rom.IsTRAINER()}");
Debuger.Log($"VS-Unisystem :{rom.IsVSUNISYSTEM()}");
NesSub_MemoryInitial();
LoadSRAM();
LoadDISK();
123
2024-07-30 18:53:36 +08:00
{
// Pad<61><64><EFBFBD>饹<EFBFBD>ڤ<EFBFBD><DAA4>ȳ<EFBFBD><C8B3>ڻ<EFBFBD><DABB><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ߥ󥰤<DFA5><F3A5B0A4>W<EFBFBD><57><EFBFBD>ΤǤ<CEA4><C7A4><EFBFBD><EFBFBD><EFBFBD>
uint crc = rom.GetPROM_CRC();
if (
crc == 0xe792de94 // Best Play - Pro Yakyuu (New) (J)
|| crc == 0xf79d684a // Best Play - Pro Yakyuu (Old) (J)
|| crc == 0xc2ef3422 // Best Play - Pro Yakyuu 2 (J)
|| crc == 0x974e8840 // Best Play - Pro Yakyuu '90 (J)
|| crc == 0xb8747abf // Best Play - Pro Yakyuu Special (J)
|| crc == 0x9fa1c11f // Castle Excellent (J)
|| crc == 0x0b0d4d1b // Derby Stallion - Zenkoku Ban (J)
|| crc == 0x728c3d98 // Downtown - Nekketsu Monogatari (J)
|| crc == 0xd68a6f33 // Dungeon Kid (J)
|| crc == 0x3a51eb04 // Fleet Commander (J)
|| crc == 0x7c46998b // Haja no Fuuin (J)
|| crc == 0x7e5d2f1a // Itadaki Street - Watashi no Mise ni Yottette (J)
|| crc == 0xcee5857b // Ninjara Hoi! (J)
|| crc == 0x50ec5e8b // Wizardry - Legacy of Llylgamyn (J)
|| crc == 0x343e9146 // Wizardry - Proving Grounds of the Mad Overlord (J)
|| crc == 0x33d07e45)
{ // Wizardry - The Knight of Diamonds (J)
pad.SetExController(EXCONTROLLER.EXCONTROLLER_TURBOFILE);
}
}
LoadTurboFile();
// VS-Unisystem<65>Υǥե<C7A5><D5A5><EFBFBD><EFBFBD><EFBFBD><EFBFBD>O<EFBFBD><4F>
if (rom.IsVSUNISYSTEM())
{
uint crc = rom.GetPROM_CRC();
m_VSDipValue = 0;
m_VSDipTable = VsUnisystem.vsdip_default;
}
Reset();
// <20><><EFBFBD>`<60><><EFBFBD><EFBFBD><EFBFBD>ФΥǥե<C7A5><D5A5><EFBFBD><EFBFBD>ȥ<EFBFBD><C8A5>ץ<EFBFBD><D7A5><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>O<EFBFBD><4F>(<28>O<EFBFBD><4F><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>r<EFBFBD><72>ʹ<EFBFBD><CAB9><EFBFBD><EFBFBD>)
GameOption.defRenderMethod = (int)GetRenderMethod();
GameOption.defIRQtype = GetIrqType();
GameOption.defFrameIRQ = GetFrameIRQmode();
GameOption.defVideoMode = GetVideoMode();
// <20>O<EFBFBD><4F><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>`<60>ɤ<EFBFBD><C9A4><EFBFBD><EFBFBD>O<EFBFBD><4F><EFBFBD><EFBFBD><EFBFBD><EFBFBD>(<28><><EFBFBD><EFBFBD><EFBFBD>ȥ꤬<C8A5>o<EFBFBD><6F><EFBFBD><EFBFBD><EFBFBD>Хǥե<C7A5><D5A5><EFBFBD><EFBFBD>Ȥ<EFBFBD><C8A4><EFBFBD><EFBFBD><EFBFBD>)
if (rom.GetMapperNo() != 20)
{
GameOption.Load(rom.GetPROM_CRC());
}
else
{
GameOption.Load(rom.GetGameID(), rom.GetMakerID());
}
SetRenderMethod((EnumRenderMethod)GameOption.nRenderMethod);
SetIrqType((IRQMETHOD)GameOption.nIRQtype);
SetFrameIRQmode(GameOption.bFrameIRQ);
SetVideoMode(GameOption.bVideoMode);
VirtuaNesCore翻译中
2024-07-23 18:31:59 +08:00
}
catch (Exception ex)
{
Debuger.LogError(ex.ToString());
迭代中
2024-07-30 11:57:09 +08:00
throw ex;
}
}
Mapper补全
2024-08-05 11:52:43 +08:00
internal int GetIrqType()
123
2024-07-30 18:53:36 +08:00
{
return nIRQtype;
}
private void LoadTurboFile()
{
MemoryUtility.ZEROMEMORY(MMU.ERAM, MMU.ERAM.Length);
if (pad.GetExController() != (int)EXCONTROLLER.EXCONTROLLER_TURBOFILE)
return;
var fp = Supporter.OpenFile(Supporter.Config.path.szSavePath, "TurboFile.vtf");
try
{
if (fp == null)
{
// xxx <20>ե<EFBFBD><D5A5><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>_<EFBFBD><5F><EFBFBD>ޤ<EFBFBD><DEA4><EFBFBD>
throw new Exception($"Can Not Open File [TurboFile.vtf]");
}
long size = fp.Length;
// <20>ե<EFBFBD><D5A5><EFBFBD><EFBFBD>륵<EFBFBD><EBA5B5><EFBFBD><EFBFBD>ȡ<EFBFBD><C8A1>
if (size > 32 * 1024)
{
size = 32 * 1024;
}
fp.Read(MMU.ERAM, 0, MMU.ERAM.Length);
fp.Close();
}
catch (Exception ex)
{
fp?.Close();
Debuger.LogError($"Loading TurboFile Error.\n{ex}");
}
}
迭代中
2024-07-30 11:57:09 +08:00
private void LoadDISK()
{
//todo : <20>ŵ<EFBFBD><C5B5><EFBFBD><EFBFBD><EFBFBD>ȡ֧<C8A1><D6A7>
}
private void LoadSRAM()
{
if (rom.IsNSF())
return;
MemoryUtility.ZEROMEMORY(MMU.WRAM, MMU.WRAM.Length);
if (!rom.IsSAVERAM())
return;
var saveFileDir = Supporter.Config.path.szSavePath;
var saveFileName = $"{rom.GetRomName()}.sav";
var fp = Supporter.OpenFile(saveFileDir, saveFileName);
try
{
if (fp == null)
{
throw new Exception("not find ram file to read");
}
Debuger.Log("Loading SAVERAM...");
int size = (int)fp.Length;
if (size <= 128 * 1024)
{
fp.Read(MMU.WRAM, 0, size);
}
Debuger.Log("OK.");
fp.Close();
}
catch (Exception ex)
{
fp?.Close();
fp = null;
}
}
private void NesSub_MemoryInitial()
{
int i;
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>N<EFBFBD><4E><EFBFBD>A
MemoryUtility.ZEROMEMORY(MMU.RAM, MMU.RAM.Length);
MemoryUtility.ZEROMEMORY(MMU.WRAM, MMU.WRAM.Length);
MemoryUtility.ZEROMEMORY(MMU.DRAM, MMU.DRAM.Length);
MemoryUtility.ZEROMEMORY(MMU.ERAM, MMU.ERAM.Length);
MemoryUtility.ZEROMEMORY(MMU.XRAM, MMU.XRAM.Length);
MemoryUtility.ZEROMEMORY(MMU.CRAM, MMU.CRAM.Length);
MemoryUtility.ZEROMEMORY(MMU.VRAM, MMU.VRAM.Length);
MemoryUtility.ZEROMEMORY(MMU.SPRAM, MMU.SPRAM.Length);
MemoryUtility.ZEROMEMORY(MMU.BGPAL, MMU.BGPAL.Length);
MemoryUtility.ZEROMEMORY(MMU.SPPAL, MMU.SPPAL.Length);
MemoryUtility.ZEROMEMORY(MMU.CPUREG, MMU.CPUREG.Length);
MemoryUtility.ZEROMEMORY(MMU.PPUREG, MMU.PPUREG.Length);
MMU.FrameIRQ = 0xC0;
MMU.PROM = MMU.VROM = null;
// 0 <20><><EFBFBD>Z<EFBFBD>h<EFBFBD>~<7E>΍<EFBFBD>
MMU.PROM_8K_SIZE = MMU.PROM_16K_SIZE = MMU.PROM_32K_SIZE = 1;
MMU.VROM_1K_SIZE = MMU.VROM_2K_SIZE = MMU.VROM_4K_SIZE = MMU.VROM_8K_SIZE = 1;
// <20>f<EFBFBD>t<EFBFBD>H<EFBFBD><48><EFBFBD>g<EFBFBD>o<EFBFBD><6F><EFBFBD>N<EFBFBD>ݒ<EFBFBD>
for (i = 0; i < 8; i++)
{
MMU.CPU_MEM_BANK[i] = null;
MMU.CPU_MEM_TYPE[i] = MMU.BANKTYPE_ROM;
MMU.CPU_MEM_PAGE[i] = 0;
}
// <20><><EFBFBD><EFBFBD>RAM/WRAM
MMU.SetPROM_Bank(0, MMU.RAM, MMU.BANKTYPE_RAM);
MMU.SetPROM_Bank(3, MMU.WRAM, MMU.BANKTYPE_RAM);
// <20>_<EFBFBD>~<7E>[
MMU.SetPROM_Bank(1, MMU.XRAM, MMU.BANKTYPE_ROM);
MMU.SetPROM_Bank(2, MMU.XRAM, MMU.BANKTYPE_ROM);
for (i = 0; i < 8; i++)
{
MMU.CRAM_USED[i] = 0;
VirtuaNesCore翻译中
2024-07-23 18:31:59 +08:00
}
}
public void CheatInitial()
{
m_CheatCode.Clear();
}
开放模拟器核心帧序号
2024-11-12 09:58:30 +08:00
public uint FrameCount { get; private set; }
翻译中
2024-07-25 11:03:58 +08:00
public void EmulateFrame(bool bDraw)
{
int scanline = 0;
if (rom.IsNSF())
{
EmulateNSF();
return;
}
VirtuaNesCore翻译中
2024-07-23 18:31:59 +08:00
翻译中
2024-07-25 11:03:58 +08:00
CheatCodeProcess();
VirtuaNesCore翻译中
2024-07-23 18:31:59 +08:00
翻译中
2024-07-25 11:03:58 +08:00
NES_scanline = scanline;
图像出现了
2024-07-31 17:40:32 +08:00
bool NotTile = RenderMethod != EnumRenderMethod.TILE_RENDER;
VirtuaNesCore翻译中
2024-07-23 18:31:59 +08:00
翻译中
2024-07-25 11:03:58 +08:00
if (RenderMethod != EnumRenderMethod.TILE_RENDER)
{
bZapper = false;
while (true)
{
ppu.SetRenderScanline(scanline);
if (scanline == 0)
{
if (RenderMethod < EnumRenderMethod.POST_RENDER)
{
EmulationCPU(nescfg.ScanlineCycles);
123
2024-07-29 09:25:19 +08:00
ppu.FrameStart();
ppu.ScanlineNext();
mapper.HSync(scanline);
ppu.ScanlineStart();
}
else
{
EmulationCPU(nescfg.HDrawCycles);
ppu.FrameStart();
ppu.ScanlineNext();
mapper.HSync(scanline);
EmulationCPU(FETCH_CYCLES * 32);
ppu.ScanlineStart();
EmulationCPU(FETCH_CYCLES * 10 + nescfg.ScanlineEndCycles);
翻译中
2024-07-25 11:03:58 +08:00
}
}
123
2024-07-29 09:25:19 +08:00
else if (scanline < 240)
{
迭代中
2024-07-30 11:57:09 +08:00
if (RenderMethod < EnumRenderMethod.POST_RENDER)
{
if (RenderMethod == EnumRenderMethod.POST_ALL_RENDER)
EmulationCPU(nescfg.ScanlineCycles);
if (bDraw)
{
ppu.Scanline(scanline, Supporter.Config.graphics.bAllSprite, Supporter.Config.graphics.bLeftClip);
}
else
{
if (pad.IsZapperMode() && scanline == ZapperY)
{
ppu.Scanline(scanline, Supporter.Config.graphics.bAllSprite, Supporter.Config.graphics.bLeftClip);
}
else
{
if (!ppu.IsSprite0(scanline))
{
ppu.DummyScanline(scanline);
}
else
{
ppu.Scanline(scanline, Supporter.Config.graphics.bAllSprite, Supporter.Config.graphics.bLeftClip);
}
}
}
ppu.ScanlineNext(); // <20><><EFBFBD><EFBFBD><EFBFBD>̈ʒu<CA92>Ń<EFBFBD><C583>X<EFBFBD>^<5E>[<5B>n<EFBFBD>͉<EFBFBD><CD89>ʂ<EFBFBD><CA82>Ⴄ
if (RenderMethod == EnumRenderMethod.PRE_ALL_RENDER)
EmulationCPU(nescfg.ScanlineCycles);
mapper.HSync(scanline);
ppu.ScanlineStart();
}
else
{
if (RenderMethod == EnumRenderMethod.POST_RENDER)
EmulationCPU(nescfg.HDrawCycles);
if (bDraw)
{
ppu.Scanline(scanline, Supporter.Config.graphics.bAllSprite, Supporter.Config.graphics.bLeftClip);
}
else
{
if (pad.IsZapperMode() && scanline == ZapperY)
{
ppu.Scanline(scanline, Supporter.Config.graphics.bAllSprite, Supporter.Config.graphics.bLeftClip);
}
else
{
if (!ppu.IsSprite0(scanline))
{
ppu.DummyScanline(scanline);
}
else
{
ppu.Scanline(scanline, Supporter.Config.graphics.bAllSprite, Supporter.Config.graphics.bLeftClip);
}
}
}
if (RenderMethod == EnumRenderMethod.PRE_RENDER)
EmulationCPU(nescfg.HDrawCycles);
ppu.ScanlineNext();
mapper.HSync(scanline);
EmulationCPU(FETCH_CYCLES * 32);
ppu.ScanlineStart();
EmulationCPU(FETCH_CYCLES * 10 + nescfg.ScanlineEndCycles);
}
}
else if (scanline == 240)
{
mapper.VSync();
if (RenderMethod < EnumRenderMethod.POST_RENDER)
{
EmulationCPU(nescfg.ScanlineCycles);
mapper.HSync(scanline);
}
else
{
EmulationCPU(nescfg.HDrawCycles);
mapper.HSync(scanline);
EmulationCPU(nescfg.HBlankCycles);
}
}
else if (scanline <= nescfg.TotalScanlines - 1)
{
pad.VSync();
123
2024-07-29 09:25:19 +08:00
迭代中
2024-07-30 11:57:09 +08:00
// VBLANK<4E><4B><EFBFBD><EFBFBD>
if (scanline == nescfg.TotalScanlines - 1)
{
ppu.VBlankEnd();
}
if (RenderMethod < EnumRenderMethod.POST_RENDER)
{
if (scanline == 241)
{
ppu.VBlankStart();
if ((MMU.PPUREG[0] & PPU.PPU_VBLANK_BIT) != 0)
{
cpu.NMI();
}
}
EmulationCPU(nescfg.ScanlineCycles);
mapper.HSync(scanline);
}
else
{
if (scanline == 241)
{
ppu.VBlankStart();
if ((MMU.PPUREG[0] & PPU.PPU_VBLANK_BIT) != 0)
{
cpu.NMI();
}
}
EmulationCPU(nescfg.HDrawCycles);
mapper.HSync(scanline);
EmulationCPU(nescfg.HBlankCycles);
}
if (scanline == nescfg.TotalScanlines - 1)
{
break;
}
123
2024-07-29 09:25:19 +08:00
}
迭代中
2024-07-30 11:57:09 +08:00
if (pad.IsZapperMode())
{
if (scanline == ZapperY)
bZapper = true;
else
bZapper = false;
}
scanline++;
NES_scanline = scanline;
翻译中
2024-07-25 11:03:58 +08:00
}
}
迭代中
2024-07-30 11:57:09 +08:00
else
{
bZapper = false;
while (true)
{
ppu.SetRenderScanline(scanline);
if (scanline == 0)
{
// <20>_<EFBFBD>~<7E>[<5B>X<EFBFBD>L<EFBFBD><4C><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>C<EFBFBD><43>
// H-Draw (4fetches*32)
EmulationCPU(FETCH_CYCLES * 128);
ppu.FrameStart();
ppu.ScanlineNext();
EmulationCPU(FETCH_CYCLES * 10);
mapper.HSync(scanline);
EmulationCPU(FETCH_CYCLES * 22);
ppu.ScanlineStart();
EmulationCPU(FETCH_CYCLES * 10 + nescfg.ScanlineEndCycles);
}
else if (scanline < 240)
{
// <20>X<EFBFBD>N<EFBFBD><4E><EFBFBD>[<5B><><EFBFBD>`<60><>(Scanline 1<>`239)
if (bDraw)
{
ppu.Scanline(scanline, Supporter.Config.graphics.bAllSprite, Supporter.Config.graphics.bLeftClip);
ppu.ScanlineNext();
EmulationCPU(FETCH_CYCLES * 10);
mapper.HSync(scanline);
EmulationCPU(FETCH_CYCLES * 22);
ppu.ScanlineStart();
EmulationCPU(FETCH_CYCLES * 10 + nescfg.ScanlineEndCycles);
}
else
{
if (pad.IsZapperMode() && scanline == ZapperY)
{
ppu.Scanline(scanline, Supporter.Config.graphics.bAllSprite, Supporter.Config.graphics.bLeftClip);
ppu.ScanlineNext();
EmulationCPU(FETCH_CYCLES * 10);
mapper.HSync(scanline);
EmulationCPU(FETCH_CYCLES * 22);
ppu.ScanlineStart();
EmulationCPU(FETCH_CYCLES * 10 + nescfg.ScanlineEndCycles);
}
else
{
if (!ppu.IsSprite0(scanline))
{
// H-Draw (4fetches*32)
EmulationCPU(FETCH_CYCLES * 128);
ppu.DummyScanline(scanline);
ppu.ScanlineNext();
EmulationCPU(FETCH_CYCLES * 10);
mapper.HSync(scanline);
EmulationCPU(FETCH_CYCLES * 22);
ppu.ScanlineStart();
EmulationCPU(FETCH_CYCLES * 10 + nescfg.ScanlineEndCycles);
}
else
{
ppu.Scanline(scanline, Supporter.Config.graphics.bAllSprite, Supporter.Config.graphics.bLeftClip);
ppu.ScanlineNext();
EmulationCPU(FETCH_CYCLES * 10);
mapper.HSync(scanline);
EmulationCPU(FETCH_CYCLES * 22);
ppu.ScanlineStart();
EmulationCPU(FETCH_CYCLES * 10 + nescfg.ScanlineEndCycles);
}
}
}
}
else if (scanline == 240)
{
// <20>_<EFBFBD>~<7E>[<5B>X<EFBFBD>L<EFBFBD><4C><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>C<EFBFBD><43> (Scanline 240)
mapper.VSync();
EmulationCPU(nescfg.HDrawCycles);
// H-Sync
mapper.HSync(scanline);
EmulationCPU(nescfg.HBlankCycles);
}
else if (scanline <= nescfg.TotalScanlines - 1)
{
pad.VSync();
// VBLANK<4E><4B><EFBFBD><EFBFBD>
if (scanline == nescfg.TotalScanlines - 1)
{
ppu.VBlankEnd();
}
if (scanline == 241)
{
ppu.VBlankStart();
if ((MMU.PPUREG[0] & PPU.PPU_VBLANK_BIT) != 0)
{
cpu.NMI();
}
}
EmulationCPU(nescfg.HDrawCycles);
// H-Sync
mapper.HSync(scanline);
EmulationCPU(nescfg.HBlankCycles);
if (scanline == nescfg.TotalScanlines - 1)
{
break;
}
}
if (pad.IsZapperMode())
{
if (scanline == ZapperY)
bZapper = true;
else
bZapper = false;
}
scanline++;
NES_scanline = scanline;
}
}
if (bDraw)
{
DrawPad();
}
开放模拟器核心帧序号
2024-11-12 09:58:30 +08:00
FrameCount++;
迭代中
2024-07-30 11:57:09 +08:00
}
private void DrawPad()
{
if (m_bMoviePlay)
{
int offset_h = 12;
int offset_v = Supporter.Config.graphics.bAllLine ? (240 - 18) : (240 - 22);
if (Supporter.Config.movie.bPadDisplay)
{
uint dwData = pad.GetSyncData();
for (int i = 0; i < 4; i++)
{
byte Data = (byte)(dwData >> (i * 8));
if ((m_MovieControl & (1 << i)) != 0)
{
DrawBitmap(offset_h, offset_v, m_PadImg);
// KEY
if ((Data & (1 << 4)) != 0) DrawBitmap(offset_h + 3, offset_v + 1, m_KeyImg0); // U
if ((Data & (1 << 5)) != 0) DrawBitmap(offset_h + 3, offset_v + 5, m_KeyImg0); // D
if ((Data & (1 << 6)) != 0) DrawBitmap(offset_h + 1, offset_v + 3, m_KeyImg0); // L
if ((Data & (1 << 7)) != 0) DrawBitmap(offset_h + 5, offset_v + 3, m_KeyImg0); // R
// START,SELECT
if ((Data & (1 << 2)) != 0) DrawBitmap(offset_h + 9, offset_v + 5, m_KeyImg1); // SELECT
if ((Data & (1 << 3)) != 0) DrawBitmap(offset_h + 13, offset_v + 5, m_KeyImg1); // START
// A,B
if ((Data & (1 << 0)) != 0) DrawBitmap(offset_h + 23, offset_v + 3, m_KeyImg2); // A
if ((Data & (1 << 1)) != 0) DrawBitmap(offset_h + 18, offset_v + 3, m_KeyImg2); // B
offset_h += 30;
}
}
}
if (Supporter.Config.movie.bTimeDisplay)
{
// Time display
int t = m_MovieStep;
int h = t / 216000;
t -= h * 216000;
int m = t / 3600;
t -= m * 3600;
int s = t / 60;
t -= s * 60;
string szTemp = $"{h:00}:{m:00}:{s:00}.{t * 100 / 60:00}";
DrawString(256 - 80 + 0, offset_v - 1, szTemp, 0x1F);
DrawString(256 - 80 + 0, offset_v + 1, szTemp, 0x1F);
DrawString(256 - 80 - 1, offset_v + 0, szTemp, 0x1F);
DrawString(256 - 80 + 1, offset_v + 0, szTemp, 0x1F);
DrawString(256 - 80, offset_v, szTemp, 0x30);
}
}
}
internal void DrawString(int x, int y, string str, byte col)
{
foreach (var @char in str)
{
DrawFont(x, y, (byte)@char, col);
x += 6;
}
}
internal void DrawFont(int x, int y, byte chr, byte col)
{
int i;
int pFnt;
int pPtr;
var Scn = ppu.GetScreenPtr();
int pScn = 8;
if (chr < 0x20 || chr > 0x7F)
return;
chr -= 0x20;
pFnt = chr * 8;
pPtr = pScn + (256 + 16) * y + x;
for (i = 0; i < 8; i++)
{
if ((Font6x8[pFnt + i] & 0x80) != 0) Scn[pPtr + 0] = col;
if ((Font6x8[pFnt + i] & 0x40) != 0) Scn[pPtr + 1] = col;
if ((Font6x8[pFnt + i] & 0x20) != 0) Scn[pPtr + 2] = col;
if ((Font6x8[pFnt + i] & 0x10) != 0) Scn[pPtr + 3] = col;
if ((Font6x8[pFnt + i] & 0x08) != 0) Scn[pPtr + 4] = col;
if ((Font6x8[pFnt + i] & 0x04) != 0) Scn[pPtr + 5] = col;
pPtr += (256 + 16);
}
}
private void DrawBitmap(int x, int y, byte[] bitMap)
{
int i, j;
int h, v;
var Scn = ppu.GetScreenPtr();
int pScn = 8 + (256 + 16) * y + x;
int pPtr;
int lpBitmap = 0;
h = bitMap[lpBitmap++];
v = bitMap[lpBitmap++];
for (j = 0; j < v; j++)
{
pPtr = pScn;
for (i = 0; i < h; i++)
{
if (bitMap[lpBitmap] != 0xFF)
{
Scn[pPtr] = bitMap[lpBitmap];
}
lpBitmap++;
pPtr++;
}
pScn += 256 + 16;
}
翻译中
2024-07-25 11:03:58 +08:00
}
VirtuaNesCore翻译中
2024-07-23 18:31:59 +08:00
图像出现了
2024-07-31 17:40:32 +08:00
int CPU_CALL_COUNT = 0;
翻译中
2024-07-25 11:03:58 +08:00
internal void EmulationCPU(int basecycles)
{
int cycles;
base_cycles += basecycles;
cycles = (int)((base_cycles / 12) - emul_cycles);
if (cycles > 0)
{
图像出现了
2024-07-31 17:40:32 +08:00
var cycleAdd = cpu.EXEC(cycles);
emul_cycles += cycleAdd;
翻译中
2024-07-25 11:03:58 +08:00
}
图像出现了
2024-07-31 17:40:32 +08:00
CPU_CALL_COUNT++;
翻译中
2024-07-25 11:03:58 +08:00
}
修复存档问题
2024-11-13 18:42:30 +08:00
public void Reset()
翻译中
2024-07-25 11:03:58 +08:00
{
SaveSRAM();
SaveDISK();
SaveTurboFile();
迭代
2024-07-26 17:52:33 +08:00
// RAM Clear
迭代中
2024-07-30 11:57:09 +08:00
MemoryUtility.ZEROMEMORY(MMU.RAM, MMU.RAM.Length);
迭代
2024-07-26 17:52:33 +08:00
if (rom.GetPROM_CRC() == 0x29401686)
迭代中
2024-07-30 11:57:09 +08:00
{ // Minna no Taabou no Nakayoshi Dai Sakusen(J)
MemoryUtility.memset(MMU.RAM, 0xFF, MMU.RAM.Length);
迭代
2024-07-26 17:52:33 +08:00
}
// RAM set
if (!rom.IsSAVERAM() && rom.GetMapperNo() != 20)
{
迭代中
2024-07-30 11:57:09 +08:00
MemoryUtility.memset(MMU.WRAM, 0xFF, MMU.WRAM.Length);
迭代
2024-07-26 17:52:33 +08:00
}
迭代中
2024-07-30 11:57:09 +08:00
MemoryUtility.ZEROMEMORY(MMU.CRAM, MMU.CRAM.Length);
MemoryUtility.ZEROMEMORY(MMU.VRAM, MMU.VRAM.Length);
迭代
2024-07-26 17:52:33 +08:00
迭代中
2024-07-30 11:57:09 +08:00
MemoryUtility.ZEROMEMORY(MMU.SPRAM, MMU.SPRAM.Length);
MemoryUtility.ZEROMEMORY(MMU.BGPAL, MMU.BGPAL.Length);
MemoryUtility.ZEROMEMORY(MMU.SPPAL, MMU.SPPAL.Length);
迭代
2024-07-26 17:52:33 +08:00
迭代中
2024-07-30 11:57:09 +08:00
MemoryUtility.ZEROMEMORY(MMU.CPUREG, MMU.CPUREG.Length);
MemoryUtility.ZEROMEMORY(MMU.PPUREG, MMU.PPUREG.Length);
迭代
2024-07-26 17:52:33 +08:00
m_bDiskThrottle = false;
SetRenderMethod(EnumRenderMethod.PRE_RENDER);
if (rom.IsPAL())
{
SetVideoMode(true);
}
MMU.PROM = rom.GetPROM();
MMU.VROM = rom.GetVROM();
MMU.PROM_8K_SIZE = rom.GetPROM_SIZE() * 2;
MMU.PROM_16K_SIZE = rom.GetPROM_SIZE();
MMU.PROM_32K_SIZE = rom.GetPROM_SIZE() / 2;
MMU.VROM_1K_SIZE = rom.GetVROM_SIZE() * 8;
MMU.VROM_2K_SIZE = rom.GetVROM_SIZE() * 4;
MMU.VROM_4K_SIZE = rom.GetVROM_SIZE() * 2;
MMU.VROM_8K_SIZE = rom.GetVROM_SIZE();
// <20>f<EFBFBD>t<EFBFBD>H<EFBFBD><48><EFBFBD>g<EFBFBD>o<EFBFBD><6F><EFBFBD>N
if (MMU.VROM_8K_SIZE != 0)
{
MMU.SetVROM_8K_Bank(0);
}
else
{
MMU.SetCRAM_8K_Bank(0);
}
// <20>~<7E><><EFBFBD>[
if (rom.Is4SCREEN())
{
MMU.SetVRAM_Mirror(MMU.VRAM_MIRROR4);
}
else if (rom.IsVMIRROR())
{
MMU.SetVRAM_Mirror(MMU.VRAM_VMIRROR);
}
else
{
MMU.SetVRAM_Mirror(MMU.VRAM_HMIRROR);
}
apu.SelectExSound(0);
ppu.Reset();
mapper.Reset();
// Trainer
if (rom.IsTRAINER())
{
Array.Copy(rom.GetTRAINER(), 0, MMU.WRAM, 0x1000, 512);
}
pad.Reset();
cpu.Reset();
apu.Reset();
if (rom.IsNSF())
{
mapper.Reset();
}
base_cycles = emul_cycles = 0;
}
internal void SetVideoMode(bool bMode)
{
bVideoMode = bMode;
if (!bVideoMode)
{
nescfg = NesConfig.NESCONFIG_NTSC;
}
else
{
nescfg = NesConfig.NESCONFIG_PAL;
}
apu.SoundSetup();
}
图像出现了
2024-07-31 17:40:32 +08:00
VirtuaNesCore翻译中
2024-07-23 18:31:59 +08:00
修复存档问题
2024-11-13 18:42:30 +08:00
public void SoftReset()
翻译中
2024-07-25 11:03:58 +08:00
{
迭代
2024-07-26 17:52:33 +08:00
pad.Reset();
cpu.Reset();
apu.Reset();
if (rom.IsNSF())
{
mapper.Reset();
}
m_bDiskThrottle = false;
base_cycles = emul_cycles = 0;
翻译中
2024-07-25 11:03:58 +08:00
}
internal void EmulateNSF()
{
迭代
2024-07-26 17:52:33 +08:00
R6502 reg = null;
ppu.Reset();
mapper.VSync();
//DEBUGOUT( "Frame\n" );
if (m_bNsfPlaying)
{
if (m_bNsfInit)
{
迭代中
2024-07-30 11:57:09 +08:00
MemoryUtility.ZEROMEMORY(MMU.RAM, MMU.RAM.Length);
迭代
2024-07-26 17:52:33 +08:00
if ((rom.GetNsfHeader().ExtraChipSelect & 0x04) == 0)
{
MemoryUtility.ZEROMEMORY(MMU.RAM, 0x2000);
}
apu.Reset();
apu.Write(0x4015, 0x0F);
apu.Write(0x4017, 0xC0);
apu.ExWrite(0x4080, 0x80); // FDS Volume 0
apu.ExWrite(0x408A, 0xE8); // FDS Envelope Speed
cpu.GetContext(ref reg);
reg.PC = 0x4710; // Init Address
reg.A = (byte)m_nNsfSongNo;
reg.X = (byte)m_nNsfSongMode;
reg.Y = 0;
reg.S = 0xFF;
reg.P = CPU.Z_FLAG | CPU.R_FLAG | CPU.I_FLAG;
// <20><><EFBFBD>S<EFBFBD>΍<EFBFBD><CE8D><EFBFBD><EFBFBD><EFBFBD><EFBFBD>˂Ă<CB82><C482><EFBFBD><EFBFBD>ă<EFBFBD><C483>[<5B>v<EFBFBD><76>(1<>b<EFBFBD><62>)
for (int i = 0; i < nescfg.TotalScanlines * 60; i++)
{
EmulationCPU(nescfg.ScanlineCycles);
cpu.GetContext(ref reg);
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>[<5B>v<EFBFBD>ɓ<EFBFBD><C993><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ƃ<EFBFBD><C682>m<EFBFBD>F<EFBFBD><46><EFBFBD><EFBFBD><EFBFBD>甲<EFBFBD><E794B2><EFBFBD><EFBFBD>
if (reg.PC == 0x4700)
{
break;
}
}
m_bNsfInit = false;
}
cpu.GetContext(ref reg);
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>[<5B>v<EFBFBD>ɓ<EFBFBD><C993><EFBFBD><EFBFBD>Ă<EFBFBD><C482><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Đݒ肷<DD92><E882B7>
if (reg.PC == 0x4700)
{
reg.PC = 0x4720; // Play Address
reg.A = 0;
reg.S = 0xFF;
}
for (int i = 0; i < nescfg.TotalScanlines; i++)
{
EmulationCPU(nescfg.ScanlineCycles);
}
}
else
{
cpu.GetContext(ref reg);
reg.PC = 0x4700; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>[<5B>v
reg.S = 0xFF;
EmulationCPU(nescfg.ScanlineCycles * nescfg.TotalScanlines);
}
翻译中
2024-07-25 11:03:58 +08:00
}
VirtuaNesCore翻译中
2024-07-23 18:31:59 +08:00
翻译中
2024-07-25 11:03:58 +08:00
internal void CheatCodeProcess()
VirtuaNesCore翻译中
2024-07-23 18:31:59 +08:00
{
迭代中
2024-07-30 11:57:09 +08:00
foreach (var it in m_CheatCode)
{
if ((it.enable & CHEATCODE.CHEAT_ENABLE) == 0)
continue;
switch (it.type)
{
case CHEATCODE.CHEAT_TYPE_ALWAYS:
CheatWrite(it.length, it.address, it.data);
break;
case CHEATCODE.CHEAT_TYPE_ONCE:
CheatWrite(it.length, it.address, it.data);
it.enable = 0;
break;
case CHEATCODE.CHEAT_TYPE_GREATER:
if (CheatRead(it.length, it.address) > it.data)
{
CheatWrite(it.length, it.address, it.data);
}
break;
case CHEATCODE.CHEAT_TYPE_LESS:
if (CheatRead(it.length, it.address) < it.data)
{
CheatWrite(it.length, it.address, it.data);
}
break;
}
}
}
private uint CheatRead(byte length, ushort addr)
{
uint data = 0;
for (int i = 0; i <= length; i++)
{
data |= (uint)(Read((ushort)(addr + i)) * (1 << (i * 8)));
}
return data;
}
private void CheatWrite(int length, ushort addr, uint data)
{
for (int i = 0; i <= length; i++)
{
Write((ushort)(addr + i), (byte)(data & 0xFF));
data >>= 8;
}
翻译中
2024-07-25 11:03:58 +08:00
}
public void Dispose()
{
cpu?.Dispose();
ppu?.Dispose();
apu?.Dispose();
pad?.Dispose();
rom?.Dispose();
}
private void SaveSRAM()
{
int i;
if (rom.IsNSF()) return;
if (rom.IsSAVERAM()) return;
for (i = 0; i < SAVERAM_SIZE; i++)
{
迭代
2024-07-26 17:52:33 +08:00
if (MMU.WRAM[i] != 0x00)
翻译中
2024-07-25 11:03:58 +08:00
break;
}
if (i < SAVERAM_SIZE)
{
var romName = rom.GetRomName();
Debuger.Log($"Saving SAVERAM...[{romName}]");
迭代
2024-07-26 17:52:33 +08:00
Supporter.SaveSRAMToFile(MMU.WRAM, romName);
翻译中
2024-07-25 11:03:58 +08:00
}
}
private void SaveDISK()
{
if (rom.GetMapperNo() != 20)
return;
int i = 0;
Stream fp = null;
DISKFILEHDR ifh;
byte[] lpDisk = rom.GetPROM();
byte[] lpWrite = rom.GetDISK();
long DiskSize = 16 + 65500 * rom.GetDiskNo();
ulong data;
try
VirtuaNesCore翻译中
2024-07-23 18:31:59 +08:00
{
翻译中
2024-07-25 11:03:58 +08:00
ifh = new DISKFILEHDR();
ifh.ID = ASCIIEncoding.ASCII.GetBytes("VirtuaNES DI");
ifh.BlockVersion = 0x0210;
ifh.ProgID = rom.GetGameID();
ifh.MakerID = (ushort)rom.GetMakerID();
ifh.DiskNo = (ushort)rom.GetDiskNo();
for (i = 16; i < DiskSize; i++)
{
if (lpWrite[i] > 0)
ifh.DifferentSize++;
}
if (ifh.DifferentSize == 0)
return;
List<byte> contents = new List<byte>();
contents.AddRange(ifh.ToBytes());
for (i = 16; i < DiskSize; i++)
{
if (lpWrite[i] > 0)
{
data = (ulong)(i & 0x00FFFFFF);
data |= ((ulong)lpDisk[i] & 0xFF) << 24;
contents.AddRange(BitConverter.GetBytes(data));
}
}
Supporter.SaveDISKToFile(contents.ToArray(), rom.GetRomName());
}
catch (Exception ex)
{
Debuger.LogError(ex.ToString());
}
}
private void SaveTurboFile()
{
迭代中
2024-07-30 11:57:09 +08:00
int i;
if (pad.GetExController() != (int)EXCONTROLLER.EXCONTROLLER_TURBOFILE)
return;
for (i = 0; i < MMU.ERAM.Length; i++)
{
if (MMU.ERAM[i] != 0x00)
break;
}
if (i < MMU.ERAM.Length)
{
Debuger.Log("Saving TURBOFILE...");
Supporter.SaveFile(MMU.ERAM, Supporter.Config.path.szSavePath, "TurboFile.vtf");
}
翻译中
2024-07-25 11:03:58 +08:00
}
internal void Clock(int cycles)
{
Tape(cycles);
Barcode(cycles);
}
private void Barcode(int cycles)
{
if (m_bBarcode)
VirtuaNesCore翻译中
2024-07-23 18:31:59 +08:00
{
翻译中
2024-07-25 11:03:58 +08:00
m_BarcodeCycles += cycles;
if (m_BarcodeCycles > 1000)
{
m_BarcodeCycles = 0;
// <20><><EFBFBD>~<7E>H
if (m_BarcodeData[m_BarcodePtr] != 0xFF)
{
m_BarcodeOut = m_BarcodeData[m_BarcodePtr++];
}
else
{
m_bBarcode = false;
m_BarcodeOut = 0;
Debuger.Log("Barcode data trasnfer complete!!");
if (!(IsTapePlay() || IsTapeRec()))
{
cpu.SetClockProcess(false);
}
}
}
}
}
public bool IsTapeRec()
{
return m_bTapeRec;
}
public bool IsTapePlay()
{
return m_bTapePlay;
}
internal void Tape(int cycles)
{
迭代中
2024-07-30 11:57:09 +08:00
if (!(IsTapePlay() || IsTapeRec()))
{
return;
}
if ((m_TapeCycles -= (double)cycles) > 0)
return;
m_TapeCycles += (nescfg.CpuClock / 32000.0);
merge
2024-08-06 17:50:51 +08:00
// m_TapeCycles += (nescfg.CpuClock / 22050.0); // <20>x<EFBFBD><78><EFBFBD><EFBFBD><EFBFBD>ă_<C483><5F><EFBFBD><EFBFBD><EFBFBD>ۂ<EFBFBD>
迭代中
2024-07-30 11:57:09 +08:00
if (m_bTapePlay)
{
int data = m_fpTape.ReadByte();
if (data != -1) //EOF
{
if ((data & 0xFF) >= 0x8C)
{
m_TapeOut = 0x02;
}
else
if ((data & 0xFF) <= 0x74)
{
m_TapeOut = 0x00;
}
}
else
{
TapeStop();
}
}
if (m_bTapeRec)
{
m_fpTape.WriteByte((m_TapeIn & 7) == 7 ? (byte)0x90 : (byte)0x70);
}
}
private void TapeStop()
{
if (!m_bBarcode)
{
cpu.SetClockProcess(false);
}
m_bTapePlay = m_bTapeRec = false;
m_fpTape?.Dispose();
m_fpTape = null;
VirtuaNesCore翻译中
2024-07-23 18:31:59 +08:00
}
翻译中
2024-07-25 14:03:52 +08:00
internal byte Read(ushort addr)
{
switch (addr >> 13)
{
case 0x00: // $0000-$1FFF
return MMU.RAM[addr & 0x07FF];
case 0x01: // $2000-$3FFF
return ppu.Read((ushort)(addr & 0xE007));
case 0x02: // $4000-$5FFF
if (addr < 0x4100)
{
return ReadReg(addr);
}
else
{
return mapper.ReadLow(addr);
}
case 0x03: // $6000-$7FFF
return mapper.ReadLow(addr);
case 0x04: // $8000-$9FFF
case 0x05: // $A000-$BFFF
case 0x06: // $C000-$DFFF
case 0x07: // $E000-$FFFF
123
2024-07-30 18:53:36 +08:00
return MMU.CPU_MEM_BANK[addr >> 13][addr & 0x1FFF];
翻译中
2024-07-25 14:03:52 +08:00
}
迭代中
2024-07-30 11:57:09 +08:00
return 0x00; // Warning<6E>\<5C>h
翻译中
2024-07-25 14:03:52 +08:00
}
private byte ReadReg(ushort addr)
{
switch (addr & 0xFF)
{
case 0x00:
case 0x01:
case 0x02:
case 0x03:
case 0x04:
case 0x05:
case 0x06:
case 0x07:
case 0x08:
case 0x09:
case 0x0A:
case 0x0B:
case 0x0C:
case 0x0D:
case 0x0E:
case 0x0F:
case 0x10:
case 0x11:
case 0x12:
case 0x13:
return apu.Read(addr);
case 0x15:
return apu.Read(addr);
case 0x14:
return (byte)(addr & 0xFF);
case 0x16:
if (rom.IsVSUNISYSTEM())
{
return pad.Read(addr);
}
else
{
return (byte)(pad.Read(addr) | 0x40 | m_TapeOut);
}
case 0x17:
if (rom.IsVSUNISYSTEM())
{
return pad.Read(addr);
}
else
{
return (byte)(pad.Read(addr) | apu.Read(addr));
}
default:
return mapper.ExRead(addr);
}
}
internal byte Barcode2()
{
byte ret = 0x00;
if (!m_bBarcode2 || m_Barcode2seq < 0)
return ret;
switch (m_Barcode2seq)
{
case 0:
m_Barcode2seq++;
m_Barcode2ptr = 0;
ret = 0x04; // d3
break;
case 1:
m_Barcode2seq++;
m_Barcode2bit = m_Barcode2data[m_Barcode2ptr];
m_Barcode2cnt = 0;
ret = 0x04; // d3
break;
case 2:
ret = (byte)((m_Barcode2bit & 0x01) != 0 ? 0x00 : 0x04); // Bit rev.
m_Barcode2bit >>= 1;
if (++m_Barcode2cnt > 7)
{
m_Barcode2seq++;
}
break;
case 3:
if (++m_Barcode2ptr > 19)
{
m_bBarcode2 = false;
m_Barcode2seq = -1;
}
else
{
m_Barcode2seq = 1;
}
break;
default:
break;
}
return ret;
}
图像出现了
2024-07-31 17:40:32 +08:00
public void SetRenderMethod(EnumRenderMethod type)
{
RenderMethod = type;
}
迭代
2024-07-25 18:34:52 +08:00
internal void Write(ushort addr, byte data)
{
switch (addr >> 13)
{
case 0x00: // $0000-$1FFF
MMU.RAM[addr & 0x07FF] = data;
break;
case 0x01: // $2000-$3FFF
if (!rom.IsNSF())
{
ppu.Write((ushort)(addr & 0xE007), data);
}
break;
case 0x02: // $4000-$5FFF
if (addr < 0x4100)
{
WriteReg(addr, data);
}
else
{
迭代
2024-07-26 17:52:33 +08:00
mapper.WriteLow(addr, data);
迭代
2024-07-25 18:34:52 +08:00
}
break;
case 0x03: // $6000-$7FFF
迭代
2024-07-26 17:52:33 +08:00
mapper.WriteLow(addr, data);
迭代
2024-07-25 18:34:52 +08:00
break;
case 0x04: // $8000-$9FFF
case 0x05: // $A000-$BFFF
case 0x06: // $C000-$DFFF
case 0x07: // $E000-$FFFF
迭代
2024-07-26 17:52:33 +08:00
mapper.Write(addr, data);
迭代
2024-07-25 18:34:52 +08:00
GenieCodeProcess();
break;
}
}
迭代
2024-07-26 17:52:33 +08:00
private void GenieCodeProcess()
{
ushort addr;
for (int i = 0; i < m_GenieCode.Count; i++)
{
addr = m_GenieCode[i].address;
if ((addr & 0x8000) != 0)
{
// 8character codes
123
2024-07-30 18:53:36 +08:00
if (MMU.CPU_MEM_BANK[addr >> 13][addr & 0x1FFF] == m_GenieCode[i].cmp)
迭代
2024-07-26 17:52:33 +08:00
{
123
2024-07-30 18:53:36 +08:00
MMU.CPU_MEM_BANK[addr >> 13][addr & 0x1FFF] = m_GenieCode[i].data;
迭代
2024-07-26 17:52:33 +08:00
}
}
else
{
// 6character codes
addr |= 0x8000;
123
2024-07-30 18:53:36 +08:00
MMU.CPU_MEM_BANK[addr >> 13][addr & 0x1FFF] = m_GenieCode[i].data;
迭代
2024-07-26 17:52:33 +08:00
}
}
}
迭代
2024-07-25 18:34:52 +08:00
private void WriteReg(ushort addr, byte data)
{
switch (addr & 0xFF)
{
case 0x00:
case 0x01:
case 0x02:
case 0x03:
case 0x04:
case 0x05:
case 0x06:
case 0x07:
case 0x08:
case 0x09:
case 0x0A:
case 0x0B:
case 0x0C:
case 0x0D:
case 0x0E:
case 0x0F:
case 0x10:
case 0x11:
case 0x12:
case 0x13:
case 0x15:
apu.Write(addr, data);
MMU.CPUREG[addr & 0xFF] = data;
break;
case 0x14:
ppu.DMA(data);
cpu.DMA(514); // DMA Pending cycle
MMU.CPUREG[addr & 0xFF] = data;
break;
case 0x16:
mapper.ExWrite(addr, data); // For VS-Unisystem
pad.Write(addr, data);
迭代
2024-07-26 17:52:33 +08:00
MMU.CPUREG[addr & 0xFF] = data;
迭代
2024-07-25 18:34:52 +08:00
m_TapeIn = data;
break;
case 0x17:
迭代
2024-07-26 17:52:33 +08:00
MMU.CPUREG[addr & 0xFF] = data;
pad.Write(addr, data);
apu.Write(addr, data);
迭代
2024-07-25 18:34:52 +08:00
break;
// VirtuaNES<45>ŗL<C597>|<7C>[<5B>g
case 0x18:
迭代
2024-07-26 17:52:33 +08:00
apu.Write(addr, data);
迭代
2024-07-25 18:34:52 +08:00
break;
default:
迭代
2024-07-26 17:52:33 +08:00
mapper.ExWrite(addr, data);
迭代
2024-07-25 18:34:52 +08:00
break;
}
}
internal bool GetVideoMode()
{
return bVideoMode;
}
internal void SetFrameIRQmode(bool bMode)
{
bFrameIRQ = bMode;
}
internal bool GetFrameIRQmode()
{
return bFrameIRQ;
}
迭代中
2024-07-30 11:57:09 +08:00
internal EnumRenderMethod GetRenderMethod()
{
return RenderMethod;
}
internal void SetIrqType(IRQMETHOD nType)
{
nIRQtype = (int)nType;
}
internal int GetScanline()
{
return NES_scanline;
}
Mapper补全
2024-08-05 11:52:43 +08:00
internal void SetSAVERAM_SIZE(int size)
{
SAVERAM_SIZE = size;
}
internal byte GetBarcodeStatus()
{
return m_BarcodeOut;
}
NEScore StateSave机制 实现
2024-08-29 17:20:01 +08:00
public State GetState()
{
State state = new State();
//HEADER
{
state.HEADER.ID = "VirtuaNES ST";
state.HEADER.BlockVersion = 0x0200;
if (rom.GetMapperNo() != 20)
state.HEADER.Ext0 = rom.GetPROM_CRC();
else
{
state.HEADER.Ext0 = rom.GetGameID();
state.HEADER.Ext1 = (ushort)rom.GetMakerID();
state.HEADER.Ext2 = (ushort)rom.GetDiskNo();
}
}
//REGISTER STATE
{
state.regBLOCK.ID = "REG DATA";
state.regBLOCK.BlockVersion = 0x0210;
state.regBLOCK.BlockSize = state.reg.GetSize();
R6502 R = null;
cpu.GetContext(ref R);
state.reg.cpureg.PC = R.PC;
state.reg.cpureg.A = R.A;
state.reg.cpureg.X = R.X;
state.reg.cpureg.Y = R.Y;
state.reg.cpureg.S = R.S;
state.reg.cpureg.P = R.P;
state.reg.cpureg.I = R.INT_pending;
int cycles = 0;
apu.GetFrameIRQ(ref cycles,
ref state.reg.cpureg.FrameIRQ_count,
ref state.reg.cpureg.FrameIRQ_type,
ref state.reg.cpureg.FrameIRQ,
ref state.reg.cpureg.FrameIRQ_occur);
state.reg.cpureg.FrameIRQ_cycles = cycles; // <20><><EFBFBD>դ<EFBFBD>INT<4E>ʞ飨<CA9E><E9A3A8>
state.reg.cpureg.DMA_cycles = cpu.GetDmaCycles();
state.reg.cpureg.emul_cycles = emul_cycles;
state.reg.cpureg.base_cycles = base_cycles;
// SAVE PPU STATE
state.reg.ppureg.reg0 = MMU.PPUREG[0];
state.reg.ppureg.reg1 = MMU.PPUREG[1];
state.reg.ppureg.reg2 = MMU.PPUREG[2];
state.reg.ppureg.reg3 = MMU.PPUREG[3];
state.reg.ppureg.reg7 = MMU.PPU7_Temp;
state.reg.ppureg.loopy_t = MMU.loopy_t;
state.reg.ppureg.loopy_v = MMU.loopy_v;
state.reg.ppureg.loopy_x = MMU.loopy_x;
state.reg.ppureg.toggle56 = MMU.PPU56Toggle;
}
//RAM STATE
{
state.ram = RAMSTAT.GetDefault();
uint size = 0;
// SAVE RAM STATE
MemoryUtility.memcpy(state.ram.RAM, MMU.RAM, state.ram.RAM.Length);
MemoryUtility.memcpy(state.ram.BGPAL, MMU.BGPAL, state.ram.BGPAL.Length);
MemoryUtility.memcpy(state.ram.SPPAL, MMU.SPPAL, state.ram.SPPAL.Length);
MemoryUtility.memcpy(state.ram.SPRAM, MMU.SPRAM, state.ram.SPRAM.Length);
// S-RAM STATE(ʹ<><CAB9>/δʹ<CEB4>ä<EFBFBD><C3A4>v<EFBFBD><76><EFBFBD>餺<EFBFBD><E9A4BA><EFBFBD>ڤ<EFBFBD><DAA4><EFBFBD><EFBFBD>Х<EFBFBD><D0A5>`<60>֤<EFBFBD><D6A4><EFBFBD>)
if (rom.IsSAVERAM())
{
size = (uint)SAVERAM_SIZE;
}
// Create Header
state.ramBLOCK.ID = "RAM DATA";
state.ramBLOCK.BlockVersion = 0x0100;
state.ramBLOCK.BlockSize = size + state.ram.GetSize();
if (rom.IsSAVERAM())
{
state.WRAM = new byte[SAVERAM_SIZE];
Array.Copy(MMU.WRAM, state.WRAM, SAVERAM_SIZE);
}
}
//BANK STATE
{
state.mmu = MMUSTAT.GetDefault();
uint size = 0;
// SAVE CPU MEMORY BANK DATA
// BANK0,1,2<>ϥХ󥯥<D0A5><F3A5AFA5>`<60>֤<EFBFBD><D6A4>v<EFBFBD>S<EFBFBD>ʤ<EFBFBD>
// VirtuaNES0.30<EFBFBD><EFBFBD><EFBFBD><EFBFBD>
// <20>Х󥯣<D0A5><F3A5AFA3><EFBFBD>SRAMʹ<4D>ä<EFBFBD><C3A4>v<EFBFBD><76><EFBFBD>餺<EFBFBD><E9A4BA><EFBFBD>`<60><>
for (int i = 3; i < 8; i++)
{
state.mmu.CPU_MEM_TYPE[i] = MMU.CPU_MEM_TYPE[i];
state.mmu.CPU_MEM_PAGE[i] = (ushort)MMU.CPU_MEM_PAGE[i];
if (MMU.CPU_MEM_TYPE[i] == MMU.BANKTYPE_RAM
|| MMU.CPU_MEM_TYPE[i] == MMU.BANKTYPE_DRAM)
{
size += 8 * 1024; // 8K BANK
}
}
// SAVE VRAM MEMORY DATA
for (int i = 0; i < 12; i++)
{
state.mmu.PPU_MEM_TYPE[i] = MMU.PPU_MEM_TYPE[i];
state.mmu.PPU_MEM_PAGE[i] = (ushort)MMU.PPU_MEM_PAGE[i];
}
size += 4 * 1024; // 1K BANK x 4 (VRAM)
for (int i = 0; i < 8; i++)
{
state.mmu.CRAM_USED[i] = MMU.CRAM_USED[i];
if (MMU.CRAM_USED[i] != 0)
{
size += 4 * 1024; // 4K BANK
}
}
// Create Header
state.mmuBLOCK.ID = "MMU DATA";
state.mmuBLOCK.BlockVersion = 0x0200;
state.mmuBLOCK.BlockSize = size + state.mmu.GetSize();
state.CPU_MEM_BANK = new List<byte>();
// WRITE CPU RAM MEMORY BANK
for (int i = 3; i < 8; i++)
{
if (state.mmu.CPU_MEM_TYPE[i] != MMU.BANKTYPE_ROM)
{
state.CPU_MEM_BANK.AddRange(MMU.CPU_MEM_BANK[i].Span(0, 8 * 1024).ToArray());
}
}
// WRITE VRAM MEMORY(<28><><EFBFBD><EFBFBD>4K<34>֤<EFBFBD><D6A4>٤ƕ<D9A4><C695><EFBFBD><EFBFBD>z<EFBFBD><7A>)
state.VRAM = new byte[4 * 1024];
Array.Copy(MMU.VRAM, state.VRAM, state.VRAM.Length);
state.CRAM = new List<byte>();
// WRITE CRAM MEMORY
for (int i = 0; i < 8; i++)
{
if (MMU.CRAM_USED[i] != 0)
{
var bytes = new byte[4 * 1024];
Array.Copy(MMU.CRAM, 0x1000 * i, bytes, 0, bytes.Length);
state.CRAM.AddRange(bytes);
}
}
}
// MMC STATE
{
state.mmc = MMCSTAT.GetDefault();
// Create Header
state.mmcBLOCK.ID = "MMC DATA";
state.mmcBLOCK.BlockVersion = 0x0100;
state.mmcBLOCK.BlockSize = state.mmc.GetSize();
if (mapper.IsStateSave())
{
mapper.SaveState(state.mmc.mmcdata);
}
}
//CONTROLLER STATE
{
// Create Header
state.ctrBLOCK.ID = "CTR DATA";
state.ctrBLOCK.BlockVersion = 0x0100;
state.ctrBLOCK.BlockSize = state.ctr.GetSize();
修复bug
2024-11-08 16:23:26 +08:00
state.ctr.pad1bit = 0;
state.ctr.pad2bit = 0;
state.ctr.pad3bit = 0;
state.ctr.pad4bit = 0;
state.ctr.strobe = 0;
NEScore StateSave机制 实现
2024-08-29 17:20:01 +08:00
}
//SND STATE
{
state.snd = SNDSTAT.GetDefault();
// Create Header
state.sndBLOCK.ID = "SND DATA";
state.sndBLOCK.BlockVersion = 0x0100;
state.sndBLOCK.BlockSize = state.snd.GetSize();
StateBuffer buffer = new StateBuffer();
apu.SaveState(buffer);
Array.Copy(buffer.Data.ToArray(), state.snd.snddata, buffer.Data.Count);
}
// DISKIMAGE STATE
if (rom.GetMapperNo() == 20)
{
var lpDisk = rom.GetPROM();
var lpWrite = rom.GetDISK();
int DiskSize = 16 + 65500 * rom.GetDiskNo();
// <20><><EFBFBD>`<60><><EFBFBD>򥫥<EFBFBD><F2A5ABA5><EFBFBD><EFBFBD><EFBFBD>
for (int i = 16; i < DiskSize; i++)
{
if (lpWrite[i] != 0)
state.dsk.DifferentSize++;
}
state.dskBLOCK.ID = "DISKDATA";
state.dskBLOCK.BlockVersion = 0x0210;
state.dskBLOCK.BlockSize = 0;
实现NesCore LoadState和SaveState
2024-09-13 17:39:48 +08:00
state.dskdata = new List<uint>();
NEScore StateSave机制 实现
2024-08-29 17:20:01 +08:00
for (int i = 16; i < DiskSize; i++)
{
if (lpWrite[i] != 0)
{
实现NesCore LoadState和SaveState
2024-09-13 17:39:48 +08:00
uint data = (uint)(i & 0x00FFFFFF);
data |= ((uint)lpDisk[i] & 0xFF) << 24;
state.dskdata.Add(data);
NEScore StateSave机制 实现
2024-08-29 17:20:01 +08:00
}
}
}
// EXCTR STATE
if (pad.GetExController() != 0)
{
state.exctrBLOCK.ID = "EXCTRDAT";
state.exctrBLOCK.BlockVersion = 0x0100;
state.exctrBLOCK.BlockSize = state.exctr.GetSize();
// Some excontrollers will default 0
state.exctr.data = pad.GetSyncExData();
}
return state;
}
public void LoadState(State state)
{
开放模拟器核心帧序号
2024-11-12 09:58:30 +08:00
FrameCount = 0;
实现NesCore LoadState和SaveState
2024-09-13 17:39:48 +08:00
//HEADER
{
state.HEADER.ID = "VirtuaNES ST";
state.HEADER.BlockVersion = 0x0200;
if (rom.GetMapperNo() != 20)
rom.SetPROM_CRC(state.HEADER.Ext0);
else
{
rom.SetGameID(state.HEADER.Ext0);
rom.SetMakerID(state.HEADER.Ext1);
rom.SetDiskNo(state.HEADER.Ext2);
}
}
//REGISTER STATE
{
R6502 R = new R6502();
R.PC = state.reg.cpureg.PC;
R.A = state.reg.cpureg.A;
R.X = state.reg.cpureg.X;
R.Y = state.reg.cpureg.Y;
R.S = state.reg.cpureg.S;
R.P = state.reg.cpureg.P;
R.INT_pending = state.reg.cpureg.I;
cpu.SetContext(R);
apu.SetFrameIRQ(
state.reg.cpureg.FrameIRQ_cycles,
state.reg.cpureg.FrameIRQ_count,
state.reg.cpureg.FrameIRQ_type,
state.reg.cpureg.FrameIRQ,
state.reg.cpureg.FrameIRQ_occur
);
cpu.SetDmaCycles(state.reg.cpureg.DMA_cycles);
emul_cycles = state.reg.cpureg.emul_cycles;
base_cycles = state.reg.cpureg.base_cycles;
// LOAD PPU STATE
MMU.PPUREG[0] = state.reg.ppureg.reg0;
MMU.PPUREG[1] = state.reg.ppureg.reg1;
MMU.PPUREG[2] = state.reg.ppureg.reg2;
MMU.PPUREG[3] = state.reg.ppureg.reg3;
MMU.PPU7_Temp = state.reg.ppureg.reg7;
MMU.loopy_t = state.reg.ppureg.loopy_t;
MMU.loopy_v = state.reg.ppureg.loopy_v;
MMU.loopy_x = state.reg.ppureg.loopy_x;
MMU.PPU56Toggle = state.reg.ppureg.toggle56;
}
//RAM STATE
{
// SAVE RAM STATE
MemoryUtility.memcpy(MMU.RAM, state.ram.RAM, state.ram.RAM.Length);
MemoryUtility.memcpy(MMU.BGPAL, state.ram.BGPAL, state.ram.BGPAL.Length);
MemoryUtility.memcpy(MMU.SPPAL, state.ram.SPPAL, state.ram.SPPAL.Length);
MemoryUtility.memcpy(MMU.SPRAM, state.ram.SPRAM, state.ram.SPRAM.Length);
if (rom.IsSAVERAM())
{
Array.Copy(state.WRAM, MMU.WRAM, SAVERAM_SIZE);
}
}
//BANK STATE
{
// SAVE CPU MEMORY BANK DATA
// BANK0,1,2<>ϥХ󥯥<D0A5><F3A5AFA5>`<60>֤<EFBFBD><D6A4>v<EFBFBD>S<EFBFBD>ʤ<EFBFBD>
// VirtuaNES0.30<EFBFBD><EFBFBD><EFBFBD><EFBFBD>
// <20>Х󥯣<D0A5><F3A5AFA3><EFBFBD>SRAMʹ<4D>ä<EFBFBD><C3A4>v<EFBFBD><76><EFBFBD>餺<EFBFBD><E9A4BA><EFBFBD>`<60><>
修复存档问题
2024-11-13 18:42:30 +08:00
for (byte i = 3; i < 8; i++)
实现NesCore LoadState和SaveState
2024-09-13 17:39:48 +08:00
{
MMU.CPU_MEM_TYPE[i] = state.mmu.CPU_MEM_TYPE[i];
MMU.CPU_MEM_PAGE[i] = state.mmu.CPU_MEM_PAGE[i];
修复存档问题
2024-11-13 18:42:30 +08:00
if (MMU.CPU_MEM_TYPE[i] == MMU.BANKTYPE_ROM)
MMU.SetPROM_8K_Bank(i, MMU.CPU_MEM_PAGE[i]);
else
{
MMU.CPU_MEM_BANK[i].SetArray(state.CPU_MEM_BANK.ToArray(), 0);
}
实现NesCore LoadState和SaveState
2024-09-13 17:39:48 +08:00
}
修复存档问题
2024-11-13 18:42:30 +08:00
// VRAM
MemoryUtility.memcpy(MMU.VRAM, state.VRAM, 4 * 1024);
// CRAM
实现NesCore LoadState和SaveState
2024-09-13 17:39:48 +08:00
for (int i = 0; i < 8; i++)
{
MMU.CRAM_USED[i] = state.mmu.CRAM_USED[i];
}
修复存档问题
2024-11-13 18:42:30 +08:00
// SAVE VRAM MEMORY DATA
for (byte i = 0; i < 12; i++)
{
if (state.mmu.PPU_MEM_TYPE[i] == MMU.BANKTYPE_VROM)
{
MMU.SetVROM_1K_Bank(i, state.mmu.PPU_MEM_PAGE[i]);
}
else if (state.mmu.PPU_MEM_TYPE[i] == MMU.BANKTYPE_CRAM)
{
MMU.SetCRAM_1K_Bank(i, state.mmu.PPU_MEM_PAGE[i]);
}
else if (state.mmu.PPU_MEM_TYPE[i] == MMU.BANKTYPE_VRAM)
{
MMU.SetVRAM_1K_Bank(i, state.mmu.PPU_MEM_PAGE[i]);
}
else
{
throw new Exception("Unknown bank types.");
}
}
实现NesCore LoadState和SaveState
2024-09-13 17:39:48 +08:00
// WRITE CPU RAM MEMORY BANK
int stateStep = 0;
var stateCPU_MEM_BANK = state.CPU_MEM_BANK.ToArray();
for (int i = 3; i < 8; i++)
{
if (state.mmu.CPU_MEM_TYPE[i] != MMU.BANKTYPE_ROM)
{
var sourceData = new Span<byte>(stateCPU_MEM_BANK, stateStep * 8 * 1024, 8 * 1024);
MMU.CPU_MEM_BANK[i].WriteTo(sourceData.ToArray(), 0, 8 * 1024);
stateStep++;
}
}
Array.Copy(state.VRAM, MMU.VRAM, state.VRAM.Length);
NEScore StateSave机制 实现
2024-08-29 17:20:01 +08:00
实现NesCore LoadState和SaveState
2024-09-13 17:39:48 +08:00
stateStep = 0;
var stateCRAM = state.CRAM.ToArray();
// LOAD CRAM MEMORY
for (int i = 0; i < 8; i++)
{
if (MMU.CRAM_USED[i] != 0)
{
var sourceData = stateCRAM.AsSpan(stateStep * 4 * 1024, 4 * 1024).ToArray();
Array.Copy(sourceData, 0, MMU.CRAM, 0x1000 * i, 4 * 1024);
}
}
}
// MMC STATE
{
修复存档问题
2024-11-13 18:42:30 +08:00
mapper.LoadState(state.mmc.mmcdata);
实现NesCore LoadState和SaveState
2024-09-13 17:39:48 +08:00
}
//CONTROLLER STATE
{
pad.pad1bit = state.ctr.pad1bit;
pad.pad2bit = state.ctr.pad2bit;
pad.pad3bit = state.ctr.pad3bit;
pad.pad4bit = state.ctr.pad4bit;
pad.SetStrobe(state.ctr.strobe == 0 ? false : true);
}
//SND STATE
{
var buffer = new StateReader(state.snd.snddata);
apu.LoadState(buffer);
}
// DISKIMAGE STATE
if (rom.GetMapperNo() == 20)
{
var lpDisk = rom.GetPROM();
var lpWrite = rom.GetDISK();
int DiskSize = 16 + 65500 * rom.GetDiskNo();
Array.Clear(lpWrite, 0, DiskSize);
for (int i = 0; i < state.dsk.DifferentSize; i++)
{
var pos = state.dskdata[i];
byte data = (byte)(pos >> 24);
pos &= 0x00FFFFFF;
if (pos >= 16 && pos < DiskSize)
{
lpDisk[pos] = data;
lpWrite[pos] = 0xFF;
}
}
}
// EXCTR STATE
if (pad.GetExController() != 0)
{
pad.SetSyncExData(state.exctr.data);
}
}
internal void SetZapperPos(int x, int y)
{
ZapperX = x; ZapperY = y;
NEScore StateSave机制 实现
2024-08-29 17:20:01 +08:00
}
迭代中
2024-07-30 11:57:09 +08:00
public enum IRQMETHOD
{
IRQ_HSYNC = 0, IRQ_CLOCK = 1
}
迭代
2024-07-25 18:34:52 +08:00
}
VirtuaNesCore翻译中
2024-07-23 18:31:59 +08:00
}
Reference in New Issue Copy Permalink