示例#1
0
        public void UpdateTimeStackDelay()
        {
            RTC_TimeStack.TimeStackDelay = Convert.ToInt32(nmTimeStackDelay.Value);
            if (cbUseTimeStack.Checked)
            {
                RTC_TimeStack.Stop();
                RTC_TimeStack.Start();
            }

            RTC_Restore.SaveRestore();
        }
示例#2
0
        private void cbUseTimeStack_CheckedChanged(object sender, EventArgs e)
        {
            if (cbUseTimeStack.Checked)
            {
                RTC_TimeStack.Start();
            }
            else
            {
                RTC_TimeStack.Stop();
            }

            RTC_Restore.SaveRestore();
        }
示例#3
0
        public static void LOAD_GAME_DONE()
        {
            if (!RTC_Core.isLoaded)
            {
                return;
            }

            if (RTC_Core.currentGameName == lastGameName)
            {
                RTC_MemoryZones.RefreshAndKeepDomains();
            }

            RTC_HellgenieEngine.ClearCheats();


            //Load Game vars into RTC_Core
            PathEntry pathEntry = Global.Config.PathEntries[Global.Game.System, "Savestates"] ??
                                  Global.Config.PathEntries[Global.Game.System, "Base"];

            RTC_Core.currentGameSystem = RTC_Core.EmuFolderCheck(pathEntry.SystemDisplayName);
            RTC_Core.currentGameName   = PathManager.FilesystemSafeName(Global.Game);
            RTC_Core.lastOpenRom       = GlobalWin.MainForm.CurrentlyOpenRom;
            RTC_RPC.RefreshPlugin();

            if (RTC_Core.currentGameName != lastGameName)
            {
                RTC_TimeStack.Reset();
                RTC_MemoryZones.AutoSelectDomains();
            }

            if (RTC_MemoryZones.pendingSelectedDomains != null)
            {
                RTC_MemoryZones.setSelectedDomains(RTC_MemoryZones.pendingSelectedDomains);
                RTC_MemoryZones.pendingSelectedDomains = null;
            }
            lastGameName = RTC_Core.currentGameName;

            //RTC_Restore.SaveRestore();

            RTC_RPC.SendToKillSwitch("UNFREEZE");
        }
示例#4
0
        public static void LoadRestore()
        {
            try
            {
                #region Loading the Restore.dat File

                lock (restoreLock)
                {
                    FileStream      FS;
                    BinaryFormatter bformatter = new BinaryFormatter();
                    FS         = File.Open(RTC_Core.rtcDir + "\\SESSION\\Restore.dat", FileMode.OpenOrCreate);
                    RTC_Status = (RestoreFile)bformatter.Deserialize(FS);
                    FS.Close();
                }

                #endregion

                #region Replacing Form Values

                switch (RTC_Status.SelectedEngine)
                {
                case CorruptionEngine.NIGHTMARE:
                    RTC_Core.SetEngineByName("Nightmare Engine");
                    break;

                case CorruptionEngine.HELLGENIE:
                    RTC_Core.SetEngineByName("Hellgenie Engine");
                    break;

                case CorruptionEngine.DISTORTION:
                    RTC_Core.SetEngineByName("Distortion Engine");
                    break;

                case CorruptionEngine.NONE:
                    break;
                }

                RTC_Core.coreForm.nmIteratorSteps.Value = Convert.ToDecimal(RTC_Status.IteratorSteps);
                RTC_Core.coreForm.nmIntensity.Value     = Convert.ToDecimal(RTC_Status.Intensity);

                RTC_Core.coreForm.cbClearCheatsOnRewind.Checked = RTC_Status.ClearCheatsOnRewind;

                string cbBlastRadius = RTC_Status.Radius.ToString();
                for (int i = 0; i < RTC_Core.coreForm.cbBlastRadius.Items.Count; i++)
                {
                    if (RTC_Core.coreForm.cbBlastRadius.Items[i].ToString() == cbBlastRadius)
                    {
                        RTC_Core.coreForm.cbBlastRadius.SelectedIndex = i;
                    }
                }

                string cbBlastType = RTC_Status.Algo.ToString();
                for (int i = 0; i < RTC_Core.coreForm.cbBlastRadius.Items.Count; i++)
                {
                    if (RTC_Core.coreForm.cbBlastType.Items[i].ToString() == cbBlastType)
                    {
                        RTC_Core.coreForm.cbBlastType.SelectedIndex = i;
                    }
                }



                RTC_Core.coreForm.nmMaxCheats.Value       = Convert.ToDecimal(RTC_Status.MaxCheats);
                RTC_Core.coreForm.nmMaxFreezes.Value      = Convert.ToDecimal(RTC_Status.MaxFreezes);
                RTC_Core.coreForm.nmDistortionDelay.Value = Convert.ToDecimal(RTC_Status.MaxAge);

                if (RTC_Status.AutoCorrupt)
                {
                    RTC_Core.coreForm.btnAutoCorrupt.Text = "Stop Auto-Corrupt";
                }
                else
                {
                    RTC_Core.coreForm.btnAutoCorrupt.Text = "Start Auto-Corrupt";
                }

                //Set Up the Memory Domains Here

                #endregion

                #region RTC_NightmareEngine

                RTC_NightmareEngine.Algo = RTC_Status.Algo;

                #endregion

                #region RTC_HellgenieEngine

                RTC_HellgenieEngine.MaxCheats = RTC_Status.MaxCheats;

                #endregion

                #region RTC_HellgenieEngine

                RTC_FreezeEngine.MaxFreezes = RTC_Status.MaxFreezes;

                #endregion

                #region RTC_DistortionEngine

                RTC_DistortionEngine.MaxAge             = RTC_Status.MaxAge;
                RTC_DistortionEngine.CurrentAge         = RTC_Status.CurrentAge;
                RTC_DistortionEngine.AllDistortionBytes = RTC_Status.AllDistortionBytes;

                #endregion

                #region RTC_ExternalRomPlugin
                RTC_ExternalRomPlugin.SelectedPlugin = RTC_Status.SelectedPlugin;

                for (int i = 0; i < RTC_Core.coreForm.cbExternalSelectedPlugin.Items.Count; i++)
                {
                    if (RTC_ExternalRomPlugin.SelectedPlugin == RTC_Core.coreForm.cbExternalSelectedPlugin.Items[i].ToString())
                    {
                        RTC_Core.coreForm.cbExternalSelectedPlugin.SelectedIndex = i;
                        break;
                    }
                }


                #endregion

                #region RTC_coreForm

                switch (RTC_Status.SelectedEngine)
                {
                case CorruptionEngine.NIGHTMARE:
                    RTC_Core.SetEngineByName("Nightmare Engine");
                    break;

                case CorruptionEngine.HELLGENIE:
                    RTC_Core.SetEngineByName("Hellgenie Engine");
                    break;

                case CorruptionEngine.DISTORTION:
                    RTC_Core.SetEngineByName("Distortion Engine");
                    break;

                case CorruptionEngine.FREEZE:
                    RTC_Core.SetEngineByName("Freeze Engine");
                    break;

                case CorruptionEngine.EXTERNALROM:
                    RTC_Core.SetEngineByName("External ROM Plugin");
                    break;
                }

                #endregion

                #region RTC_GH_Form

                RTC_Core.ghForm.currentSelectedState = RTC_Status.currentSelectedState;

                switch (RTC_Core.ghForm.currentSelectedState)
                {
                case "01":
                    RTC_Core.ghForm.btnSavestate_Click(RTC_Core.ghForm.btnSavestate01, new EventArgs());
                    break;

                case "02":
                    RTC_Core.ghForm.btnSavestate_Click(RTC_Core.ghForm.btnSavestate02, new EventArgs());
                    break;

                case "03":
                    RTC_Core.ghForm.btnSavestate_Click(RTC_Core.ghForm.btnSavestate03, new EventArgs());
                    break;

                case "04":
                    RTC_Core.ghForm.btnSavestate_Click(RTC_Core.ghForm.btnSavestate04, new EventArgs());
                    break;

                case "05":
                    RTC_Core.ghForm.btnSavestate_Click(RTC_Core.ghForm.btnSavestate05, new EventArgs());
                    break;

                case "06":
                    RTC_Core.ghForm.btnSavestate_Click(RTC_Core.ghForm.btnSavestate06, new EventArgs());
                    break;

                case "07":
                    RTC_Core.ghForm.btnSavestate_Click(RTC_Core.ghForm.btnSavestate07, new EventArgs());
                    break;

                case "08":
                    RTC_Core.ghForm.btnSavestate_Click(RTC_Core.ghForm.btnSavestate08, new EventArgs());
                    break;

                case "09":
                    RTC_Core.ghForm.btnSavestate_Click(RTC_Core.ghForm.btnSavestate09, new EventArgs());
                    break;

                case "10":
                    RTC_Core.ghForm.btnSavestate_Click(RTC_Core.ghForm.btnSavestate10, new EventArgs());
                    break;

                case "11":
                    RTC_Core.ghForm.btnSavestate_Click(RTC_Core.ghForm.btnSavestate11, new EventArgs());
                    break;

                case "12":
                    RTC_Core.ghForm.btnSavestate_Click(RTC_Core.ghForm.btnSavestate12, new EventArgs());
                    break;

                case "13":
                    RTC_Core.ghForm.btnSavestate_Click(RTC_Core.ghForm.btnSavestate13, new EventArgs());
                    break;

                case "14":
                    RTC_Core.ghForm.btnSavestate_Click(RTC_Core.ghForm.btnSavestate14, new EventArgs());
                    break;

                case "15":
                    RTC_Core.ghForm.btnSavestate_Click(RTC_Core.ghForm.btnSavestate15, new EventArgs());
                    break;

                case "16":
                    RTC_Core.ghForm.btnSavestate_Click(RTC_Core.ghForm.btnSavestate16, new EventArgs());
                    break;

                case "17":
                    RTC_Core.ghForm.btnSavestate_Click(RTC_Core.ghForm.btnSavestate17, new EventArgs());
                    break;

                case "18":
                    RTC_Core.ghForm.btnSavestate_Click(RTC_Core.ghForm.btnSavestate18, new EventArgs());
                    break;

                case "19":
                    RTC_Core.ghForm.btnSavestate_Click(RTC_Core.ghForm.btnSavestate19, new EventArgs());
                    break;

                case "20":
                    RTC_Core.ghForm.btnSavestate_Click(RTC_Core.ghForm.btnSavestate20, new EventArgs());
                    break;
                }


                RTC_Core.ghForm.btnParentKeys  = RTC_Status.btnParentKeys;
                RTC_Core.ghForm.btnAttachedRom = RTC_Status.btnAttachedRom;

                RTC_Core.ghForm.DontLoadSelectedStash     = RTC_Status.DontLoadSelectedStash;
                RTC_Core.ghForm.DontLoadSelectedStockpile = RTC_Status.DontLoadSelectedStockpile;


                if (RTC_Status.ghMode == "CORRUPT")
                {
                    RTC_Core.ghForm.rbCorrupt.Checked = true;
                }
                else if (RTC_Status.ghMode == "INJECT")
                {
                    RTC_Core.ghForm.rbInject.Checked = true;
                }
                else
                {
                    RTC_Core.ghForm.rbOriginal.Checked = true;
                }


                RTC_Core.ghForm.cbAutoLoadState.Checked        = RTC_Status.AutoLoadState;
                RTC_Core.ghForm.cbLoadOnSelect.Checked         = RTC_Status.LoadOnSelect;
                RTC_Core.ghForm.cbStashCorrupted.Checked       = RTC_Status.StashCorrupted;
                RTC_Core.ghForm.cbStashInjected.Checked        = RTC_Status.StashInjected;
                RTC_Core.ghForm.cbRenderAtLoad.Checked         = RTC_Status.RenderAtLoad;
                RTC_Core.ghForm.cbRenderAtCorrupt.Checked      = RTC_Status.RenderAtCorrupt;
                RTC_Core.ghForm.cbSavestateLoadOnClick.Checked = RTC_Status.SavestateLoadOnClick;

                if (RTC_Status.ExportFormat == "NONE")
                {
                    RTC_Core.ghForm.rbRenderNone.Checked = true;
                }
                else if (RTC_Status.ExportFormat == "MPEG")
                {
                    RTC_Core.ghForm.rbRenderMPEG.Checked = true;
                }
                else if (RTC_Status.ExportFormat == "WAV")
                {
                    RTC_Core.ghForm.rbRenderWAV.Checked = true;
                }
                else if (RTC_Status.ExportFormat == "AVI")
                {
                    RTC_Core.ghForm.rbRenderAVI.Checked = true;
                }

                RTC_Core.ghForm.lbStockpile.Items.AddRange(RTC_Status.StockpileListboxItems.ToArray());

                RTC_Core.ghForm.cbBackupHistory.Checked = RTC_Status.BackupHistory;

                if (RTC_Status.BackupHistory)
                {
                    RTC_Core.ghForm.lbStashHistory.Items.AddRange(RTC_Status.StashHistoryListboxItems.ToArray());
                }


                #endregion

                #region RTC_Core

                //Default Values
                RTC_Core.SelectedEngine      = RTC_Status.SelectedEngine;
                RTC_Core.IteratorSteps       = RTC_Status.IteratorSteps;
                RTC_Core.Radius              = RTC_Status.Radius;
                RTC_Core.Intensity           = RTC_Status.Intensity;
                RTC_Core.ClearCheatsOnRewind = RTC_Status.ClearCheatsOnRewind;

                //Flags
                RTC_Core.AutoCorrupt       = RTC_Status.AutoCorrupt;
                RTC_Core.ExtractBlastLayer = RTC_Status.ExtractBlastLayer;

                RTC_Core.lastOpenRom = RTC_Status.lastOpenRom;

                if (RTC_Core.lastOpenRom != null)
                {
                    RTC_Core.LoadRom(RTC_Core.lastOpenRom);
                    RTC_MemoryZones.pendingSelectedDomains = RTC_Status.SelectedDomains;
                }
                else
                {
                    RTC_Core.AutoCorrupt = false;
                    RTC_Core.LoadDefaultRom();
                }

                //General Values

                //Memory object references
                RTC_Core.currentStockpile = RTC_Status.currentStockpile;

                if (RTC_Core.currentStockpile != null && RTC_Core.currentStockpile.Filename != null)
                {
                    RTC_Core.ghForm.btnSaveStockpile.Enabled   = true;
                    RTC_Core.ghForm.btnSaveStockpile.BackColor = Color.Tomato;
                }

                #endregion

                #region RTC_TimeStack & RTC_TimeFlow

                RTC_Core.coreForm.cbUseTimeStack.Checked = RTC_Status.TimeStack;
                RTC_Core.coreForm.nmTimeStackDelay.Value = Convert.ToDecimal(RTC_Status.TimeStackDelay);

                if (RTC_Status.TimeStack)
                {
                    RTC_TimeStack.LoadTimeStack();
                }

                if (RTC_Status.TimeMap)
                {
                    RTC_TimeFlow.Start();
                }

                #endregion

                GlobalWin.MainForm.Activate();
            }
            catch (Exception ex)
            {
                MessageBox.Show("Something wrong happenned in RTC_Restore -> LoadRestore() \n\n" + ex.ToString());
            }
        }
示例#5
0
        public static bool HOTKEY_CHECK(string trigger)
        {// You can go to the injected Hotkey Hijack by searching #HotkeyHijack
            switch (trigger)
            {
            default:
                return(false);

            case "Manual Blast":
                RTC_Core.coreForm.btnManualBlast_Click(null, null);
                break;

            case "Start/Stop AutoCorrupt":
                RTC_Core.coreForm.btnAutoCorrupt_Click(null, null);
                break;

            case "Error Delay--":
                if (RTC_Core.coreForm.track_ErrorDelay.Value > 1)
                {
                    RTC_Core.coreForm.track_ErrorDelay.Value--;
                    RTC_Core.coreForm.track_ErrorDelay_Scroll(null, null);
                }
                break;

            case "Error Delay++":
                if (RTC_Core.coreForm.track_ErrorDelay.Value < RTC_Core.coreForm.track_ErrorDelay.Maximum)
                {
                    RTC_Core.coreForm.track_ErrorDelay.Value++;
                    RTC_Core.coreForm.track_ErrorDelay_Scroll(null, null);
                }
                break;

            case "Intensity--":
                if (RTC_Core.coreForm.track_Intensity.Value > 1)
                {
                    RTC_Core.coreForm.track_Intensity.Value--;
                    RTC_Core.coreForm.track_Intensity_Scroll(null, null);
                }
                break;

            case "Intensity++":
                if (RTC_Core.coreForm.track_Intensity.Value < RTC_Core.coreForm.track_Intensity.Maximum)
                {
                    RTC_Core.coreForm.track_Intensity.Value++;
                    RTC_Core.coreForm.track_Intensity_Scroll(null, null);
                }
                break;

            case "GH Load and Corrupt":
                RTC_Core.ghForm.cbAutoLoadState.Checked = true;
                RTC_Core.ghForm.btnCorrupt_Click(null, null);
                break;

            case "GH Corrupt w/o Load":
                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;
                break;

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

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

            case "Reset TimeStack":
                RTC_TimeStack.Reset();
                break;

            case "TimeStack Jump":
                RTC_TimeStack.Jump();
                break;

            case "Induce KS Crash":
                RTC_RPC.Stop();
                break;

            case "Send Raw to Stash":
                RTC_Core.ghForm.btnSendRaw_Click(null, null);
                break;

            case "Blast Toggle":
                RTC_Core.ghForm.btnBlastToggle_Click(null, null);
                break;
            }
            return(true);
        }
示例#6
0
        public void StartEasyMode(bool useTemplate)
        {
            if (Global.Emulator is NullEmulator)
            {
                MessageBox.Show("Please load a game in BizHawk before using the RTC in Easy Mode");
                return;
            }

            if (useTemplate)
            {
                //Put Console templates HERE
                string thisSystem = Global.Game.System.ToString().ToUpper();

                switch (thisSystem)
                {
                case "NES":         //Nintendo Entertainment system
                    RTC_Core.SetEngineByName("Nightmare Engine");
                    RTC_Core.Intensity     = 2;
                    RTC_Core.IteratorSteps = 1;
                    break;


                case "GB":          //Gameboy
                case "GBC":         //Gameboy Color
                    RTC_Core.SetEngineByName("Nightmare Engine");
                    RTC_Core.Intensity     = 1;
                    RTC_Core.IteratorSteps = 4;
                    break;

                case "SNES":        //Super Nintendo
                    RTC_Core.SetEngineByName("Nightmare Engine");
                    RTC_Core.Intensity     = 4;
                    RTC_Core.IteratorSteps = 8;
                    break;


                case "GBA":         //Gameboy Advance
                    RTC_Core.SetEngineByName("Nightmare Engine");
                    RTC_Core.Intensity     = 1;
                    RTC_Core.IteratorSteps = 1;
                    break;

                case "N64":         //Nintendo 64
                    RTC_Core.SetEngineByName("Nightmare Engine");
                    RTC_Core.Intensity     = 70;
                    RTC_Core.IteratorSteps = 5;
                    break;

                case "SG":          //Sega SG-1000
                case "GG":          //Sega GameGear
                case "SMS":         //Sega Master System
                case "GEN":         //Sega Genesis and CD
                case "PCE":         //PC-Engine / Turbo Grafx
                case "PSX":         //Sony Playstation 1
                case "A26":         //Atari 2600
                case "A78":         //Atari 7800
                case "LYNX":        //Atari Lynx
                case "INTV":        //Intellivision
                case "PCECD":       //related to PC-Engine / Turbo Grafx
                case "SGX":         //related to PC-Engine / Turbo Grafx
                case "TI83":        //Ti-83 Calculator
                case "WSWAN":       //Wonderswan
                case "C64":         //Commodore 64
                case "Coleco":      //Colecovision
                case "SGB":         //Super Gameboy
                case "SAT":         //Sega Saturn
                case "DGB":
                    MessageBox.Show("WARNING: No Easy-Mode template was made for this system. Please configure it manually and use the current settings.");
                    break;

                    //TODO: Add more zones like gamegear, atari, turbo graphx
                }
            }

            RTC_Core.AutoCorrupt = true;

            RTC_TimeStack.Reset();
            cbUseTimeStack.Checked = true;
            RTC_TimeFlow.Start();
            GlobalWin.MainForm.Focus();
        }
示例#7
0
 public void btnTimeStackJump_Click(object sender, EventArgs e)
 {
     RTC_TimeStack.Jump();
 }
示例#8
0
 public void btnResetTimeStack_Click(object sender, EventArgs e)
 {
     RTC_TimeStack.Reset();
 }
示例#9
0
 public void Push(string key)
 {
     ts.Push(key);
     RTC_TimeStack.SaveTimeStack();
 }