public static bool ApplyStashkey(StashKey sk, bool _loadBeforeOperation = true)
{
PreApplyStashkey();
var token = RTC_NetCore.HugeOperationStart("LAZY");
if (loadBeforeOperation && _loadBeforeOperation)
{
if (!LoadStateAndBlastLayer(sk))
{
RTC_NetCore.HugeOperationEnd(token);
return(isCorruptionApplied);
}
}
else
{
RTC_Core.SendCommandToBizhawk(new RTC_Command(CommandType.BLAST)
{
blastlayer = sk.BlastLayer, isReplay = true
});
}
RTC_NetCore.HugeOperationEnd(token);
isCorruptionApplied = (sk.BlastLayer != null && sk.BlastLayer.Layer.Count > 0);
PostApplyStashkey();
return(isCorruptionApplied);
}
public CorruptCloudGameData(StashKey key)
{
PathEntry pathEntry = Global.Config.PathEntries[Global.Game.System, "Savestates"] ??
Global.Config.PathEntries[Global.Game.System, "Base"];
fileHash = Global.Game.Hash;
originalFileName = GlobalWin.MainForm.CurrentlyOpenRom;
if (originalFileName.IndexOf("\\") != -1)
{
originalFileName = originalFileName.Substring(originalFileName.LastIndexOf("\\") + 1);
}
originalGameName = PathManager.FilesystemSafeName(Global.Game);
originalGameSystem = RTC_Core.EmuFolderCheck(pathEntry.SystemDisplayName);
if (key.ParentKey == null)
{
originalKey = key.Key;
}
else
{
originalKey = key.ParentKey;
}
string originalSavestateFilename = key.GameName + "." + key.ParentKey + ".timejump.State"; // get savestate name
originalSavestate = File.ReadAllBytes(RTC_Core.bizhawkDir + "\\" + key.GameSystem + "\\State\\" + originalSavestateFilename);
originalKey = RTC_Core.GetRandomKey();
}
private void btnGpJumpBack_Click(object sender, EventArgs e)
{
try
{
btnGpJumpBack.Visible = false;
if (RTC_StockpileManager.allBackupStates.Count == 0)
{
return;
}
StashKey sk = RTC_StockpileManager.allBackupStates.Pop();
if (sk != null)
{
sk.Run();
}
RTC_GameProtection.Reset();
}
finally
{
if (RTC_StockpileManager.allBackupStates.Count != 0)
{
btnGpJumpBack.Visible = true;
}
}
}
public static bool LoadState(StashKey sk, bool ReloadRom = true, bool applyBlastLayer = true)
{
return((bool)RTC_Core.SendCommandToBizhawk(new RTC_Command(CommandType.REMOTE_LOADSTATE)
{
objectValue = new object[] { sk, ReloadRom, false, applyBlastLayer }
}, true));
}
public static StashKey SaveState(bool SendToStashDico, StashKey _sk = null, bool sync = true)
{
return((StashKey)RTC_Core.SendCommandToBizhawk(new RTC_Command(CommandType.REMOTE_SAVESTATE)
{
objectValue = new object[] { SendToStashDico, _sk }
}, sync));
}
public void SwapGameState()
{
if (side == NetworkSide.DISCONNECTED)
{
return;
}
RTC_Command cmd = new RTC_Command(CommandType.PULLSWAPSTATE);
string romFullFilename = GlobalWin.MainForm.CurrentlyOpenRom;
cmd.romFilename = romFullFilename.Substring(romFullFilename.LastIndexOf("\\") + 1, romFullFilename.Length - (romFullFilename.LastIndexOf("\\") + 1));
if (!PeerHasRom(cmd.romFilename))
{
cmd.romData = File.ReadAllBytes(GlobalWin.MainForm.CurrentlyOpenRom);
}
StashKey sk = RTC_StockpileManager.SaveState(false);
cmd.stashkey = sk;
sk.EmbedState();
cmd.Priority = true;
SendCommand(cmd, false);
}
public static void GenerateVmdFromStashkey(StashKey sk)
{
var proto = new VmdPrototype(sk.BlastLayer);
AddVMD(proto);
RTC_Core.vmdPoolForm.RefreshVMDs();
}
public RTC_NoteEditor_Form(StashKey _sk, DataGridView _dgv)
{
sk = _sk;
dgv = _dgv;
InitializeComponent();
this.Show();
}
public static bool LoadStateAndBlastLayer(StashKey sk, bool ReloadRom = true)
{
object returnValue = RTC_Core.SendCommandToBizhawk(new RTC_Command(CommandType.REMOTE_LOADSTATE)
{
objectValue = new object[] { sk, ReloadRom, (sk.BlastLayer != null && sk.BlastLayer.Layer.Count > 0) }
}, true);
return(returnValue != null ? (bool)returnValue : false);
}
public void ButtonClicked(object sender, EventArgs e)
{
Button btn = (Button)sender;
StashKey sk = (StashKey)btn.Tag;
RTC_Command cmd = new RTC_Command(CommandType.BLAST);
cmd.blastlayer = sk.BlastLayer;
RTC_Core.Multiplayer.SendCommand(cmd, false, true);
}
public static bool InjectFromStashkey(StashKey sk, bool _loadBeforeOperation = true)
{
PreApplyStashkey();
StashKey psk = RTC_StockpileManager.getCurrentSavestateStashkey();
if (psk == null && loadBeforeOperation && _loadBeforeOperation)
{
RTC_Core.StopSound();
MessageBox.Show("The Glitch Harvester could not perform the INJECT action\n\nEither no Savestate Box was selected in the Savestate Manager\nor the Savetate Box itself is empty.");
RTC_Core.StartSound();
return(false);
}
if (psk.SystemCore != sk.SystemCore && !RTC_Core.AllowCrossCoreCorruption)
{
MessageBox.Show("Merge attempt failed: Core mismatch\n\n" + $"{psk.GameName} -> {psk.SystemName} -> {psk.SystemCore}\n{sk.GameName} -> {sk.SystemName} -> {sk.SystemCore}");
return(isCorruptionApplied);
}
currentStashkey = new StashKey(RTC_Core.GetRandomKey(), psk.ParentKey, sk.BlastLayer);
currentStashkey.RomFilename = psk.RomFilename;
currentStashkey.SystemName = psk.SystemName;
currentStashkey.SystemCore = psk.SystemCore;
currentStashkey.GameName = psk.GameName;
if (loadBeforeOperation && _loadBeforeOperation)
{
if (!LoadStateAndBlastLayer(currentStashkey))
{
return(false);
}
}
else
{
RTC_Core.SendCommandToBizhawk(new RTC_Command(CommandType.BLAST)
{
blastlayer = sk.BlastLayer
}, true);
}
isCorruptionApplied = (sk.BlastLayer != null);
if (stashAfterOperation)
{
StashHistory.Add(currentStashkey);
RTC_Core.ghForm.RefreshStashHistory();
}
PostApplyStashkey();
return(isCorruptionApplied);
}
private void dgvStockpile_CellClick(object sender, DataGridViewCellEventArgs e)
{
try
{
dgvStockpile.Enabled = false;
if (e != null)
{
var senderGrid = (DataGridView)sender;
if (senderGrid.Columns[e.ColumnIndex] is DataGridViewButtonColumn &&
e.RowIndex >= 0)
{
StashKey sk = (StashKey)senderGrid.Rows[e.RowIndex].Cells["Item"].Value;
if (RTC_NoteEditor_Form.currentlyOpenNoteForm == null)
{
RTC_NoteEditor_Form.currentlyOpenNoteForm = new RTC_NoteEditor_Form(sk, senderGrid);
}
else
{
if (RTC_NoteEditor_Form.currentlyOpenNoteForm.Visible)
{
RTC_NoteEditor_Form.currentlyOpenNoteForm.Close();
}
RTC_NoteEditor_Form.currentlyOpenNoteForm = new RTC_NoteEditor_Form(sk, senderGrid);
}
return;
}
}
if ((RTC_Core.ghForm.cbLoadOnSelect.Checked || sender == null) && dgvStockpile.SelectedRows.Count > 0)
{
RTC_Core.ghForm.rbCorrupt.Checked = true;
RTC_StockpileManager.currentStashkey = (dgvStockpile.SelectedRows[0].Cells[0].Value as StashKey);
RTC_StockpileManager.ApplyStashkey(RTC_StockpileManager.currentStashkey);
RTC_Core.ghForm.lbStashHistory.ClearSelected();
RTC_Core.ghForm.dgvStockpile.ClearSelection();
RTC_Core.ghForm.IsCorruptionApplied = !(RTC_StockpileManager.currentStashkey.BlastLayer == null || RTC_StockpileManager.currentStashkey.BlastLayer.Layer.Count == 0);
}
}
finally
{
dgvStockpile.Enabled = true;
}
}
public void RefreshButtons()
{
if (!this.Visible)
{
return;
}
foreach (Button btn in allButtons)
{
this.Controls.Remove(btn);
}
allButtons.Clear();
maxColumns = calculateMaxColumns();
if (RTC_Core.ghForm.dgvStockpile.Rows.Count == 0)
{
lbEmptyStockpile.Visible = true;
}
else
{
lbEmptyStockpile.Visible = false;
}
double i = 0;
foreach (DataGridViewRow dataRow in RTC_Core.ghForm.dgvStockpile.Rows)
{
StashKey sk = (StashKey)dataRow.Cells["Item"].Value;
int row = Convert.ToInt32(Math.Floor(i / maxColumns));
int column = Convert.ToInt32(i % maxColumns);
Button btn = new Button();
btn.Text = sk.ToString();
btn.Tag = sk;
btn.Click += new EventHandler(ButtonClicked);
btn.Size = new Size(btnWidth, btnHeight);
btn.Location = new Point((horizontalMargin + (column * (btn.Size.Width + horizontalMargin))), (verticalMargin + (row * (btn.Size.Height + verticalMargin))));
btn.BackColor = Color.FromArgb(224, 224, 224);
btn.FlatStyle = FlatStyle.Flat;
this.Controls.Add(btn);
allButtons.Add(btn);
i++;
}
}
private void btnSendToStash_Click(object sender, EventArgs e)
{
StashKey newSk = (StashKey)sk.Clone();
//newSk.Key = RTC_Core.GetRandomKey();
//newSk.Alias = null;
RTC_StockpileManager.StashHistory.Add(newSk);
RTC_Core.ghForm.RefreshStashHistory();
RTC_Core.ghForm.dgvStockpile.ClearSelection();
RTC_Core.ghForm.DontLoadSelectedStash = true;
RTC_Core.ghForm.lbStashHistory.SelectedIndex = RTC_Core.ghForm.lbStashHistory.Items.Count - 1;
GC.Collect();
GC.WaitForPendingFinalizers();
}
public void LoadStashkey(StashKey _sk)
{
if (_sk == null || _sk.BlastLayer == null || _sk.BlastLayer.Layer == null)
{
return;
}
//lbBlastLayer.Items.Clear();
sk = (StashKey)_sk.Clone();
//lbBlastLayer.DataSource = sk.BlastLayer.Layer;
//foreach (var item in sk.blastlayer.Layer)
// lbBlastLayer.Items.Add(item);
RefreshBlastLayer();
this.Show();
}
public static StashKey SaveState_NET(bool SendToStashDico, StashKey _sk = null, bool threadSave = false)
{
string Key = RTC_Core.GetRandomKey();
string statePath;
StashKey sk;
if (_sk == null)
{
Key = RTC_Core.GetRandomKey();
statePath = RTC_Core.SaveSavestate_NET(Key, threadSave);
sk = new StashKey(Key, Key, null);
}
else
{
Key = _sk.Key;
statePath = _sk.StateFilename;
sk = _sk;
}
if (statePath == null)
{
return(null);
}
sk.StateShortFilename = statePath.Substring(statePath.LastIndexOf("\\") + 1, statePath.Length - (statePath.LastIndexOf("\\") + 1));
sk.StateFilename = statePath;
if (SendToStashDico)
{
RTC_Core.SendCommandToRTC(new RTC_Command(CommandType.REMOTE_KEY_PUSHSAVESTATEDICO)
{
objectValue = new object[] { sk, currentSavestateKey }
});
if (RTC_Hooks.isRemoteRTC)
{
RTC_StockpileManager.SavestateStashkeyDico[currentSavestateKey] = sk;
}
}
return(sk);
}
public static bool OriginalFromStashkey(StashKey sk)
{
PreApplyStashkey();
if (sk == null)
{
MessageBox.Show("No StashKey could be loaded");
return(false);
}
if (!LoadState(sk, true, false))
{
return(isCorruptionApplied);
}
isCorruptionApplied = false;
PostApplyStashkey();
return(isCorruptionApplied);
}
private void btnLoadCorrupt_Click(object sender, EventArgs e)
{
BlastLayer bl = new BlastLayer();
foreach (var item in lbBlastLayer.Items)
{
BlastUnit bu = (item as BlastUnit);
if (bu.IsEnabled)
{
bl.Layer.Add(bu);
}
}
StashKey newSk = (StashKey)sk.Clone();
newSk.BlastLayer = (BlastLayer)bl.Clone();
GC.Collect();
GC.WaitForPendingFinalizers();
newSk.Run();
}
public static bool MergeStashkeys(List <StashKey> sks, bool _stashAfterOperation = true)
{
PreApplyStashkey();
if (sks != null && sks.Count > 1)
{
var token = RTC_NetCore.HugeOperationStart();
StashKey master = sks[0];
string masterSystemCore = master.SystemCore;
bool allCoresIdentical = true;
foreach (StashKey item in sks)
{
if (item.SystemCore != master.SystemCore)
{
allCoresIdentical = false;
break;
}
}
if (!allCoresIdentical && !RTC_Core.AllowCrossCoreCorruption)
{
MessageBox.Show("Merge attempt failed: Core mismatch\n\n" + string.Join("\n", sks.Select(it => $"{it.GameName} -> {it.SystemName} -> {it.SystemCore}")));
RTC_NetCore.HugeOperationEnd(token);
return(false);
}
BlastLayer bl = new BlastLayer();
foreach (StashKey item in sks)
{
bl.Layer.AddRange(item.BlastLayer.Layer);
}
currentStashkey = new StashKey(RTC_Core.GetRandomKey(), master.ParentKey, bl);
currentStashkey.RomFilename = master.RomFilename;
currentStashkey.SystemName = master.SystemName;
currentStashkey.SystemCore = master.SystemCore;
currentStashkey.GameName = master.GameName;
//RTC_NetCore.HugeOperationEnd(token);
token = RTC_NetCore.HugeOperationStart("LAZY");
if (loadBeforeOperation)
{
if (!LoadStateAndBlastLayer(currentStashkey))
{
RTC_NetCore.HugeOperationEnd(token);
return(isCorruptionApplied);
}
}
else
{
RTC_Core.SendCommandToBizhawk(new RTC_Command(CommandType.BLAST)
{
blastlayer = currentStashkey.BlastLayer
});
}
isCorruptionApplied = (currentStashkey.BlastLayer != null && currentStashkey.BlastLayer.Layer.Count > 0);
if (stashAfterOperation && _stashAfterOperation)
{
StashHistory.Add(currentStashkey);
RTC_Core.ghForm.RefreshStashHistory();
}
RTC_NetCore.HugeOperationEnd(token);
PostApplyStashkey();
return(true);
}
else
{
MessageBox.Show("You need 2 or more items for Merging");
return(false);
}
}
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);
}
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);
}
public static StashKey getRawBlastlayer()
{
RTC_Core.StopSound();
StashKey sk = RTC_StockpileManager.SaveState_NET(false);
BlastLayer bl = new BlastLayer();
foreach (var item in Global.CheatList)
{
string[] disassembleCheat = item.Name.Split('|');
if (disassembleCheat[0] == "RTC Cheat")
{
string _domain = disassembleCheat[1];
long _address = Convert.ToInt64(disassembleCheat[2]);
BizHawk.Client.Common.DisplayType _displayType = BizHawk.Client.Common.DisplayType.Unsigned;
bool _bigEndian = Convert.ToBoolean(disassembleCheat[4]);
byte[] _value = disassembleCheat[5].Split(',').Select(it => Convert.ToByte(it)).ToArray();
bool _isEnabled = Convert.ToBoolean(disassembleCheat[6]);
bool _isFreeze = Convert.ToBoolean(disassembleCheat[7]);
bl.Layer.Add(new BlastCheat(_domain, _address, _displayType, _bigEndian, _value, _isEnabled, _isFreeze));
}
}
bl.Layer.AddRange(RTC_PipeEngine.AllBlastPipes);
string thisSystem = Global.Game.System;
string romFilename = GlobalWin.MainForm.CurrentlyOpenRom;
var rp = RTC_MemoryDomains.GetRomParts(thisSystem, romFilename);
if (rp.error == null)
{
if (rp.primarydomain != null)
{
List <byte> addData = new List <byte>();
if (rp.skipbytes != 0)
{
byte[] padding = new byte[rp.skipbytes];
for (int i = 0; i < rp.skipbytes; i++)
{
padding[i] = 0;
}
addData.AddRange(padding);
}
addData.AddRange(RTC_MemoryDomains.getDomainData(rp.primarydomain));
if (rp.seconddomain != null)
{
addData.AddRange(RTC_MemoryDomains.getDomainData(rp.seconddomain));
}
byte[] corrupted = addData.ToArray();
byte[] original = File.ReadAllBytes(GlobalWin.MainForm.CurrentlyOpenRom);
if (RTC_MemoryDomains.MemoryInterfaces.ContainsKey("32X FB")) //Flip 16-bit words on 32X rom
{
original = original.FlipWords(2);
}
else if (thisSystem.ToUpper() == "N64")
{
original = BizHawk.Client.Common.RomGame.MutateSwapN64(original);
}
else if (GlobalWin.MainForm.CurrentlyOpenRom.ToUpper().Contains(".SMD"))
{
original = BizHawk.Client.Common.RomGame.DeInterleaveSMD(original);
}
for (int i = 0; i < rp.skipbytes; i++)
{
original[i] = 0;
}
BlastLayer romBlast = RTC_ExternalRomPlugin.GetBlastLayer(original, corrupted);
if (romBlast != null && romBlast.Layer.Count > 0)
{
bl.Layer.AddRange(romBlast.Layer);
}
}
}
sk.BlastLayer = bl;
RTC_Core.StartSound();
return(sk);
}
public static bool Corrupt(bool _loadBeforeOperation = true)
{
PreApplyStashkey();
var token = RTC_NetCore.HugeOperationStart("LAZY");
StashKey psk = RTC_StockpileManager.getCurrentSavestateStashkey();
if (psk == null)
{
RTC_Core.StopSound();
MessageBox.Show("The Glitch Harvester could not perform the CORRUPT action\n\nEither no Savestate Box was selected in the Savestate Manager\nor the Savetate Box itself is empty.");
RTC_Core.StartSound();
RTC_NetCore.HugeOperationEnd(token);
return(false);
}
string currentGame = (string)RTC_Core.SendCommandToBizhawk(new RTC_Command(CommandType.REMOTE_KEY_GETGAMENAME), true);
if (psk.GameName != currentGame)
{
RTC_Core.LoadRom(psk.RomFilename, true);
RTC_Core.ecForm.RefreshDomains();
RTC_Core.ecForm.setMemoryDomainsAllButSelectedDomains(RTC_MemoryDomains.GetBlacklistedDomains());
}
BlastLayer bl = (BlastLayer)RTC_Core.SendCommandToBizhawk(new RTC_Command(CommandType.BLAST)
{
objectValue = RTC_MemoryDomains.SelectedDomains
}, true);
currentStashkey = new StashKey(RTC_Core.GetRandomKey(), psk.ParentKey, bl);
currentStashkey.RomFilename = psk.RomFilename;
currentStashkey.SystemName = psk.SystemName;
currentStashkey.SystemCore = psk.SystemCore;
currentStashkey.GameName = psk.GameName;
if (loadBeforeOperation && _loadBeforeOperation)
{
if (!LoadStateAndBlastLayer(currentStashkey))
{
RTC_NetCore.HugeOperationEnd(token);
return(isCorruptionApplied);
}
}
else
{
RTC_Core.SendCommandToBizhawk(new RTC_Command(CommandType.BLAST)
{
blastlayer = bl
});
}
isCorruptionApplied = (bl != null);
if (stashAfterOperation && bl != null)
{
StashHistory.Add(currentStashkey);
RTC_Core.ghForm.RefreshStashHistory();
RTC_Core.ghForm.dgvStockpile.ClearSelection();
RTC_Core.ghForm.DontLoadSelectedStash = true;
RTC_Core.ghForm.lbStashHistory.SelectedIndex = RTC_Core.ghForm.lbStashHistory.Items.Count - 1;
}
RTC_NetCore.HugeOperationEnd(token);
PostApplyStashkey();
return(isCorruptionApplied);
}