コード例 #1
0
        public RTC_Command Process_RTCExtensions(RTC_Command cmd)
        {
            RTC_Command cmdBack = null;

            switch (cmd.Type)
            {
            case CommandType.ASYNCBLAST:
            {
                BlastLayer bl = RTC_Core.Blast(null, RTC_MemoryDomains.SelectedDomains);
                if (bl != null)
                {
                    bl.Apply();
                }
            }
            break;

            case CommandType.BLAST:
            {
                BlastLayer bl       = null;
                string[]   _domains = (string[])cmd.objectValue;

                if (_domains == null)
                {
                    _domains = RTC_MemoryDomains.SelectedDomains;
                }

                if (cmd.blastlayer != null)
                {
                    cmd.blastlayer.Apply(cmd.isReplay);
                }
                else
                {
                    bl = RTC_Core.Blast(null, _domains);
                }

                if (cmd.requestGuid != null)
                {
                    cmdBack             = new RTC_Command(CommandType.RETURNVALUE);
                    cmdBack.objectValue = bl;
                }
            }

            break;

            case CommandType.STASHKEY:

                if (!File.Exists(RTC_Core.rtcDir + "\\TEMP\\" + cmd.romFilename))
                {
                    File.WriteAllBytes(RTC_Core.rtcDir + "\\TEMP\\" + cmd.romFilename, cmd.romData);
                }

                cmd.stashkey.RomFilename = RTC_Core.rtcDir + "\\TEMP\\" + RTC_Extensions.getShortFilenameFromPath(cmd.romFilename);

                cmd.stashkey.DeployState();

                cmd.stashkey.Run();

                break;

            case CommandType.PULLROM:
                cmdBack             = new RTC_Command(CommandType.PUSHROM);
                cmdBack.romFilename = RTC_Extensions.getShortFilenameFromPath(GlobalWin.MainForm.CurrentlyOpenRom);

                if (!PeerHasRom(cmdBack.romFilename))
                {
                    cmdBack.romData = File.ReadAllBytes(GlobalWin.MainForm.CurrentlyOpenRom);
                }

                break;

            case CommandType.PUSHROM:
                if (cmd.romData != null)
                {
                    cmd.romFilename = RTC_Extensions.getShortFilenameFromPath(cmd.romFilename);
                    if (!File.Exists(RTC_Core.rtcDir + "\\TEMP\\" + cmd.romFilename))
                    {
                        File.WriteAllBytes(RTC_Core.rtcDir + "\\TEMP\\" + cmd.romFilename, cmd.romData);
                    }
                }

                RTC_Core.LoadRom(RTC_Core.rtcDir + "\\TEMP\\" + cmd.romFilename);
                break;

            case CommandType.PULLSTATE:
                cmdBack = new RTC_Command(CommandType.PUSHSTATE);
                StashKey sk_PULLSTATE = RTC_StockpileManager.SaveState(false);
                cmdBack.stashkey = sk_PULLSTATE;
                sk_PULLSTATE.EmbedState();

                break;

            case CommandType.PUSHSTATE:
                cmd.stashkey.DeployState();
                RTC_StockpileManager.LoadState(cmd.stashkey, false);

                if (RTC_Core.multiForm.cbPullStateToGlitchHarvester.Checked)
                {
                    StashKey sk_PUSHSTATE = RTC_StockpileManager.SaveState(true, cmd.stashkey);
                    sk_PUSHSTATE.RomFilename = GlobalWin.MainForm.CurrentlyOpenRom;
                }

                break;

            case CommandType.PULLSWAPSTATE:

                cmdBack             = new RTC_Command(CommandType.PUSHSWAPSTATE);
                cmdBack.romFilename = RTC_Extensions.getShortFilenameFromPath(GlobalWin.MainForm.CurrentlyOpenRom);

                if (!PeerHasRom(cmdBack.romFilename))
                {
                    cmdBack.romData = File.ReadAllBytes(GlobalWin.MainForm.CurrentlyOpenRom);
                }

                StashKey sk_PULLSWAPSTATE = RTC_StockpileManager.SaveState(false);
                cmdBack.stashkey = sk_PULLSWAPSTATE;
                sk_PULLSWAPSTATE.EmbedState();

                cmd.romFilename = RTC_Extensions.getShortFilenameFromPath(cmd.romFilename);

                if (!File.Exists(RTC_Core.rtcDir + "\\TEMP\\" + cmd.romFilename))
                {
                    File.WriteAllBytes(RTC_Core.rtcDir + "\\TEMP\\" + cmd.romFilename, cmd.romData);
                }
                RTC_Core.LoadRom(RTC_Core.rtcDir + "\\TEMP\\" + cmd.romFilename);

                cmd.stashkey.DeployState();
                RTC_StockpileManager.LoadState(cmd.stashkey, false);

                if (RTC_Core.multiForm.GameOfSwapTimer != null)
                {
                    RTC_Core.multiForm.GameOfSwapCounter = 64;
                }

                break;

            case CommandType.PUSHSWAPSTATE:

                cmd.romFilename = RTC_Extensions.getShortFilenameFromPath(cmd.romFilename);

                if (cmd.romData != null)
                {
                    if (!File.Exists(RTC_Core.rtcDir + "\\TEMP\\" + cmd.romFilename))
                    {
                        File.WriteAllBytes(RTC_Core.rtcDir + "\\TEMP\\" + cmd.romFilename, cmd.romData);
                    }
                }

                RTC_Core.LoadRom(RTC_Core.rtcDir + "\\TEMP\\" + cmd.romFilename);

                cmd.stashkey.DeployState();
                RTC_StockpileManager.LoadState(cmd.stashkey, false);

                if (RTC_Core.multiForm.GameOfSwapTimer != null)
                {
                    RTC_Core.multiForm.GameOfSwapCounter = 64;
                }

                break;

            case CommandType.PULLSCREEN:
                cmdBack        = new RTC_Command(CommandType.PUSHSCREEN);
                cmdBack.screen = GlobalWin.MainForm.MakeScreenshotImage().ToSysdrawingBitmap();
                break;

            case CommandType.REQUESTSTREAM:
                RTC_Core.multiForm.cbStreamScreenToPeer.Checked = true;
                break;

            case CommandType.PUSHSCREEN:
                UpdatePeerScreen(cmd.screen);
                break;

            case CommandType.GAMEOFSWAPSTART:
                RTC_Core.multiForm.StartGameOfSwap(false);
                break;

            case CommandType.GAMEOFSWAPSTOP:
                RTC_Core.multiForm.StopGameOfSwap(true);
                break;

            case CommandType.REMOTE_PUSHPARAMS:
                (cmd.objectValue as RTC_Params).Deploy();
                break;

            case CommandType.REMOTE_PUSHVMDS:
                RTC_MemoryDomains.VmdPool.Clear();
                foreach (var proto in (cmd.objectValue as VmdPrototype[]))
                {
                    RTC_MemoryDomains.AddVMD(proto);
                }

                break;

            case CommandType.REMOTE_LOADROM:
                RTC_Core.LoadRom_NET(cmd.romFilename);
                break;

            case CommandType.REMOTE_LOADSTATE:
            {
                StashKey sk            = (StashKey)(cmd.objectValue as object[])[0];
                bool     reloadRom     = (bool)(cmd.objectValue as object[])[1];
                bool     runBlastLayer = (bool)(cmd.objectValue as object[])[2];

                bool returnValue = RTC_StockpileManager.LoadState_NET(sk, reloadRom);

                RTC_MemoryDomains.RefreshDomains(false);

                if (runBlastLayer)
                {
                    RTC_Core.SendCommandToBizhawk(new RTC_Command(CommandType.BLAST)
                        {
                            blastlayer = sk.BlastLayer, isReplay = true
                        });
                }

                cmdBack             = new RTC_Command(CommandType.RETURNVALUE);
                cmdBack.objectValue = returnValue;
            }
            break;

            case CommandType.REMOTE_MERGECONFIG:
                Stockpile.MergeBizhawkConfig_NET();
                break;

            case CommandType.REMOTE_IMPORTKEYBINDS:
                Stockpile.ImportBizhawkKeybinds_NET();
                break;

            case CommandType.REMOTE_SAVESTATE:
            {
                StashKey sk = RTC_StockpileManager.SaveState_NET((bool)(cmd.objectValue as object[])[0], (StashKey)(cmd.objectValue as object[])[1]);
                if (cmd.requestGuid != null)
                {
                    cmdBack             = new RTC_Command(CommandType.RETURNVALUE);
                    cmdBack.objectValue = sk;
                }
            }
            break;

            case CommandType.REMOTE_BACKUPKEY_REQUEST:
            {
                if (!RTC_Hooks.isNormalAdvance)
                {
                    break;
                }

                cmdBack = new RTC_Command(CommandType.REMOTE_BACKUPKEY_STASH);

                bool multiThread = false;

                // apparently multithread savestates doesn't work well right now.
                // We can try again in a future version of bizhawk

                /*
                 * if (new string[] {
                 *   "SNES", "GB", "GBC", "GBA",
                 * }.Contains(Global.Game.System.ToString().ToUpper()))
                 *  multiThread = false;
                 */

                cmdBack.objectValue = RTC_StockpileManager.SaveState_NET(false, null, multiThread);
                break;
            }

            case CommandType.REMOTE_BACKUPKEY_STASH:
                RTC_StockpileManager.backupedState = (StashKey)cmd.objectValue;
                RTC_StockpileManager.allBackupStates.Push((StashKey)cmd.objectValue);
                RTC_Core.coreForm.btnGpJumpBack.Visible = true;
                RTC_Core.coreForm.btnGpJumpNow.Visible  = true;
                break;

            case CommandType.REMOTE_DOMAIN_PEEKBYTE:
                cmdBack             = new RTC_Command(CommandType.RETURNVALUE);
                cmdBack.objectValue = RTC_MemoryDomains.getInterface((string)(cmd.objectValue as object[])[0]).PeekByte((long)(cmd.objectValue as object[])[1]);
                break;

            case CommandType.REMOTE_DOMAIN_POKEBYTE:
                RTC_MemoryDomains.getInterface((string)(cmd.objectValue as object[])[0]).PokeByte((long)(cmd.objectValue as object[])[1], (byte)(cmd.objectValue as object[])[2]);
                break;

            case CommandType.REMOTE_DOMAIN_GETDOMAINS:
                cmdBack             = new RTC_Command(CommandType.RETURNVALUE);
                cmdBack.objectValue = RTC_MemoryDomains.getInterfaces();

                break;

            case CommandType.REMOTE_DOMAIN_VMD_ADD:
                RTC_MemoryDomains.AddVMD((cmd.objectValue as VmdPrototype));
                break;

            case CommandType.REMOTE_DOMAIN_VMD_REMOVE:
                RTC_MemoryDomains.RemoveVMD((cmd.objectValue as string));
                break;

            case CommandType.REMOTE_DOMAIN_SETSELECTEDDOMAINS:
                RTC_MemoryDomains.UpdateSelectedDomains((string[])cmd.objectValue);
                break;

            case CommandType.REMOTE_DOMAIN_SYSTEM:
                cmdBack             = new RTC_Command(CommandType.RETURNVALUE);
                cmdBack.objectValue = Global.Game.System.ToString().ToUpper();
                break;

            case CommandType.REMOTE_DOMAIN_SYSTEMPREFIX:
                cmdBack             = new RTC_Command(CommandType.RETURNVALUE);
                cmdBack.objectValue = PathManager.SaveStatePrefix(Global.Game);
                break;

            case CommandType.REMOTE_KEY_PUSHSAVESTATEDICO:
            {
                var key = (string)(cmd.objectValue as object[])[1];
                var sk  = (StashKey)((cmd.objectValue as object[])[0]);
                RTC_StockpileManager.SavestateStashkeyDico[key] = sk;
                RTC_Core.ghForm.refreshSavestateTextboxes();
            }
            break;

            case CommandType.REMOTE_KEY_GETSYSTEMNAME:
                cmdBack             = new RTC_Command(CommandType.RETURNVALUE);
                cmdBack.objectValue = (Global.Config.PathEntries[Global.Game.System, "Savestates"] ?? Global.Config.PathEntries[Global.Game.System, "Base"]).SystemDisplayName;
                break;

            case CommandType.REMOTE_KEY_GETSYSTEMCORE:
                cmdBack             = new RTC_Command(CommandType.RETURNVALUE);
                cmdBack.objectValue = StashKey.getCoreName_NET((string)cmd.objectValue);
                break;

            case CommandType.REMOTE_KEY_GETGAMENAME:
                cmdBack             = new RTC_Command(CommandType.RETURNVALUE);
                cmdBack.objectValue = PathManager.FilesystemSafeName(Global.Game);
                break;

            case CommandType.REMOTE_KEY_GETSYNCSETTINGS:
                cmdBack             = new RTC_Command(CommandType.RETURNVALUE);
                cmdBack.objectValue = StashKey.getSyncSettings_NET((string)cmd.objectValue);
                break;

            case CommandType.REMOTE_KEY_PUTSYNCSETTINGS:
                cmdBack = new RTC_Command(CommandType.RETURNVALUE);
                break;

            case CommandType.REMOTE_KEY_GETOPENROMFILENAME:
                cmdBack             = new RTC_Command(CommandType.RETURNVALUE);
                cmdBack.objectValue = GlobalWin.MainForm.CurrentlyOpenRom;
                break;

            case CommandType.REMOTE_KEY_GETRAWBLASTLAYER:
                cmdBack             = new RTC_Command(CommandType.RETURNVALUE);
                cmdBack.objectValue = RTC_StockpileManager.getRawBlastlayer();
                break;

            case CommandType.BIZHAWK_SET_OSDDISABLED:
                RTC_Core.BizhawkOsdDisabled = (bool)cmd.objectValue;
                break;

            case CommandType.REMOTE_SET_SAVESTATEBOX:
                RTC_StockpileManager.currentSavestateKey = (string)cmd.objectValue;
                break;

            case CommandType.REMOTE_SET_AUTOCORRUPT:
                RTC_Core.AutoCorrupt = (bool)cmd.objectValue;
                break;

            case CommandType.REMOTE_SET_CUSTOMPRECISION:
                RTC_Core.CustomPrecision = (int)cmd.objectValue;
                break;

            case CommandType.REMOTE_SET_INTENSITY:
                RTC_Core.Intensity = (int)cmd.objectValue;
                break;

            case CommandType.REMOTE_SET_ERRORDELAY:
                RTC_Core.ErrorDelay = (int)cmd.objectValue;
                break;

            case CommandType.REMOTE_SET_BLASTRADIUS:
                RTC_Core.Radius = (BlastRadius)cmd.objectValue;
                break;

            case CommandType.REMOTE_SET_RESTOREBLASTLAYERBACKUP:
                if (RTC_StockpileManager.lastBlastLayerBackup != null)
                {
                    RTC_StockpileManager.lastBlastLayerBackup.Apply(true);
                }
                break;

            case CommandType.REMOTE_SET_NIGHTMARE_TYPE:
                RTC_NightmareEngine.Algo = (BlastByteAlgo)cmd.objectValue;
                break;

            case CommandType.REMOTE_SET_HELLGENIE_MAXCHEATS:
                RTC_HellgenieEngine.MaxCheats = (int)cmd.objectValue;
                break;

            case CommandType.REMOTE_SET_HELLGENIE_CHEARCHEATSREWIND:
                RTC_Core.ClearCheatsOnRewind = (bool)cmd.objectValue;
                break;

            case CommandType.REMOTE_SET_HELLGENIE_CLEARALLCHEATS:
                if (Global.CheatList != null)
                {
                    Global.CheatList.Clear();
                }
                break;

            case CommandType.REMOTE_SET_HELLGENIE_REMOVEEXCESSCHEATS:
                while (Global.CheatList.Count > RTC_HellgenieEngine.MaxCheats)
                {
                    Global.CheatList.Remove(Global.CheatList[0]);
                }
                break;

            case CommandType.REMOTE_SET_PIPE_MAXPIPES:
                RTC_PipeEngine.MaxPipes = (int)cmd.objectValue;
                break;

            case CommandType.REMOTE_SET_PIPE_TILTVALUE:
                RTC_PipeEngine.tiltValue = (int)cmd.objectValue;
                break;


            case CommandType.REMOTE_SET_PIPE_CLEARPIPES:
                RTC_PipeEngine.AllBlastPipes.Clear();
                RTC_PipeEngine.lastDomain = null;
                break;

            case CommandType.REMOTE_SET_PIPE_LOCKPIPES:
                RTC_PipeEngine.LockPipes = (bool)cmd.objectValue;
                break;

            case CommandType.REMOTE_SET_PIPE_CHAINEDPIPES:
                RTC_PipeEngine.ChainedPipes = (bool)cmd.objectValue;
                break;

            case CommandType.REMOTE_SET_PIPE_PROCESSONSTEP:
                RTC_PipeEngine.ProcessOnStep = (bool)cmd.objectValue;
                break;

            case CommandType.REMOTE_SET_PIPE_CLEARPIPESREWIND:
                RTC_Core.ClearPipesOnRewind = (bool)cmd.objectValue;
                break;


            case CommandType.REMOTE_SET_ENGINE:
                RTC_Core.SelectedEngine = (CorruptionEngine)cmd.objectValue;
                break;

            case CommandType.REMOTE_SET_DISTORTION_DELAY:
                RTC_DistortionEngine.MaxAge     = (int)cmd.objectValue;
                RTC_DistortionEngine.CurrentAge = 0;
                RTC_DistortionEngine.AllDistortionBytes.Clear();
                break;

            case CommandType.REMOTE_SET_DISTORTION_RESYNC:
                RTC_DistortionEngine.CurrentAge = 0;
                RTC_DistortionEngine.AllDistortionBytes.Clear();
                break;

            case CommandType.REMOTE_SET_VECTOR_LIMITER:
                RTC_VectorEngine.limiterList = (string[])cmd.objectValue;
                break;

            case CommandType.REMOTE_SET_VECTOR_VALUES:
                RTC_VectorEngine.valueList = (string[])cmd.objectValue;
                break;

            case CommandType.REMOTE_EVENT_LOADGAMEDONE_NEWGAME:

                if (RTC_Core.isStandalone && RTC_GameProtection.isRunning)
                {
                    RTC_GameProtection.Reset();
                }

                RTC_Core.AutoCorrupt = false;
                //RTC_StockpileManager.isCorruptionApplied = false;
                RTC_Core.ecForm.RefreshDomains();
                RTC_Core.ecForm.setMemoryDomainsAllButSelectedDomains(RTC_MemoryDomains.GetBlacklistedDomains());
                RTC_Core.ecForm.lbCoreDefault.Text = $"Core default: { RTC_MemoryDomains.MemoryInterfaces[RTC_MemoryDomains.MainDomain].WordSize * 8}-bit";
                break;

            case CommandType.REMOTE_EVENT_LOADGAMEDONE_SAMEGAME:
                //RTC_StockpileManager.isCorruptionApplied = false;
                RTC_Core.ecForm.RefreshDomainsAndKeepSelected();
                RTC_Core.ecForm.lbCoreDefault.Text = $"Core default: { RTC_MemoryDomains.MemoryInterfaces[RTC_MemoryDomains.MainDomain].WordSize * 8}-bit";
                break;

            case CommandType.REMOTE_EVENT_CLOSEBIZHAWK:
                GlobalWin.MainForm.Close();
                break;

            case CommandType.REMOTE_EVENT_SAVEBIZHAWKCONFIG:
                GlobalWin.MainForm.SaveConfig();
                break;

            case CommandType.REMOTE_EVENT_BIZHAWKSTARTED:

                if (RTC_StockpileManager.backupedState == null)
                {
                    RTC_Core.coreForm.AutoCorrupt = false;
                }

                RTC_Core.SendCommandToBizhawk(new RTC_Command(CommandType.REMOTE_PUSHPARAMS)
                {
                    objectValue = new RTC_Params()
                }, true, true);

                RTC_Core.SendCommandToBizhawk(new RTC_Command(CommandType.REMOTE_PUSHVMDS)
                {
                    objectValue = RTC_MemoryDomains.VmdPool.Values.Select(it => (it as VirtualMemoryDomain).proto).ToArray()
                }, true, true);


                Thread.Sleep(100);

                if (RTC_StockpileManager.backupedState != null)
                {
                    RTC_Core.ecForm.RefreshDomainsAndKeepSelected(RTC_StockpileManager.backupedState.SelectedDomains.ToArray());
                }

                if (RTC_Core.coreForm.cbUseGameProtection.Checked)
                {
                    RTC_GameProtection.Start();
                }

                break;


            case CommandType.REMOTE_HOTKEY_MANUALBLAST:
                RTC_Core.coreForm.btnManualBlast_Click(null, null);
                break;

            case CommandType.REMOTE_HOTKEY_AUTOCORRUPTTOGGLE:
                RTC_Core.coreForm.btnAutoCorrupt_Click(null, null);
                break;

            case CommandType.REMOTE_HOTKEY_ERRORDELAYDECREASE:
                if (RTC_Core.ecForm.nmErrorDelay.Value > 1)
                {
                    RTC_Core.ecForm.nmErrorDelay.Value--;
                }
                break;

            case CommandType.REMOTE_HOTKEY_ERRORDELAYINCREASE:
                if (RTC_Core.ecForm.nmErrorDelay.Value < RTC_Core.ecForm.track_ErrorDelay.Maximum)
                {
                    RTC_Core.ecForm.nmErrorDelay.Value++;
                }
                break;

            case CommandType.REMOTE_HOTKEY_INTENSITYDECREASE:
                if (RTC_Core.ecForm.nmIntensity.Value > 1)
                {
                    RTC_Core.ecForm.nmIntensity.Value--;
                }
                break;

            case CommandType.REMOTE_HOTKEY_INTENSITYINCREASE:
                if (RTC_Core.ecForm.nmIntensity.Value < RTC_Core.ecForm.track_Intensity.Maximum)
                {
                    RTC_Core.ecForm.nmIntensity.Value++;
                }
                break;

            case CommandType.REMOTE_HOTKEY_GHLOADCORRUPT:
                if (!RTC_NetCore.NetCoreCommandSynclock)
                {
                    RTC_NetCore.NetCoreCommandSynclock = true;

                    RTC_Core.ghForm.cbAutoLoadState.Checked = true;
                    RTC_Core.ghForm.btnCorrupt_Click(null, null);

                    RTC_NetCore.NetCoreCommandSynclock = false;
                }
                break;

            case CommandType.REMOTE_HOTKEY_GHCORRUPT:
                if (!RTC_NetCore.NetCoreCommandSynclock)
                {
                    RTC_NetCore.NetCoreCommandSynclock = true;

                    bool isload = RTC_Core.ghForm.cbAutoLoadState.Checked;
                    RTC_Core.ghForm.cbAutoLoadState.Checked = false;
                    RTC_Core.ghForm.btnCorrupt_Click(null, null);
                    RTC_Core.ghForm.cbAutoLoadState.Checked = isload;

                    RTC_NetCore.NetCoreCommandSynclock = false;
                }
                break;

            case CommandType.REMOTE_HOTKEY_GHLOAD:
                RTC_Core.ghForm.btnSaveLoad.Text = "LOAD";
                RTC_Core.ghForm.btnSaveLoad_Click(null, null);
                break;

            case CommandType.REMOTE_HOTKEY_GHSAVE:
                RTC_Core.ghForm.btnSaveLoad.Text = "SAVE";
                RTC_Core.ghForm.btnSaveLoad_Click(null, null);
                break;

            case CommandType.REMOTE_HOTKEY_GHSTASHTOSTOCKPILE:
                RTC_Core.ghForm.AddStashToStockpile(false);
                break;

            case CommandType.REMOTE_HOTKEY_SENDRAWSTASH:
                RTC_Core.ghForm.btnSendRaw_Click(null, null);
                break;

            case CommandType.REMOTE_HOTKEY_BLASTRAWSTASH:
                RTC_Core.SendCommandToBizhawk(new RTC_Command(CommandType.ASYNCBLAST));
                RTC_Core.ghForm.btnSendRaw_Click(null, null);
                break;

            case CommandType.REMOTE_HOTKEY_BLASTLAYERTOGGLE:
                RTC_Core.ghForm.btnBlastToggle_Click(null, null);
                break;

            case CommandType.REMOTE_HOTKEY_BLASTLAYERREBLAST:

                if (RTC_StockpileManager.currentStashkey == null || RTC_StockpileManager.currentStashkey.BlastLayer.Layer.Count == 0)
                {
                    RTC_Core.ghForm.IsCorruptionApplied = false;
                    break;
                }

                RTC_Core.ghForm.IsCorruptionApplied = true;
                RTC_Core.SendCommandToRTC(new RTC_Command(CommandType.BLAST)
                {
                    blastlayer = RTC_StockpileManager.currentStashkey.BlastLayer
                });
                break;

            case CommandType.REMOTE_RENDER_START:
                RTC_Render.StartRender_NET();
                break;

            case CommandType.REMOTE_RENDER_STOP:
                RTC_Render.StopRender_NET();
                break;

            case CommandType.REMOTE_RENDER_SETTYPE:
                RTC_Render.lastType = (RENDERTYPE)cmd.objectValue;
                break;

            case CommandType.REMOTE_RENDER_STARTED:
                RTC_Core.ghForm.btnRender.Text      = "Stop Render";
                RTC_Core.ghForm.btnRender.ForeColor = Color.GreenYellow;
                break;

            case CommandType.REMOTE_RENDER_RENDERATLOAD:
                RTC_StockpileManager.renderAtLoad = (bool)cmd.objectValue;
                break;
            }


            return(cmdBack);
        }
コード例 #2
0
        public static bool LoadState_NET(StashKey sk, bool ReloadRom = true)
        {
            if (sk == null)
            {
                return(false);
            }

            StashKey.setCore(sk);
            string GameSystem     = sk.SystemName;
            string GameName       = sk.GameName;
            string Key            = sk.ParentKey;
            bool   GameHasChanged = false;
            string TheoricalSaveStateFilename;

            RTC_Core.StopSound();

            if (ReloadRom)
            {
                string ss = null;
                RTC_Core.LoadRom_NET(sk.RomFilename);

                //If the syncsettings are different, update them and load it again. Otheriwse, leave as is
                if (sk.SyncSettings != (ss = StashKey.getSyncSettings_NET(ss)))
                {
                    StashKey.putSyncSettings_NET(sk);
                    RTC_Core.LoadRom_NET(sk.RomFilename);
                }
                GameHasChanged = true;
            }



            RTC_Core.StartSound();


            PathEntry pathEntry = Global.Config.PathEntries[Global.Game.System, "Savestates"] ??
                                  Global.Config.PathEntries[Global.Game.System, "Base"];

            if (!GameHasChanged)
            {
                TheoricalSaveStateFilename = RTC_Core.bizhawkDir + "\\" + GameSystem + "\\State\\" + GameName + "." + Key + ".timejump.State";
            }
            else
            {
                TheoricalSaveStateFilename = RTC_Core.bizhawkDir + "\\" + RTC_Core.EmuFolderCheck(pathEntry.SystemDisplayName) + "\\State\\" + PathManager.FilesystemSafeName(Global.Game) + "." + Key + ".timejump.State";
            }


            if (File.Exists(TheoricalSaveStateFilename))
            {
                RTC_Core.LoadSavestate_NET(Key);
            }
            else
            {
                RTC_Core.StopSound();
                MessageBox.Show($"Error loading savestate : (File {Key + ".timejump"} not found)");
                RTC_Core.StartSound();
                return(false);
            }

            return(true);
        }