Merge branch 'master' of http://git.axibug.com/sin365/AxibugEmuOnline

# Conflicts:
#	AxibugEmuOnline.Client/Assets/Script/AppMain/AxiInputSP.Settings/NESMultiKeysSetting.cs
#	AxibugEmuOnline.Client/Assets/Script/AppMain/AxibugEmuOnline.Client.asmdef

.gitignore

@@ -14,6 +14,9 @@
 /AxibugEmuOnline.Client/ProjectSettings/AutoStreamingSettings.asset
 /AxibugEmuOnline.Client/Logs
 
+/AxibugEmuOnline.Client/Assets/AxiProjectTools/AxiNSPack/switch_keys/*.keys
+/AxibugEmuOnline.Client/Assets/AxiProjectTools/AxiNSPack/switch_keys/*.keys.meta
+
 /virtuanessrc097-master
 /AxibugEmuOnline.Server/config.cfg
 /AxibugEmuOnline.Server/bin/

AxibugEmuOnline.Client/Assets/AxiProjectTools/AxiNSPack.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 611bc182f939ea147a72b08613e2d2ba
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

AxibugEmuOnline.Client/Assets/AxiProjectTools/AxiNSPack/Editors.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: cbe37300d75dbd641be2e6dca83a913c
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

AxibugEmuOnline.Client/Assets/AxiProjectTools/AxiNSPack/Editors/AxibugNSPTools.cs

@@ -0,0 +1,329 @@
+#if UNITY_EDITOR_WIN
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Text.RegularExpressions;
+using UnityEditor;
+using UnityEditor.Build.Reporting;
+using UnityEngine;
+
+namespace AxibugEmuOnline.Editors
+{
+    public class AxibugNSPTools : Editor
+    {
+        static string WorkRoot = Path.GetFullPath(Path.Combine(Application.dataPath, "AxiProjectTools/AxiNSPack"));
+        static string switch_keys = Path.GetFullPath(Path.Combine(Application.dataPath, "AxiProjectTools/AxiNSPack/switch_keys"));
+        static string hacpack_root = Path.GetFullPath(Path.Combine(Application.dataPath, "AxiProjectTools/AxiNSPack/hacpack"));
+        static Dictionary<string, string> tools = new Dictionary<string, string>();
+        static string prodKeysPath;
+
+        [MenuItem("Axibug移植工具/Switch/AxibugNSPTools/RepackNSP(仅重新构建NPS）")]
+        static void RepackNSP()
+        {
+            if (!CheckEnvironmentVariable())
+                return;
+
+            string path = EditorUtility.OpenFilePanel(
+                title: "选择 .nsp 文件",
+                directory: Path.Combine(Application.dataPath, ".."), // 默认路径为项目 Assets 目录
+                extension: "nsp" // 限制文件类型为 .nsp
+            );
+
+            if (string.IsNullOrEmpty(path))
+                return;
+
+            RepackNSP(path);
+        }
+
+        [MenuItem("Axibug移植工具/Switch/AxibugNSPTools/Build With RepackNSP(打包NSP并重新构建NPS）")]
+        public static void BuildWithRepackNSP()
+        {
+            if (!CheckEnvironmentVariable())
+                return;
+
+            if (!EditorUtility.DisplayDialog("打包", $"确认打包NSP?", "继续", "取消"))
+                return;
+
+            var levels = new List<string>();
+            foreach (var scene in EditorBuildSettings.scenes)
+            {
+                if (scene.enabled)
+                    levels.Add(scene.path);
+            }
+
+            var buildOpt = EditorUserBuildSettings.development ? BuildOptions.Development : BuildOptions.None;
+            if (EditorUserBuildSettings.buildWithDeepProfilingSupport)
+                buildOpt |= BuildOptions.EnableDeepProfilingSupport;
+            if (EditorUserBuildSettings.allowDebugging)
+                buildOpt |= BuildOptions.AllowDebugging;
+
+            //勾选构建NSP包
+            EditorUserBuildSettings.switchCreateRomFile = true;
+
+#if UNITY_2018_1_OR_NEWER && !UNITY_6000_0_OR_NEWER
+            string titleid = PlayerSettings.Switch.applicationID;
+#else
+            string titleid = "null";
+#endif
+            string targetName = $"{Application.productName}_{titleid}.nsp";
+
+            string _locationPathName = $"Output/NSPBuild/{targetName}";
+            var options = new BuildPlayerOptions
+            {
+                scenes = levels.ToArray(),
+                locationPathName = _locationPathName,
+                target = BuildTarget.Switch,
+                options = buildOpt
+            };
+
+            try
+            {
+                BuildReport report = BuildPipeline.BuildPlayer(options);
+            }
+            catch(Exception ex)
+            {
+                Debug.LogError($"[AxibugNSPTools] Unity Build NSP 错误:{ex.ToString()}");
+                return;
+            }
+
+            string NSPFullPath = Path.GetFullPath(Path.Combine(Application.dataPath, "..", _locationPathName));
+            RepackNSP(NSPFullPath);
+        }
+
+        static bool CheckEnvironmentVariable()
+        {
+            // 获取环境变量（需要添加环境变量检查）
+            string sdkRoot = Environment.GetEnvironmentVariable("NINTENDO_SDK_ROOT");
+            if (string.IsNullOrEmpty(sdkRoot))
+            {
+                Debug.LogError($"[AxibugNSPTools]请先正确配置环境变量:NINTENDO_SDK_ROOT,(若已配置，则保证配置后彻底重启Unity Hub和Unity)");
+                return false;
+            }
+
+            #region 获取prod.keys文件路径
+            prodKeysPath = Path.Combine(
+                switch_keys,
+                "prod.keys"
+            );
+
+            if (!File.Exists(prodKeysPath))
+            {
+                Debug.LogError($"[AxibugNSPTools]未找到 prod.keys! 请先准备文件，path:{prodKeysPath}");
+                return false;
+            }
+            #endregion
+
+            return true;
+        }
+
+        static void RepackNSP(string nspFile)
+        {
+            #region 初始化工具路径
+            // 获取环境变量（需要添加环境变量检查）
+            string sdkRoot = Environment.GetEnvironmentVariable("NINTENDO_SDK_ROOT");
+            tools["authoringTool"] = Path.Combine(sdkRoot, "Tools/CommandLineTools/AuthoringTool/AuthoringTool.exe");
+            tools["hacPack"] = Path.Combine(hacpack_root, "hacpack");
+            #endregion
+
+            #region 处理NSP文件路径
+            string nspFilePath = nspFile;
+            string nspFileName = Path.GetFileName(nspFilePath);
+            string nspParentDir = Path.GetDirectoryName(nspFilePath);
+            #endregion
+
+            #region 提取Title ID
+            string titleID = ExtractTitleID(nspFilePath);
+            if (string.IsNullOrEmpty(titleID))
+            {
+                Debug.LogError($"[AxibugNSPTools]NSP文件名一部分，必须包含TitleID");
+                return;
+            }
+            Debug.Log($"[AxibugNSPTools]Using Title ID: {titleID}");
+            #endregion
+
+            EditorUtility.DisplayProgressBar("AxibugNSPTools", $"清理临时目录", 0);
+            #region 清理临时目录
+            CleanDirectory(Path.Combine(nspParentDir, "repacker_extract"));
+            CleanDirectory(Path.Combine(Path.GetTempPath(), "NCA"));
+            CleanDirectory(Path.Combine(WorkRoot, "hacpack_backup"));
+            #endregion
+
+            EditorUtility.DisplayProgressBar("AxibugNSPTools", $"解包NSP文件", 0.2f);
+            #region 解包NSP文件
+            string extractPath = Path.Combine(nspParentDir, "repacker_extract");
+            ExecuteCommand($"{tools["authoringTool"]} extract -o \"{extractPath}\" \"{nspFilePath}\"");
+
+            string controlPath = null;
+            string programPath = null;
+            FindNACPAndNPDPaths(extractPath, ref controlPath, ref programPath);
+            if (controlPath == null || programPath == null)
+            {
+                Debug.LogError("[AxibugNSPTools] Critical directory structure not found!");
+                return;
+            }
+            #endregion
+
+            #region 重建NCA/NSP
+            string tmpPath = Path.Combine(Path.GetTempPath(), "NCA");
+            EditorUtility.DisplayProgressBar("AxibugNSPTools", $"重建NCA", 0.6f);
+            string programNCA = BuildProgramNCA(tmpPath, titleID, programPath);
+            EditorUtility.DisplayProgressBar("AxibugNSPTools", $"重建NCA", 0.7f);
+            string controlNCA = BuildControlNCA(tmpPath, titleID, controlPath);
+            EditorUtility.DisplayProgressBar("AxibugNSPTools", $"重建NCA", 0.8f);
+            BuildMetaNCA(tmpPath, titleID, programNCA, controlNCA);
+            EditorUtility.DisplayProgressBar("AxibugNSPTools", $"重建NSP", 0.9f);
+            string outputNSP = BuildFinalNSP(nspFilePath, nspParentDir, tmpPath, titleID);
+            EditorUtility.DisplayProgressBar("AxibugNSPTools", $"重建NSP", 1f);
+            Debug.Log($"[AxibugNSPTools]Repacking completed: {outputNSP}");
+            EditorUtility.ClearProgressBar();
+            #endregion
+        }
+
+        #region 辅助方法
+        static string GetUserInput()
+        {
+            Console.Write("Enter the NSP filepath: ");
+            return Console.ReadLine();
+        }
+
+        static string ExtractTitleID(string path)
+        {
+            var match = Regex.Match(path, @"0100[\dA-Fa-f]{12}");
+            return match.Success ? match.Value : null;
+        }
+
+
+        static void CleanDirectory(string path)
+        {
+            if (Directory.Exists(path))
+            {
+                Directory.Delete(path, true);
+                while (Directory.Exists(path)) ; // 等待删除完成
+            }
+        }
+
+        static void FindNACPAndNPDPaths(string basePath, ref string controlPath, ref string programPath)
+        {
+            foreach (var dir in Directory.GetDirectories(basePath))
+            {
+                if (File.Exists(Path.Combine(dir, "fs0/control.nacp")))
+                    controlPath = dir;
+                if (File.Exists(Path.Combine(dir, "fs0/main.npdm")))
+                    programPath = dir;
+            }
+        }
+
+        static string ExecuteCommand(string command)
+        {
+            var process = new System.Diagnostics.Process()
+            {
+                StartInfo = new System.Diagnostics.ProcessStartInfo
+                {
+                    FileName = "cmd.exe",
+                    Arguments = $"/C {command}",
+                    RedirectStandardOutput = true,
+                    RedirectStandardError = true,  // 增加错误流重定向
+                    UseShellExecute = false,
+                    CreateNoWindow = true,
+                    StandardOutputEncoding = Encoding.UTF8,  // 明确指定编码
+                    StandardErrorEncoding = Encoding.UTF8
+                }
+            };
+
+            var outputBuilder = new StringBuilder();
+            var errorBuilder = new StringBuilder();
+
+            // 使用事件处理程序捕获实时输出
+            process.OutputDataReceived += (sender, args) =>
+            {
+                if (!string.IsNullOrEmpty(args.Data))
+                {
+                    outputBuilder.AppendLine(args.Data);
+                    Debug.Log($"[AxibugNSPTools]{args.Data}");
+                }
+            };
+
+            process.ErrorDataReceived += (sender, args) =>
+            {
+                if (!string.IsNullOrEmpty(args.Data))
+                {
+                    errorBuilder.AppendLine(args.Data);
+                    Debug.LogError($"[AxibugNSPTools]{args.Data}");
+                }
+            };
+
+            process.Start();
+
+            // 开始异步读取输出
+            process.BeginOutputReadLine();
+            process.BeginErrorReadLine();
+
+            // 等待进程退出（此时流已关闭）
+            process.WaitForExit();
+
+            // 将错误信息附加到主输出
+            if (errorBuilder.Length > 0)
+            {
+                outputBuilder.AppendLine("\nError Output:");
+                outputBuilder.Append(errorBuilder);
+            }
+
+            return outputBuilder.ToString();
+        }
+        #endregion
+
+        #region NCA构建逻辑
+        static string BuildProgramNCA(string tmpPath, string titleID, string programDir)
+        {
+            string args = $"-k \"{prodKeysPath}\" -o \"{tmpPath}\" --titleid {titleID} " +
+                          $"--type nca --ncatype program --exefsdir \"{programDir}/fs0\" " +
+                          $"--romfsdir \"{programDir}/fs1\" --logodir \"{programDir}/fs2\"";
+
+            string output = ExecuteCommand($"{tools["hacPack"]} {args}");
+            return ParseNCAOutput(output, "Program");
+        }
+
+        static string BuildControlNCA(string tmpPath, string titleID, string controlDir)
+        {
+            string args = $"-k \"{prodKeysPath}\" -o \"{tmpPath}\" --titleid {titleID} " +
+                          $"--type nca --ncatype control --romfsdir \"{controlDir}/fs0\"";
+
+            string output = ExecuteCommand($"{tools["hacPack"]} {args}");
+
+            return ParseNCAOutput(output, "Control");
+        }
+
+        static void BuildMetaNCA(string tmpPath, string titleID, string programNCA, string controlNCA)
+        {
+            string args = $"-k \"{prodKeysPath}\" -o \"{tmpPath}\" --titleid {titleID} " +
+                          $"--type nca --ncatype meta --titletype application " +
+                          $"--programnca \"{programNCA}\" --controlnca \"{controlNCA}\"";
+
+            ExecuteCommand($"{tools["hacPack"]} {args}");
+        }
+
+        static string BuildFinalNSP(string origPath, string parentDir, string tmpPath, string titleID)
+        {
+            string outputPath = origPath.Replace(".nsp", "_repacked.nsp");
+            if (File.Exists(outputPath)) File.Delete(outputPath);
+
+            string args = $"-k \"{prodKeysPath}\" -o \"{parentDir}\" --titleid {titleID} " +
+                          $"--type nsp --ncadir \"{tmpPath}\"";
+
+            ExecuteCommand($"{tools["hacPack"]} {args}");
+            File.Move(Path.Combine(parentDir, $"{titleID}.nsp"), outputPath);
+            return outputPath;
+        }
+
+        static string ParseNCAOutput(string output, string type)
+        {
+            var line = output.Split('\n')
+                .FirstOrDefault(l => l.Contains($"Created {type} NCA:"));
+            return line?.Split(':').Last().Trim();
+        }
+        #endregion
+    }
+}
+#endif

AxibugEmuOnline.Client/Assets/AxiProjectTools/AxiNSPack/Editors/AxibugNSPTools.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 55aa3f0466c30bc4683cdbdc4dd75940

AxibugEmuOnline.Client/Assets/AxiProjectTools/AxiNSPack/hacpack.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: d90c85ddb14ad7e4e9a6242ba135da0b
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

AxibugEmuOnline.Client/Assets/AxiProjectTools/AxiNSPack/hacpack/Tools.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: b31e2ae7250c09548a777d4dcdfe2d1f
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

AxibugEmuOnline.Client/Assets/AxiProjectTools/AxiNSPack/hacpack/Tools/hacPackTools-NACP.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 7be57cd4293e9dc4297ea9b83fe08b18
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

AxibugEmuOnline.Client/Assets/AxiProjectTools/AxiNSPack/hacpack/Tools/hacPackTools-NACP/hptnacp.exe.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: e1252f6d74d67ee48af0a0342aecc981
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

AxibugEmuOnline.Client/Assets/AxiProjectTools/AxiNSPack/hacpack/Tools/hacPackTools-NACP/sample_hbemnu.nacp.xml

@@ -0,0 +1,152 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Application>
+    <Title>
+        <Language>AmericanEnglish</Language>
+        <Name>Homebrew Menu</Name>
+        <Publisher>Yellows8</Publisher>
+    </Title>
+    <Title>
+        <Language>BritishEnglish</Language>
+        <Name>Homebrew Menu</Name>
+        <Publisher>Yellows8</Publisher>
+    </Title>
+    <Title>
+        <Language>Japanese</Language>
+        <Name>Homebrew Menu</Name>
+        <Publisher>Yellows8</Publisher>
+    </Title>
+    <Title>
+        <Language>French</Language>
+        <Name>Homebrew Menu</Name>
+        <Publisher>Yellows8</Publisher>
+    </Title>
+    <Title>
+        <Language>German</Language>
+        <Name>Homebrew Menu</Name>
+        <Publisher>Yellows8</Publisher>
+    </Title>
+    <Title>
+        <Language>LatinAmericanSpanish</Language>
+        <Name>Homebrew Menu</Name>
+        <Publisher>Yellows8</Publisher>
+    </Title>
+    <Title>
+        <Language>Spanish</Language>
+        <Name>Homebrew Menu</Name>
+        <Publisher>Yellows8</Publisher>
+    </Title>
+    <Title>
+        <Language>Italian</Language>
+        <Name>Homebrew Menu</Name>
+        <Publisher>Yellows8</Publisher>
+    </Title>
+    <Title>
+        <Language>Dutch</Language>
+        <Name>Homebrew Menu</Name>
+        <Publisher>Yellows8</Publisher>
+    </Title>
+    <Title>
+        <Language>CanadianFrench</Language>
+        <Name>Homebrew Menu</Name>
+        <Publisher>Yellows8</Publisher>
+    </Title>
+    <Title>
+        <Language>Portuguese</Language>
+        <Name>Homebrew Menu</Name>
+        <Publisher>Yellows8</Publisher>
+    </Title>
+    <Title>
+        <Language>Russian</Language>
+        <Name>Homebrew Menu</Name>
+        <Publisher>Yellows8</Publisher>
+    </Title>
+    <Isbn/>
+    <StartupUserAccount>Required</StartupUserAccount>
+    <UserAccountSwitchLock>Disable</UserAccountSwitchLock>
+    <ParentalControl>None</ParentalControl>
+    <SupportedLanguage>AmericanEnglish</SupportedLanguage>
+    <SupportedLanguage>BritishEnglish</SupportedLanguage>
+    <SupportedLanguage>Japanese</SupportedLanguage>
+    <SupportedLanguage>French</SupportedLanguage>
+    <SupportedLanguage>German</SupportedLanguage>
+    <SupportedLanguage>LatinAmericanSpanish</SupportedLanguage>
+    <SupportedLanguage>Spanish</SupportedLanguage>
+    <SupportedLanguage>Italian</SupportedLanguage>
+    <SupportedLanguage>Dutch</SupportedLanguage>
+    <SupportedLanguage>CanadianFrench</SupportedLanguage>
+    <SupportedLanguage>Russian</SupportedLanguage>
+    <Screenshot>Allow</Screenshot>
+    <VideoCapture>Disable</VideoCapture>
+    <PresenceGroupId>0x0104444444441001</PresenceGroupId>
+    <DisplayVersion>2.0</DisplayVersion>
+    <Rating>
+        <Organization>CERO</Organization>
+        <Age>12</Age>
+    </Rating>
+    <Rating>
+        <Organization>ESRB</Organization>
+        <Age>10</Age>
+    </Rating>
+    <Rating>
+        <Organization>USK</Organization>
+        <Age>12</Age>
+    </Rating>
+    <Rating>
+        <Organization>PEGI</Organization>
+        <Age>12</Age>
+    </Rating>
+    <Rating>
+        <Organization>PEGIPortugal</Organization>
+        <Age>12</Age>
+    </Rating>
+    <Rating>
+        <Organization>PEGIBBFC</Organization>
+        <Age>12</Age>
+    </Rating>
+    <Rating>
+        <Organization>Russian</Organization>
+        <Age>12</Age>
+    </Rating>
+    <Rating>
+        <Organization>ACB</Organization>
+        <Age>13</Age>
+    </Rating>
+    <Rating>
+        <Organization>OFLC</Organization>
+        <Age>13</Age>
+    </Rating>
+    <DataLossConfirmation>Required</DataLossConfirmation>
+    <PlayLogPolicy>All</PlayLogPolicy>
+    <SaveDataOwnerId>0x0104444444441001</SaveDataOwnerId>
+    <UserAccountSaveDataSize>0x0000000003e00000</UserAccountSaveDataSize>
+    <UserAccountSaveDataJournalSize>0x0000000000180000</UserAccountSaveDataJournalSize>
+    <DeviceSaveDataSize>0x0000000000000000</DeviceSaveDataSize>
+    <DeviceSaveDataJournalSize>0x0000000000000000</DeviceSaveDataJournalSize>
+    <BcatDeliveryCacheStorageSize>0x0000000000000000</BcatDeliveryCacheStorageSize>
+    <ApplicationErrorCodeCategory/>
+    <AddOnContentBaseId>0x0104444444442001</AddOnContentBaseId>
+    <LogoType>Nintendo</LogoType>
+    <LocalCommunicationId>0x0104444444441001</LocalCommunicationId>
+    <LogoHandling>Auto</LogoHandling>
+    <SeedForPseudoDeviceId>0x0000000000000000</SeedForPseudoDeviceId>
+    <BcatPassphrase/>
+    <AddOnContentRegistrationType>AllOnLaunch</AddOnContentRegistrationType>
+    <UserAccountSaveDataSizeMax>0x0000000000000000</UserAccountSaveDataSizeMax>
+    <UserAccountSaveDataJournalSizeMax>0x0000000000000000</UserAccountSaveDataJournalSizeMax>
+    <DeviceSaveDataSizeMax>0x0000000000000000</DeviceSaveDataSizeMax>
+    <DeviceSaveDataJournalSizeMax>0x0000000000000000</DeviceSaveDataJournalSizeMax>
+    <TemporaryStorageSize>0x0000000000000000</TemporaryStorageSize>
+    <CacheStorageSize>0x0000000000000000</CacheStorageSize>
+    <CacheStorageJournalSize>0x0000000000000000</CacheStorageJournalSize>
+    <CacheStorageDataAndJournalSizeMax>0x0000000000000000</CacheStorageDataAndJournalSizeMax>
+    <CacheStorageIndexMax>0x0000000000000000</CacheStorageIndexMax>
+    <Hdcp>None</Hdcp>
+    <CrashReport>Deny</CrashReport>
+    <RuntimeAddOnContentInstall>Deny</RuntimeAddOnContentInstall>
+    <PlayLogQueryableApplicationId>0x0000000000000000</PlayLogQueryableApplicationId>
+    <PlayLogQueryCapability>None</PlayLogQueryCapability>
+    <Repair>None</Repair>
+    <Attribute>None</Attribute>
+    <ProgramIndex>0</ProgramIndex>
+    <RequiredNetworkServiceLicenseOnLaunch>None</RequiredNetworkServiceLicenseOnLaunch>
+</Application>

AxibugEmuOnline.Client/Assets/AxiProjectTools/AxiNSPack/hacpack/Tools/hacPackTools-NACP/sample_hbemnu.nacp.xml.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 42c1295c31de3a948825b9e8e9e8184f
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

AxibugEmuOnline.Client/Assets/AxiProjectTools/AxiNSPack/hacpack/hacpack.exe.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 7b1b3ff7954facb409d3ba6f9840f762
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

AxibugEmuOnline.Client/Assets/AxiProjectTools/AxiNSPack/switch_keys.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 409c6e8e5ead0ac4991ea6c243e407dd
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

AxibugEmuOnline.Client/Assets/AxiProjectTools/AxiNSPack/switch_keys/copy prod.keys To here.txt.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 08bd0c8a53daacb4ea23b14dde156354
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

AxibugEmuOnline.Client/Assets/AxiProjectTools/Editors/AxiAutoBuild.cs

@@ -0,0 +1,118 @@
+#if UNITY_EDITOR
+using AxibugEmuOnline.Editors;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using UnityEditor;
+using UnityEditor.Build.Reporting;
+using UnityEngine;
+
+public static class AxiAutoBuild
+{
+    [MenuItem("Axibug移植工具/AutoBuild/Build ALL")]
+    public static void Build_Build_ALL()
+    {
+        Build_Global(BuildTarget.Android);
+        Build_Global(BuildTarget.iOS);
+        Build_Global(BuildTarget.StandaloneWindows);
+        Build_Global(BuildTarget.StandaloneLinux64);
+        Build_Global(BuildTarget.WSAPlayer);
+        AxibugNSPTools.BuildWithRepackNSP();
+    }
+
+    [MenuItem("Axibug移植工具/AutoBuild/Android")]
+    public static void Build_Android()
+    {
+        Build_Global(BuildTarget.Android);
+    }
+
+    [MenuItem("Axibug移植工具/AutoBuild/IOS")]
+    public static void Build_IOS()
+    {
+        Build_Global(BuildTarget.iOS);
+    }
+    [MenuItem("Axibug移植工具/AutoBuild/PC")]
+    public static void Build_PC()
+    {
+        Build_Global(BuildTarget.StandaloneWindows);
+    }
+    [MenuItem("Axibug移植工具/AutoBuild/Linux")]
+    public static void Build_Linux64()
+    {
+        Build_Global(BuildTarget.StandaloneLinux64);
+    }
+    [MenuItem("Axibug移植工具/AutoBuild/UWP")]
+    public static void Build_UWP()
+    {
+        Build_Global(BuildTarget.WSAPlayer);
+    }
+
+    [MenuItem("Axibug移植工具/AutoBuild/EmbeddedLinux")]
+    public static void Build_EmbeddedLinux()
+    {
+        Build_Global(BuildTarget.EmbeddedLinux);
+    }
+
+    [MenuItem("Axibug移植工具/AutoBuild/Switch")]
+    public static void Build_Switch()
+    {
+        AxibugNSPTools.BuildWithRepackNSP();
+    }
+
+
+    public static void Build_Global(BuildTarget target)
+    {
+        if (!EditorUtility.DisplayDialog("打包", $"确认打包{target}?", "继续", "取消"))
+            return;
+
+        var levels = new List<string>();
+        foreach (var scene in EditorBuildSettings.scenes)
+        {
+            if (scene.enabled)
+                levels.Add(scene.path);
+        }
+
+        var buildOpt = EditorUserBuildSettings.development ? BuildOptions.Development : BuildOptions.None;
+        if (EditorUserBuildSettings.buildWithDeepProfilingSupport)
+            buildOpt |= BuildOptions.EnableDeepProfilingSupport;
+        if (EditorUserBuildSettings.allowDebugging)
+            buildOpt |= BuildOptions.AllowDebugging;
+
+        string targetName = $"{Application.productName}_{DateTime.Now.ToString("yyyyMMddHHmmss")}";
+
+        targetName += target switch
+        {
+            BuildTarget.Android => ".apk",
+            BuildTarget.iOS => ".ipa",
+            BuildTarget.StandaloneWindows => ".exe",
+            _ => "",
+        };
+
+
+        string _locationPathName = $"Output/{target}/{targetName}";
+        string FullPath = Path.GetFullPath(Path.Combine(Application.dataPath, "..", _locationPathName));
+        string dirPath = Path.GetDirectoryName(FullPath);
+        if (!Directory.Exists(dirPath))
+            Directory.CreateDirectory(dirPath);
+
+        var options = new BuildPlayerOptions
+        {
+            scenes = levels.ToArray(),
+            locationPathName = _locationPathName,
+            target = target,
+            options = buildOpt
+        };
+
+        try
+        {
+            BuildReport report = BuildPipeline.BuildPlayer(options);
+        }
+        catch (Exception ex)
+        {
+            Debug.LogError($"[AutoBuild] Unity Build {target} 错误:{ex.ToString()}");
+            return;
+        }
+    }
+
+}
+#endif

AxibugEmuOnline.Client/Assets/AxiProjectTools/Editors/AxiAutoBuild.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: e3b8550d3919d1044b50eb20f0c50fb8

AxibugEmuOnline.Client/Assets/AxiProjectTools/Editors/AxiProjectTools.cs

@@ -29,7 +29,7 @@ public class AxiProjectTools : EditorWindow
 		}
 	}
 
-	[MenuItem("Axibug移植工具/[1]采集所有预制体和场景下的UGUI组件")]
+	[MenuItem("Axibug移植工具/ToLowVersionUnity/[1]采集所有预制体和场景下的UGUI组件")]
 	public static void Part1()
 	{
 		GoTAxiProjectToolsSence();
@@ -132,7 +132,7 @@ public class AxiProjectTools : EditorWindow
 #endif
 	}
 
-	[MenuItem("Axibug移植工具/[2]生成中间脚本代码")]
+	[MenuItem("Axibug移植工具/ToLowVersionUnity/[2]生成中间脚本代码")]
 	public static void Part2()
 	{
 		if (UnityEngine.Windows.Directory.Exists(outCsDir))
@@ -161,7 +161,7 @@ public class AxiProjectTools : EditorWindow
 		Debug.Log("<Color=#FFF333>处理完毕  [2]生成中间脚本代码</color>");
 	}
 
-	[MenuItem("Axibug移植工具/[3]收集生成的脚本")]
+	[MenuItem("Axibug移植工具/ToLowVersionUnity/[3]收集生成的脚本")]
 	public static void Part3()
 	{
 		AxiPrefabCache cache = AssetDatabase.LoadAssetAtPath<AxiPrefabCache>(cachecfgPath);
@@ -205,7 +205,7 @@ public class AxiProjectTools : EditorWindow
 	}
 
 
-	[MenuItem("Axibug移植工具/[4]替换所有预制体和场景中的组件")]
+	[MenuItem("Axibug移植工具/ToLowVersionUnity/[4]替换所有预制体和场景中的组件")]
 	public static void Part4()
 	{
 		AxiPrefabCache cache = AssetDatabase.LoadAssetAtPath<AxiPrefabCache>(cachecfgPath);
@@ -259,7 +259,7 @@ public class AxiProjectTools : EditorWindow
 	}
 
 
-	[MenuItem("Axibug移植工具/[5]UnPack所有嵌套预制体和场景中的预制体")]
+	[MenuItem("Axibug移植工具/ToLowVersionUnity/[5]UnPack所有嵌套预制体和场景中的预制体")]
 	public static void UnpackPrefabs()
 	{
 
@@ -350,7 +350,7 @@ public class AxiProjectTools : EditorWindow
 	}
 
 
-	[MenuItem("Axibug移植工具/[6]修复Sprite")]
+	[MenuItem("Axibug移植工具/ToLowVersionUnity/[6]修复Sprite")]
 	public static void FixMultipleMaterialSprites()
 	{
 		string[] guids = AssetDatabase.FindAssets("t:sprite");

AxibugEmuOnline.Client/Assets/Plugins/AxiReplay/FrameProfiler.cs

@@ -34,6 +34,22 @@ namespace AxiReplay
             m_targetFrameRate = targetFrameRate;
         }
 
+        /// <summary>
+        /// 临时方法(暂行）
+        /// </summary>
+        /// <param name="mRemoteForwardCount"></param>
+        /// <returns></returns>
+        /// <exception cref="NotImplementedException"></exception>
+        public int TempFrameCount(int mRemoteForwardCount)
+        {
+            if (mRemoteForwardCount == 0)
+                return 0;
+            if (mRemoteForwardCount < 5)
+                return 1;
+            else
+                return (int)Math.Ceiling(mRemoteForwardCount / 5f);
+        }
+
         void CalcCacheCount()
         {
             double deltaMax = 0;

AxibugEmuOnline.Client/Assets/Plugins/AxiReplay/NetReplay.cs

@@ -103,7 +103,8 @@ namespace AxiReplay
 
 
             //if (targetFrame == mNextReplay.FrameStartID && targetFrame <= mRemoteFrameIdx && mNetReplayQueue.Count > 0)
-            if (targetFrame == mNextReplay.FrameStartID && targetFrame <= mRemoteFrameIdx && mNetReplayQueue.Count >= mRemoteForwardCount)
+            //if (targetFrame == mNextReplay.FrameStartID && targetFrame <= mRemoteFrameIdx && mNetReplayQueue.Count >= mRemoteForwardCount)
+            if (targetFrame == mNextReplay.FrameStartID && targetFrame <= mRemoteFrameIdx && mNetReplayQueue.Count >= frameProfiler.TempFrameCount(mRemoteForwardCount))
             {
                 //当前帧追加
                 mCurrClientFrameIdx = targetFrame;

AxibugEmuOnline.Client/Assets/Plugins/Essgee.Unity/Emulation/Machines/ColecoVision.cs

@@ -5,6 +5,7 @@ using Essgee.Emulation.Configuration;
 using Essgee.Emulation.CPU;
 using Essgee.Emulation.Video;
 using Essgee.EventArguments;
+using Essgee.Metadata;
 using Essgee.Utilities;
 using System;
 using System.Collections.Generic;
@@ -182,7 +183,10 @@ namespace Essgee.Emulation.Machines
 
         private void LoadBios()
         {
-            var (type, bootstrapRomData) = CartridgeLoader.Load(configuration.BiosRom, "ColecoVision BIOS");
+
+            //var (type, bootstrapRomData) = CartridgeLoader.Load(configuration.BiosRom, "ColecoVision BIOS");
+            //直接加载BootStrap
+            GameMetadataHandler.instance.gameMetaReources.GetDatBytes("Bootstrap/[BIOS] ColecoVision (USA, Europe).col", out byte[] bootstrapRomData);
             bios = new ColecoCartridge(bootstrapRomData.Length, 0);
             bios.LoadRom(bootstrapRomData);
         }

AxibugEmuOnline.Client/Assets/Plugins/Essgee.Unity/Emulation/Video/SegaGGVDP.cs

@@ -51,19 +51,11 @@ namespace Essgee.Emulation.Video
         //GCHandle? lasyRenderHandle;
         protected override void PrepareRenderScreen()
         {
-            //// 固定数组，防止垃圾回收器移动它  
-            //var bitmapcolorRect_handle = GCHandle.Alloc(outputFramebuffer.Clone() as byte[], GCHandleType.Pinned);
-            //// 获取数组的指针  
-            //IntPtr mFrameDataPtr = bitmapcolorRect_handle.AddrOfPinnedObject();
-
-            var eventArgs = RenderScreenEventArgs.Create(numVisiblePixels, numVisibleScanlines, outputFramebuffer_Ptr);
+            //var eventArgs = RenderScreenEventArgs.Create(numVisiblePixels, numVisibleScanlines, outputFramebuffer_Ptr);
+            //这里要改成viewport的中间区域的分辨率
+            var eventArgs = RenderScreenEventArgs.Create(Viewport.Width, Viewport.Height, outputFramebuffer_Ptr);
             OnRenderScreen(eventArgs);
             eventArgs.Release();
-            //if (lasyRenderHandle != null)
-            //    lasyRenderHandle.Value.Free();
-            //lasyRenderHandle = bitmapcolorRect_handle;
-
-            //OnRenderScreen(new RenderScreenEventArgs(Viewport.Width, Viewport.Height, outputFramebuffer.Clone() as byte[]));
         }
 
         private bool ModifyAndVerifyCoordinates(ref int x, ref int y)

AxibugEmuOnline.Client/Assets/Plugins/Essgee.Unity/Metadata/GameMetadataHandler.cs

@@ -19,10 +19,11 @@ namespace Essgee.Metadata
 
     public class GameMetadataHandler
     {
+        public static GameMetadataHandler instance;
         //static string datDirectoryPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Assets", "No-Intro");
         //static string metadataDatabaseFilePath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Assets", "MetadataDatabase.json");
 
-        IGameMetaReources gameMetaReources;
+        public IGameMetaReources gameMetaReources;
         //readonly Dictionary<string, DatFile> datFiles;
         readonly List<CartridgeJSON> cartMetadataDatabase;
 
@@ -31,6 +32,7 @@ namespace Essgee.Metadata
 
         public GameMetadataHandler(IGameMetaReources metaresources)
         {
+            instance = this;
             gameMetaReources = metaresources;
 
             //if (!gameMetaReources.GetCartMetadataDatabase(out string loadedData))
@@ -356,6 +358,12 @@ namespace Essgee.Metadata
             ////EssgeeLogger.EnqueueMessageSuccess($"Metadata initialized; {NumKnownGames} game(s) known across {NumKnownSystems} system(s).");
         }
 
+        ~GameMetadataHandler()
+        {
+            if(instance == this)
+                instance = null;
+        }
+
         public GameMetadata GetGameMetadata(string datFilename, string romFilename, uint romCrc32, int romSize)
         {
             /* Sanity checks */

AxibugEmuOnline.Client/Assets/Plugins/StoicGooseUnity.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 9604fb0f1487b95488164f5dc29a00ba
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

AxibugEmuOnline.Client/Assets/Plugins/StoicGooseUnity/AxiMemory.cs

@@ -0,0 +1,180 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Runtime.InteropServices;
+
+namespace StoicGooseUnity
+{
+    public static class StoicGooseUnityAxiMem
+    {
+        public static void Init() => AxiMemoryEx.Init();
+        public static void FreeAllGCHandle() => AxiMemoryEx.FreeAllGCHandle();
+    }
+    internal unsafe static class AxiMemoryEx
+    {
+        static HashSet<GCHandle> GCHandles = new HashSet<GCHandle>();
+
+        public static void Init()
+        {
+            FreeAllGCHandle();
+            set_TempBuffer = new byte[0x100000];
+        }
+
+        public static void GetObjectPtr(this object srcObj, ref GCHandle handle, ref uint* ptr)
+        {
+            GetObjectPtr(srcObj, ref handle, out IntPtr intptr);
+            ptr = (uint*)intptr;
+        }
+
+        public static void GetObjectPtr(this object srcObj, ref GCHandle handle, ref short* ptr)
+        {
+            GetObjectPtr(srcObj, ref handle, out IntPtr intptr);
+            ptr = (short*)intptr;
+        }
+        public static void GetObjectPtr(this object srcObj, ref GCHandle handle, ref ushort* ptr)
+        {
+            GetObjectPtr(srcObj, ref handle, out IntPtr intptr);
+            ptr = (ushort*)intptr;
+        }
+        public static void GetObjectPtr(this object srcObj, ref GCHandle handle, ref int* ptr)
+        {
+            GetObjectPtr(srcObj, ref handle, out IntPtr intptr);
+            ptr = (int*)intptr;
+        }
+        public static void GetObjectPtr(this object srcObj, ref GCHandle handle, ref byte* ptr)
+        {
+            GetObjectPtr(srcObj, ref handle, out IntPtr intptr);
+            ptr = (byte*)intptr;
+        }
+
+        public static void GetObjectPtr(this object srcObj, ref GCHandle handle, ref byte* ptr, out IntPtr intptr)
+        {
+            GetObjectPtr(srcObj, ref handle, out intptr);
+            ptr = (byte*)intptr;
+        }
+
+        static void GetObjectPtr(this object srcObj, ref GCHandle handle, out IntPtr intptr)
+        {
+            ReleaseGCHandle(ref handle);
+            handle = GCHandle.Alloc(srcObj, GCHandleType.Pinned);
+            GCHandles.Add(handle);
+            intptr = handle.AddrOfPinnedObject();
+        }
+
+        public static void ReleaseGCHandle(this ref GCHandle handle)
+        {
+            if (handle.IsAllocated)
+                handle.Free();
+            GCHandles.Remove(handle);
+        }
+
+        public static void FreeAllGCHandle()
+        {
+            foreach (var handle in GCHandles)
+            {
+                if (handle.IsAllocated)
+                    handle.Free();
+            }
+            GCHandles.Clear();
+        }
+
+        #region 指针化 TempBuffer
+        static byte[] TempBuffer_src;
+        static GCHandle TempBuffer_handle;
+        public static byte* TempBuffer;
+        public static byte[] set_TempBuffer
+        {
+            set
+            {
+                TempBuffer_handle.ReleaseGCHandle();
+                if (value == null)
+                    return;
+                TempBuffer_src = value;
+                TempBuffer_src.GetObjectPtr(ref TempBuffer_handle, ref TempBuffer);
+            }
+        }
+        #endregion
+
+        public static void Write(this BinaryWriter bw, byte* bufferPtr, int offset, int count)
+        {
+            // 使用指针复制数据到临时数组
+            Buffer.MemoryCopy(bufferPtr + offset, TempBuffer, 0, count);
+            // 使用BinaryWriter写入临时数组
+            bw.Write(TempBuffer_src, 0, count);
+        }
+        public static void Write(this FileStream fs, byte* bufferPtr, int offset, int count)
+        {
+            // 使用指针复制数据到临时数组
+            Buffer.MemoryCopy(bufferPtr + offset, TempBuffer, 0, count);
+            // 使用BinaryWriter写入临时数组
+            fs.Write(TempBuffer_src, 0, count);
+        }
+        public static int Read(this FileStream fs, byte* bufferPtr, int offset, int count)
+        {
+            // 使用BinaryWriter写入临时数组
+            count = fs.Read(TempBuffer_src, offset, count);
+            // 使用指针复制数据到临时数组
+            Buffer.MemoryCopy(TempBuffer, bufferPtr + offset, 0, count);
+            return count;
+        }
+    }
+
+    internal unsafe static class AxiArray
+    {
+
+        public static void Copy(byte* src, int srcindex, byte* target, int targetindex, int count)
+        {
+            int singlesize = sizeof(byte);
+            long totalBytesToCopy = count * singlesize;
+            Buffer.MemoryCopy(&src[srcindex], &target[targetindex], totalBytesToCopy, totalBytesToCopy);
+        }
+        public static void Copy(short* src, int srcindex, short* target, int targetindex, int count)
+        {
+            int singlesize = sizeof(short);
+            long totalBytesToCopy = count * singlesize;
+            Buffer.MemoryCopy(&src[srcindex], &target[targetindex], totalBytesToCopy, totalBytesToCopy);
+        }
+        public static void Copy(ushort* src, int srcindex, ushort* target, int targetindex, int count)
+        {
+            int singlesize = sizeof(ushort);
+            long totalBytesToCopy = count * singlesize;
+            Buffer.MemoryCopy(&src[srcindex], &target[targetindex], totalBytesToCopy, totalBytesToCopy);
+        }
+
+        public static void Copy(byte* src, byte* target, int index, int count)
+        {
+            int singlesize = sizeof(byte);
+            long totalBytesToCopy = count * singlesize;
+            Buffer.MemoryCopy(&src[index], &target[index], totalBytesToCopy, totalBytesToCopy);
+        }
+
+        public static void Copy(ushort* src, ushort* target, int index, int count)
+        {
+            int singlesize = sizeof(ushort);
+            long totalBytesToCopy = count * singlesize;
+            Buffer.MemoryCopy(&src[index], &target[index], totalBytesToCopy, totalBytesToCopy);
+        }
+        public static void Copy(ushort* src, ushort* target, int count)
+        {
+            int singlesize = sizeof(ushort);
+            long totalBytesToCopy = count * singlesize;
+            Buffer.MemoryCopy(src, target, totalBytesToCopy, totalBytesToCopy);
+        }
+        public static void Copy(byte* src, byte* target, int count)
+        {
+            int singlesize = sizeof(byte);
+            long totalBytesToCopy = count * singlesize;
+            Buffer.MemoryCopy(src, target, totalBytesToCopy, totalBytesToCopy);
+        }
+        public static void Clear(byte* data, int index, int lenght)
+        {
+            for (int i = index; i < lenght; i++, index++)
+                data[index] = 0;
+        }
+        public static void Clear(ushort* data, int index, int lenght)
+        {
+            for (int i = index; i < lenght; i++, index++)
+                data[index] = 0;
+        }
+    }
+}

AxibugEmuOnline.Client/Assets/Plugins/StoicGooseUnity/AxiMemory.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 920eb4ce49315964e9537a20e38e6151

AxibugEmuOnline.Client/Assets/Plugins/StoicGooseUnity/StoicGoose.Common.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 7e1e5391f68e92f4db7f61cf8ed9557e
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

AxibugEmuOnline.Client/Assets/Plugins/StoicGooseUnity/StoicGoose.Common/Attributes.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 70afb0cb69f156a4b877a6dd0462fa04
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

AxibugEmuOnline.Client/Assets/Plugins/StoicGooseUnity/StoicGoose.Common/Attributes/BitDescriptionAttribute.cs

@@ -0,0 +1,21 @@
+using System;
+
+namespace StoicGoose.Common.Attributes
+{
+	[AttributeUsage(AttributeTargets.Field | AttributeTargets.Property)]
+	public class BitDescriptionAttribute : Attribute
+	{
+		public string Description { get; set; } = string.Empty;
+		public int LowBit { get; set; } = -1;
+		public int HighBit { get; set; } = -1;
+
+		public string BitString => LowBit != -1 ? $"B{LowBit}{(HighBit > LowBit ? $"-{HighBit}" : string.Empty)}: " : string.Empty;
+
+		public BitDescriptionAttribute(string desc, int low = -1, int high = -1)
+		{
+			Description = desc;
+			LowBit = low;
+			HighBit = high;
+		}
+	}
+}

AxibugEmuOnline.Client/Assets/Plugins/StoicGooseUnity/StoicGoose.Common/Attributes/BitDescriptionAttribute.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: d881068effe996b459fdd198b8e7b046

AxibugEmuOnline.Client/Assets/Plugins/StoicGooseUnity/StoicGoose.Common/Attributes/FormatAttribute.cs

@@ -0,0 +1,17 @@
+using System;
+
+namespace StoicGoose.Common.Attributes
+{
+	[AttributeUsage(AttributeTargets.Field | AttributeTargets.Property)]
+	public class FormatAttribute : Attribute
+	{
+		public string Format { get; set; } = string.Empty;
+		public int Shift { get; set; } = 0;
+
+		public FormatAttribute(string format, int shift = 0)
+		{
+			Format = format;
+			Shift = shift;
+		}
+	}
+}

AxibugEmuOnline.Client/Assets/Plugins/StoicGooseUnity/StoicGoose.Common/Attributes/FormatAttribute.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 2e358d7d3a0a0dd4a835853c38de5b88

AxibugEmuOnline.Client/Assets/Plugins/StoicGooseUnity/StoicGoose.Common/Attributes/PortAttribute.cs

@@ -0,0 +1,18 @@
+using System;
+using System.Collections.Generic;
+
+namespace StoicGoose.Common.Attributes
+{
+	[AttributeUsage(AttributeTargets.Field | AttributeTargets.Property)]
+	public class PortAttribute : Attribute
+	{
+		public string Name { get; set; } = string.Empty;
+		public List<ushort> Numbers { get; set; } = new();
+
+		public PortAttribute(string name, params ushort[] numbers)
+		{
+			Name = name;
+			Numbers.AddRange(numbers);
+		}
+	}
+}

AxibugEmuOnline.Client/Assets/Plugins/StoicGooseUnity/StoicGoose.Common/Attributes/PortAttribute.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: e622fd59969209c48842cc5f6951d34f

AxibugEmuOnline.Client/Assets/Plugins/StoicGooseUnity/StoicGoose.Common/Drawing.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 62a562265df1f9b41949fb0a0d5d4491
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

AxibugEmuOnline.Client/Assets/Plugins/StoicGooseUnity/StoicGoose.Common/Drawing/RgbaFile.cs

@@ -0,0 +1,55 @@
+using System;
+using System.IO;
+using System.Linq;
+
+namespace StoicGoose.Common.Drawing
+{
+	/* RGBA bitmap file format -- https://github.com/bzotto/rgba_bitmap
+	 * ".rgba is the dumbest possible image interchange format, now available for your programming pleasure."
+	 */
+
+	public class RgbaFile
+	{
+		const string expectedMagic = "RGBA";
+
+		public string MagicNumber { get; protected set; }
+		public uint Width { get; protected set; }
+		public uint Height { get; protected set; }
+		public byte[] PixelData { get; protected set; }
+
+		public RgbaFile(string filename) : this(new FileStream(filename, FileMode.Open, FileAccess.Read, FileShare.ReadWrite)) { }
+
+		public RgbaFile(Stream stream)
+		{
+			MagicNumber = ReadString(stream, 4);
+			Width = ReadUInt32(stream);
+			Height = ReadUInt32(stream);
+			PixelData = new byte[Width * Height * 4];
+			stream.Read(PixelData);
+		}
+
+		public RgbaFile(uint width, uint height, byte[] pixelData)
+		{
+			MagicNumber = expectedMagic;
+			Width = width;
+			Height = height;
+			PixelData = pixelData;
+		}
+
+		public void Save(string filename) => Save(new FileStream(filename, FileMode.Create, FileAccess.Write, FileShare.ReadWrite));
+
+		public void Save(Stream stream)
+		{
+			WriteString(stream, MagicNumber);
+			WriteUInt32(stream, Width);
+			WriteUInt32(stream, Height);
+			stream.Write(PixelData);
+		}
+
+		private static string ReadString(Stream stream, int length) => new(Enumerable.Range(0, length).Select(_ => (char)stream.ReadByte()).ToArray());
+		private static uint ReadUInt32(Stream stream) => (uint)(((stream.ReadByte() & 0xFF) << 24) | ((stream.ReadByte() & 0xFF) << 16) | ((stream.ReadByte() & 0xFF) << 8) | ((stream.ReadByte() & 0xFF) << 0));
+
+		private static void WriteString(Stream stream, string str) => Array.ForEach(str.ToCharArray(), (x) => stream.WriteByte((byte)x));
+		private static void WriteUInt32(Stream stream, uint val) { stream.WriteByte((byte)((val >> 24) & 0xFF)); stream.WriteByte((byte)((val >> 16) & 0xFF)); stream.WriteByte((byte)((val >> 8) & 0xFF)); stream.WriteByte((byte)((val >> 0) & 0xFF)); }
+	}
+}

AxibugEmuOnline.Client/Assets/Plugins/StoicGooseUnity/StoicGoose.Common/Drawing/RgbaFile.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 319acc894b323fd4f90b8e025383be58

AxibugEmuOnline.Client/Assets/Plugins/StoicGooseUnity/StoicGoose.Common/Extensions.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: d8d552996c36ed1478421faa10628ce6
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

AxibugEmuOnline.Client/Assets/Plugins/StoicGooseUnity/StoicGoose.Common/Extensions/ObjectExtensionMethods.cs

@@ -0,0 +1,20 @@
+//using Newtonsoft.Json;
+
+//namespace StoicGoose.Common.Extensions
+//{
+//	public static class ObjectExtensionMethods
+//	{
+//		/* https://dotnetcoretutorials.com/2020/09/09/cloning-objects-in-c-and-net-core/ */
+//		public static T Clone<T>(this T source)
+//		{
+//			if (source is null) return default;
+//			return JsonConvert.DeserializeObject<T>(JsonConvert.SerializeObject(source, new JsonSerializerSettings()
+//			{
+//				ReferenceLoopHandling = ReferenceLoopHandling.Ignore
+//			}), new JsonSerializerSettings()
+//			{
+//				ObjectCreationHandling = ObjectCreationHandling.Replace
+//			});
+//		}
+//	}
+//}

AxibugEmuOnline.Client/Assets/Plugins/StoicGooseUnity/StoicGoose.Common/Extensions/ObjectExtensionMethods.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 6e4fde992b04dbe42be66c0ea83bb7c1

AxibugEmuOnline.Client/Assets/Plugins/StoicGooseUnity/StoicGoose.Common/Extensions/SerializationExtensionMethods.cs

@@ -0,0 +1,31 @@
+//using System.IO;
+
+//using Newtonsoft.Json;
+
+//namespace StoicGoose.Common.Extensions
+//{
+//	public static class SerializationExtensionMethods
+//	{
+//		public static void SerializeToFile(this object obj, string jsonFileName)
+//		{
+//			SerializeToFile(obj, jsonFileName, new JsonSerializerSettings() { Formatting = Formatting.Indented });
+//		}
+
+//		public static void SerializeToFile(this object obj, string jsonFileName, JsonSerializerSettings serializerSettings)
+//		{
+//			using var writer = new StreamWriter(jsonFileName);
+//			writer.Write(JsonConvert.SerializeObject(obj, serializerSettings));
+//		}
+
+//		public static T DeserializeFromFile<T>(this string jsonFileName)
+//		{
+//			using var reader = new StreamReader(jsonFileName);
+//			return (T)JsonConvert.DeserializeObject(reader.ReadToEnd(), typeof(T), new JsonSerializerSettings() { Formatting = Formatting.Indented });
+//		}
+
+//		public static T DeserializeObject<T>(this string jsonString)
+//		{
+//			return (T)JsonConvert.DeserializeObject(jsonString, typeof(T), new JsonSerializerSettings() { Formatting = Formatting.Indented });
+//		}
+//	}
+//}

AxibugEmuOnline.Client/Assets/Plugins/StoicGooseUnity/StoicGoose.Common/Extensions/SerializationExtensionMethods.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 07c7fb2a5f53f2f4aaa60f1673087d9c

AxibugEmuOnline.Client/Assets/Plugins/StoicGooseUnity/StoicGoose.Common/Extensions/StringExtensionMethods.cs

@@ -0,0 +1,29 @@
+using System;
+using System.Collections.Generic;
+using System.Text.RegularExpressions;
+
+namespace StoicGoose.Common.Extensions
+{
+	public static class StringExtensionMethods
+	{
+		/* Modified from https://stackoverflow.com/a/2641383 */
+		public static List<int> IndexOfAll(this string str, string value)
+		{
+			if (string.IsNullOrEmpty(value))
+				throw new ArgumentException("Search string is null or empty", nameof(value));
+
+			var idxs = new List<int>();
+			for (var i = 0; ; i += value.Length)
+			{
+				i = str.IndexOf(value, i);
+				if (i == -1) return idxs;
+				idxs.Add(i);
+			}
+		}
+
+		public static string EnsureEndsWithPeriod(this string str) => str + (!str.EndsWith('.') ? "." : string.Empty);
+
+		/* Regex via https://superuser.com/a/380778 */
+		public static string RemoveAnsi(this string str) => Regex.Replace(str, @"\x1b\[[0-9;]*[mGKHF]", "");
+	}
+}

AxibugEmuOnline.Client/Assets/Plugins/StoicGooseUnity/StoicGoose.Common/Extensions/StringExtensionMethods.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: da7cb8ba3dd19cb4e96fedb8dd687ab0

AxibugEmuOnline.Client/Assets/Plugins/StoicGooseUnity/StoicGoose.Common/Localization.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 2df240a96bd839c46a5d441273339c11
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

AxibugEmuOnline.Client/Assets/Plugins/StoicGooseUnity/StoicGoose.Common/Localization/Localizer.cs

@@ -0,0 +1,37 @@
+//using System;
+//using System.Globalization;
+//using System.Linq;
+//using System.Text.RegularExpressions;
+
+//using Newtonsoft.Json;
+//using Newtonsoft.Json.Linq;
+
+//namespace StoicGoose.Common.Localization
+//{
+//	public static class Localizer
+//	{
+//		public static string FallbackCulture { get; set; } = "en";
+
+//		static JObject source = default;
+
+//		public static void Initialize(string jsonData) => source = JsonConvert.DeserializeObject(jsonData) as JObject;
+
+//		public static CultureInfo[] GetSupportedLanguages() => source?.Children().Select(x => new CultureInfo((x as JProperty).Name)).ToArray() ?? Array.Empty<CultureInfo>();
+
+//		private static JToken GetToken(string path) => source?.SelectToken($"{CultureInfo.CurrentUICulture.TwoLetterISOLanguageName}.{path}") ?? source?.SelectToken($"{FallbackCulture}.{path}");
+//		public static string GetString(string path) => GetToken(path)?.Value<string>() ?? path[(path.LastIndexOf('.') + 1)..];
+//		public static string GetString(string path, object parameters)
+//		{
+//			var result = GetString(path);
+//			var properties = parameters.GetType().GetProperties();
+//			foreach (Match match in Regex.Matches(result, @"{(?<param>[^}:]*):*(?<format>[^}]*)}").Where(x => x.Success))
+//			{
+//				var property = properties.First(x => x.Name == match.Groups["param"].Value);
+//				var format = match.Groups["format"].Value;
+//				var formattedValue = string.IsNullOrEmpty(format) ? $"{property.GetValue(parameters)}" : string.Format($"{{0:{format}}}", property.GetValue(parameters));
+//				result = result.Replace(match.Value, formattedValue);
+//			}
+//			return result;
+//		}
+//	}
+//}

AxibugEmuOnline.Client/Assets/Plugins/StoicGooseUnity/StoicGoose.Common/Localization/Localizer.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: e82b9629c32ff9f46bfd29ee8db43083

AxibugEmuOnline.Client/Assets/Plugins/StoicGooseUnity/StoicGoose.Common/Utilities.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 6d169728b1f850a4db4171c5dab2507c
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

AxibugEmuOnline.Client/Assets/Plugins/StoicGooseUnity/StoicGoose.Common/Utilities/Ansi.cs

@@ -0,0 +1,147 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace StoicGoose.Common.Utilities
+{
+	public static class Ansi
+	{
+		public readonly static string Reset = "\x1B[0m";
+		public readonly static string Black = "\x1B[30m";
+		public readonly static string Red = "\x1B[31m";
+		public readonly static string Green = "\x1B[32m";
+		public readonly static string Yellow = "\x1B[33m";
+		public readonly static string Blue = "\x1B[34m";
+		public readonly static string Magenta = "\x1B[35m";
+		public readonly static string Cyan = "\x1B[36m";
+		public readonly static string White = "\x1B[37m";
+
+		public static string RGB(byte r, byte g, byte b) => $"\x1B[38;2;{r};{g};{b}m";
+
+		// Such a stupid gimmick... but hey, I like stupid gimmicks and I especially like making them, so whatever~
+		public static string Gradient(string text, bool useHsl, params (byte r, byte g, byte b)[] colors)
+		{
+			var stepsPerColor = (int)Math.Round(text.Length / (colors.Length - 1f), MidpointRounding.AwayFromZero);
+			var steps = Math.Max(stepsPerColor * (colors.Length - 1), text.Length);
+
+			List<(byte r, byte g, byte b)> gradient = new();
+
+			for (int i = 0, c = 0; i < steps; i += stepsPerColor, c++)
+			{
+				// TODO: this is a workaround for a out-of-range bug, but ugh, it's for a mere gimmick barely anyone will ever see, soooooo... whatever!
+				if (c + 1 >= colors.Length) c--;
+
+				if (useHsl)
+				{
+					var (h1, s1, l1) = RgbToHsl(colors[c + 0].r, colors[c + 0].g, colors[c + 0].b);
+					var (h2, s2, l2) = RgbToHsl(colors[c + 1].r, colors[c + 1].g, colors[c + 1].b);
+
+					for (var j = 0; j < stepsPerColor; j++)
+					{
+						var by = Math.Clamp(j / 1f / ((stepsPerColor - 1) / 1f), 0f, 1f);
+						var (h, s, l) = Lerp(h1, s1, l1, h2, s2, l2, by);
+						gradient.Add(HslToRgb(h, s, l));
+					}
+				}
+				else
+				{
+					var (r1, g1, b1) = (colors[c + 0].r / 255f, colors[c + 0].g / 255f, colors[c + 0].b / 255f);
+					var (r2, g2, b2) = (colors[c + 1].r / 255f, colors[c + 1].g / 255f, colors[c + 1].b / 255f);
+
+					for (var j = 0; j < stepsPerColor; j++)
+					{
+						var by = Math.Clamp(j / 1f / ((stepsPerColor - 1) / 1f), 0f, 1f);
+						gradient.Add(((byte)(Lerp(r1, r2, by) * 255), (byte)(Lerp(g1, g2, by) * 255), (byte)(Lerp(b1, b2, by) * 255)));
+					}
+				}
+			}
+
+			var builder = new StringBuilder();
+			for (var i = 0; i < Math.Min(gradient.Count, text.Length); i++)
+				builder.Append($"{RGB(gradient[i].r, gradient[i].g, gradient[i].b)}{text[i]}");
+			return builder.ToString();
+		}
+
+		private static float Lerp(float v1, float v2, float by) => v1 * (1f - by) + v2 * by;
+		private static (float h, float s, float l) Lerp(float h1, float s1, float l1, float h2, float s2, float l2, float by) => (Lerp(h1, h2, by) % 360f, Math.Clamp(Lerp(s1, s2, by), 0f, 1f), Math.Clamp(Lerp(l1, l2, by), 0f, 1f));
+
+		// http://www.easyrgb.com/en/math.php
+		private static (float h, float s, float l) RgbToHsl(byte red, byte green, byte blue)
+		{
+			float h = 0f, s, l;
+
+			var r = red / 255f;
+			var g = green / 255f;
+			var b = blue / 255f;
+
+			var min = Math.Min(Math.Min(r, g), b);
+			var max = Math.Max(Math.Max(r, g), b);
+			var deltaMax = max - min;
+
+			l = (max + min) / 2f;
+
+			if (deltaMax == 0)
+			{
+				h = 0;
+				s = 0;
+			}
+			else
+			{
+				if (l < 0.5f) s = deltaMax / (max + min);
+				else s = deltaMax / (2f - max - min);
+
+				var deltaR = ((max - r) / 6f + deltaMax / 2f) / deltaMax;
+				var deltaG = ((max - g) / 6f + deltaMax / 2f) / deltaMax;
+				var deltaB = ((max - b) / 6f + deltaMax / 2f) / deltaMax;
+
+				if (r == max) h = deltaB - deltaG;
+				else if (g == max) h = 1f / 3f + deltaR - deltaB;
+				else if (b == max) h = 2f / 3f + deltaG - deltaR;
+
+				if (h < 0f) h++;
+				if (h > 1f) h--;
+			}
+
+			return (h, s, l);
+		}
+
+		// http://www.easyrgb.com/en/math.php
+		private static (byte r, byte g, byte b) HslToRgb(float hue, float saturation, float lightness)
+		{
+			byte r, g, b;
+
+			if (saturation == 0f)
+			{
+				r = (byte)(lightness * 255);
+				g = (byte)(lightness * 255);
+				b = (byte)(lightness * 255);
+			}
+			else
+			{
+				float v1, v2;
+
+				if (lightness < 0.5f) v2 = lightness * (1f + saturation);
+				else v2 = lightness + saturation - saturation * lightness;
+
+				v1 = 2f * lightness - v2;
+
+				r = (byte)(255 * HueToRgb(v1, v2, hue + 1f / 3f));
+				g = (byte)(255 * HueToRgb(v1, v2, hue));
+				b = (byte)(255 * HueToRgb(v1, v2, hue - 1f / 3f));
+			}
+
+			return (r, g, b);
+		}
+
+		private static float HueToRgb(float v1, float v2, float vh)
+		{
+			if (vh < 0f) vh++;
+			if (vh > 1) vh--;
+
+			if (6f * vh < 1f) return v1 + (v2 - v1) * 6f * vh;
+			if (2f * vh < 1f) return v2;
+			if (3f * vh < 2f) return v1 + (v2 - v1) * (2f / 3f - vh) * 6f;
+			return v1;
+		}
+	}
+}

AxibugEmuOnline.Client/Assets/Plugins/StoicGooseUnity/StoicGoose.Common/Utilities/Ansi.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 0f30cf7d655b21e49a24ff276bbc9861

AxibugEmuOnline.Client/Assets/Plugins/StoicGooseUnity/StoicGoose.Common/Utilities/Bcd.cs

@@ -0,0 +1,8 @@
+namespace StoicGoose.Common.Utilities
+{
+	public static class Bcd
+	{
+		public static int DecimalToBcd(int value) => ((value / 10) << 4) + (value % 10);
+		public static int BcdToDecimal(int value) => ((value >> 4) * 10) + value % 16;
+	}
+}

AxibugEmuOnline.Client/Assets/Plugins/StoicGooseUnity/StoicGoose.Common/Utilities/Bcd.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: e71734276750fc04990a5d08f116ee5d

AxibugEmuOnline.Client/Assets/Plugins/StoicGooseUnity/StoicGoose.Common/Utilities/BitHandling.cs

@@ -0,0 +1,15 @@
+namespace StoicGoose.Common.Utilities
+{
+	public static class BitHandling
+	{
+		public static void ChangeBit(ref byte value, int bit, bool state)
+		{
+			if (state)
+				value |= (byte)(1 << bit);
+			else
+				value &= (byte)~(1 << bit);
+		}
+
+		public static bool IsBitSet(byte value, int bit) => (value & (1 << bit)) != 0;
+	}
+}

AxibugEmuOnline.Client/Assets/Plugins/StoicGooseUnity/StoicGoose.Common/Utilities/BitHandling.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: d00bd13e7a297b34683f7c739fc50d46

AxibugEmuOnline.Client/Assets/Plugins/StoicGooseUnity/StoicGoose.Common/Utilities/ConfigurationBase.cs

@@ -0,0 +1,67 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace StoicGoose.Common.Utilities
+{
+	public abstract class ConfigurationBase<T> where T : class, new()
+	{
+		public static readonly Dictionary<string, object> Defaults = default;
+
+		static ConfigurationBase()
+		{
+			Defaults = GetDefaultValues();
+		}
+
+		private static Dictionary<string, object> GetDefaultValues()
+		{
+			var dict = new Dictionary<string, object>();
+			var instance = new T();
+
+			foreach (var property in typeof(T).GetProperties().Where(x => x.CanWrite))
+			{
+				var value = property.GetValue(instance);
+				if (value == null || (property.PropertyType == typeof(string) && string.IsNullOrEmpty(value as string))) continue;
+				dict.Add(property.Name, value);
+			}
+
+			return dict;
+		}
+
+		public void ResetToDefault(string name)
+		{
+			var property = GetType().GetProperty(name);
+			if (property == null) throw new ArgumentException($"Setting '{name}' not found in {GetType().Name}", nameof(name));
+			property.SetValue(this, Defaults[name]);
+		}
+	}
+
+	public static class ConfigurationBase
+	{
+		public static void CopyConfiguration(object source, object destination)
+		{
+			if (source == null) throw new ArgumentNullException(nameof(source), "Source cannot be null");
+			if (destination == null) throw new ArgumentNullException(nameof(destination), "Destination cannot be null");
+
+			var sourceType = source.GetType();
+			var destType = destination.GetType();
+
+			foreach (var sourceProperty in sourceType.GetProperties().Where(x => x.CanRead))
+			{
+				var destProperty = destType.GetProperty(sourceProperty.Name);
+				if (destProperty == null || !destProperty.CanWrite || destProperty.GetSetMethod(true) == null || destProperty.GetSetMethod(true).IsPrivate ||
+					destProperty.GetSetMethod(true).Attributes.HasFlag(System.Reflection.MethodAttributes.Static) ||
+					!destProperty.PropertyType.IsAssignableFrom(sourceProperty.PropertyType))
+					continue;
+
+				var sourceValue = sourceProperty.GetValue(source, null);
+				var destValue = destProperty.GetValue(destination, null);
+
+				if ((sourceProperty.PropertyType.BaseType.IsGenericType ? sourceProperty.PropertyType.BaseType.GetGenericTypeDefinition() : sourceProperty.PropertyType.BaseType) == typeof(ConfigurationBase<>))
+					CopyConfiguration(sourceValue, destValue);
+				else
+					destProperty.SetValue(destination, sourceValue);
+			}
+		}
+	}
+}

AxibugEmuOnline.Client/Assets/Plugins/StoicGooseUnity/StoicGoose.Common/Utilities/ConfigurationBase.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 76e83b1a596480f48a7afe097d979b83

AxibugEmuOnline.Client/Assets/Plugins/StoicGooseUnity/StoicGoose.Common/Utilities/Crc32.cs

@@ -0,0 +1,82 @@
+using System;
+using System.IO;
+
+namespace StoicGoose.Common.Utilities
+{
+	public static class Crc32
+	{
+		static readonly uint[] crcTable;
+		static readonly uint crcPolynomial = 0xEDB88320;
+		static readonly uint crcSeed = 0xFFFFFFFF;
+
+		static Crc32()
+		{
+			crcTable = new uint[256];
+
+			for (var i = 0; i < 256; i++)
+			{
+				var entry = (uint)i;
+				for (int j = 0; j < 8; j++)
+				{
+					if ((entry & 0x00000001) == 0x00000001) entry = (entry >> 1) ^ crcPolynomial;
+					else entry >>= 1;
+				}
+				crcTable[i] = entry;
+			}
+		}
+
+		private static void VerifyStartAndLength(int dataLength, int segmentStart, int segmentLength)
+		{
+			if (segmentStart >= dataLength) throw new Exception("Segment start offset is greater than total length");
+			if (segmentLength > dataLength) throw new Exception("Segment length is greater than total length");
+			if ((segmentStart + segmentLength) > dataLength) throw new Exception("Segment end offset is greater than total length");
+		}
+
+		public static uint Calculate(FileInfo fileInfo)
+		{
+			return Calculate(fileInfo, 0, (int)fileInfo.Length);
+		}
+
+		public static uint Calculate(FileInfo fileInfo, int start, int length)
+		{
+			VerifyStartAndLength((int)fileInfo.Length, start, length);
+
+			using FileStream file = fileInfo.Open(FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
+			return Calculate(file, start, length);
+		}
+
+		public static uint Calculate(Stream stream)
+		{
+			return Calculate(stream, 0, (int)stream.Length);
+		}
+
+		public static uint Calculate(Stream stream, int start, int length)
+		{
+			VerifyStartAndLength((int)stream.Length, start, length);
+
+			var lastStreamPosition = stream.Position;
+			var data = new byte[length];
+			stream.Position = start;
+			stream.Read(data, 0, length);
+			var crc = Calculate(data, 0, data.Length);
+			stream.Position = lastStreamPosition;
+
+			return crc;
+		}
+
+		public static uint Calculate(byte[] data)
+		{
+			return Calculate(data, 0, data.Length);
+		}
+
+		public static uint Calculate(byte[] data, int start, int length)
+		{
+			VerifyStartAndLength(data.Length, start, length);
+
+			uint crc = crcSeed;
+			for (var i = start; i < (start + length); i++)
+				crc = ((crc >> 8) ^ crcTable[data[i] ^ (crc & 0x000000FF)]);
+			return ~crc;
+		}
+	}
+}

AxibugEmuOnline.Client/Assets/Plugins/StoicGooseUnity/StoicGoose.Common/Utilities/Crc32.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: afa4b03878ac3704bb52cae6e463f1f0

AxibugEmuOnline.Client/Assets/Plugins/StoicGooseUnity/StoicGoose.Common/Utilities/Log.cs

@@ -0,0 +1,87 @@
+using System.Collections.Generic;
+
+namespace StoicGoose.Common.Utilities
+{
+    public enum LogSeverity { Verbose, Debug, Information, Warning, Error, Fatal }
+    public enum LogType { Debug, Warning, Error }
+
+    public interface IStoicGooseLogger
+    {
+        public void Log(LogType logtype, string message);
+        public void Debug(string message);
+        public void Warning(string message);
+        public void Err(string message);
+    }
+
+    public static class Log
+	{
+		const string defaultTemplate = "{Message}{NewLine}{Exception}";
+
+		readonly static Dictionary<LogSeverity, LogType> severityToEventLevelMapping = new()
+		{
+			{ LogSeverity.Verbose, LogType.Debug },
+			{ LogSeverity.Debug, LogType.Debug },
+			{ LogSeverity.Information, LogType.Debug },
+			{ LogSeverity.Warning, LogType.Warning },
+			{ LogSeverity.Error, LogType.Error },
+			{ LogSeverity.Fatal, LogType.Error }
+		};
+
+		readonly static Dictionary<LogSeverity, string> logSeverityAnsiColors = new()
+		{
+			{ LogSeverity.Verbose, Ansi.White },
+			{ LogSeverity.Debug, Ansi.Cyan },
+			{ LogSeverity.Information, Ansi.Green },
+			{ LogSeverity.Warning, Ansi.Yellow },
+			{ LogSeverity.Error, Ansi.Magenta },
+			{ LogSeverity.Fatal, Ansi.Red }
+		};
+
+		static IStoicGooseLogger mainLogger;
+
+		public static void Initialize(IStoicGooseLogger logger)
+		{
+			mainLogger = logger;
+		}
+
+
+		public static void WriteLine(string message) => mainLogger.Debug(message);
+		//public static void WriteFatal(string message) => Write(LogEventLevel.Fatal, message);
+
+		//private static void Write(LogEventLevel logEventLevel, string message)
+		//{
+		//	mainLogger?.Write(logEventLevel, message);
+		//	fileLogger?.Write(logEventLevel, message.RemoveAnsi());
+		//}
+
+		public static void WriteEvent(LogSeverity severity, object source, string message)
+		{
+			var eventLevel = severityToEventLevelMapping.ContainsKey(severity) ? severityToEventLevelMapping[severity] : LogType.Debug;
+			var logMessage = $"{logSeverityAnsiColors[severity]}[{source?.GetType().Name ?? string.Empty}]{Ansi.Reset}: {message}";
+			mainLogger.Log(eventLevel, logMessage);
+		}
+	}
+
+	//class TextWriterSink : ILogEventSink
+	//{
+	//	readonly TextWriter textWriter = default;
+	//	readonly ITextFormatter textFormatter = default;
+
+	//	readonly object syncRoot = new();
+
+	//	//public TextWriterSink(TextWriter writer, ITextFormatter formatter)
+	//	//{
+	//	//	textWriter = writer;
+	//	//	textFormatter = formatter ?? throw new ArgumentNullException(nameof(formatter));
+	//	//}
+
+	//	public void Emit(LogEvent logEvent)
+	//	{
+	//		lock (syncRoot)
+	//		{
+	//			textFormatter.Format(logEvent ?? throw new ArgumentNullException(nameof(logEvent)), textWriter);
+	//			textWriter.Flush();
+	//		}
+	//	}
+	//}
+}

AxibugEmuOnline.Client/Assets/Plugins/StoicGooseUnity/StoicGoose.Common/Utilities/Log.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 916e8e9742f5dfc41823c7eb3a544606

AxibugEmuOnline.Client/Assets/Plugins/StoicGooseUnity/StoicGoose.Common/Utilities/Resources.cs

@@ -0,0 +1,41 @@
+using System.IO;
+using System.Reflection;
+
+using StoicGoose.Common.Drawing;
+
+namespace StoicGoose.Common.Utilities
+{
+	public static class Resources
+	{
+		private static Stream GetEmbeddedResourceStream(string name)
+		{
+			var assembly = Assembly.GetEntryAssembly();
+			name = $"{assembly.GetName().Name}.{name}";
+			return assembly.GetManifestResourceStream(name);
+		}
+
+		public static RgbaFile GetEmbeddedRgbaFile(string name)
+		{
+			using var stream = GetEmbeddedResourceStream(name);
+			if (stream == null) return null;
+			return new RgbaFile(stream);
+		}
+
+		public static string GetEmbeddedText(string name)
+		{
+			using var stream = GetEmbeddedResourceStream(name);
+			if (stream == null) return string.Empty;
+			using var reader = new StreamReader(stream);
+			return reader.ReadToEnd();
+		}
+
+		public static byte[] GetEmbeddedRawData(string name)
+		{
+			using var stream = GetEmbeddedResourceStream(name);
+			if (stream == null) return null;
+			var buffer = new byte[stream.Length];
+			stream.Read(buffer, 0, buffer.Length);
+			return buffer;
+		}
+	}
+}

AxibugEmuOnline.Client/Assets/Plugins/StoicGooseUnity/StoicGoose.Common/Utilities/Resources.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 20f7f2e2f16528949b80073b5e8778f9

AxibugEmuOnline.Client/Assets/Plugins/StoicGooseUnity/StoicGoose.Core.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: b4feaaee1d7195a46a3aa956e4128489
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

AxibugEmuOnline.Client/Assets/Plugins/StoicGooseUnity/StoicGoose.Core/Bootstrap.cs

@@ -0,0 +1,41 @@
+using System;
+
+using StoicGoose.Core.Interfaces;
+
+namespace StoicGoose.Core
+{
+	public class Bootstrap : IComponent
+	{
+		readonly byte[] rom = Array.Empty<byte>();
+		readonly uint romMask = 0;
+
+		public Bootstrap(int size)
+		{
+			rom = new byte[size];
+			romMask = (uint)(rom.Length - 1);
+		}
+
+		public void Reset()
+		{
+			//
+		}
+
+		public void Shutdown()
+		{
+			//
+		}
+
+		public void LoadRom(byte[] data)
+		{
+			if (data.Length != rom.Length)
+				throw new Exception("Data size mismatch error");
+
+			Buffer.BlockCopy(data, 0, rom, 0, data.Length);
+		}
+
+		public byte ReadMemory(uint address)
+		{
+			return rom[address & romMask];
+		}
+	}
+}

AxibugEmuOnline.Client/Assets/Plugins/StoicGooseUnity/StoicGoose.Core/Bootstrap.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: d194949ecf04a5341b082bac647c847d

AxibugEmuOnline.Client/Assets/Plugins/StoicGooseUnity/StoicGoose.Core/CPU.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: c1c58bce2e7f29f419b70dc124e97204
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

AxibugEmuOnline.Client/Assets/Plugins/StoicGooseUnity/StoicGoose.Core/CPU/V30MZ.Addressing.cs

@@ -0,0 +1,96 @@
+namespace StoicGoose.Core.CPU
+{
+	public sealed partial class V30MZ
+	{
+		private byte ReadOpcodeEb()
+		{
+			ReadModRM();
+			if (modRm.Mod == ModRM.Modes.Register)
+				return GetRegister8((RegisterNumber8)modRm.Mem);
+			else
+				return ReadMemory8(modRm.Segment, modRm.Offset);
+		}
+
+		private ushort ReadOpcodeEw()
+		{
+			ReadModRM();
+			if (modRm.Mod == ModRM.Modes.Register)
+				return GetRegister16((RegisterNumber16)modRm.Mem);
+			else
+				return ReadMemory16(modRm.Segment, modRm.Offset);
+		}
+
+		private void WriteOpcodeEb(byte value)
+		{
+			ReadModRM();
+			if (modRm.Mod == ModRM.Modes.Register)
+				SetRegister8((RegisterNumber8)modRm.Mem, value);
+			else
+				WriteMemory8(modRm.Segment, modRm.Offset, value);
+		}
+
+		private void WriteOpcodeEw(ushort value)
+		{
+			ReadModRM();
+			if (modRm.Mod == ModRM.Modes.Register)
+				SetRegister16((RegisterNumber16)modRm.Mem, value);
+			else
+				WriteMemory16(modRm.Segment, modRm.Offset, value);
+		}
+
+		private byte ReadOpcodeGb()
+		{
+			ReadModRM();
+			return GetRegister8((RegisterNumber8)modRm.Reg);
+		}
+
+		private ushort ReadOpcodeGw()
+		{
+			ReadModRM();
+			return GetRegister16((RegisterNumber16)modRm.Reg);
+		}
+
+		private void WriteOpcodeGb(byte value)
+		{
+			ReadModRM();
+			SetRegister8((RegisterNumber8)modRm.Reg, value);
+		}
+
+		private void WriteOpcodeGw(ushort value)
+		{
+			ReadModRM();
+			SetRegister16((RegisterNumber16)modRm.Reg, value);
+		}
+
+		private ushort ReadOpcodeSw()
+		{
+			ReadModRM();
+			return GetSegment((SegmentNumber)modRm.Reg);
+		}
+
+		private void WriteOpcodeSw(ushort value)
+		{
+			ReadModRM();
+			SetSegment((SegmentNumber)modRm.Reg, value);
+		}
+
+		private byte ReadOpcodeIb()
+		{
+			return ReadMemory8(cs, ip++);
+		}
+
+		private ushort ReadOpcodeIw()
+		{
+			var value = ReadMemory16(cs, ip);
+			ip += 2;
+			return value;
+		}
+
+		private ushort ReadOpcodeJb()
+		{
+			var tmp1 = (ushort)(ip + 1);
+			var tmp2 = (sbyte)ReadOpcodeIb();
+			return (ushort)(tmp1 + tmp2);
+		}
+	}
+}

AxibugEmuOnline.Client/Assets/Plugins/StoicGooseUnity/StoicGoose.Core/CPU/V30MZ.Addressing.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: e1f6daccd87f15e48a0e766b94f6d27f

AxibugEmuOnline.Client/Assets/Plugins/StoicGooseUnity/StoicGoose.Core/CPU/V30MZ.Flags.cs

@@ -0,0 +1,49 @@
+using System;
+
+namespace StoicGoose.Core.CPU
+{
+	public sealed partial class V30MZ
+	{
+		[Flags]
+		public enum Flags : ushort
+		{
+			Carry = 1 << 0,            /* CF */
+			ReservedB1 = 1 << 1,       /* (reserved) */
+			Parity = 1 << 2,           /* PF */
+			ReservedB3 = 1 << 3,       /* (reserved) */
+			Auxiliary = 1 << 4,        /* AF */
+			ReservedB5 = 1 << 5,       /* (reserved) */
+			Zero = 1 << 6,             /* ZF */
+			Sign = 1 << 7,             /* SF */
+			Trap = 1 << 8,             /* TF */
+			InterruptEnable = 1 << 9,  /* IF */
+			Direction = 1 << 10,       /* DF */
+			Overflow = 1 << 11,        /* OF */
+			ReservedB12 = 1 << 12,     /* (reserved) */
+			ReservedB13 = 1 << 13,     /* (reserved) */
+			ReservedB14 = 1 << 14,     /* (reserved) */
+			ReservedB15 = 1 << 15      /* (reserved) */
+		}
+
+		private void SetFlags(Flags flags)
+		{
+			this.flags |= flags;
+		}
+
+		private void ClearFlags(Flags flags)
+		{
+			this.flags &= ~flags;
+		}
+
+		public bool IsFlagSet(Flags flags)
+		{
+			return (this.flags & flags) == flags;
+		}
+
+		private void SetClearFlagConditional(Flags flags, bool condition)
+		{
+			if (condition) this.flags |= flags;
+			else this.flags &= ~flags;
+		}
+	}
+}

AxibugEmuOnline.Client/Assets/Plugins/StoicGooseUnity/StoicGoose.Core/CPU/V30MZ.Flags.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 8d3774b3b6efb724ca93707535be9a35

AxibugEmuOnline.Client/Assets/Plugins/StoicGooseUnity/StoicGoose.Core/CPU/V30MZ.Implementations.cs

@@ -0,0 +1,527 @@
+namespace StoicGoose.Core.CPU
+{
+	public sealed partial class V30MZ
+	{
+		private byte Add8(bool withCarry, byte a, byte b)
+		{
+			int result = a + b + (withCarry && IsFlagSet(Flags.Carry) ? 1 : 0);
+
+			// CF, PF, AF, ZF, SF, OF = according to result
+			SetClearFlagConditional(Flags.Carry, (result & 0x100) != 0);
+			SetClearFlagConditional(Flags.Parity, CalculateParity(result & 0xFF));
+			SetClearFlagConditional(Flags.Auxiliary, ((a ^ b ^ result) & 0x10) != 0);
+			SetClearFlagConditional(Flags.Zero, (result & 0xFF) == 0);
+			SetClearFlagConditional(Flags.Sign, (result & 0x80) != 0);
+			SetClearFlagConditional(Flags.Overflow, ((result ^ a) & (result ^ b) & 0x80) != 0);
+
+			return (byte)result;
+		}
+
+		private ushort Add16(bool withCarry, ushort a, ushort b)
+		{
+			int result = a + b + (withCarry && IsFlagSet(Flags.Carry) ? 1 : 0);
+
+			// CF, PF, AF, ZF, SF, OF = according to result
+			SetClearFlagConditional(Flags.Carry, (result & 0x10000) != 0);
+			SetClearFlagConditional(Flags.Parity, CalculateParity(result & 0xFF));
+			SetClearFlagConditional(Flags.Auxiliary, ((a ^ b ^ result) & 0x10) != 0);
+			SetClearFlagConditional(Flags.Zero, (result & 0xFFFF) == 0);
+			SetClearFlagConditional(Flags.Sign, (result & 0x8000) != 0);
+			SetClearFlagConditional(Flags.Overflow, ((result ^ a) & (result ^ b) & 0x8000) != 0);
+
+			return (ushort)result;
+		}
+
+		private byte Or8(byte a, byte b)
+		{
+			int result = a | b;
+
+			// CF, OF = cleared; PF, ZF, SF = according to result; AF = undefined
+			ClearFlags(Flags.Carry);
+			SetClearFlagConditional(Flags.Parity, CalculateParity(result & 0xFF));
+			//Aux
+			SetClearFlagConditional(Flags.Zero, (result & 0xFF) == 0);
+			SetClearFlagConditional(Flags.Sign, (result & 0x80) != 0);
+			ClearFlags(Flags.Overflow);
+
+			return (byte)result;
+		}
+
+		private ushort Or16(ushort a, ushort b)
+		{
+			int result = a | b;
+
+			// CF, OF = cleared; PF, ZF, SF = according to result; AF = undefined
+			ClearFlags(Flags.Carry);
+			SetClearFlagConditional(Flags.Parity, CalculateParity(result & 0xFF));
+			//Aux
+			SetClearFlagConditional(Flags.Zero, (result & 0xFFFF) == 0);
+			SetClearFlagConditional(Flags.Sign, (result & 0x8000) != 0);
+			ClearFlags(Flags.Overflow);
+
+			return (ushort)result;
+		}
+
+		private byte Sub8(bool withBorrow, byte a, byte b)
+		{
+			int result = a - (b + (withBorrow && IsFlagSet(Flags.Carry) ? 1 : 0));
+
+			// CF, PF, AF, ZF, SF, OF = according to result
+			SetClearFlagConditional(Flags.Carry, (result & 0x100) != 0);
+			SetClearFlagConditional(Flags.Parity, CalculateParity(result & 0xFF));
+			SetClearFlagConditional(Flags.Auxiliary, ((a ^ b ^ result) & 0x10) != 0);
+			SetClearFlagConditional(Flags.Zero, (result & 0xFF) == 0);
+			SetClearFlagConditional(Flags.Sign, (result & 0x80) != 0);
+			SetClearFlagConditional(Flags.Overflow, ((result ^ a) & (a ^ b) & 0x80) != 0);
+
+			return (byte)result;
+		}
+
+		private ushort Sub16(bool withBorrow, ushort a, ushort b)
+		{
+			int result = a - (b + (withBorrow && IsFlagSet(Flags.Carry) ? 1 : 0));
+
+			// CF, PF, AF, ZF, SF, OF = according to result
+			SetClearFlagConditional(Flags.Carry, (result & 0x10000) != 0);
+			SetClearFlagConditional(Flags.Parity, CalculateParity(result & 0xFF));
+			SetClearFlagConditional(Flags.Auxiliary, ((a ^ b ^ result) & 0x10) != 0);
+			SetClearFlagConditional(Flags.Zero, (result & 0xFFFF) == 0);
+			SetClearFlagConditional(Flags.Sign, (result & 0x8000) != 0);
+			SetClearFlagConditional(Flags.Overflow, ((result ^ a) & (a ^ b) & 0x8000) != 0);
+
+			return (ushort)result;
+		}
+
+		private byte And8(byte a, byte b)
+		{
+			int result = a & b;
+
+			// CF, OF = cleared; PF, ZF, SF = according to result; AF = undefined
+			ClearFlags(Flags.Carry);
+			SetClearFlagConditional(Flags.Parity, CalculateParity(result & 0xFF));
+			//Aux
+			SetClearFlagConditional(Flags.Zero, (result & 0xFF) == 0);
+			SetClearFlagConditional(Flags.Sign, (result & 0x80) != 0);
+			ClearFlags(Flags.Overflow);
+
+			return (byte)result;
+		}
+
+		private ushort And16(ushort a, ushort b)
+		{
+			int result = a & b;
+
+			// CF, OF = cleared; PF, ZF, SF = according to result; AF = undefined
+			ClearFlags(Flags.Carry);
+			SetClearFlagConditional(Flags.Parity, CalculateParity(result & 0xFF));
+			//Aux
+			SetClearFlagConditional(Flags.Zero, (result & 0xFFFF) == 0);
+			SetClearFlagConditional(Flags.Sign, (result & 0x8000) != 0);
+			ClearFlags(Flags.Overflow);
+
+			return (ushort)result;
+		}
+
+		private void Daa(bool isSubtract)
+		{
+			byte oldAl = ax.Low;
+
+			if (((oldAl & 0x0F) > 0x09) || IsFlagSet(Flags.Auxiliary))
+			{
+				ax.Low += (byte)(isSubtract ? -0x06 : 0x06);
+				SetFlags(Flags.Auxiliary);
+			}
+			else
+				ClearFlags(Flags.Auxiliary);
+
+			if ((oldAl > 0x99) || IsFlagSet(Flags.Carry))
+			{
+				ax.Low += (byte)(isSubtract ? -0x60 : 0x60);
+				SetFlags(Flags.Carry);
+			}
+			else
+				ClearFlags(Flags.Carry);
+
+			SetClearFlagConditional(Flags.Parity, CalculateParity(ax.Low & 0xFF));
+			SetClearFlagConditional(Flags.Zero, (ax.Low & 0xFF) == 0);
+			SetClearFlagConditional(Flags.Sign, (ax.Low & 0x80) != 0);
+		}
+
+		private byte Xor8(byte a, byte b)
+		{
+			int result = a ^ b;
+
+			// CF, OF = cleared; PF, ZF, SF = according to result; AF = undefined
+			ClearFlags(Flags.Carry);
+			SetClearFlagConditional(Flags.Parity, CalculateParity(result & 0xFF));
+			//Aux
+			SetClearFlagConditional(Flags.Zero, (result & 0xFF) == 0);
+			SetClearFlagConditional(Flags.Sign, (result & 0x80) != 0);
+			ClearFlags(Flags.Overflow);
+
+			return (byte)result;
+		}
+
+		private ushort Xor16(ushort a, ushort b)
+		{
+			int result = a ^ b;
+
+			// CF, OF = cleared; PF, ZF, SF = according to result; AF = undefined
+			ClearFlags(Flags.Carry);
+			SetClearFlagConditional(Flags.Parity, CalculateParity(result & 0xFF));
+			//Aux
+			SetClearFlagConditional(Flags.Zero, (result & 0xFFFF) == 0);
+			SetClearFlagConditional(Flags.Sign, (result & 0x8000) != 0);
+			ClearFlags(Flags.Overflow);
+
+			return (ushort)result;
+		}
+
+		private void Aaa(bool isSubtract)
+		{
+			if (((ax.Low & 0x0F) > 0x09) || IsFlagSet(Flags.Auxiliary))
+			{
+				ax.Low = (byte)(ax.Low + (isSubtract ? -0x06 : 0x06));
+				ax.High = (byte)(ax.High + (isSubtract ? -0x01 : 0x01));
+
+				SetFlags(Flags.Auxiliary);
+				SetFlags(Flags.Carry);
+			}
+			else
+			{
+				ClearFlags(Flags.Auxiliary);
+				ClearFlags(Flags.Carry);
+			}
+
+			ax.Low &= 0x0F;
+		}
+
+		private byte Inc8(byte a)
+		{
+			int result = a + 1;
+
+			// PF, AF, ZF, SF, OF = according to result, CF = undefined
+			//Carry
+			SetClearFlagConditional(Flags.Parity, CalculateParity(result & 0xFF));
+			SetClearFlagConditional(Flags.Auxiliary, ((a ^ 1 ^ result) & 0x10) != 0);
+			SetClearFlagConditional(Flags.Zero, (result & 0xFF) == 0);
+			SetClearFlagConditional(Flags.Sign, (result & 0x80) != 0);
+			SetClearFlagConditional(Flags.Overflow, ((result ^ a) & (result ^ 1) & 0x80) != 0);
+
+			return (byte)result;
+		}
+
+		private ushort Inc16(ushort a)
+		{
+			int result = a + 1;
+
+			// PF, AF, ZF, SF, OF = according to result, CF = undefined
+			//Carry
+			SetClearFlagConditional(Flags.Parity, CalculateParity(result & 0xFF));
+			SetClearFlagConditional(Flags.Auxiliary, ((a ^ 1 ^ result) & 0x10) != 0);
+			SetClearFlagConditional(Flags.Zero, (result & 0xFFFF) == 0);
+			SetClearFlagConditional(Flags.Sign, (result & 0x8000) != 0);
+			SetClearFlagConditional(Flags.Overflow, ((result ^ a) & (result ^ 1) & 0x8000) != 0);
+
+			return (ushort)result;
+		}
+
+		private byte Dec8(byte a)
+		{
+			int result = a - 1;
+
+			// PF, AF, ZF, SF, OF = according to result, CF = undefined
+			//Carry
+			SetClearFlagConditional(Flags.Parity, CalculateParity(result & 0xFF));
+			SetClearFlagConditional(Flags.Auxiliary, ((a ^ 1 ^ result) & 0x10) != 0);
+			SetClearFlagConditional(Flags.Zero, (result & 0xFF) == 0);
+			SetClearFlagConditional(Flags.Sign, (result & 0x80) != 0);
+			SetClearFlagConditional(Flags.Overflow, ((result ^ a) & (a ^ 1) & 0x80) != 0);
+
+			return (byte)result;
+		}
+
+		private ushort Dec16(ushort a)
+		{
+			int result = a - 1;
+
+			// PF, AF, ZF, SF, OF = according to result, CF = undefined
+			//Carry
+			SetClearFlagConditional(Flags.Parity, CalculateParity(result & 0xFF));
+			SetClearFlagConditional(Flags.Auxiliary, ((a ^ 1 ^ result) & 0x10) != 0);
+			SetClearFlagConditional(Flags.Zero, (result & 0xFFFF) == 0);
+			SetClearFlagConditional(Flags.Sign, (result & 0x8000) != 0);
+			SetClearFlagConditional(Flags.Overflow, ((result ^ a) & (a ^ 1) & 0x8000) != 0);
+
+			return (ushort)result;
+		}
+
+		private byte Rol8(bool withCarry, byte a, byte b)
+		{
+			int result;
+
+			if (withCarry)
+			{
+				result = a;
+				for (var n = 0; n < b; n++)
+				{
+					var carry = result & 0x80;
+					result = (result << 1) | (IsFlagSet(Flags.Carry) ? 0x01 : 0);
+					SetClearFlagConditional(Flags.Carry, carry != 0);
+				}
+				SetClearFlagConditional(Flags.Overflow, ((a ^ result) & 0x80) != 0);
+				result &= 0xFF;
+			}
+			else
+			{
+				result = (a << b) | (a >> (8 - b));
+				SetClearFlagConditional(Flags.Carry, ((a << b) & (1 << 8)) != 0);
+				SetClearFlagConditional(Flags.Overflow, ((a ^ result) & 0x80) != 0);
+				result &= 0xFF;
+			}
+
+			return (byte)result;
+		}
+
+		private ushort Rol16(bool withCarry, ushort a, ushort b)
+		{
+			int result;
+
+			if (withCarry)
+			{
+				result = a;
+				for (var n = 0; n < b; n++)
+				{
+					var carry = result & 0x80;
+					result = (result << 1) | (IsFlagSet(Flags.Carry) ? 0x0001 : 0);
+					SetClearFlagConditional(Flags.Carry, carry != 0);
+				}
+				SetClearFlagConditional(Flags.Overflow, ((a ^ result) & 0x8000) != 0);
+				result &= 0xFFFF;
+			}
+			else
+			{
+				result = (a << b) | (a >> (16 - b));
+				SetClearFlagConditional(Flags.Carry, ((a << b) & (1 << 16)) != 0);
+				SetClearFlagConditional(Flags.Overflow, ((a ^ result) & 0x8000) != 0);
+				result &= 0xFFFF;
+			}
+
+			return (ushort)result;
+		}
+
+		private byte Ror8(bool withCarry, byte a, byte b)
+		{
+			int result;
+
+			if (withCarry)
+			{
+				result = a;
+				for (var n = 0; n < b; n++)
+				{
+					var carry = result & 0x01;
+					result = (IsFlagSet(Flags.Carry) ? 0x80 : 0) | (result >> 1);
+					SetClearFlagConditional(Flags.Carry, carry != 0);
+				}
+				SetClearFlagConditional(Flags.Overflow, ((a ^ result) & 0x80) != 0);
+				result &= 0xFF;
+			}
+			else
+			{
+				result = (a >> b) | (a << (8 - b));
+				SetClearFlagConditional(Flags.Carry, ((a >> (b - 1)) & 0x01) != 0);
+				SetClearFlagConditional(Flags.Overflow, ((a ^ result) & 0x80) != 0);
+				result &= 0xFF;
+			}
+
+			return (byte)result;
+		}
+
+		private ushort Ror16(bool withCarry, ushort a, ushort b)
+		{
+			int result;
+
+			if (withCarry)
+			{
+				result = a;
+				for (var n = 0; n < b; n++)
+				{
+					var carry = result & 0x01;
+					result = (IsFlagSet(Flags.Carry) ? 0x8000 : 0) | (result >> 1);
+					SetClearFlagConditional(Flags.Carry, carry != 0);
+				}
+				SetClearFlagConditional(Flags.Overflow, ((a ^ result) & 0x8000) != 0);
+				result &= 0xFFFF;
+			}
+			else
+			{
+				result = (a >> b) | (a << (16 - b));
+				SetClearFlagConditional(Flags.Carry, ((a >> (b - 1)) & 0x01) != 0);
+				SetClearFlagConditional(Flags.Overflow, ((a ^ result) & 0x8000) != 0);
+				result &= 0xFFFF;
+			}
+
+			return (ushort)result;
+		}
+
+		private byte Shl8(byte a, byte b)
+		{
+			int result = (a << b) & 0xFF;
+
+			if (b != 0)
+			{
+				SetClearFlagConditional(Flags.Carry, ((a << b) & (1 << 8)) != 0);
+				SetClearFlagConditional(Flags.Parity, CalculateParity(result & 0xFF));
+				//Aux
+				SetClearFlagConditional(Flags.Zero, (result & 0xFF) == 0);
+				SetClearFlagConditional(Flags.Sign, (result & 0x80) != 0);
+				if (b == 1) SetClearFlagConditional(Flags.Overflow, ((a ^ result) & 0x80) != 0);
+			}
+
+			return (byte)result;
+		}
+
+		private ushort Shl16(ushort a, ushort b)
+		{
+			int result = (a << b) & 0xFFFF;
+
+			if (b != 0)
+			{
+				SetClearFlagConditional(Flags.Carry, ((a << b) & (1 << 16)) != 0);
+				SetClearFlagConditional(Flags.Parity, CalculateParity(result & 0xFF));
+				//Aux
+				SetClearFlagConditional(Flags.Zero, (result & 0xFFFF) == 0);
+				SetClearFlagConditional(Flags.Sign, (result & 0x8000) != 0);
+				if (b == 1) SetClearFlagConditional(Flags.Overflow, ((a ^ result) & 0x8000) != 0);
+			}
+
+			return (ushort)result;
+		}
+
+		private byte Shr8(bool signed, byte a, byte b)
+		{
+			if (signed && (b & 16) != 0)
+			{
+				SetClearFlagConditional(Flags.Carry, (a & 0x80) != 0);
+				return (byte)(0 - (IsFlagSet(Flags.Carry) ? 1 : 0));
+			}
+
+			int result = (a >> b) & 0xFF;
+
+			SetClearFlagConditional(Flags.Carry, ((a >> (b - 1)) & (1 << 0)) != 0);
+			if (signed && (a & 0x80) != 0) result |= 0xFF << (8 - b);
+			SetClearFlagConditional(Flags.Parity, CalculateParity(result & 0xFF));
+			//Aux
+			SetClearFlagConditional(Flags.Zero, (result & 0xFF) == 0);
+			SetClearFlagConditional(Flags.Sign, (result & 0x80) != 0);
+			SetClearFlagConditional(Flags.Overflow, !signed && ((a ^ result) & 0x80) != 0);
+
+			return (byte)result;
+		}
+
+		private ushort Shr16(bool signed, ushort a, ushort b)
+		{
+			if (signed && (b & 16) != 0)
+			{
+				SetClearFlagConditional(Flags.Carry, (a & 0x8000) != 0);
+				return (ushort)(0 - (IsFlagSet(Flags.Carry) ? 1 : 0));
+			}
+
+			int result = (a >> b) & 0xFFFF;
+
+			SetClearFlagConditional(Flags.Carry, ((a >> (b - 1)) & (1 << 0)) != 0);
+			if (signed && (a & 0x8000) != 0) result |= 0xFFFF << (16 - b);
+			SetClearFlagConditional(Flags.Parity, CalculateParity(result & 0xFF));
+			//Aux
+			SetClearFlagConditional(Flags.Zero, (result & 0xFFFF) == 0);
+			SetClearFlagConditional(Flags.Sign, (result & 0x8000) != 0);
+			SetClearFlagConditional(Flags.Overflow, !signed && ((a ^ result) & 0x8000) != 0);
+
+			return (ushort)result;
+		}
+
+		private byte Neg8(byte b)
+		{
+			int result = -b & 0xFF;
+
+			// CF = is operand non-zero?; PF, AF, ZF, SF, OF = according to result
+			SetClearFlagConditional(Flags.Carry, b != 0);
+			SetClearFlagConditional(Flags.Parity, CalculateParity(result & 0xFF));
+			SetClearFlagConditional(Flags.Auxiliary, ((0 ^ b ^ result) & 0x10) != 0);
+			SetClearFlagConditional(Flags.Zero, (result & 0xFF) == 0);
+			SetClearFlagConditional(Flags.Sign, (result & 0x80) != 0);
+			SetClearFlagConditional(Flags.Overflow, ((result ^ 0) & (0 ^ b) & 0x80) != 0);
+
+			return (byte)result;
+		}
+
+		private ushort Neg16(ushort b)
+		{
+			int result = -b & 0xFFFF;
+
+			// CF = is operand non-zero?; PF, AF, ZF, SF, OF = according to result
+			SetClearFlagConditional(Flags.Carry, b != 0);
+			SetClearFlagConditional(Flags.Parity, CalculateParity(result & 0xFF));
+			SetClearFlagConditional(Flags.Auxiliary, ((0 ^ b ^ result) & 0x10) != 0);
+			SetClearFlagConditional(Flags.Zero, (result & 0xFFFF) == 0);
+			SetClearFlagConditional(Flags.Sign, (result & 0x8000) != 0);
+			SetClearFlagConditional(Flags.Overflow, ((result ^ 0) & (0 ^ b) & 0x8000) != 0);
+
+			return (ushort)result;
+		}
+
+		private ushort Mul8(bool signed, byte a, byte b)
+		{
+			uint result = (uint)(signed ? ((sbyte)a * (sbyte)b) : (a * b));
+
+			// CF, OF = is upper half of result non-zero?; PF, AF, ZF, SF = undefined
+			SetClearFlagConditional(Flags.Overflow, (result >> 8) != 0);
+			SetClearFlagConditional(Flags.Carry, (result >> 8) != 0);
+
+			return (ushort)result;
+		}
+
+		private uint Mul16(bool signed, ushort a, ushort b)
+		{
+			uint result = (uint)(signed ? ((short)a * (short)b) : (a * b));
+
+			// CF, OF = is upper half of result non-zero?; PF, AF, ZF, SF = undefined
+			SetClearFlagConditional(Flags.Overflow, (result >> 16) != 0);
+			SetClearFlagConditional(Flags.Carry, (result >> 16) != 0);
+
+			return (uint)result;
+		}
+
+		private ushort Div8(bool signed, ushort a, byte b)
+		{
+			if (b == 0)
+			{
+				Interrupt(0);
+				return a;
+			}
+
+			int quotient = signed ? ((short)a / (sbyte)b) : (a / b);
+			int remainder = signed ? ((short)a % (sbyte)b) : (a % b);
+
+			// CF, PF, AF, ZF, SF, OF = undefined
+
+			return (ushort)(((remainder & 0xFF) << 8) | (quotient & 0xFF));
+		}
+
+		private uint Div16(bool signed, uint a, ushort b)
+		{
+			if (b == 0)
+			{
+				Interrupt(0);
+				return a;
+			}
+
+			int quotient = signed ? ((int)a / (short)b) : (int)(a / b);
+			int remainder = signed ? ((int)a % (short)b) : (int)(a % b);
+
+			// CF, PF, AF, ZF, SF, OF = undefined
+
+			return (uint)(((remainder & 0xFFFF) << 16) | (quotient & 0xFFFF));
+		}
+	}
+}

AxibugEmuOnline.Client/Assets/Plugins/StoicGooseUnity/StoicGoose.Core/CPU/V30MZ.Implementations.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 5828627e3b453af4f9d1280493414226

AxibugEmuOnline.Client/Assets/Plugins/StoicGooseUnity/StoicGoose.Core/CPU/V30MZ.Memory.cs

@@ -0,0 +1,37 @@
+namespace StoicGoose.Core.CPU
+{
+	public sealed partial class V30MZ
+	{
+		private byte ReadMemory8(ushort segment, ushort offset)
+		{
+			return machine.ReadMemory((uint)((segment << 4) + offset));
+		}
+
+		private ushort ReadMemory16(ushort segment, ushort offset)
+		{
+			return (ushort)((machine.ReadMemory((uint)((segment << 4) + offset + 1)) << 8) | machine.ReadMemory((uint)((segment << 4) + offset)));
+		}
+
+		private void WriteMemory8(ushort segment, ushort offset, byte value)
+		{
+			machine.WriteMemory((uint)((segment << 4) + offset), value);
+		}
+
+		private void WriteMemory16(ushort segment, ushort offset, ushort value)
+		{
+			machine.WriteMemory((uint)((segment << 4) + offset), (byte)(value & 0xFF));
+			machine.WriteMemory((uint)((segment << 4) + offset + 1), (byte)(value >> 8));
+		}
+
+		private ushort ReadPort16(ushort port)
+		{
+			return (ushort)(machine.ReadPort((ushort)(port + 1)) << 8 | machine.ReadPort(port));
+		}
+
+		private void WritePort16(ushort port, ushort value)
+		{
+			machine.WritePort(port, (byte)(value & 0xFF));
+			machine.WritePort((ushort)(port + 1), (byte)(value >> 8));
+		}
+	}
+}

AxibugEmuOnline.Client/Assets/Plugins/StoicGooseUnity/StoicGoose.Core/CPU/V30MZ.Memory.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 9fbe65ebef4c3df439fcb960d59e10f6

AxibugEmuOnline.Client/Assets/Plugins/StoicGooseUnity/StoicGoose.Core/CPU/V30MZ.Miscellaneous.cs

@@ -0,0 +1,48 @@
+namespace StoicGoose.Core.CPU
+{
+	public sealed partial class V30MZ
+	{
+		private void Push(ushort value)
+		{
+			sp -= 2;
+			WriteMemory16(ss, sp, value);
+		}
+
+		private ushort Pop()
+		{
+			var value = ReadMemory16(ss, sp);
+			sp += 2;
+			return value;
+		}
+
+		private int Loop()
+		{
+			if (--cx.Word != 0) { ip = ReadOpcodeJb(); return 4; }
+			else { ip++; return 1; }
+		}
+
+		private int LoopWhile(bool condition)
+		{
+			if (--cx.Word != 0 && condition) { ip = ReadOpcodeJb(); return 5; }
+			else { ip++; return 2; }
+		}
+
+		private int JumpConditional(bool condition)
+		{
+			if (condition) { ip = ReadOpcodeJb(); return 4; }
+			else { ip++; return 1; }
+		}
+
+		private static bool CalculateParity(int result)
+		{
+			int bitsSet = 0;
+			while (result != 0) { bitsSet += result & 0x01; result >>= 1; }
+			return bitsSet == 0 || (bitsSet % 2) == 0;
+		}
+
+		private static void Exchange(ref ushort a, ref ushort b)
+		{
+			(b, a) = (a, b);
+		}
+	}
+}

AxibugEmuOnline.Client/Assets/Plugins/StoicGooseUnity/StoicGoose.Core/CPU/V30MZ.Miscellaneous.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 253866b049a8cb445ab91a6c6cbb65e7

AxibugEmuOnline.Client/Assets/Plugins/StoicGooseUnity/StoicGoose.Core/CPU/V30MZ.ModRM.cs

@@ -0,0 +1,103 @@
+namespace StoicGoose.Core.CPU
+{
+	public sealed partial class V30MZ
+	{
+		ModRM modRm;
+
+		private void ReadModRM()
+		{
+			if (modRm.IsSet) return;
+
+			modRm.Set(ReadMemory8(cs, ip++));
+			switch (modRm.Mod)
+			{
+				case ModRM.Modes.NoDisplacement:
+					switch (modRm.Mem)
+					{
+						case 0b000: modRm.Segment = GetSegmentViaOverride(SegmentNumber.DS); modRm.Offset = (ushort)(bx.Word + si); break;
+						case 0b001: modRm.Segment = GetSegmentViaOverride(SegmentNumber.DS); modRm.Offset = (ushort)(bx.Word + di); break;
+						case 0b010: modRm.Segment = GetSegmentViaOverride(SegmentNumber.SS); modRm.Offset = (ushort)(bp + si); break;
+						case 0b011: modRm.Segment = GetSegmentViaOverride(SegmentNumber.SS); modRm.Offset = (ushort)(bp + di); break;
+						case 0b100: modRm.Segment = GetSegmentViaOverride(SegmentNumber.DS); modRm.Offset = si; break;
+						case 0b101: modRm.Segment = GetSegmentViaOverride(SegmentNumber.DS); modRm.Offset = di; break;
+						case 0b110: modRm.Segment = GetSegmentViaOverride(SegmentNumber.DS); modRm.Offset = ReadMemory16(cs, ip); ip += 2; break;
+						case 0b111: modRm.Segment = GetSegmentViaOverride(SegmentNumber.DS); modRm.Offset = bx.Word; break;
+					}
+					break;
+
+				case ModRM.Modes.OneByteDisplacement:
+					{
+						var displacement = (sbyte)ReadMemory8(cs, ip);
+						ip++;
+						switch (modRm.Mem)
+						{
+							case 0b000: modRm.Segment = GetSegmentViaOverride(SegmentNumber.DS); modRm.Offset = (ushort)(bx.Word + si + displacement); break;
+							case 0b001: modRm.Segment = GetSegmentViaOverride(SegmentNumber.DS); modRm.Offset = (ushort)(bx.Word + di + displacement); break;
+							case 0b010: modRm.Segment = GetSegmentViaOverride(SegmentNumber.SS); modRm.Offset = (ushort)(bp + si + displacement); break;
+							case 0b011: modRm.Segment = GetSegmentViaOverride(SegmentNumber.SS); modRm.Offset = (ushort)(bp + di + displacement); break;
+							case 0b100: modRm.Segment = GetSegmentViaOverride(SegmentNumber.DS); modRm.Offset = (ushort)(si + displacement); break;
+							case 0b101: modRm.Segment = GetSegmentViaOverride(SegmentNumber.DS); modRm.Offset = (ushort)(di + displacement); break;
+							case 0b110: modRm.Segment = GetSegmentViaOverride(SegmentNumber.SS); modRm.Offset = (ushort)(bp + displacement); break;
+							case 0b111: modRm.Segment = GetSegmentViaOverride(SegmentNumber.DS); modRm.Offset = (ushort)(bx.Word + displacement); break;
+						}
+					}
+					break;
+
+				case ModRM.Modes.TwoByteDisplacement:
+					{
+						var displacement = (short)ReadMemory16(cs, ip);
+						ip += 2;
+						switch (modRm.Mem)
+						{
+							case 0b000: modRm.Segment = GetSegmentViaOverride(SegmentNumber.DS); modRm.Offset = (ushort)(bx.Word + si + displacement); break;
+							case 0b001: modRm.Segment = GetSegmentViaOverride(SegmentNumber.DS); modRm.Offset = (ushort)(bx.Word + di + displacement); break;
+							case 0b010: modRm.Segment = GetSegmentViaOverride(SegmentNumber.SS); modRm.Offset = (ushort)(bp + si + displacement); break;
+							case 0b011: modRm.Segment = GetSegmentViaOverride(SegmentNumber.SS); modRm.Offset = (ushort)(bp + di + displacement); break;
+							case 0b100: modRm.Segment = GetSegmentViaOverride(SegmentNumber.DS); modRm.Offset = (ushort)(si + displacement); break;
+							case 0b101: modRm.Segment = GetSegmentViaOverride(SegmentNumber.DS); modRm.Offset = (ushort)(di + displacement); break;
+							case 0b110: modRm.Segment = GetSegmentViaOverride(SegmentNumber.SS); modRm.Offset = (ushort)(bp + displacement); break;
+							case 0b111: modRm.Segment = GetSegmentViaOverride(SegmentNumber.DS); modRm.Offset = (ushort)(bx.Word + displacement); break;
+						}
+					}
+					break;
+			}
+		}
+
+		struct ModRM
+		{
+			public enum Modes : byte
+			{
+				NoDisplacement = 0b00,
+				OneByteDisplacement = 0b01,
+				TwoByteDisplacement = 0b10,
+				Register = 0b11
+			}
+
+			byte data;
+
+			public Modes Mod => (Modes)((data >> 6) & 0b11);
+			public byte Reg => (byte)((data >> 3) & 0b111);
+			public byte Mem => (byte)((data >> 0) & 0b111);
+
+			public ushort Segment, Offset;
+
+			public bool IsSet;
+
+			public void Set(byte value)
+			{
+				data = value;
+
+				IsSet = true;
+			}
+
+			public void Reset()
+			{
+				data = 0;
+				Segment = 0;
+				Offset = 0;
+
+				IsSet = false;
+			}
+		}
+	}
+}

AxibugEmuOnline.Client/Assets/Plugins/StoicGooseUnity/StoicGoose.Core/CPU/V30MZ.ModRM.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: a81e97a11c345494da1d600ffa5e81c2

AxibugEmuOnline.Client/Assets/Plugins/StoicGooseUnity/StoicGoose.Core/CPU/V30MZ.OpcodeTable.cs

@@ -0,0 +1,905 @@
+using System;
+
+namespace StoicGoose.Core.CPU
+{
+	public sealed partial class V30MZ
+	{
+		delegate int Instruction(V30MZ cpu);
+		readonly static Instruction[] instructions = new Instruction[256]
+		{
+			/* 0x00 */      /* ADD Eb Gb */                 (cpu) => { cpu.WriteOpcodeEb(cpu.Add8(false, cpu.ReadOpcodeEb(), cpu.ReadOpcodeGb())); return 1; },
+							/* ADD Ew Gw */                 (cpu) => { cpu.WriteOpcodeEw(cpu.Add16(false, cpu.ReadOpcodeEw(), cpu.ReadOpcodeGw())); return 1; },
+							/* ADD Gb Eb */                 (cpu) => { cpu.WriteOpcodeGb(cpu.Add8(false, cpu.ReadOpcodeGb(), cpu.ReadOpcodeEb())); return 1; },
+							/* ADD Gw Ew */                 (cpu) => { cpu.WriteOpcodeGw(cpu.Add16(false, cpu.ReadOpcodeGw(), cpu.ReadOpcodeEw())); return 1; },
+			/* 0x04 */      /* ADD AL Ib */                 (cpu) => { cpu.ax.Low = cpu.Add8(false, cpu.ax.Low, cpu.ReadOpcodeIb()); return 1; },
+							/* ADD AX Iw */                 (cpu) => { cpu.ax.Word = cpu.Add16(false, cpu.ax.Word, cpu.ReadOpcodeIw()); return 1; },
+							/* PUSH ES */                   (cpu) => { cpu.Push(cpu.es); return 1; },
+							/* POP ES */                    (cpu) => { cpu.es = cpu.Pop(); return 1; },
+			/* 0x08 */      /* OR Eb Gb */                  (cpu) => { cpu.WriteOpcodeEb(cpu.Or8(cpu.ReadOpcodeEb(), cpu.ReadOpcodeGb())); return 1; },
+							/* OR Ew Gw */                  (cpu) => { cpu.WriteOpcodeEw(cpu.Or16(cpu.ReadOpcodeEw(), cpu.ReadOpcodeGw())); return 1; },
+							/* OR Gb Eb */                  (cpu) => { cpu.WriteOpcodeGb(cpu.Or8(cpu.ReadOpcodeGb(), cpu.ReadOpcodeEb())); return 1; },
+							/* OR Gw Ew */                  (cpu) => { cpu.WriteOpcodeGw(cpu.Or16(cpu.ReadOpcodeGw(), cpu.ReadOpcodeEw())); return 1; },
+			/* 0x0C */      /* OR AL Ib */                  (cpu) => { cpu.ax.Low = cpu.Or8(cpu.ax.Low, cpu.ReadOpcodeIb()); return 1; },
+							/* OR AX Iw */                  (cpu) => { cpu.ax.Word = cpu.Or16(cpu.ax.Word, cpu.ReadOpcodeIw()); return 1; },
+							/* PUSH CS */                   (cpu) => { cpu.Push(cpu.cs); return 1; },
+							/* (Invalid; NOP?) */			(cpu) => 3,
+
+			/* 0x10 */      /* ADC Eb Gb */                 (cpu) => { cpu.WriteOpcodeEb(cpu.Add8(true, cpu.ReadOpcodeEb(), cpu.ReadOpcodeGb())); return 1; },
+							/* ADC Ew Gw */                 (cpu) => { cpu.WriteOpcodeEw(cpu.Add16(true, cpu.ReadOpcodeEw(), cpu.ReadOpcodeGw())); return 1; },
+							/* ADC Gb Eb */                 (cpu) => { cpu.WriteOpcodeGb(cpu.Add8(true, cpu.ReadOpcodeGb(), cpu.ReadOpcodeEb())); return 1; },
+							/* ADC Gw Ew */                 (cpu) => { cpu.WriteOpcodeGw(cpu.Add16(true, cpu.ReadOpcodeGw(), cpu.ReadOpcodeEw())); return 1; },
+			/* 0x14 */      /* ADC AL Ib */                 (cpu) => { cpu.ax.Low = cpu.Add8(true, cpu.ax.Low, cpu.ReadOpcodeIb()); return 1; },
+							/* ADC AX Iw */                 (cpu) => { cpu.ax.Word = cpu.Add16(true, cpu.ax.Word, cpu.ReadOpcodeIw()); return 1; },
+							/* PUSH SS */                   (cpu) => { cpu.Push(cpu.ss); return 1; },
+							/* POP SS */                    (cpu) => { cpu.ss = cpu.Pop(); return 1; },
+			/* 0x18 */      /* SBB Eb Gb */                 (cpu) => { cpu.WriteOpcodeEb(cpu.Sub8(true, cpu.ReadOpcodeEb(), cpu.ReadOpcodeGb())); return 1; },
+							/* SBB Ew Gw */                 (cpu) => { cpu.WriteOpcodeEw(cpu.Sub16(true, cpu.ReadOpcodeEw(), cpu.ReadOpcodeGw())); return 1; },
+							/* SBB Gb Eb */                 (cpu) => { cpu.WriteOpcodeGb(cpu.Sub8(true, cpu.ReadOpcodeGb(), cpu.ReadOpcodeEb())); return 1; },
+							/* SBB Gw Ew */                 (cpu) => { cpu.WriteOpcodeGw(cpu.Sub16(true, cpu.ReadOpcodeGw(), cpu.ReadOpcodeEw())); return 1; },
+			/* 0x1C */      /* SBB AL Ib */                 (cpu) => { cpu.ax.Low = cpu.Sub8(true, cpu.ax.Low, cpu.ReadOpcodeIb()); return 1; },
+							/* SBB AX Iw */                 (cpu) => { cpu.ax.Word = cpu.Sub16(true, cpu.ax.Word, cpu.ReadOpcodeIw()); return 1; },
+							/* PUSH DS */                   (cpu) => { cpu.Push(cpu.ds); return 1; },
+							/* POP DS */                    (cpu) => { cpu.ds = cpu.Pop(); return 1; },
+                            
+			/* 0x20 */      /* AND Eb Gb */                 (cpu) => { cpu.WriteOpcodeEb(cpu.And8(cpu.ReadOpcodeEb(), cpu.ReadOpcodeGb())); return 1; },
+							/* AND Ew Gw */                 (cpu) => { cpu.WriteOpcodeEw(cpu.And16(cpu.ReadOpcodeEw(), cpu.ReadOpcodeGw())); return 1; },
+							/* AND Gb Eb */                 (cpu) => { cpu.WriteOpcodeGb(cpu.And8(cpu.ReadOpcodeGb(), cpu.ReadOpcodeEb())); return 1; },
+							/* AND Gw Ew */                 (cpu) => { cpu.WriteOpcodeGw(cpu.And16(cpu.ReadOpcodeGw(), cpu.ReadOpcodeEw())); return 1; },
+			/* 0x24 */      /* AND AL Ib */                 (cpu) => { cpu.ax.Low = cpu.And8(cpu.ax.Low, cpu.ReadOpcodeIb()); return 1; },
+							/* AND AX Iw */                 (cpu) => { cpu.ax.Word = cpu.And16(cpu.ax.Word, cpu.ReadOpcodeIw()); return 1; },
+							/* (Prefix ES) */               (cpu) => 0,
+							/* DAA */                       (cpu) => { cpu.Daa(false); return 10; },
+			/* 0x28 */      /* SUB Eb Gb */                 (cpu) => { cpu.WriteOpcodeEb(cpu.Sub8(false, cpu.ReadOpcodeEb(), cpu.ReadOpcodeGb())); return 1; },
+							/* SUB Ew Gw */                 (cpu) => { cpu.WriteOpcodeEw(cpu.Sub16(false, cpu.ReadOpcodeEw(), cpu.ReadOpcodeGw())); return 1; },
+							/* SUB Gb Eb */                 (cpu) => { cpu.WriteOpcodeGb(cpu.Sub8(false, cpu.ReadOpcodeGb(), cpu.ReadOpcodeEb())); return 1; },
+							/* SUB Gw Ew */                 (cpu) => { cpu.WriteOpcodeGw(cpu.Sub16(false, cpu.ReadOpcodeGw(), cpu.ReadOpcodeEw())); return 1; },
+			/* 0x2C */      /* SUB AL Ib */                 (cpu) => { cpu.ax.Low = cpu.Sub8(false, cpu.ax.Low, cpu.ReadOpcodeIb()); return 1; },
+							/* SUB AX Iw */                 (cpu) => { cpu.ax.Word = cpu.Sub16(false, cpu.ax.Word, cpu.ReadOpcodeIw()); return 1; },
+							/* (Prefix CS) */               (cpu) => 0,
+							/* DAS */                       (cpu) => { cpu.Daa(true); return 10; },
+                            
+			/* 0x30 */      /* XOR Eb Gb */                 (cpu) => { cpu.WriteOpcodeEb(cpu.Xor8(cpu.ReadOpcodeEb(), cpu.ReadOpcodeGb())); return 1; },
+							/* XOR Ew Gw */                 (cpu) => { cpu.WriteOpcodeEw(cpu.Xor16(cpu.ReadOpcodeEw(), cpu.ReadOpcodeGw())); return 1; },
+							/* XOR Gb Eb */                 (cpu) => { cpu.WriteOpcodeGb(cpu.Xor8(cpu.ReadOpcodeGb(), cpu.ReadOpcodeEb())); return 1; },
+							/* XOR Gw Ew */                 (cpu) => { cpu.WriteOpcodeGw(cpu.Xor16(cpu.ReadOpcodeGw(), cpu.ReadOpcodeEw())); return 1; },
+			/* 0x34 */      /* XOR AL Ib */                 (cpu) => { cpu.ax.Low = cpu.Xor8(cpu.ax.Low, cpu.ReadOpcodeIb()); return 1; },
+							/* XOR AX Iw */                 (cpu) => { cpu.ax.Word = cpu.Xor16(cpu.ax.Word, cpu.ReadOpcodeIw()); return 1; },
+							/* (Prefix SS) */               (cpu) => 0,
+							/* AAA */                       (cpu) => { cpu.Aaa(false); return 9; },
+			/* 0x38 */      /* CMP Eb Gb */                 (cpu) => { cpu.Sub8(false, cpu.ReadOpcodeEb(), cpu.ReadOpcodeGb()); return 1; },
+							/* CMP Ew Gw */                 (cpu) => { cpu.Sub16(false, cpu.ReadOpcodeEw(), cpu.ReadOpcodeGw()); return 1; },
+							/* CMP Gb Eb */                 (cpu) => { cpu.Sub8(false, cpu.ReadOpcodeGb(), cpu.ReadOpcodeEb()); return 1; },
+							/* CMP Gw Ew */                 (cpu) => { cpu.Sub16(false, cpu.ReadOpcodeGw(), cpu.ReadOpcodeEw()); return 1; },
+			/* 0x3C */      /* CMP AL Ib */                 (cpu) => { cpu.Sub8(false, cpu.ax.Low, cpu.ReadOpcodeIb()); return 1; },
+							/* CMP AX Iw */                 (cpu) => { cpu.Sub16(false, cpu.ax.Word, cpu.ReadOpcodeIw()); return 1; },
+							/* (Prefix DS) */               (cpu) => 0,
+							/* AAS */                       (cpu) => { cpu.Aaa(true); return 9; },
+
+			/* 0x40 */      /* INC AX */                    (cpu) => { cpu.ax.Word = cpu.Inc16(cpu.ax.Word); return 1; },
+							/* INC CX */                    (cpu) => { cpu.cx.Word = cpu.Inc16(cpu.cx.Word); return 1; },
+							/* INC DX */                    (cpu) => { cpu.dx.Word = cpu.Inc16(cpu.dx.Word); return 1; },
+							/* INC BX */                    (cpu) => { cpu.bx.Word = cpu.Inc16(cpu.bx.Word); return 1; },
+			/* 0x44 */      /* INC SP */                    (cpu) => { cpu.sp = cpu.Inc16(cpu.sp); return 1; },
+							/* INC BP */                    (cpu) => { cpu.bp = cpu.Inc16(cpu.bp); return 1; },
+							/* INC SI */                    (cpu) => { cpu.si = cpu.Inc16(cpu.si); return 1; },
+							/* INC DI */                    (cpu) => { cpu.di = cpu.Inc16(cpu.di); return 1; },
+			/* 0x48 */      /* DEC AX */                    (cpu) => { cpu.ax.Word = cpu.Dec16(cpu.ax.Word); return 1; },
+							/* DEC CX */                    (cpu) => { cpu.cx.Word = cpu.Dec16(cpu.cx.Word); return 1; },
+							/* DEC DX */                    (cpu) => { cpu.dx.Word = cpu.Dec16(cpu.dx.Word); return 1; },
+							/* DEC BX */                    (cpu) => { cpu.bx.Word = cpu.Dec16(cpu.bx.Word); return 1; },
+			/* 0x4C */      /* DEC SP */                    (cpu) => { cpu.sp = cpu.Dec16(cpu.sp); return 1; },
+							/* DEC BP */                    (cpu) => { cpu.bp = cpu.Dec16(cpu.bp); return 1; },
+							/* DEC SI */                    (cpu) => { cpu.si = cpu.Dec16(cpu.si); return 1; },
+							/* DEC DI */                    (cpu) => { cpu.di = cpu.Dec16(cpu.di); return 1; },
+
+			/* 0x50 */      /* PUSH AX */                   (cpu) => { cpu.Push(cpu.ax.Word); return 1; },
+							/* PUSH CX */                   (cpu) => { cpu.Push(cpu.cx.Word); return 1; },
+							/* PUSH DX */                   (cpu) => { cpu.Push(cpu.dx.Word); return 1; },
+							/* PUSH BX */                   (cpu) => { cpu.Push(cpu.bx.Word); return 1; },
+			/* 0x54 */      /* PUSH SP */                   (cpu) => { cpu.Push(cpu.sp); return 1; },
+							/* PUSH BP */                   (cpu) => { cpu.Push(cpu.bp); return 1; },
+							/* PUSH SI */                   (cpu) => { cpu.Push(cpu.si); return 1; },
+							/* PUSH DI */                   (cpu) => { cpu.Push(cpu.di); return 1; },
+			/* 0x58 */      /* POP AX */                    (cpu) => { cpu.ax.Word = cpu.Pop(); return 1; },
+							/* POP CX */                    (cpu) => { cpu.cx.Word = cpu.Pop(); return 1; },
+							/* POP DX */                    (cpu) => { cpu.dx.Word = cpu.Pop(); return 1; },
+							/* POP BX */                    (cpu) => { cpu.bx.Word = cpu.Pop(); return 1; },
+			/* 0x5C */      /* POP SP */                    (cpu) => { cpu.sp = cpu.Pop(); return 1; },
+							/* POP BP */                    (cpu) => { cpu.bp = cpu.Pop(); return 1; },
+							/* POP SI */                    (cpu) => { cpu.si = cpu.Pop(); return 1; },
+							/* POP DI */                    (cpu) => { cpu.di = cpu.Pop(); return 1; },
+
+			/* 0x60 */      /* PUSHA */                     Opcode0x60,
+							/* POPA */                      Opcode0x61,
+							/* BOUND Gw E */                Opcode0x62,
+							/* (Invalid; NOP?) */			(cpu) => 3,
+			/* 0x64 */      /* (Invalid; NOP?) */			(cpu) => 3,
+							/* (Invalid; NOP?) */			(cpu) => 3,
+							/* (Invalid; NOP?) */			(cpu) => 3,
+							/* (Invalid; NOP?) */			(cpu) => 3,
+			/* 0x68 */      /* PUSH Iw */                   (cpu) => { cpu.Push(cpu.ReadOpcodeIw()); return 1; },
+							/* IMUL Gw Ew Iw */             (cpu) => { cpu.ReadModRM(); cpu.WriteOpcodeGw((ushort)cpu.Mul16(true, cpu.ReadOpcodeEw(), cpu.ReadOpcodeIw())); return 4; },
+							/* PUSH Ib */                   (cpu) => { cpu.Push((ushort)(sbyte)cpu.ReadOpcodeIb()); return 1; },
+							/* IMUL Gb Eb Ib */             (cpu) => { cpu.ReadModRM(); cpu.WriteOpcodeGw((ushort)cpu.Mul16(true, cpu.ReadOpcodeEw(), (ushort)(sbyte)cpu.ReadOpcodeIb())); return 4; },
+			/* 0x6C */      /* INSB */                      Opcode0x6C,
+							/* INSW */                      Opcode0x6D,
+							/* OUTSB */                     Opcode0x6E,
+							/* OUTSW */                     Opcode0x6F,
+
+			/* 0x70 */      /* JO */                        (cpu) => cpu.JumpConditional(cpu.IsFlagSet(Flags.Overflow)),
+							/* JNO */                       (cpu) => cpu.JumpConditional(!cpu.IsFlagSet(Flags.Overflow)),
+							/* JB */                        (cpu) => cpu.JumpConditional(cpu.IsFlagSet(Flags.Carry)),
+							/* JNB */                       (cpu) => cpu.JumpConditional(!cpu.IsFlagSet(Flags.Carry)),
+			/* 0x74 */      /* JZ */                        (cpu) => cpu.JumpConditional(cpu.IsFlagSet(Flags.Zero)),
+							/* JNZ */                       (cpu) => cpu.JumpConditional(!cpu.IsFlagSet(Flags.Zero)),
+							/* JBE */                       (cpu) => cpu.JumpConditional(cpu.IsFlagSet(Flags.Carry) || cpu.IsFlagSet(Flags.Zero)),
+							/* JA */                        (cpu) => cpu.JumpConditional(!cpu.IsFlagSet(Flags.Carry) && !cpu.IsFlagSet(Flags.Zero)),
+			/* 0x78 */      /* JS */                        (cpu) => cpu.JumpConditional(cpu.IsFlagSet(Flags.Sign)),
+							/* JNS */                       (cpu) => cpu.JumpConditional(!cpu.IsFlagSet(Flags.Sign)),
+							/* JPE */                       (cpu) => cpu.JumpConditional(cpu.IsFlagSet(Flags.Parity)),
+							/* JPO */                       (cpu) => cpu.JumpConditional(!cpu.IsFlagSet(Flags.Parity)),
+			/* 0x7C */      /* JL */                        (cpu) => cpu.JumpConditional(!cpu.IsFlagSet(Flags.Zero) && cpu.IsFlagSet(Flags.Sign) != cpu.IsFlagSet(Flags.Overflow)),
+							/* JGE */                       (cpu) => cpu.JumpConditional(cpu.IsFlagSet(Flags.Zero) || cpu.IsFlagSet(Flags.Sign) == cpu.IsFlagSet(Flags.Overflow)),
+							/* JLE */                       (cpu) => cpu.JumpConditional(cpu.IsFlagSet(Flags.Zero) || cpu.IsFlagSet(Flags.Sign) != cpu.IsFlagSet(Flags.Overflow)),
+							/* JG */                        (cpu) => cpu.JumpConditional(!cpu.IsFlagSet(Flags.Zero) && cpu.IsFlagSet(Flags.Sign) == cpu.IsFlagSet(Flags.Overflow)),
+
+			/* 0x80 */      /* GRP1 Eb Ib */                Opcode0x80,
+							/* GRP1 Ew Iw */                Opcode0x81,
+							/* GRP1 Eb Ib */                Opcode0x80,
+							/* GRP1 Ew Ib */                Opcode0x83,
+			/* 0x84 */      /* TEST Gb Eb */                (cpu) => { cpu.And8(cpu.ReadOpcodeGb(), cpu.ReadOpcodeEb()); return 1; },
+							/* TEST Gw Ew */                (cpu) => { cpu.And16(cpu.ReadOpcodeGw(), cpu.ReadOpcodeEw()); return 1; },
+							/* XCHG Gb Eb */                (cpu) => { var temp = cpu.ReadOpcodeGb(); cpu.WriteOpcodeGb(cpu.ReadOpcodeEb()); cpu.WriteOpcodeEb(temp); return 3; },
+							/* XCHG Gw Ew */                (cpu) => { var temp = cpu.ReadOpcodeGw(); cpu.WriteOpcodeGw(cpu.ReadOpcodeEw()); cpu.WriteOpcodeEw(temp); return 3; },
+			/* 0x88 */      /* MOV Eb Gb */                 (cpu) => { cpu.WriteOpcodeEb(cpu.ReadOpcodeGb()); return 1; },
+							/* MOV Ew Gw */                 (cpu) => { cpu.WriteOpcodeEw(cpu.ReadOpcodeGw()); return 1; },
+							/* MOV Gb Eb */                 (cpu) => { cpu.WriteOpcodeGb(cpu.ReadOpcodeEb()); return 1; },
+							/* MOV Gw Ew */                 (cpu) => { cpu.WriteOpcodeGw(cpu.ReadOpcodeEw()); return 1; },
+			/* 0x8C */      /* MOV Ew Sw */                 (cpu) => { cpu.WriteOpcodeEw(cpu.ReadOpcodeSw()); return 1; },
+							/* LEA Gw M */                  Opcode0x8D,
+							/* MOV Sw Ew */                 (cpu) => { cpu.WriteOpcodeSw(cpu.ReadOpcodeEw()); return 1; },
+							/* POP Ew */                    (cpu) => { cpu.WriteOpcodeEw(cpu.Pop()); return 1; },
+
+			/* 0x90 */      /* NOP (XCHG AX AX) */          (cpu) => { Exchange(ref cpu.ax.Word, ref cpu.ax.Word); return 3; },
+							/* XCHG CX AX */                (cpu) => { Exchange(ref cpu.cx.Word, ref cpu.ax.Word); return 3; },
+							/* XCHG DX AX */                (cpu) => { Exchange(ref cpu.dx.Word, ref cpu.ax.Word); return 3; },
+							/* XCHG BX AX */                (cpu) => { Exchange(ref cpu.bx.Word, ref cpu.ax.Word); return 3; },
+			/* 0x94 */      /* XCHG SP AX */                (cpu) => { Exchange(ref cpu.sp, ref cpu.ax.Word); return 3; },
+							/* XCHG BP AX */                (cpu) => { Exchange(ref cpu.bp, ref cpu.ax.Word); return 3; },
+							/* XCHG SI AX */                (cpu) => { Exchange(ref cpu.si, ref cpu.ax.Word); return 3; },
+							/* XCHG DI AX */                (cpu) => { Exchange(ref cpu.di, ref cpu.ax.Word); return 3; },
+			/* 0x98 */      /* CBW */                       (cpu) => { cpu.ax.Word = (ushort)(sbyte)cpu.ax.Low; return 2; },
+							/* CWD */                       (cpu) => { var value = (uint)(short)cpu.ax.Word; cpu.dx.Word = (ushort)((value >> 16) & 0xFFFF); cpu.ax.Word = (ushort)((value >> 0) & 0xFFFF); return 2; },
+							/* CALL Ap */                   Opcode0x9A,
+							/* WAIT */                      (cpu) => 1,
+			/* 0x9C */      /* PUSHF */                     (cpu) => { cpu.Push((ushort)cpu.flags); return 1; },
+							/* POPF */                      (cpu) => { cpu.flags = (Flags)cpu.Pop(); return 1; },
+							/* SAHF */                      Opcode0x9E,
+							/* LAHF */                      (cpu) => { cpu.ax.High = (byte)cpu.flags; return 2; },
+
+			/* 0xA0 */      /* MOV AL Aw */                 (cpu) => { cpu.ax.Low = cpu.ReadMemory8(cpu.GetSegmentViaOverride(SegmentNumber.DS), cpu.ReadOpcodeIw()); return 1; },
+							/* MOV AX Aw */                 (cpu) => { cpu.ax.Word = cpu.ReadMemory16(cpu.GetSegmentViaOverride(SegmentNumber.DS), cpu.ReadOpcodeIw()); return 1; },
+							/* MOV Aw AL */                 (cpu) => { cpu.WriteMemory8(cpu.GetSegmentViaOverride(SegmentNumber.DS), cpu.ReadOpcodeIw(), cpu.ax.Low); return 1; },
+							/* MOV Aw AX */                 (cpu) => { cpu.WriteMemory16(cpu.GetSegmentViaOverride(SegmentNumber.DS), cpu.ReadOpcodeIw(), cpu.ax.Word); return 1; },
+			/* 0xA4 */      /* MOVSB */                     Opcode0xA4,
+							/* MOVSW */                     Opcode0xA5,
+							/* CMPSB */                     Opcode0xA6,
+							/* CMPSW */                     Opcode0xA7,
+			/* 0xA8 */      /* TEST AL Ib */                (cpu) => { cpu.And8(cpu.ax.Low, cpu.ReadOpcodeIb()); return 1; },
+							/* TEST AX Iw */                (cpu) => { cpu.And16(cpu.ax.Word, cpu.ReadOpcodeIw()); return 1; },
+							/* STOSB */                     Opcode0xAA,
+							/* STOSW */                     Opcode0xAB,
+			/* 0xAC */      /* LODSB */                     Opcode0xAC,
+							/* LODSW */                     Opcode0xAD,
+							/* SCASB */                     Opcode0xAE,
+							/* SCASW */                     Opcode0xAF,
+
+			/* 0xB0 */      /* MOV AL Ib */                 (cpu) => { cpu.ax.Low = cpu.ReadOpcodeIb(); return 1; },
+							/* MOV CL Ib */                 (cpu) => { cpu.cx.Low = cpu.ReadOpcodeIb(); return 1; },
+							/* MOV DL Ib */                 (cpu) => { cpu.dx.Low = cpu.ReadOpcodeIb(); return 1; },
+							/* MOV BL Ib */                 (cpu) => { cpu.bx.Low = cpu.ReadOpcodeIb(); return 1; },
+			/* 0xB4 */      /* MOV AH Ib */                 (cpu) => { cpu.ax.High = cpu.ReadOpcodeIb(); return 1; },
+							/* MOV CH Ib */                 (cpu) => { cpu.cx.High = cpu.ReadOpcodeIb(); return 1; },
+							/* MOV DH Ib */                 (cpu) => { cpu.dx.High = cpu.ReadOpcodeIb(); return 1; },
+							/* MOV BH Ib */                 (cpu) => { cpu.bx.High = cpu.ReadOpcodeIb(); return 1; },
+			/* 0xB8 */      /* MOV AX Iw */                 (cpu) => { cpu.ax.Word = cpu.ReadOpcodeIw(); return 1; },
+							/* MOV CX Iw */                 (cpu) => { cpu.cx.Word = cpu.ReadOpcodeIw(); return 1; },
+							/* MOV DX Iw */                 (cpu) => { cpu.dx.Word = cpu.ReadOpcodeIw(); return 1; },
+							/* MOV BX Iw */                 (cpu) => { cpu.bx.Word = cpu.ReadOpcodeIw(); return 1; },
+			/* 0xBC */      /* MOV SP Iw */                 (cpu) => { cpu.sp = cpu.ReadOpcodeIw(); return 1; },
+							/* MOV BP Iw */                 (cpu) => { cpu.bp = cpu.ReadOpcodeIw(); return 1; },
+							/* MOV SI Iw */                 (cpu) => { cpu.si = cpu.ReadOpcodeIw(); return 1; },
+							/* MOV DI Iw */                 (cpu) => { cpu.di = cpu.ReadOpcodeIw(); return 1; },
+
+			/* 0xC0 */      /* GRP2 Eb Ib */                Opcode0xC0,
+							/* GRP2 Ew Ib */                Opcode0xC1,
+							/* RET Iw */                    (cpu) => { var offset = cpu.ReadOpcodeIw(); cpu.ip = cpu.Pop(); cpu.sp += offset; return 5; },
+							/* RET */                       (cpu) => { cpu.ip = cpu.Pop(); return 5; },
+			/* 0xC4 */      /* LES Gw Mp */                 Opcode0xC4,
+							/* LDS Gw Mp */                 Opcode0xC5,
+							/* MOV Eb Ib */                 (cpu) => { cpu.ReadModRM(); cpu.WriteOpcodeEb(cpu.ReadOpcodeIb()); return 1; },
+							/* MOV Ew Iw */                 (cpu) => { cpu.ReadModRM(); cpu.WriteOpcodeEw(cpu.ReadOpcodeIw()); return 1; },
+			/* 0xC8 */      /* ENTER */                     Opcode0xC8,
+							/* LEAVE */                     (cpu) => { cpu.sp = cpu.bp; cpu.bp = cpu.Pop(); return 1; },
+							/* RETF Iw */                   (cpu) => { var offset = cpu.ReadOpcodeIw(); cpu.ip = cpu.Pop(); cpu.cs = cpu.Pop(); cpu.sp += offset; return 8; },
+							/* RETF */                      (cpu) => { cpu.ip = cpu.Pop(); cpu.cs = cpu.Pop(); return 7; },
+			/* 0xCC */      /* INT 3 */                     (cpu) => { cpu.Interrupt(3); return 8; },
+							/* INT Ib */                    (cpu) => { cpu.Interrupt(cpu.ReadOpcodeIb()); return 9; },
+							/* INTO */                      (cpu) => { if (cpu.IsFlagSet(Flags.Overflow)) cpu.Interrupt(4); return 5; },
+							/* IRET */                      (cpu) => { cpu.ip = cpu.Pop(); cpu.cs = cpu.Pop(); cpu.flags = (Flags)cpu.Pop(); return 9; },
+
+			/* 0xD0 */      /* GRP2 Eb 1 */                 Opcode0xD0,
+							/* GRP2 Ew 1 */                 Opcode0xD1,
+							/* GRP2 Eb CL */                Opcode0xD2,
+							/* GRP2 Ew CL */                Opcode0xD3,
+			/* 0xD4 */      /* AAM */                       Opcode0xD4,
+							/* AAD */                       Opcode0xD5,
+							/* (undocumented XLAT) */       (cpu) => { cpu.ax.Low = cpu.ReadMemory8(cpu.GetSegmentViaOverride(SegmentNumber.DS), (ushort)(cpu.bx.Word + cpu.ax.Low)); return 4; },
+							/* XLAT */                      (cpu) => { cpu.ax.Low = cpu.ReadMemory8(cpu.GetSegmentViaOverride(SegmentNumber.DS), (ushort)(cpu.bx.Word + cpu.ax.Low)); return 4; },
+			/* 0xD8 */      /* (Invalid; NOP?) */			(cpu) => 3,
+							/* (Invalid; NOP?) */			(cpu) => 3,
+							/* (Invalid; NOP?) */			(cpu) => 3,
+							/* (Invalid; NOP?) */			(cpu) => 3,
+			/* 0xDC */      /* (Invalid; NOP?) */			(cpu) => 3,
+							/* (Invalid; NOP?) */			(cpu) => 3,
+							/* (Invalid; NOP?) */			(cpu) => 3,
+							/* (Invalid; NOP?) */			(cpu) => 3,
+
+			/* 0xE0 */      /* LOOPNZ Jb */                 (cpu) => { return cpu.LoopWhile(!cpu.IsFlagSet(Flags.Zero)); },
+							/* LOOPZ Jb */                  (cpu) => { return cpu.LoopWhile(cpu.IsFlagSet(Flags.Zero)); },
+							/* LOOP Jb */                   (cpu) => { return cpu.Loop(); },
+							/* JCXZ */                      (cpu) => { return cpu.JumpConditional(cpu.cx.Word == 0); },
+			/* 0xE4 */      /* IN Ib AL */                  (cpu) => { cpu.ax.Low = cpu.machine.ReadPort(cpu.ReadOpcodeIb()); return 6; },
+							/* IN Ib AX */                  (cpu) => { cpu.ax.Word = cpu.ReadPort16(cpu.ReadOpcodeIb()); return 6; },
+							/* OUT Ib AL */                 (cpu) => { cpu.machine.WritePort(cpu.ReadOpcodeIb(), cpu.ax.Low); return 6; },
+							/* OUT Ib AX */                 (cpu) => { cpu.WritePort16(cpu.ReadOpcodeIb(), cpu.ax.Word); return 6; },
+			/* 0xE8 */      /* CALL Jv */                   (cpu) => { var offset = cpu.ReadOpcodeIw(); cpu.Push(cpu.ip); cpu.ip += offset; return 4; },
+							/* JMP Jv */                    (cpu) => { var offset = cpu.ReadOpcodeIw(); cpu.ip += offset; return 3; },
+							/* JMP Ap */                    (cpu) => { var newIp = cpu.ReadOpcodeIw(); var newCs = cpu.ReadOpcodeIw(); cpu.ip = newIp; cpu.cs = newCs; return 5; },
+							/* JMP Jb */                    (cpu) => { cpu.ip = cpu.ReadOpcodeJb(); return 3; },
+			/* 0xEC */      /* IN AL DX */                  (cpu) => { cpu.ax.Low = cpu.machine.ReadPort(cpu.dx.Word); return 4; },
+							/* IN AX DX */                  (cpu) => { cpu.ax.Word = cpu.ReadPort16(cpu.dx.Word); return 4; },
+							/* OUT DX AL */                 (cpu) => { cpu.machine.WritePort(cpu.dx.Word, cpu.ax.Low); return 4; },
+							/* OUT DX AX */                 (cpu) => { cpu.WritePort16(cpu.dx.Word, cpu.ax.Word); return 4; },
+
+			/* 0xF0 */      /* (Prefix LOCK) */             (cpu) => 0,
+							/* (Invalid; NOP?) */			(cpu) => 3,
+							/* (Prefix REPNZ) */            (cpu) => 0,
+							/* (Prefix REPZ) */             (cpu) => 0,
+			/* 0xF4 */      /* HLT */                       (cpu) => { cpu.halted = true; return 8; },
+							/* CMC */                       (cpu) => { cpu.SetClearFlagConditional(Flags.Carry, !cpu.IsFlagSet(Flags.Carry)); return 4; },
+							/* GRP3 Eb */                   Opcode0xF6,
+							/* GRP3 Ew */                   Opcode0xF7,
+			/* 0xF8 */      /* CLC */                       (cpu) => { cpu.ClearFlags(Flags.Carry); return 4; },
+							/* STC */                       (cpu) => { cpu.SetFlags(Flags.Carry); return 4; },
+							/* CLI */                       (cpu) => { cpu.ClearFlags(Flags.InterruptEnable); return 4; },
+							/* STI */                       (cpu) => { cpu.SetFlags(Flags.InterruptEnable); return 4; },
+			/* 0xFC */      /* CLD */                       (cpu) => { cpu.ClearFlags(Flags.Direction); return 4; },
+							/* STD */                       (cpu) => { cpu.SetFlags(Flags.Direction); return 4; },
+							/* GRP4 Eb */                   Opcode0xFE,
+							/* GRP4 Ew */                   Opcode0xFF
+		};
+
+		private static int Opcode0x60(V30MZ cpu)
+		{
+			/* PUSHA */
+			var oldSp = cpu.sp;
+			cpu.Push(cpu.ax.Word);
+			cpu.Push(cpu.cx.Word);
+			cpu.Push(cpu.dx.Word);
+			cpu.Push(cpu.bx.Word);
+			cpu.Push(oldSp);
+			cpu.Push(cpu.bp);
+			cpu.Push(cpu.si);
+			cpu.Push(cpu.di);
+			return 8;
+		}
+
+		private static int Opcode0x61(V30MZ cpu)
+		{
+			/* POPA */
+			cpu.di = cpu.Pop();
+			cpu.si = cpu.Pop();
+			cpu.bp = cpu.Pop();
+			cpu.Pop(); /* don't restore SP */
+			cpu.bx.Word = cpu.Pop();
+			cpu.dx.Word = cpu.Pop();
+			cpu.cx.Word = cpu.Pop();
+			cpu.ax.Word = cpu.Pop();
+			return 8;
+		}
+
+		private static int Opcode0x62(V30MZ cpu)
+		{
+			/* BOUND Gw E */
+			cpu.ReadModRM();
+			var lo = cpu.ReadMemory16(cpu.modRm.Segment, (ushort)(cpu.modRm.Offset + 0));
+			var hi = cpu.ReadMemory16(cpu.modRm.Segment, (ushort)(cpu.modRm.Offset + 2));
+			var reg = cpu.GetRegister16((RegisterNumber16)cpu.modRm.Mem);
+			if (reg < lo || reg > hi) cpu.Interrupt(5);
+			return 12;
+		}
+
+		private static int Opcode0x6C(V30MZ cpu)
+		{
+			/* INSB */
+			var cycles = 5;
+			if (!cpu.prefixHasRepeat)
+				cpu.InString(false);
+			else if (cpu.cx.Word != 0)
+			{
+				do { cpu.InString(false); cycles += 5; } while (--cpu.cx.Word != 0);
+			}
+			return cycles;
+		}
+
+		private static int Opcode0x6D(V30MZ cpu)
+		{
+			/* INSW */
+			var cycles = 5;
+			if (!cpu.prefixHasRepeat)
+				cpu.InString(true);
+			else if (cpu.cx.Word != 0)
+			{
+				do { cpu.InString(true); cycles += 5; } while (--cpu.cx.Word != 0);
+			}
+			return cycles;
+		}
+
+		private static int Opcode0x6E(V30MZ cpu)
+		{
+			/* OUTSB */
+			var cycles = 5;
+			if (!cpu.prefixHasRepeat)
+				cpu.OutString(false);
+			else if (cpu.cx.Word != 0)
+			{
+				do { cpu.OutString(false); cycles += 6; } while (--cpu.cx.Word != 0);
+			}
+			return cycles;
+		}
+
+		private static int Opcode0x6F(V30MZ cpu)
+		{
+			/* OUTSW */
+			var cycles = 5;
+			if (!cpu.prefixHasRepeat)
+				cpu.OutString(true);
+			else if (cpu.cx.Word != 0)
+			{
+				do { cpu.OutString(true); cycles += 6; } while (--cpu.cx.Word != 0);
+			}
+			return cycles;
+		}
+
+		private static int Opcode0x80(V30MZ cpu)
+		{
+			/* GRP1 Eb Ib */
+			int cycles;
+			cpu.ReadModRM();
+			switch (cpu.modRm.Reg)
+			{
+				case 0x0: /* ADD */ cpu.WriteOpcodeEb(cpu.Add8(false, cpu.ReadOpcodeEb(), cpu.ReadOpcodeIb())); cycles = 1; break;
+				case 0x1: /* OR  */ cpu.WriteOpcodeEb(cpu.Or8(cpu.ReadOpcodeEb(), cpu.ReadOpcodeIb())); cycles = 1; break;
+				case 0x2: /* ADC */ cpu.WriteOpcodeEb(cpu.Add8(true, cpu.ReadOpcodeEb(), cpu.ReadOpcodeIb())); cycles = 1; break;
+				case 0x3: /* SBB */ cpu.WriteOpcodeEb(cpu.Sub8(true, cpu.ReadOpcodeEb(), cpu.ReadOpcodeIb())); cycles = 1; break;
+				case 0x4: /* AND */ cpu.WriteOpcodeEb(cpu.And8(cpu.ReadOpcodeEb(), cpu.ReadOpcodeIb())); cycles = 1; break;
+				case 0x5: /* SUB */ cpu.WriteOpcodeEb(cpu.Sub8(false, cpu.ReadOpcodeEb(), cpu.ReadOpcodeIb())); cycles = 1; break;
+				case 0x6: /* XOR */ cpu.WriteOpcodeEb(cpu.Xor8(cpu.ReadOpcodeEb(), cpu.ReadOpcodeIb())); cycles = 1; break;
+				case 0x7: /* CMP */ cpu.Sub8(false, cpu.ReadOpcodeEb(), cpu.ReadOpcodeIb()); cycles = 1; break;
+				default: throw new Exception("Invalid opcode");
+			}
+			return cycles;
+		}
+
+		private static int Opcode0x81(V30MZ cpu)
+		{
+			/* GRP1 Ew Iw */
+			int cycles;
+			cpu.ReadModRM();
+			switch (cpu.modRm.Reg)
+			{
+				case 0x0: /* ADD */ cpu.WriteOpcodeEw(cpu.Add16(false, cpu.ReadOpcodeEw(), cpu.ReadOpcodeIw())); cycles = 1; break;
+				case 0x1: /* OR  */ cpu.WriteOpcodeEw(cpu.Or16(cpu.ReadOpcodeEw(), cpu.ReadOpcodeIw())); cycles = 1; break;
+				case 0x2: /* ADC */ cpu.WriteOpcodeEw(cpu.Add16(true, cpu.ReadOpcodeEw(), cpu.ReadOpcodeIw())); cycles = 1; break;
+				case 0x3: /* SBB */ cpu.WriteOpcodeEw(cpu.Sub16(true, cpu.ReadOpcodeEw(), cpu.ReadOpcodeIw())); cycles = 1; break;
+				case 0x4: /* AND */ cpu.WriteOpcodeEw(cpu.And16(cpu.ReadOpcodeEw(), cpu.ReadOpcodeIw())); cycles = 1; break;
+				case 0x5: /* SUB */ cpu.WriteOpcodeEw(cpu.Sub16(false, cpu.ReadOpcodeEw(), cpu.ReadOpcodeIw())); cycles = 1; break;
+				case 0x6: /* XOR */ cpu.WriteOpcodeEw(cpu.Xor16(cpu.ReadOpcodeEw(), cpu.ReadOpcodeIw())); cycles = 1; break;
+				case 0x7: /* CMP */ cpu.Sub16(false, cpu.ReadOpcodeEw(), cpu.ReadOpcodeIw()); cycles = 1; break;
+				default: throw new Exception("Invalid opcode");
+			}
+			return cycles;
+		}
+
+		private static int Opcode0x83(V30MZ cpu)
+		{
+			/* GRP1 Ew Ib */
+			int cycles;
+			cpu.ReadModRM();
+			switch (cpu.modRm.Reg)
+			{
+				case 0x0: /* ADD */ cpu.WriteOpcodeEw(cpu.Add16(false, cpu.ReadOpcodeEw(), (ushort)(sbyte)cpu.ReadOpcodeIb())); cycles = 1; break;
+				case 0x1: /* OR  */ cpu.WriteOpcodeEw(cpu.Or16(cpu.ReadOpcodeEw(), (ushort)(sbyte)cpu.ReadOpcodeIb())); cycles = 1; break;
+				case 0x2: /* ADC */ cpu.WriteOpcodeEw(cpu.Add16(true, cpu.ReadOpcodeEw(), (ushort)(sbyte)cpu.ReadOpcodeIb())); cycles = 1; break;
+				case 0x3: /* SBB */ cpu.WriteOpcodeEw(cpu.Sub16(true, cpu.ReadOpcodeEw(), (ushort)(sbyte)cpu.ReadOpcodeIb())); cycles = 1; break;
+				case 0x4: /* AND */ cpu.WriteOpcodeEw(cpu.And16(cpu.ReadOpcodeEw(), (ushort)(sbyte)cpu.ReadOpcodeIb())); cycles = 1; break;
+				case 0x5: /* SUB */ cpu.WriteOpcodeEw(cpu.Sub16(false, cpu.ReadOpcodeEw(), (ushort)(sbyte)cpu.ReadOpcodeIb())); cycles = 1; break;
+				case 0x6: /* XOR */ cpu.WriteOpcodeEw(cpu.Xor16(cpu.ReadOpcodeEw(), (ushort)(sbyte)cpu.ReadOpcodeIb())); cycles = 1; break;
+				case 0x7: /* CMP */ cpu.Sub16(false, cpu.ReadOpcodeEw(), (ushort)(sbyte)cpu.ReadOpcodeIb()); cycles = 1; break;
+				default: throw new Exception("Invalid opcode");
+			}
+			return cycles;
+		}
+
+		private static int Opcode0x8D(V30MZ cpu)
+		{
+			/* LEA Gw M */
+			cpu.ReadModRM();
+			if (cpu.modRm.Mod != ModRM.Modes.Register)
+			{
+				cpu.WriteOpcodeGw(cpu.modRm.Offset);
+			}
+			return 8;
+		}
+
+		private static int Opcode0x9A(V30MZ cpu)
+		{
+			/* CALL Ap */
+			var newIp = cpu.ReadOpcodeIw();
+			var newCs = cpu.ReadOpcodeIw();
+
+			cpu.Push(cpu.cs);
+			cpu.Push(cpu.ip);
+
+			cpu.ip = newIp;
+			cpu.cs = newCs;
+
+			return 9;
+		}
+
+		private static int Opcode0x9E(V30MZ cpu)
+		{
+			/* SAHF */
+			cpu.SetClearFlagConditional(Flags.Sign, ((Flags)cpu.ax.High & Flags.Sign) == Flags.Sign);
+			cpu.SetClearFlagConditional(Flags.Zero, ((Flags)cpu.ax.High & Flags.Zero) == Flags.Zero);
+			cpu.SetClearFlagConditional(Flags.Auxiliary, ((Flags)cpu.ax.High & Flags.Auxiliary) == Flags.Auxiliary);
+			cpu.SetClearFlagConditional(Flags.Parity, ((Flags)cpu.ax.High & Flags.Parity) == Flags.Parity);
+			cpu.SetClearFlagConditional(Flags.Carry, ((Flags)cpu.ax.High & Flags.Carry) == Flags.Carry);
+			return 4;
+		}
+
+		private static int Opcode0xA4(V30MZ cpu)
+		{
+			/* MOVSB */
+			var cycles = 5;
+			if (!cpu.prefixHasRepeat)
+				cpu.MoveString(false);
+			else if (cpu.cx.Word != 0)
+			{
+				do { cpu.MoveString(false); cycles += 5; } while (--cpu.cx.Word != 0);
+			}
+			return cycles;
+		}
+
+		private static int Opcode0xA5(V30MZ cpu)
+		{
+			/* MOVSW */
+			var cycles = 5;
+			if (!cpu.prefixHasRepeat)
+				cpu.MoveString(true);
+			else if (cpu.cx.Word != 0)
+			{
+				do { cpu.MoveString(true); cycles += 5; } while (--cpu.cx.Word != 0);
+			}
+			return cycles;
+		}
+
+		private static int Opcode0xA6(V30MZ cpu)
+		{
+			/* CMPSB */
+			var cycles = 5;
+			if (!cpu.prefixHasRepeat)
+				cpu.CompareString(false);
+			else if (cpu.cx.Word != 0)
+			{
+				do { cpu.CompareString(false); cycles += 4; } while (--cpu.cx.Word != 0 && (cpu.prefixRepeatOnNotEqual ? !cpu.IsFlagSet(Flags.Zero) : cpu.IsFlagSet(Flags.Zero)));
+			}
+			return cycles;
+		}
+
+		private static int Opcode0xA7(V30MZ cpu)
+		{
+			/* CMPSW */
+			var cycles = 5;
+			if (!cpu.prefixHasRepeat)
+				cpu.CompareString(true);
+			else if (cpu.cx.Word != 0)
+			{
+				do { cpu.CompareString(true); cycles += 4; } while (--cpu.cx.Word != 0 && (cpu.prefixRepeatOnNotEqual ? !cpu.IsFlagSet(Flags.Zero) : cpu.IsFlagSet(Flags.Zero)));
+			}
+			return cycles;
+		}
+
+		private static int Opcode0xAA(V30MZ cpu)
+		{
+			/* STOSB */
+			var cycles = 5;
+			if (!cpu.prefixHasRepeat)
+				cpu.StoreString(false);
+			else if (cpu.cx.Word != 0)
+			{
+				do { cpu.StoreString(false); cycles += 2; } while (--cpu.cx.Word != 0);
+			}
+			return cycles;
+		}
+
+		private static int Opcode0xAB(V30MZ cpu)
+		{
+			/* STOSW */
+			var cycles = 5;
+			if (!cpu.prefixHasRepeat)
+				cpu.StoreString(true);
+			else if (cpu.cx.Word != 0)
+			{
+				do { cpu.StoreString(true); cycles += 2; } while (--cpu.cx.Word != 0);
+			}
+			return cycles;
+		}
+
+		private static int Opcode0xAC(V30MZ cpu)
+		{
+			/* LODSB */
+			var cycles = 5;
+			if (!cpu.prefixHasRepeat)
+				cpu.LoadString(false);
+			else if (cpu.cx.Word != 0)
+			{
+				do { cpu.LoadString(false); cycles += 2; } while (--cpu.cx.Word != 0);
+			}
+			return cycles;
+		}
+
+		private static int Opcode0xAD(V30MZ cpu)
+		{
+			/* LODSW */
+			var cycles = 5;
+			if (!cpu.prefixHasRepeat)
+				cpu.LoadString(true);
+			else if (cpu.cx.Word != 0)
+			{
+				do { cpu.LoadString(true); cycles += 2; } while (--cpu.cx.Word != 0);
+			}
+			return cycles;
+		}
+
+		private static int Opcode0xAE(V30MZ cpu)
+		{
+			/* SCASB */
+			var cycles = 5;
+			if (!cpu.prefixHasRepeat)
+				cpu.ScanString(false);
+			else if (cpu.cx.Word != 0)
+			{
+				do { cpu.ScanString(false); cycles += 3; } while (--cpu.cx.Word != 0 && (cpu.prefixRepeatOnNotEqual ? !cpu.IsFlagSet(Flags.Zero) : cpu.IsFlagSet(Flags.Zero)));
+			}
+			return cycles;
+		}
+
+		private static int Opcode0xAF(V30MZ cpu)
+		{
+			/* SCASW */
+			var cycles = 5;
+			if (!cpu.prefixHasRepeat)
+				cpu.ScanString(true);
+			else if (cpu.cx.Word != 0)
+			{
+				do { cpu.ScanString(true); cycles += 3; } while (--cpu.cx.Word != 0 && (cpu.prefixRepeatOnNotEqual ? !cpu.IsFlagSet(Flags.Zero) : cpu.IsFlagSet(Flags.Zero)));
+			}
+			return cycles;
+		}
+
+		private static int Opcode0xC0(V30MZ cpu)
+		{
+			/* GRP2 Eb Ib */
+			int cycles;
+			cpu.ReadModRM();
+			switch (cpu.modRm.Reg)
+			{
+				case 0x0: /* ROL */ cpu.WriteOpcodeEb(cpu.Rol8(false, cpu.ReadOpcodeEb(), cpu.ReadOpcodeIb())); cycles = 3; break;
+				case 0x1: /* ROR */ cpu.WriteOpcodeEb(cpu.Ror8(false, cpu.ReadOpcodeEb(), cpu.ReadOpcodeIb())); cycles = 3; break;
+				case 0x2: /* RCL */ cpu.WriteOpcodeEb(cpu.Rol8(true, cpu.ReadOpcodeEb(), cpu.ReadOpcodeIb())); cycles = 3; break;
+				case 0x3: /* RCR */ cpu.WriteOpcodeEb(cpu.Ror8(true, cpu.ReadOpcodeEb(), cpu.ReadOpcodeIb())); cycles = 3; break;
+				case 0x4: /* SHL */ cpu.WriteOpcodeEb(cpu.Shl8(cpu.ReadOpcodeEb(), cpu.ReadOpcodeIb())); cycles = 3; break;
+				case 0x5: /* SHR */ cpu.WriteOpcodeEb(cpu.Shr8(false, cpu.ReadOpcodeEb(), cpu.ReadOpcodeIb())); cycles = 3; break;
+				case 0x6: /* --- */ cycles = 3; break;
+				case 0x7: /* SAR */ cpu.WriteOpcodeEb(cpu.Shr8(true, cpu.ReadOpcodeEb(), cpu.ReadOpcodeIb())); cycles = 3; break;
+				default: throw new Exception("Invalid opcode");
+			}
+			return cycles;
+		}
+
+		private static int Opcode0xC1(V30MZ cpu)
+		{
+			/* GRP2 Ew Ib */
+			int cycles;
+			cpu.ReadModRM();
+			switch (cpu.modRm.Reg)
+			{
+				case 0x0: /* ROL */ cpu.WriteOpcodeEw(cpu.Rol16(false, cpu.ReadOpcodeEw(), cpu.ReadOpcodeIb())); cycles = 3; break;
+				case 0x1: /* ROR */ cpu.WriteOpcodeEw(cpu.Ror16(false, cpu.ReadOpcodeEw(), cpu.ReadOpcodeIb())); cycles = 3; break;
+				case 0x2: /* RCL */ cpu.WriteOpcodeEw(cpu.Rol16(true, cpu.ReadOpcodeEw(), cpu.ReadOpcodeIb())); cycles = 3; break;
+				case 0x3: /* RCR */ cpu.WriteOpcodeEw(cpu.Ror16(true, cpu.ReadOpcodeEw(), cpu.ReadOpcodeIb())); cycles = 3; break;
+				case 0x4: /* SHL */ cpu.WriteOpcodeEw(cpu.Shl16(cpu.ReadOpcodeEw(), cpu.ReadOpcodeIb())); cycles = 3; break;
+				case 0x5: /* SHR */ cpu.WriteOpcodeEw(cpu.Shr16(false, cpu.ReadOpcodeEw(), cpu.ReadOpcodeIb())); cycles = 3; break;
+				case 0x6: /* --- */ cycles = 3; break;
+				case 0x7: /* SAR */ cpu.WriteOpcodeEw(cpu.Shr16(true, cpu.ReadOpcodeEw(), cpu.ReadOpcodeIb())); cycles = 3; break;
+				default: throw new Exception("Invalid opcode");
+			}
+			return cycles;
+		}
+
+		private static int Opcode0xC4(V30MZ cpu)
+		{
+			/* LES Gw Mp */
+			cpu.ReadModRM();
+			if (cpu.modRm.Mod != ModRM.Modes.Register)
+			{
+				cpu.WriteOpcodeGw(cpu.ReadOpcodeEw());
+				cpu.es = cpu.ReadMemory16(cpu.modRm.Segment, (ushort)(cpu.modRm.Offset + 2));
+			}
+			return 8;
+		}
+
+		private static int Opcode0xC5(V30MZ cpu)
+		{
+			/* LDS Gw Mp */
+			cpu.ReadModRM();
+			if (cpu.modRm.Mod != ModRM.Modes.Register)
+			{
+				cpu.WriteOpcodeGw(cpu.ReadOpcodeEw());
+				cpu.ds = cpu.ReadMemory16(cpu.modRm.Segment, (ushort)(cpu.modRm.Offset + 2));
+			}
+			return 8;
+		}
+
+		private static int Opcode0xC8(V30MZ cpu)
+		{
+			/* ENTER */
+			var offset = cpu.ReadOpcodeIw();
+			var length = (byte)(cpu.ReadOpcodeIb() & 0x1F);
+
+			cpu.Push(cpu.bp);
+			cpu.bp = cpu.sp;
+			cpu.sp -= offset;
+
+			if (length != 0)
+			{
+				for (var i = 1; i < length; i++)
+					cpu.Push(cpu.ReadMemory16(cpu.ss, (ushort)(cpu.bp - i * 2)));
+				cpu.Push(cpu.bp);
+			}
+			return 7;
+		}
+
+		private static int Opcode0xD0(V30MZ cpu)
+		{
+			/* GRP2 Eb 1 */
+			int cycles;
+			cpu.ReadModRM();
+			switch (cpu.modRm.Reg)
+			{
+				case 0x0: /* ROL */ cpu.WriteOpcodeEb(cpu.Rol8(false, cpu.ReadOpcodeEb(), 1)); cycles = 1; break;
+				case 0x1: /* ROR */ cpu.WriteOpcodeEb(cpu.Ror8(false, cpu.ReadOpcodeEb(), 1)); cycles = 1; break;
+				case 0x2: /* RCL */ cpu.WriteOpcodeEb(cpu.Rol8(true, cpu.ReadOpcodeEb(), 1)); cycles = 1; break;
+				case 0x3: /* RCR */ cpu.WriteOpcodeEb(cpu.Ror8(true, cpu.ReadOpcodeEb(), 1)); cycles = 1; break;
+				case 0x4: /* SHL */ cpu.WriteOpcodeEb(cpu.Shl8(cpu.ReadOpcodeEb(), 1)); cycles = 1; break;
+				case 0x5: /* SHR */ cpu.WriteOpcodeEb(cpu.Shr8(false, cpu.ReadOpcodeEb(), 1)); cycles = 1; break;
+				case 0x6: /* --- */ cycles = 3; break;
+				case 0x7: /* SAR */ cpu.WriteOpcodeEb(cpu.Shr8(true, cpu.ReadOpcodeEb(), 1)); cycles = 1; break;
+				default: throw new Exception("Invalid opcode");
+			}
+			return cycles;
+		}
+
+		private static int Opcode0xD1(V30MZ cpu)
+		{
+			/* GRP2 Ew 1 */
+			int cycles;
+			cpu.ReadModRM();
+			switch (cpu.modRm.Reg)
+			{
+				case 0x0: /* ROL */ cpu.WriteOpcodeEw(cpu.Rol16(false, cpu.ReadOpcodeEw(), 1)); cycles = 1; break;
+				case 0x1: /* ROR */ cpu.WriteOpcodeEw(cpu.Ror16(false, cpu.ReadOpcodeEw(), 1)); cycles = 1; break;
+				case 0x2: /* RCL */ cpu.WriteOpcodeEw(cpu.Rol16(true, cpu.ReadOpcodeEw(), 1)); cycles = 1; break;
+				case 0x3: /* RCR */ cpu.WriteOpcodeEw(cpu.Ror16(true, cpu.ReadOpcodeEw(), 1)); cycles = 1; break;
+				case 0x4: /* SHL */ cpu.WriteOpcodeEw(cpu.Shl16(cpu.ReadOpcodeEw(), 1)); cycles = 1; break;
+				case 0x5: /* SHR */ cpu.WriteOpcodeEw(cpu.Shr16(false, cpu.ReadOpcodeEw(), 1)); cycles = 1; break;
+				case 0x6: /* --- */ cycles = 3; break;
+				case 0x7: /* SAR */ cpu.WriteOpcodeEw(cpu.Shr16(true, cpu.ReadOpcodeEw(), 1)); cycles = 1; break;
+				default: throw new Exception("Invalid opcode");
+			}
+			return cycles;
+		}
+
+		private static int Opcode0xD2(V30MZ cpu)
+		{
+			/* GRP2 Eb CL */
+			int cycles;
+			cpu.ReadModRM();
+			switch (cpu.modRm.Reg)
+			{
+				case 0x0: /* ROL */ cpu.WriteOpcodeEb(cpu.Rol8(false, cpu.ReadOpcodeEb(), cpu.cx.Low)); cycles = 3; break;
+				case 0x1: /* ROR */ cpu.WriteOpcodeEb(cpu.Ror8(false, cpu.ReadOpcodeEb(), cpu.cx.Low)); cycles = 3; break;
+				case 0x2: /* RCL */ cpu.WriteOpcodeEb(cpu.Rol8(true, cpu.ReadOpcodeEb(), cpu.cx.Low)); cycles = 3; break;
+				case 0x3: /* RCR */ cpu.WriteOpcodeEb(cpu.Ror8(true, cpu.ReadOpcodeEb(), cpu.cx.Low)); cycles = 3; break;
+				case 0x4: /* SHL */ cpu.WriteOpcodeEb(cpu.Shl8(cpu.ReadOpcodeEb(), cpu.cx.Low)); cycles = 3; break;
+				case 0x5: /* SHR */ cpu.WriteOpcodeEb(cpu.Shr8(false, cpu.ReadOpcodeEb(), cpu.cx.Low)); cycles = 3; break;
+				case 0x6: /* --- */ cycles = 3; break;
+				case 0x7: /* SAR */ cpu.WriteOpcodeEb(cpu.Shr8(true, cpu.ReadOpcodeEb(), cpu.cx.Low)); cycles = 3; break;
+				default: throw new Exception("Invalid opcode");
+			}
+			return cycles;
+		}
+
+		private static int Opcode0xD3(V30MZ cpu)
+		{
+			/* GRP2 Ew CL */
+			int cycles;
+			cpu.ReadModRM();
+			switch (cpu.modRm.Reg)
+			{
+				case 0x0: /* ROL */ cpu.WriteOpcodeEw(cpu.Rol16(false, cpu.ReadOpcodeEw(), cpu.cx.Low)); cycles = 3; break;
+				case 0x1: /* ROR */ cpu.WriteOpcodeEw(cpu.Ror16(false, cpu.ReadOpcodeEw(), cpu.cx.Low)); cycles = 3; break;
+				case 0x2: /* RCL */ cpu.WriteOpcodeEw(cpu.Rol16(true, cpu.ReadOpcodeEw(), cpu.cx.Low)); cycles = 3; break;
+				case 0x3: /* RCR */ cpu.WriteOpcodeEw(cpu.Ror16(true, cpu.ReadOpcodeEw(), cpu.cx.Low)); cycles = 3; break;
+				case 0x4: /* SHL */ cpu.WriteOpcodeEw(cpu.Shl16(cpu.ReadOpcodeEw(), cpu.cx.Low)); cycles = 3; break;
+				case 0x5: /* SHR */ cpu.WriteOpcodeEw(cpu.Shr16(false, cpu.ReadOpcodeEw(), cpu.cx.Low)); cycles = 3; break;
+				case 0x6: /* --- */ cycles = 3; break;
+				case 0x7: /* SAR */ cpu.WriteOpcodeEw(cpu.Shr16(true, cpu.ReadOpcodeEw(), cpu.cx.Low)); cycles = 3; break;
+				default: throw new Exception("Invalid opcode");
+			}
+			return cycles;
+		}
+
+		/* NOTE: AAM/AAD: While NEC V20/V30 do ignore immediate & always use base 10 (1), V30MZ does *not* ignore the immediate (2)
+		 * (1): https://www.vcfed.org/forum/forum/technical-support/vintage-computer-programming/36551/
+		 * (2): https://github.com/xdanieldzd/StoicGoose/issues/9
+		 */
+
+		private static int Opcode0xD4(V30MZ cpu)
+		{
+			/* AAM */
+			var value = cpu.ReadOpcodeIb();
+			if (value == 0)
+			{
+				/* Division-by-zero exception */
+				cpu.Interrupt(0);
+			}
+			else
+			{
+				cpu.ax.High = (byte)(cpu.ax.Low / value);
+				cpu.ax.Low = (byte)(cpu.ax.Low % value);
+				cpu.SetClearFlagConditional(Flags.Parity, CalculateParity(cpu.ax.Low));
+				cpu.SetClearFlagConditional(Flags.Zero, (cpu.ax.Word & 0xFFFF) == 0);
+				cpu.SetClearFlagConditional(Flags.Sign, (cpu.ax.Word & 0x8000) != 0);
+			}
+			return 16;
+		}
+
+		private static int Opcode0xD5(V30MZ cpu)
+		{
+			/* AAD */
+			var value = cpu.ReadOpcodeIb();
+			cpu.ax.Low = (byte)(cpu.ax.High * value + cpu.ax.Low);
+			cpu.ax.High = 0;
+			cpu.SetClearFlagConditional(Flags.Parity, CalculateParity(cpu.ax.Low));
+			cpu.SetClearFlagConditional(Flags.Zero, (cpu.ax.Word & 0xFFFF) == 0);
+			cpu.SetClearFlagConditional(Flags.Sign, (cpu.ax.Word & 0x8000) != 0);
+			return 6;
+		}
+
+		private static int Opcode0xF6(V30MZ cpu)
+		{
+			/* GRP3 Eb */
+			int cycles;
+			cpu.ReadModRM();
+			switch (cpu.modRm.Reg)
+			{
+				case 0x0: /* TEST */ cpu.And8(cpu.ReadOpcodeEb(), cpu.ReadOpcodeIb()); cycles = 1; break;
+				case 0x1: /* --- */ cycles = 3; break;
+				case 0x2: /* NOT */ cpu.WriteOpcodeEb((byte)~cpu.ReadOpcodeEb()); cycles = 1; break;
+				case 0x3: /* NEG */ cpu.WriteOpcodeEb(cpu.Neg8(cpu.ReadOpcodeEb())); cycles = 1; break;
+				case 0x4: /* MUL */ cpu.ax.Word = cpu.Mul8(false, cpu.ax.Low, cpu.ReadOpcodeEb()); cycles = 3; break;
+				case 0x5: /* IMUL */ cpu.ax.Word = cpu.Mul8(true, cpu.ax.Low, cpu.ReadOpcodeEb()); cycles = 3; break;
+				case 0x6: /* DIV */ cpu.ax.Word = cpu.Div8(false, cpu.ax.Word, cpu.ReadOpcodeEb()); cycles = 15; break;
+				case 0x7: /* IDIV */ cpu.ax.Word = cpu.Div8(true, cpu.ax.Word, cpu.ReadOpcodeEb()); cycles = 17; break;
+				default: throw new Exception("Invalid opcode");
+			}
+			return cycles;
+		}
+
+		private static int Opcode0xF7(V30MZ cpu)
+		{
+			/* GRP3 Ew */
+			int cycles;
+			cpu.ReadModRM();
+			switch (cpu.modRm.Reg)
+			{
+				case 0x0: /* TEST */ cpu.And16(cpu.ReadOpcodeEw(), cpu.ReadOpcodeIw()); cycles = 1; break;
+				case 0x1: /* --- */ cycles = 3; break;
+				case 0x2: /* NOT */ cpu.WriteOpcodeEw((ushort)~cpu.ReadOpcodeEw()); cycles = 1; break;
+				case 0x3: /* NEG */ cpu.WriteOpcodeEw(cpu.Neg16(cpu.ReadOpcodeEw())); cycles = 1; break;
+				case 0x4: /* MUL */ { var result = cpu.Mul16(false, cpu.ax.Word, cpu.ReadOpcodeEw()); cpu.dx.Word = (ushort)((result >> 16) & 0xFFFF); cpu.ax.Word = (ushort)((result >> 0) & 0xFFFF); cycles = 3; } break;
+				case 0x5: /* IMUL */ { var result = cpu.Mul16(true, cpu.ax.Word, cpu.ReadOpcodeEw()); cpu.dx.Word = (ushort)((result >> 16) & 0xFFFF); cpu.ax.Word = (ushort)((result >> 0) & 0xFFFF); cycles = 3; } break;
+				case 0x6: /* DIV */ { var result = cpu.Div16(false, (uint)(cpu.dx.Word << 16 | cpu.ax.Word), cpu.ReadOpcodeEw()); cpu.dx.Word = (ushort)((result >> 16) & 0xFFFF); cpu.ax.Word = (ushort)((result >> 0) & 0xFFFF); cycles = 23; } break;
+				case 0x7: /* IDIV */ { var result = cpu.Div16(true, (uint)(cpu.dx.Word << 16 | cpu.ax.Word), cpu.ReadOpcodeEw()); cpu.dx.Word = (ushort)((result >> 16) & 0xFFFF); cpu.ax.Word = (ushort)((result >> 0) & 0xFFFF); cycles = 24; } break;
+				default: throw new Exception("Invalid opcode");
+			}
+			return cycles;
+		}
+
+		private static int Opcode0xFE(V30MZ cpu)
+		{
+			/* GRP4 Eb */
+			int cycles;
+			cpu.ReadModRM();
+			switch (cpu.modRm.Reg)
+			{
+				case 0x0: /* INC */ cpu.WriteOpcodeEb(cpu.Inc8(cpu.ReadOpcodeEb())); cycles = 1; break;
+				case 0x1: /* DEC */ cpu.WriteOpcodeEb(cpu.Dec8(cpu.ReadOpcodeEb())); cycles = 1; break;
+				default: throw new Exception("Invalid opcode");
+			}
+			return cycles;
+		}
+
+		private static int Opcode0xFF(V30MZ cpu)
+		{
+			/* GRP4 Ew */
+			int cycles;
+			cpu.ReadModRM();
+			switch (cpu.modRm.Reg)
+			{
+				case 0x0: /* INC */ cpu.WriteOpcodeEw(cpu.Inc16(cpu.ReadOpcodeEw())); cycles = 1; break;
+				case 0x1: /* DEC */ cpu.WriteOpcodeEw(cpu.Dec16(cpu.ReadOpcodeEw())); cycles = 1; break;
+				case 0x2: /* CALL */
+					{
+						var offset = cpu.ReadOpcodeEw();
+						cpu.Push(cpu.ip);
+						cpu.ip = offset;
+						cycles = 5;
+					}
+					break;
+				case 0x3: /* CALL Mp */
+					{
+						if (cpu.modRm.Mod != ModRM.Modes.Register)
+						{
+							var offset = cpu.ReadMemory16(cpu.modRm.Segment, (ushort)(cpu.modRm.Offset + 0));
+							var segment = cpu.ReadMemory16(cpu.modRm.Segment, (ushort)(cpu.modRm.Offset + 2));
+							cpu.Push(cpu.cs);
+							cpu.Push(cpu.ip);
+							cpu.cs = segment;
+							cpu.ip = offset;
+						}
+						cycles = 11;
+					}
+					break;
+				case 0x4: /* JMP */ cpu.ip = cpu.ReadOpcodeEw(); cycles = 4; break;
+				case 0x5: /* JMP Mp */
+					{
+						if (cpu.modRm.Mod != ModRM.Modes.Register)
+						{
+							cpu.ip = cpu.ReadMemory16(cpu.modRm.Segment, (ushort)(cpu.modRm.Offset + 0));
+							cpu.cs = cpu.ReadMemory16(cpu.modRm.Segment, (ushort)(cpu.modRm.Offset + 2));
+						}
+						cycles = 9;
+					}
+					break;
+				case 0x6: /* PUSH */ cpu.Push(cpu.ReadOpcodeEw()); cycles = 3; break;
+				case 0x7: /* --- */ cycles = 3; break;
+				default: throw new Exception("Invalid opcode");
+			}
+			return cycles;
+		}
+	}
+}

AxibugEmuOnline.Client/Assets/Plugins/StoicGooseUnity/StoicGoose.Core/CPU/V30MZ.OpcodeTable.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 7f721c42886f2904c9a7eda1c94b6d14

AxibugEmuOnline.Client/Assets/Plugins/StoicGooseUnity/StoicGoose.Core/CPU/V30MZ.Prefixes.cs

@@ -0,0 +1,71 @@
+namespace StoicGoose.Core.CPU
+{
+	public sealed partial class V30MZ
+	{
+		SegmentNumber prefixSegOverride;
+		bool prefixHasRepeat;
+		bool prefixRepeatOnNotEqual;
+
+		private void ResetPrefixes()
+		{
+			prefixSegOverride = SegmentNumber.Unset;
+			prefixHasRepeat = false;
+			prefixRepeatOnNotEqual = false;
+		}
+
+		private bool HandlePrefixes(byte op)
+		{
+			var isOpcode = true;
+
+			switch (op)
+			{
+				/* Prefixes */
+				case 0x26:
+					/* :ES */
+					prefixSegOverride = SegmentNumber.ES;
+					isOpcode = false;
+					break;
+
+				case 0x2E:
+					/* :CS */
+					prefixSegOverride = SegmentNumber.CS;
+					isOpcode = false;
+					break;
+
+				case 0x36:
+					/* :SS */
+					prefixSegOverride = SegmentNumber.SS;
+					isOpcode = false;
+					break;
+
+				case 0x3E:
+					/* :DS */
+					prefixSegOverride = SegmentNumber.DS;
+					isOpcode = false;
+					break;
+
+				case 0xF0:
+					/* LOCK */
+					//TODO: implement??
+					isOpcode = false;
+					break;
+
+				case 0xF2:
+					/* REPNE */
+					prefixHasRepeat = true;
+					prefixRepeatOnNotEqual = true;
+					isOpcode = false;
+					break;
+
+				case 0xF3:
+					/* REP/REPE */
+					prefixHasRepeat = true;
+					prefixRepeatOnNotEqual = false;
+					isOpcode = false;
+					break;
+			}
+
+			return isOpcode;
+		}
+	}
+}

AxibugEmuOnline.Client/Assets/Plugins/StoicGooseUnity/StoicGoose.Core/CPU/V30MZ.Prefixes.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: dff52160b1aa55c48a07722be9d654ff

AxibugEmuOnline.Client/Assets/Plugins/StoicGooseUnity/StoicGoose.Core/CPU/V30MZ.Registers.cs

@@ -0,0 +1,111 @@
+using System;
+using System.Runtime.InteropServices;
+
+namespace StoicGoose.Core.CPU
+{
+	public sealed partial class V30MZ
+	{
+		enum RegisterNumber8 : byte
+		{
+			AL = 0b000,
+			CL = 0b001,
+			DL = 0b010,
+			BL = 0b011,
+			AH = 0b100,
+			CH = 0b101,
+			DH = 0b110,
+			BH = 0b111
+		}
+
+		enum RegisterNumber16 : byte
+		{
+			AX = 0b000,
+			CX = 0b001,
+			DX = 0b010,
+			BX = 0b011,
+			SP = 0b100,
+			BP = 0b101,
+			SI = 0b110,
+			DI = 0b111
+		}
+
+		private byte GetRegister8(RegisterNumber8 reg)
+		{
+			return reg switch
+			{
+				RegisterNumber8.AL => ax.Low,
+				RegisterNumber8.CL => cx.Low,
+				RegisterNumber8.DL => dx.Low,
+				RegisterNumber8.BL => bx.Low,
+				RegisterNumber8.AH => ax.High,
+				RegisterNumber8.CH => cx.High,
+				RegisterNumber8.DH => dx.High,
+				RegisterNumber8.BH => bx.High,
+				_ => throw new ArgumentException("Invalid register", nameof(reg)),
+			};
+		}
+
+		private ushort GetRegister16(RegisterNumber16 reg)
+		{
+			return reg switch
+			{
+				RegisterNumber16.AX => ax.Word,
+				RegisterNumber16.CX => cx.Word,
+				RegisterNumber16.DX => dx.Word,
+				RegisterNumber16.BX => bx.Word,
+				RegisterNumber16.SP => sp,
+				RegisterNumber16.BP => bp,
+				RegisterNumber16.SI => si,
+				RegisterNumber16.DI => di,
+				_ => throw new ArgumentException("Invalid register", nameof(reg)),
+			};
+		}
+
+		private void SetRegister8(RegisterNumber8 reg, byte value)
+		{
+			switch (reg)
+			{
+				case RegisterNumber8.AL: ax.Low = value; break;
+				case RegisterNumber8.CL: cx.Low = value; break;
+				case RegisterNumber8.DL: dx.Low = value; break;
+				case RegisterNumber8.BL: bx.Low = value; break;
+				case RegisterNumber8.AH: ax.High = value; break;
+				case RegisterNumber8.CH: cx.High = value; break;
+				case RegisterNumber8.DH: dx.High = value; break;
+				case RegisterNumber8.BH: bx.High = value; break;
+				default: throw new ArgumentException("Invalid register", nameof(reg));
+			}
+		}
+
+		private void SetRegister16(RegisterNumber16 reg, ushort value)
+		{
+			switch (reg)
+			{
+				case RegisterNumber16.AX: ax.Word = value; break;
+				case RegisterNumber16.CX: cx.Word = value; break;
+				case RegisterNumber16.DX: dx.Word = value; break;
+				case RegisterNumber16.BX: bx.Word = value; break;
+				case RegisterNumber16.SP: sp = value; break;
+				case RegisterNumber16.BP: bp = value; break;
+				case RegisterNumber16.SI: si = value; break;
+				case RegisterNumber16.DI: di = value; break;
+				default: throw new ArgumentException("Invalid register", nameof(reg));
+			}
+		}
+
+		[StructLayout(LayoutKind.Explicit)]
+		public struct Register16
+		{
+			[FieldOffset(0)]
+			public byte Low;
+			[FieldOffset(1)]
+			public byte High;
+
+			[FieldOffset(0)]
+			public ushort Word;
+
+			public static implicit operator Register16(ushort value) => new() { Word = value };
+
+		}
+	}
+}

AxibugEmuOnline.Client/Assets/Plugins/StoicGooseUnity/StoicGoose.Core/CPU/V30MZ.Registers.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: a4d62a2a12b27744ea0c51ed3e7a2500

AxibugEmuOnline.Client/Assets/Plugins/StoicGooseUnity/StoicGoose.Core/CPU/V30MZ.Segments.cs

@@ -0,0 +1,45 @@
+using System;
+
+namespace StoicGoose.Core.CPU
+{
+	public sealed partial class V30MZ
+	{
+		enum SegmentNumber : byte
+		{
+			ES = 0b00,
+			CS = 0b01,
+			SS = 0b10,
+			DS = 0b11,
+			Unset = 0xFF
+		}
+
+		private ushort GetSegment(SegmentNumber seg)
+		{
+			return seg switch
+			{
+				SegmentNumber.ES => es,
+				SegmentNumber.CS => cs,
+				SegmentNumber.SS => ss,
+				SegmentNumber.DS => ds,
+				_ => throw new ArgumentException("Invalid segment", nameof(seg)),
+			};
+		}
+
+		private void SetSegment(SegmentNumber seg, ushort value)
+		{
+			switch (seg)
+			{
+				case SegmentNumber.ES: es = value; break;
+				case SegmentNumber.CS: cs = value; break;
+				case SegmentNumber.SS: ss = value; break;
+				case SegmentNumber.DS: ds = value; break;
+				default: throw new ArgumentException("Invalid segment", nameof(seg));
+			}
+		}
+
+		private ushort GetSegmentViaOverride(SegmentNumber seg)
+		{
+			return GetSegment(prefixSegOverride != SegmentNumber.Unset ? prefixSegOverride : seg);
+		}
+	}
+}

AxibugEmuOnline.Client/Assets/Plugins/StoicGooseUnity/StoicGoose.Core/CPU/V30MZ.Segments.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: f05e782fc3972e146a5970e63968477a

AxibugEmuOnline.Client/Assets/Plugins/StoicGooseUnity/StoicGoose.Core/CPU/V30MZ.Strings.cs

@@ -0,0 +1,104 @@
+namespace StoicGoose.Core.CPU
+{
+	public sealed partial class V30MZ
+	{
+		private static int GetIncrement(bool is16Bit, bool isDirectionFlagSet)
+		{
+			return isDirectionFlagSet ? (is16Bit ? -2 : -1) : (is16Bit ? 2 : 1);
+		}
+
+		private void InString(bool is16Bit)
+		{
+			var increment = GetIncrement(is16Bit, IsFlagSet(Flags.Direction));
+
+			if (!is16Bit)
+				WriteMemory8(es, di, machine.ReadPort(dx.Word));
+			else
+				WriteMemory16(es, di, ReadPort16(dx.Word));
+
+			di = (ushort)(di + increment);
+		}
+
+		private void OutString(bool is16Bit)
+		{
+			var increment = GetIncrement(is16Bit, IsFlagSet(Flags.Direction));
+
+			var temp = GetSegmentViaOverride(SegmentNumber.DS);
+
+			if (!is16Bit)
+				machine.WritePort(dx.Word, ReadMemory8(temp, si));
+			else
+				WritePort16(dx.Word, ReadMemory16(temp, si));
+
+			si = (ushort)(si + increment);
+		}
+
+		private void MoveString(bool is16Bit)
+		{
+			var increment = GetIncrement(is16Bit, IsFlagSet(Flags.Direction));
+
+			var temp = GetSegmentViaOverride(SegmentNumber.DS);
+
+			if (!is16Bit)
+				WriteMemory8(es, di, ReadMemory8(temp, si));
+			else
+				WriteMemory16(es, di, ReadMemory16(temp, si));
+
+			di = (ushort)(di + increment);
+			si = (ushort)(si + increment);
+		}
+
+		private void CompareString(bool is16Bit)
+		{
+			var increment = GetIncrement(is16Bit, IsFlagSet(Flags.Direction));
+
+			var temp = GetSegmentViaOverride(SegmentNumber.DS);
+
+			if (!is16Bit)
+				Sub8(false, ReadMemory8(temp, si), ReadMemory8(es, di));
+			else
+				Sub16(false, ReadMemory16(temp, si), ReadMemory16(es, di));
+
+			di = (ushort)(di + increment);
+			si = (ushort)(si + increment);
+		}
+
+		private void StoreString(bool is16Bit)
+		{
+			var increment = GetIncrement(is16Bit, IsFlagSet(Flags.Direction));
+
+			if (!is16Bit)
+				WriteMemory8(es, di, ax.Low);
+			else
+				WriteMemory16(es, di, ax.Word);
+
+			di = (ushort)(di + increment);
+		}
+
+		private void LoadString(bool is16Bit)
+		{
+			var increment = GetIncrement(is16Bit, IsFlagSet(Flags.Direction));
+
+			var temp = GetSegmentViaOverride(SegmentNumber.DS);
+
+			if (!is16Bit)
+				ax.Low = ReadMemory8(temp, si);
+			else
+				ax.Word = ReadMemory16(temp, si);
+
+			si = (ushort)(si + increment);
+		}
+
+		private void ScanString(bool is16Bit)
+		{
+			var increment = GetIncrement(is16Bit, IsFlagSet(Flags.Direction));
+
+			if (!is16Bit)
+				Sub8(false, ax.Low, ReadMemory8(es, di));
+			else
+				Sub16(false, ax.Word, ReadMemory16(es, di));
+
+			di = (ushort)(di + increment);
+		}
+	}
+}

AxibugEmuOnline.Client/Assets/Plugins/StoicGooseUnity/StoicGoose.Core/CPU/V30MZ.Strings.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 43c1a3a659adfb244be70cdc0ded4be7

AxibugEmuOnline.Client/Assets/Plugins/StoicGooseUnity/StoicGoose.Core/CPU/V30MZ.cs

@@ -0,0 +1,139 @@
+using StoicGoose.Core.Interfaces;
+
+namespace StoicGoose.Core.CPU
+{
+	public sealed partial class V30MZ : IComponent
+	{
+		// TODO: attempt prefetch emulation (Meitantei Conan - Nishi no Meitantei Saidai no Kiki; cart changes banks on startup, can no longer execute jump, execs garbage)
+
+		/* Parent machine instance */
+		readonly IMachine machine = default;
+
+		/* General registers */
+		Register16 ax, bx, cx, dx;
+		ushort sp, bp, si, di;
+		/* Segment registers */
+		ushort cs, ds, ss, es;
+		/* Status and instruction registers */
+		ushort ip;
+		Flags flags;
+
+		bool halted;
+		int opCycles, intCycles;
+
+		/* Public properties for registers */
+		public Register16 AX { get => ax; set => ax = value; }
+		public Register16 BX { get => bx; set => bx = value; }
+		public Register16 CX { get => cx; set => cx = value; }
+		public Register16 DX { get => dx; set => dx = value; }
+		public ushort SP { get => sp; set => sp = value; }
+		public ushort BP { get => bp; set => bp = value; }
+		public ushort SI { get => si; set => si = value; }
+		public ushort DI { get => di; set => di = value; }
+		public ushort CS { get => cs; set => cs = value; }
+		public ushort DS { get => ds; set => ds = value; }
+		public ushort SS { get => ss; set => ss = value; }
+		public ushort ES { get => es; set => es = value; }
+		public ushort IP { get => ip; set => ip = value; }
+
+		public bool IsHalted { get => halted; set => halted = value; }
+
+		public V30MZ(IMachine machine)
+		{
+			this.machine = machine;
+
+			Reset();
+		}
+
+		public void Reset()
+		{
+			/* CPU reset */
+			flags = Flags.ReservedB1 | Flags.ReservedB12 | Flags.ReservedB13 | Flags.ReservedB14 | Flags.ReservedB15;
+			ip = 0x0000;
+			cs = 0xFFFF;
+			ds = 0x0000;
+			ss = 0x0000;
+			es = 0x0000;
+
+			/* Initialized by WS bootstrap */
+			ax.Word = 0x0000;
+			dx.Word = 0x0000;
+			bp = 0x0000;
+			ss = 0x0000;
+			sp = 0x2000;
+			ds = 0x0000;
+			es = 0x0000;
+
+			/* Misc variables */
+			halted = false;
+			opCycles = intCycles = 0;
+
+			ResetPrefixes();
+			modRm.Reset();
+		}
+
+		public void Shutdown()
+		{
+			//
+		}
+
+		public void Interrupt(int vector)
+		{
+			/* Resume execution */
+			halted = false;
+
+			/* Read interrupt handler's segment & offset */
+			var offset = ReadMemory16(0, (ushort)((vector * 4) + 0));
+			var segment = ReadMemory16(0, (ushort)((vector * 4) + 2));
+
+			/* Push state, clear flags, etc. */
+			Push((ushort)flags);
+			Push(cs);
+			Push(ip);
+
+			ClearFlags(Flags.InterruptEnable);
+			ClearFlags(Flags.Trap);
+
+			ResetPrefixes();
+			modRm.Reset();
+
+			intCycles = 32;
+
+			/* Continue with interrupt handler */
+			cs = segment;
+			ip = offset;
+		}
+
+		public int Step()
+		{
+			var cycles = 0;
+
+			if (halted)
+			{
+				/* CPU is halted */
+				cycles++;
+			}
+			else
+			{
+				/* Read any prefixes & opcode */
+				byte opcode;
+				while (!HandlePrefixes(opcode = ReadMemory8(cs, ip++))) { }
+
+				/* Execute instruction */
+				opCycles = instructions[opcode](this);
+
+				cycles += opCycles;
+				opCycles = 0;
+			}
+
+			cycles += intCycles;
+			intCycles = 0;
+
+			/* Reset state for next instruction */
+			ResetPrefixes();
+			modRm.Reset();
+
+			return cycles;
+		}
+	}
+}

AxibugEmuOnline.Client/Assets/Plugins/StoicGooseUnity/StoicGoose.Core/CPU/V30MZ.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 946e7f92ed1c35e45bd71bbcd108695c

AxibugEmuOnline.Client/Assets/Plugins/StoicGooseUnity/StoicGoose.Core/Cartridges.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 4878ed813b76a834abf448a6d1c96295
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

AxibugEmuOnline.Client/Assets/Plugins/StoicGooseUnity/StoicGoose.Core/Cartridges/Cartridge.cs

@@ -0,0 +1,248 @@
+using System;
+
+using StoicGoose.Common.Utilities;
+using StoicGoose.Core.EEPROMs;
+using StoicGoose.Core.Interfaces;
+
+namespace StoicGoose.Core.Cartridges
+{
+	public class Cartridge : IComponent
+	{
+		byte[] rom, sram;
+		uint romMask, sramMask;
+
+		Metadata metadata;
+
+		/* REG_BANK_xxx */
+		byte romBank2, sramBank, romBank0, romBank1;
+
+		/* REG_EEP_xxx -> EEPROM class */
+		EEPROM eeprom = default;
+
+		/* REG_RTC_xxx -> RTC class */
+		RTC rtc = default;
+
+		public bool IsLoaded => rom?.Length > 0;
+		public int SizeInBytes => rom?.Length ?? 0;
+		public uint Crc32 { get; private set; } = default;
+
+		public Metadata Metadata => metadata;
+
+		public Cartridge()
+		{
+			rom = Array.Empty<byte>();
+			sram = Array.Empty<byte>();
+		}
+
+		public void Reset()
+		{
+			romBank2 = 0xFF;
+			sramBank = 0xFF;
+			romBank0 = 0xFF;
+			romBank1 = 0xFF;
+
+			eeprom?.Reset();
+			rtc?.Reset();
+
+			// HACK: set RTC to current date/time on boot for testing
+			rtc?.Program(DateTime.Now);
+		}
+
+		public void Shutdown()
+		{
+			eeprom?.Shutdown();
+			rtc?.Shutdown();
+		}
+
+		public void LoadRom(byte[] data)
+		{
+			rom = data;
+			romMask = (uint)(rom.Length - 1);
+
+			metadata = new Metadata(rom);
+
+			if (metadata.SaveSize != 0)
+			{
+				if (metadata.IsSramSave)
+				{
+					sram = new byte[metadata.SaveSize];
+					sramMask = (uint)(sram.Length - 1);
+				}
+				else if (metadata.IsEepromSave)
+				{
+					switch (metadata.SaveType)
+					{
+						// TODO: verify size/address bits
+						case Metadata.SaveTypes.Eeprom1Kbit: eeprom = new EEPROM(metadata.SaveSize, 6); break;
+						case Metadata.SaveTypes.Eeprom16Kbit: eeprom = new EEPROM(metadata.SaveSize, 10); break;
+						case Metadata.SaveTypes.Eeprom8Kbit: eeprom = new EEPROM(metadata.SaveSize, 9); break;
+					}
+				}
+			}
+
+			if (metadata.IsRtcPresent)
+			{
+				// NOTE: "RTC present" flag is not entirely consistent; ex. Digimon Tamers Battle Spirit has the flag, but does not have an RTC
+				rtc = new RTC();
+			}
+
+			Crc32 = Common.Utilities.Crc32.Calculate(rom);
+
+			Log.WriteEvent(LogSeverity.Information, this, "ROM loaded.");
+			Log.WriteLine($"~ {Ansi.Cyan}Cartridge metadata{Ansi.Reset} ~");
+			Log.WriteLine($" Publisher ID: {Metadata.PublisherCode}, {Metadata.PublisherName} [0x{Metadata.PublisherId:X2}]");
+			Log.WriteLine($" System type: {Metadata.SystemType}");
+			Log.WriteLine($" Game ID: 0x{Metadata.GameId:X2}");
+			Log.WriteLine($"  Calculated ID string: {Metadata.GameIdString}");
+			Log.WriteLine($" Game revision: 0x{Metadata.GameRevision:X2}");
+			Log.WriteLine($" ROM size: {Metadata.RomSize} [0x{(byte)Metadata.RomSize:X2}]");
+			Log.WriteLine($" Save type/size: {Metadata.SaveType}/{Metadata.SaveSize} [0x{(byte)Metadata.SaveType:X2}]");
+			Log.WriteLine($" Misc flags: 0x{Metadata.MiscFlags:X2}");
+			Log.WriteLine($"  Orientation: {Metadata.Orientation}");
+			Log.WriteLine($"  ROM bus width: {Metadata.RomBusWidth}");
+			Log.WriteLine($"  ROM access speed: {Metadata.RomAccessSpeed}");
+			Log.WriteLine($" RTC present: {Metadata.IsRtcPresent} [0x{Metadata.RtcPresentFlag:X2}]");
+			Log.WriteLine($" Checksum (from metadata): 0x{Metadata.Checksum:X4}");
+			Log.WriteLine($"  Checksum (calculated): 0x{Metadata.CalculatedChecksum:X4}");
+			Log.WriteLine($"  Checksum is {(metadata.IsChecksumValid ? $"{Ansi.Green}valid" : $"{Ansi.Red}invalid")}{Ansi.Reset}!");
+
+			if (metadata.PublisherId == 0x01 && metadata.GameId == 0x27)
+			{
+				// HACK: Meitantei Conan - Nishi no Meitantei Saidai no Kiki, prevent crash on startup (see TODO in V30MZ, prefetching)
+				rom[0xFFFE8] = 0xEA;
+				rom[0xFFFE9] = 0x00;
+				rom[0xFFFEA] = 0x00;
+				rom[0xFFFEB] = 0x00;
+				rom[0xFFFEC] = 0x20;
+				Log.WriteLine($"~ {Ansi.Red}Conan prefetch hack enabled{Ansi.Reset} ~");
+			}
+		}
+
+		public void LoadSram(byte[] data)
+		{
+			if (data.Length != sram.Length) throw new Exception("Sram size mismatch");
+			Buffer.BlockCopy(data, 0, sram, 0, data.Length);
+		}
+
+		public void LoadEeprom(byte[] data)
+		{
+			eeprom?.LoadContents(data);
+		}
+
+		public byte[] GetSram()
+		{
+			return sram.Clone() as byte[];
+		}
+
+		public byte[] GetEeprom()
+		{
+			return eeprom?.GetContents().Clone() as byte[];
+		}
+
+		public bool Step(int clockCyclesInStep)
+		{
+			return rtc != null && rtc.Step(clockCyclesInStep);
+		}
+
+		public byte ReadMemory(uint address)
+		{
+			return address switch
+			{
+				/* SRAM */
+				var n when n >= 0x010000 && n < 0x020000 && sram.Length != 0 => sram[((uint)(sramBank << 16) | (address & 0x0FFFF)) & sramMask],
+				/* ROM bank 0 */
+				var n when n >= 0x020000 && n < 0x030000 && rom.Length != 0 => rom[((uint)(romBank0 << 16) | (address & 0x0FFFF)) & romMask],
+				/* ROM bank 1 */
+				var n when n >= 0x030000 && n < 0x040000 && rom.Length != 0 => rom[((uint)(romBank1 << 16) | (address & 0x0FFFF)) & romMask],
+				/* ROM bank 2 */
+				var n when n >= 0x040000 && n < 0x100000 && rom.Length != 0 => rom[((uint)(romBank2 << 20) | (address & 0xFFFFF)) & romMask],
+				/* Unmapped */
+				_ => 0x90,
+			};
+		}
+
+		public void WriteMemory(uint address, byte value)
+		{
+			/* SRAM */
+			if (address >= 0x010000 && address < 0x020000 && sram.Length != 0)
+				sram[((uint)(sramBank << 16) | (address & 0x0FFFF)) & sramMask] = value;
+		}
+
+		public byte ReadPort(ushort port)
+		{
+			return port switch
+			{
+				/* REG_BANK_ROM2 */
+				0xC0 => romBank2,
+				/* REG_BANK_SRAM */
+				0xC1 => sramBank,
+				/* REG_BANK_ROM0 */
+				0xC2 => romBank0,
+				/* REG_BANK_ROM1 */
+				0xC3 => romBank1,
+				/* REG_EEP_DATA (low) */
+				0xC4 => eeprom != null ? eeprom.ReadPort((byte)(port - 0xC4)) : (byte)0x90,
+				/* REG_EEP_DATA (high) */
+				0xC5 => eeprom != null ? eeprom.ReadPort((byte)(port - 0xC4)) : (byte)0x90,
+				/* REG_EEP_ADDR (low) */
+				0xC6 => eeprom != null ? eeprom.ReadPort((byte)(port - 0xC4)) : (byte)0x90,
+				/* REG_EEP_ADDR (high) */
+				0xC7 => eeprom != null ? eeprom.ReadPort((byte)(port - 0xC4)) : (byte)0x90,
+				/* REG_EEP_STATUS (read) */
+				0xC8 => eeprom != null ? eeprom.ReadPort((byte)(port - 0xC4)) : (byte)0x90,
+				/* REG_RTC_STATUS (read) */
+				0xCA => rtc != null ? rtc.ReadPort((byte)(port - 0xCA)) : (byte)0x90,
+				/* REG_RTC_DATA */
+				0xCB => rtc != null ? rtc.ReadPort((byte)(port - 0xCA)) : (byte)0x90,
+				/* Unmapped */
+				_ => 0x90,
+			};
+		}
+
+		public void WritePort(ushort port, byte value)
+		{
+			switch (port)
+			{
+				case 0xC0:
+					/* REG_BANK_ROM2 */
+					romBank2 = value;
+					break;
+
+				case 0xC1:
+					/* REG_BANK_SRAM */
+					sramBank = value;
+					break;
+
+				case 0xC2:
+					/* REG_BANK_ROM0 */
+					romBank0 = value;
+					break;
+
+				case 0xC3:
+					/* REG_BANK_ROM1 */
+					romBank1 = value;
+					break;
+
+				case 0xC4:
+				case 0xC5:
+				case 0xC6:
+				case 0xC7:
+				case 0xC8:
+					/* REG_EEP_DATA (low) */
+					/* REG_EEP_DATA (high) */
+					/* REG_EEP_ADDR (low) */
+					/* REG_EEP_ADDR (high) */
+					/* REG_EEP_CMD (write) */
+					eeprom?.WritePort((byte)(port - 0xC4), value);
+					break;
+
+				case 0xCA:
+				case 0xCB:
+					/* REG_RTC_CMD (write) */
+					/* REG_RTC_DATA */
+					rtc?.WritePort((byte)(port - 0xCA), value);
+					break;
+			}
+		}
+	}
+}

AxibugEmuOnline.Client/Assets/Plugins/StoicGooseUnity/StoicGoose.Core/Cartridges/Cartridge.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 4de2597a945e9a14082b644bcddf3e4e

AxibugEmuOnline.Client/Assets/Plugins/StoicGooseUnity/StoicGoose.Core/Cartridges/Metadata.cs

@@ -0,0 +1,171 @@
+using System.Collections.Generic;
+
+namespace StoicGoose.Core.Cartridges
+{
+	public class Metadata
+	{
+		public enum SystemTypes : byte
+		{
+			WonderSwan = 0x00,
+			WonderSwanColor = 0x01
+		}
+
+		public enum RomSizes : byte
+		{
+			Rom1Mbit = 0x00,     // ???
+			Rom2Mbit = 0x01,     // ???
+			Rom4Mbit = 0x02,
+			Rom8Mbit = 0x03,
+			Rom16Mbit = 0x04,
+			Rom24Mbit = 0x05,
+			Rom32Mbit = 0x06,
+			Rom48Mbit = 0x07,
+			Rom64Mbit = 0x08,
+			Rom128Mbit = 0x09
+		}
+
+		public enum SaveTypes : byte
+		{
+			None = 0x00,
+			Sram64Kbit = 0x01,
+			Sram256Kbit = 0x02,
+			Sram1Mbit = 0x03,
+			Sram2Mbit = 0x04,
+			Sram4Mbit = 0x05,
+			Eeprom1Kbit = 0x10,
+			Eeprom16Kbit = 0x20,
+			Eeprom8Kbit = 0x50      //???
+		}
+
+		public enum Orientations : byte
+		{
+			Horizontal = 0 << 0,
+			Vertical = 1 << 0,
+		}
+
+		public enum RomBusWidths : byte
+		{
+			Width16Bit = 0 << 1,
+			Width8Bit = 1 << 1,
+		}
+
+		public enum RomAccessSpeeds : byte
+		{
+			Speed3Cycle = 0 << 2,
+			Speed1Cycle = 1 << 2
+		}
+
+		readonly Dictionary<byte, (string code, string name)> publishers = new()
+		{
+			{ 0x00, ("???", "Misc. (invalid)") },
+			{ 0x01, ("BAN", "Bandai") },
+			{ 0x02, ("TAT", "Taito") },
+			{ 0x03, ("TMY", "Tomy") },
+			{ 0x04, ("KEX", "Koei") },
+			{ 0x05, ("DTE", "Data East") },
+			{ 0x06, ("AAE", "Asmik Ace") },
+			{ 0x07, ("MDE", "Media Entertainment") },
+			{ 0x08, ("NHB", "Nichibutsu") },
+			{ 0x0A, ("CCJ", "Coconuts Japan") },
+			{ 0x0B, ("SUM", "Sammy") },
+			{ 0x0C, ("SUN", "Sunsoft") },
+			{ 0x0D, ("PAW", "Mebius (?)") },
+			{ 0x0E, ("BPR", "Banpresto") },
+			{ 0x10, ("JLC", "Jaleco") },
+			{ 0x11, ("MGA", "Imagineer") },
+			{ 0x12, ("KNM", "Konami") },
+			{ 0x16, ("KBS", "Kobunsha") },
+			{ 0x17, ("BTM", "Bottom Up") },
+			{ 0x18, ("KGT", "Kaga Tech") },
+			{ 0x19, ("SRV", "Sunrise") },
+			{ 0x1A, ("CFT", "Cyber Front") },
+			{ 0x1B, ("MGH", "Mega House") },
+			{ 0x1D, ("BEC", "Interbec") },
+			{ 0x1E, ("NAP", "Nihon Application") },
+			{ 0x1F, ("BVL", "Bandai Visual") },
+			{ 0x20, ("ATN", "Athena") },
+			{ 0x21, ("KDX", "KID") },
+			{ 0x22, ("HAL", "HAL Corporation") },
+			{ 0x23, ("YKE", "Yuki Enterprise") },
+			{ 0x24, ("OMM", "Omega Micott") },
+			{ 0x25, ("LAY", "Layup") },
+			{ 0x26, ("KDK", "Kadokawa Shoten") },
+			{ 0x27, ("SHL", "Shall Luck") },
+			{ 0x28, ("SQR", "Squaresoft") },
+			{ 0x2A, ("SCC", "NTT DoCoMo (?)") },    /* MobileWonderGate */
+			{ 0x2B, ("TMC", "Tom Create") },
+			{ 0x2D, ("NMC", "Namco") },
+			{ 0x2E, ("SES", "Movic (?)") },
+			{ 0x2F, ("HTR", "E3 Staff (?)") },
+			{ 0x31, ("VGD", "Vanguard") },
+			{ 0x32, ("MGT", "Megatron") },
+			{ 0x33, ("WIZ", "Wiz") },
+			{ 0x36, ("CAP", "Capcom") },
+		};
+
+		readonly Dictionary<SaveTypes, int> saveSizes = new()
+		{
+			{ SaveTypes.None, 0 },
+			{ SaveTypes.Sram64Kbit, 1024 * 8 },
+			{ SaveTypes.Sram256Kbit, 1024 * 32 },
+			{ SaveTypes.Sram1Mbit, 1024 * 128 },
+			{ SaveTypes.Sram2Mbit, 1024 * 256 },
+			{ SaveTypes.Sram4Mbit, 1024 * 512 },
+			{ SaveTypes.Eeprom1Kbit, 2 * 64 },
+			{ SaveTypes.Eeprom16Kbit, 2 * 1024 },
+			{ SaveTypes.Eeprom8Kbit, 2 * 512 },
+		};
+
+		public byte PublisherId { get; private set; }
+		public SystemTypes SystemType { get; private set; }
+		public byte GameId { get; private set; }
+		public byte GameRevision { get; private set; }
+		public RomSizes RomSize { get; private set; }
+		public SaveTypes SaveType { get; private set; }
+		public byte MiscFlags { get; private set; }
+		public byte RtcPresentFlag { get; private set; }
+		public ushort Checksum { get; private set; }
+
+		public string PublisherCode => publishers.ContainsKey(PublisherId) ? publishers[PublisherId].code : "???";
+		public string PublisherName => publishers.ContainsKey(PublisherId) ? publishers[PublisherId].name : "(Unknown)";
+
+		public string GameIdString => $"SWJ-{PublisherCode}{(SystemType == SystemTypes.WonderSwan ? "0" : "C")}{GameId:X2}";
+
+		public Orientations Orientation => (Orientations)(MiscFlags & (1 << 0));
+		public RomBusWidths RomBusWidth => (RomBusWidths)(MiscFlags & (1 << 1));
+		public RomAccessSpeeds RomAccessSpeed => (RomAccessSpeeds)(MiscFlags & (1 << 2));
+
+		public int SaveSize => saveSizes.ContainsKey(SaveType) ? saveSizes[SaveType] : 0;
+
+		public bool IsSramSave =>
+			SaveType == SaveTypes.Sram64Kbit || SaveType == SaveTypes.Sram256Kbit ||
+			SaveType == SaveTypes.Sram1Mbit || SaveType == SaveTypes.Sram2Mbit || SaveType == SaveTypes.Sram4Mbit;
+
+		public bool IsEepromSave =>
+			SaveType == SaveTypes.Eeprom1Kbit || SaveType == SaveTypes.Eeprom16Kbit || SaveType == SaveTypes.Eeprom8Kbit;
+
+		public bool IsRtcPresent => RtcPresentFlag != 0;
+
+		public ushort CalculatedChecksum { get; private set; }
+
+		public bool IsChecksumValid => Checksum == CalculatedChecksum;
+
+		public Metadata(byte[] data)
+		{
+			var offset = data.Length - 10;
+			PublisherId = data[offset + 0];
+			SystemType = (SystemTypes)data[offset + 1];
+			GameId = data[offset + 2];
+			GameRevision = data[offset + 3];
+			RomSize = (RomSizes)data[offset + 4];
+			SaveType = (SaveTypes)data[offset + 5];
+			MiscFlags = data[offset + 6];
+			RtcPresentFlag = data[offset + 7];
+			Checksum = (ushort)(data[offset + 9] << 8 | data[offset + 8]);
+
+			CalculatedChecksum = 0;
+			for (var i = 0; i < data.Length - 2; i++)
+				CalculatedChecksum += data[i + 0];
+		}
+	}
+}

AxibugEmuOnline.Client/Assets/Plugins/StoicGooseUnity/StoicGoose.Core/Cartridges/Metadata.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 6ca048ba38a22c849a012278fc9515f3

AxibugEmuOnline.Client/Assets/Plugins/StoicGooseUnity/StoicGoose.Core/Cartridges/RTC.cs

@@ -0,0 +1,349 @@
+using System;
+
+using StoicGoose.Common.Utilities;
+using StoicGoose.Core.Interfaces;
+using StoicGoose.Core.Machines;
+
+using static StoicGoose.Common.Utilities.BitHandling;
+
+namespace StoicGoose.Core.Cartridges
+{
+	/* Seiko S-3511A real-time clock, through Bandai 2003 mapper
+	 * - https://forums.nesdev.org/viewtopic.php?t=21513
+	 * - https://datasheetspdf.com/pdf-file/1087347/Seiko/S-3511A/1
+	 */
+
+	// TODO: interrupts, save/load current state
+
+	public sealed class RTC : IPortAccessComponent
+	{
+		const int cyclesInSecond = (int)MachineCommon.CpuClock;
+
+		readonly byte[] numPayloadBytes = new byte[] { 0, 1, 7, 3, 2, 2, 2 };
+		readonly int[] numDaysPerMonth = new int[] { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
+
+		/* WS - Status & data registers */
+		byte wsData;
+		byte payloadIndex;
+
+		/* WS+RTC - Communication */
+		byte command;
+		bool isReadAccess;
+
+		/* RTC - Real-time data register */
+		byte year, month, day, dayOfWeek, hour, minute, second;
+		bool isPm, isTestModeActive;
+
+		/* RTC - Status register */
+		bool isPowered, is24HourMode;
+		bool intAE, intME, intFE;
+
+		/* RTC - Alarm time/frequency duty setting register */
+		ushort intRegister;
+
+		(bool pm, byte hour, byte minute) alarmTime => (IsBitSet((byte)(intRegister >> 0), 7), (byte)((intRegister >> 0) & 0b00111111), (byte)((intRegister >> 8) & 0b01111111));
+		int selectedInterruptFreq
+		{
+			get
+			{
+				var freq = 0;
+				for (var j = 0; j < 16; j++) if (((intRegister >> j) & 0b1) == 0b1) freq |= 32768 >> j;
+				return freq;
+			}
+		}
+
+		int cycleCount;
+
+		public RTC()
+		{
+			//
+		}
+
+		public void Reset()
+		{
+			wsData = 0;
+			payloadIndex = 0;
+
+			command = 0;
+			isReadAccess = false;
+
+			year = dayOfWeek = hour = minute = second = 0;
+			month = day = 1;
+			isPm = isTestModeActive = false;
+
+			is24HourMode = intAE = intME = false;
+			isPowered = intFE = true;
+
+			intRegister = 0x8000;
+
+			cycleCount = 0;
+		}
+
+		public void Shutdown()
+		{
+			//
+		}
+
+		public void Program(DateTime dateTime)
+		{
+			year = (byte)(dateTime.Year % 100);
+			month = (byte)(dateTime.Month % 13);
+			day = (byte)(dateTime.Day % 32);
+			dayOfWeek = (byte)((int)dateTime.DayOfWeek % 8);
+			hour = (byte)(dateTime.Hour % 25);
+			minute = (byte)(dateTime.Minute % 60);
+			second = (byte)(dateTime.Second % 60);
+		}
+
+		public bool Step(int clockCyclesInStep)
+		{
+			var interrupt = false;
+
+			for (var i = 0; i < clockCyclesInStep; i++)
+			{
+				if (intFE && !intME)
+				{
+					/* Selected frequency steady interrupt output */
+
+					// TODO probably not right
+					if (cycleCount >= selectedInterruptFreq)
+						interrupt = true;
+
+				}
+				else if (!intFE && intME)
+				{
+					/* Per-minute edge interrupt output */
+					// TODO
+				}
+				else if (intFE && intME)
+				{
+					/* Per-minute steady interrupt output */
+					// TODO
+				}
+				else if (!intFE && !intME && intAE)
+				{
+					/* Alarm interrupt output */
+					if (alarmTime.pm == isPm && Bcd.BcdToDecimal(alarmTime.hour) == hour && Bcd.BcdToDecimal(alarmTime.minute) == minute)
+						interrupt = true;
+				}
+
+				cycleCount++;
+				if (cycleCount >= cyclesInSecond)
+				{
+					UpdateClock();
+					cycleCount = 0;
+				}
+			}
+
+			return interrupt;
+		}
+
+		private void UpdateClock()
+		{
+			second++;
+			if (second < 60) return;
+
+			second = 0;
+			minute++;
+			if (minute < 60) return;
+
+			minute = 0;
+			hour++;
+			if (hour < 24) return;
+
+			hour = 0;
+			dayOfWeek++;
+			dayOfWeek %= 7;
+
+			day++;
+			var extraDay = (month == 2 && (year % 4) == 0 && ((year % 100) != 0 || (year % 400) == 0)) ? 1 : 0;
+			if (day < numDaysPerMonth[month] + extraDay) return;
+
+			day = 0;
+			month++;
+			if (month < 12) return;
+
+			month = 0;
+			year++;
+		}
+
+		private void PerformAccess()
+		{
+			switch (command & 0b111)
+			{
+				case 0b000:
+					/* Reset */
+					wsData = 0;
+
+					year = 0;
+					month = 1;
+					day = 1;
+					dayOfWeek = 0;
+					hour = 0;
+					minute = 0;
+					second = 0;
+
+					isPowered = is24HourMode = false;
+					intAE = intME = intFE = false;
+
+					intRegister = 0x0000;
+					break;
+
+				case 0b001:
+					/* Status register access */
+					if (isReadAccess)
+					{
+						wsData = 0;
+						ChangeBit(ref wsData, 7, isPowered);
+						ChangeBit(ref wsData, 6, is24HourMode);
+						ChangeBit(ref wsData, 5, intAE);
+						ChangeBit(ref wsData, 3, intME);
+						ChangeBit(ref wsData, 1, intFE);
+					}
+					else
+					{
+						is24HourMode = IsBitSet(wsData, 6);
+						intAE = IsBitSet(wsData, 5);
+						intME = IsBitSet(wsData, 3);
+						intFE = IsBitSet(wsData, 1);
+					}
+					break;
+
+				case 0b010:
+					/* Real-time data access 1 */
+					if (isReadAccess)
+					{
+						wsData = 0;
+						switch (payloadIndex)
+						{
+							case 0: wsData = (byte)Bcd.DecimalToBcd(year); break;
+							case 1: wsData = (byte)Bcd.DecimalToBcd(month); break;
+							case 2: wsData = (byte)Bcd.DecimalToBcd(day); break;
+							case 3: wsData = (byte)Bcd.DecimalToBcd(dayOfWeek); break;
+							case 4: wsData = (byte)Bcd.DecimalToBcd(hour); ChangeBit(ref wsData, 7, isPm); break;
+							case 5: wsData = (byte)Bcd.DecimalToBcd(minute); break;
+							case 6: wsData = (byte)Bcd.DecimalToBcd(second); ChangeBit(ref wsData, 7, isTestModeActive); break;
+						}
+					}
+					else
+					{
+						switch (payloadIndex)
+						{
+							case 0: year = (byte)Bcd.BcdToDecimal(wsData); break;
+							case 1: month = (byte)Bcd.BcdToDecimal(wsData); break;
+							case 2: day = (byte)Bcd.BcdToDecimal(wsData); break;
+							case 3: dayOfWeek = (byte)Bcd.BcdToDecimal(wsData); break;
+							case 4: hour = (byte)(Bcd.BcdToDecimal(wsData) & 0b01111111); isPm = IsBitSet(wsData, 7); break;
+							case 5: minute = (byte)Bcd.BcdToDecimal(wsData); break;
+							case 6: second = (byte)(Bcd.BcdToDecimal(wsData) & 0b01111111); isTestModeActive = IsBitSet(wsData, 7); break;
+						}
+					}
+					break;
+
+				case 0b011:
+					/* Real-time data access 2 */
+					if (isReadAccess)
+					{
+						wsData = 0;
+						switch (payloadIndex)
+						{
+							case 0: wsData = (byte)Bcd.DecimalToBcd(hour); ChangeBit(ref wsData, 7, isPm); break;
+							case 1: wsData = (byte)Bcd.DecimalToBcd(minute); break;
+							case 2: wsData = (byte)Bcd.DecimalToBcd(second); ChangeBit(ref wsData, 7, isTestModeActive); break;
+						}
+					}
+					else
+					{
+						switch (payloadIndex)
+						{
+							case 0: hour = (byte)(Bcd.BcdToDecimal(wsData) & 0b01111111); isPm = IsBitSet(wsData, 7); break;
+							case 1: minute = (byte)Bcd.BcdToDecimal(wsData); break;
+							case 2: second = (byte)(Bcd.BcdToDecimal(wsData) & 0b01111111); isTestModeActive = IsBitSet(wsData, 7); break;
+						}
+					}
+					break;
+
+				case 0b100:
+					/* Alarm time/frequency duty setting */
+					if (isReadAccess)
+					{
+						wsData = 0;
+						switch (payloadIndex)
+						{
+							case 0: wsData = (byte)((intRegister >> 0) & 0xFF); break;
+							case 1: wsData = (byte)((intRegister >> 8) & 0xFF); break;
+						}
+					}
+					else
+					{
+						switch (payloadIndex)
+						{
+							case 0: intRegister = (ushort)((intRegister & 0xFF00) | (wsData << 0)); break;
+							case 1: intRegister = (ushort)((intRegister & 0x00FF) | (wsData << 8)); break;
+						}
+					}
+					break;
+
+				case 0b101:
+					/* Unknown/invalid */
+					if (isReadAccess)
+					{
+						wsData = 0xFF;
+					}
+					break;
+
+				case 0b110:
+					/* Test mode start -- ignored */
+					break;
+
+				case 0b111:
+					/* Test mode end -- ignored */
+					break;
+
+				default:
+					break;
+			}
+		}
+
+		public byte ReadPort(ushort port)
+		{
+			var retVal = (byte)0x90;
+
+			if (port == 0)
+			{
+				PerformAccess();
+
+				payloadIndex++;
+
+				ChangeBit(ref retVal, 7, true); // TODO: correct?
+				ChangeBit(ref retVal, 4, payloadIndex < numPayloadBytes[command & 0b111]);
+				ChangeBit(ref retVal, 0, true);
+				retVal |= (byte)((command & 0b1111) << 1);
+
+				if (payloadIndex >= numPayloadBytes[command & 0b111])
+					payloadIndex = 0;
+			}
+			else if (port == 1)
+			{
+				retVal = wsData;
+			}
+
+			return retVal;
+		}
+
+		public void WritePort(ushort port, byte value)
+		{
+			if (port == 0)
+			{
+				isReadAccess = IsBitSet(value, 0);
+				command = (byte)((value >> 1) & 0b111);
+
+				PerformAccess();
+			}
+			else if (port == 1)
+			{
+				wsData = value;
+			}
+		}
+	}
+}

AxibugEmuOnline.Client/Assets/Plugins/StoicGooseUnity/StoicGoose.Core/Cartridges/RTC.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: acdef41e0d8804e45a3033ad3f95f77e

AxibugEmuOnline.Client/Assets/Plugins/StoicGooseUnity/StoicGoose.Core/DMA.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: e29bbdbdcb911604ea0efb453913bff8
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: