public void default_settings_randomizes_enemies_in_dungeons()
{
RomData romData = Utilities.LoadRom("rando.sfc");
Random rand = new Random(0);
var requirements = new SpriteRequirementCollection();
var spriteGroups = new SpriteGroupCollection(romData, rand, requirements);
spriteGroups.LoadSpriteGroups();
DungeonEnemyRandomizer der = new DungeonEnemyRandomizer(romData, rand, spriteGroups, requirements);
der.RandomizeDungeonEnemies(new OptionFlags()
{
RandomizeEnemies = true, EnemiesAbsorbable = true
});
foreach (var sg in der.spriteGroupCollection.SpriteGroups)
{
output.WriteLine($"GroupID: {sg.GroupId} (Dungeon GroupId: {sg.DungeonGroupId}) - SG0: {sg.SubGroup0} - SG1: {sg.SubGroup1} - SG2: {sg.SubGroup2} - SG3: {sg.SubGroup3}");
}
foreach (var r in der.roomCollection.Rooms)
{
output.WriteLine($"RoomID: {r.RoomId} - GroupID: {r.GraphicsBlockId}");
foreach (var s in r.Sprites)
{
output.WriteLine($"\tSpriteID: {s.SpriteId} - Address: {s.Address}");
}
}
}
/// <summary>
/// Initialise a RomData object
/// </summary>
/// <param name="machineType"></param>
/// <param name="rom"></param>
/// <param name="type"></param>
/// <param name="romPosition"></param>
/// <returns></returns>
public static RomData InitROM(MachineType machineType, byte[] rom, ROMChipType type, int romPosition = 0)
{
RomData RD = new RomData();
RD.RomBytes = new byte[rom.Length];
RD.RomBytes = rom;
RD.ROMType = type;
if (type == ROMChipType.Upper)
{
RD.ROMPosition = romPosition;
}
for (int i = 0; i < rom.Length; i++)
{
RD.RomBytes[i] = rom[i];
}
switch (machineType)
{
case MachineType.CPC464:
break;
case MachineType.CPC6128:
break;
}
return(RD);
}
static void Main(string[] args)
{
FileStream fs = new FileStream("zelda.sfc", FileMode.Open, FileAccess.Read);
byte[] rom_data = new byte[fs.Length];
fs.Read(rom_data, 0, (int)fs.Length);
fs.Close();
Array.Resize(ref rom_data, 4 * 1024 * 1024);
RomData rom = new RomData(rom_data);
Patch patch = new Patch("patchData.json");
patch.PatchRom(rom);
GeneralPatches.MoveRoomHeaders(rom);
var patches = rom.GeneratePatch();
patch.AddPatches(patches);
var patchJson = patch.ExportJson();
File.WriteAllText("enemizerBasePatch.json", patchJson);
}
private void emulatorTreeView_RomSelected(RomData rom)
{
selectedRom = rom;
romDataView.ChildUpdate(rom);
romDataView.Visible = true;
PlayGameBtn.Visible = true;
}
protected override RomData ScraperSpecificGetAllData(RomData dataToFillOut)
{
string dataTerm = string.Format(getAllDataUrl, dataToFillOut.ScraperUniqueKey, apiKey);
string finalUrl = string.Format("{0}{1}", rootUrl, dataTerm);
string results = MakeTextRequest(finalUrl, headers);
if (results != string.Empty)
{
GiantBombGameResults resultData = SerializationUtilities.DeserializeString <GiantBombGameResults>(results, DataFormat.JSON);
if (resultData.results != null)
{
var extractedResults = resultData.results;
dataToFillOut.Description = extractedResults.deck;
if (extractedResults.publishers?.Length > 0)
{
dataToFillOut.Publisher = extractedResults.publishers[0].name;
}
if (extractedResults.developers?.Length > 0)
{
dataToFillOut.Developer = extractedResults.developers[0].name;
}
dataToFillOut.Rating = GetRating(extractedResults.reviews);
dataToFillOut.NumPlayers = GetNumPlayers(extractedResults.releases);
GetImages(dataToFillOut, extractedResults);
}
}
return(dataToFillOut);
}
private bool LoadProject()
{
projectBrowseDialog.SelectedPath = "";
projectBrowseDialog.Description = "Open project from directory";
Win32Forms.DialogResult result = projectBrowseDialog.ShowDialog(win32Window);
string dirPath = projectBrowseDialog.SelectedPath;
if (dirPath == "" || result == Win32Forms.DialogResult.Abort || result == Win32Forms.DialogResult.Cancel)
{
return(false);
}
if (!Directory.Exists(dirPath))
{
return(false);
}
RomData romData = null;
try
{
romData = RomData.ImportFromDirectory(dirPath);
}
catch (Exception ex)
{
MessageBox.Show("Error: " + ex.Message, "Error opening project", MessageBoxButton.OK, MessageBoxImage.Error);
return(false);
}
App.MainViewModel = new MainModel(romData);
DataContext = App.MainViewModel;
Title = "map2agb - " + dirPath;
lastSaveLocation = dirPath;
return(true);
}
public LearnVM(PokemonEditorVM pm, int move)
{
pokemon = pm;
Move = RomData.GetMove(move);
_isLearned = pokemon.Model.HasMove(move);
_methods = new List <LearnMethod>();
}
public VisorScript(RomData rom, string nombrePokemon, string script)
{
InitializeComponent();
Title = "Script-" + rom.Rom.Nombre + "-" + nombrePokemon;
txtScritp.Text = script;
switch (rom.Edicion.AbreviacionRom)
{
case AbreviacionCanon.AXV:
Background = Brushes.LightCoral;
break;
case AbreviacionCanon.AXP:
Background = Brushes.LightSkyBlue;
break;
case AbreviacionCanon.BPE:
Background = Brushes.LightSeaGreen;
break;
case AbreviacionCanon.BPR:
Background = Brushes.LightSalmon;
break;
case AbreviacionCanon.BPG:
Background = Brushes.LightGreen;
break;
default:
throw new ArgumentOutOfRangeException();
}
}
public List <RomData> Search(RomData dataToSearchFor)
{
List <RomData> returnList = new List <RomData>();
returnList.AddRange(ScraperSpecificSearch(dataToSearchFor));
return(returnList);
}
public static Dictionary <string, RomData> GetHashDictionary(List <DataGroup> data)
{
var output = new Dictionary <string, RomData>();
foreach (var group in data)
{
foreach (var game in group.Games)
{
foreach (var rom in game.Roms)
{
RomData romInfo;
if (output.ContainsKey(rom.Crc32))
{
romInfo = output[rom.Crc32];
}
else
{
output[rom.Crc32] = romInfo = new RomData();
romInfo.Name = rom.Name;
romInfo.Crc32 = rom.Crc32;
}
foreach (var id in game.TgdbId)
{
if (!romInfo.TgdbId.Contains(id))
{
romInfo.TgdbId.Add(id);
}
}
}
}
}
return(output);
}
public void Update()
{
if (leftRequested)
{
leftRequested = false;
carousel.ChangeSelectedItem(InputType.LEFT);
}
if (rightRequested)
{
rightRequested = false;
carousel.ChangeSelectedItem(InputType.RIGHT);
}
if (selectRequested)
{
selectRequested = false;
RomData romData = (RomData)carousel.GetSelectedItem();
var emuMgr = EmulatorManager.Instance;
emuMgr.RunEmulator(romData);
}
if (backRequested)
{
backRequested = false;
EmulatorSelectionWindowState windowState = new EmulatorSelectionWindowState(textRenderer);
WindowStateChanged?.Invoke(new WindowStateChangedEventArgs()
{
NewWindowState = windowState
});
}
}
private void RetrieveImages(RomData dataToFillOut, IgdbScreenshotData[] images)
{
if (images?.Length > 0)
{
// sorts the list into largest to smallest
var sortedImages = images.OrderBy(i => (i.width * i.height)).ToList();
// Largest image will be the background
string size = "screenshot_huge_2x";
string id = images.First().cloudinary_id;
dataToFillOut.Background = RequestImage(size, id);
// Smallest image will be the icon / logo
size = "logo_med_2x";
id = images.Last().cloudinary_id;
dataToFillOut.Logo = RequestImage(size, id);
// cover image will be the second smallest image
size = "cover_big_2x";
id = images.Count() > 1 ? images.ElementAt(images.Count() - 2).cloudinary_id : images.First().cloudinary_id;
dataToFillOut.BoxArt = RequestImage(size, id);
// banner image will be the second largest image
size = "screenshot_big_2x";
id = images.Count() > 1 ? images.ElementAt(1).cloudinary_id : images.First().cloudinary_id;
dataToFillOut.Banner = RequestImage(size, id);
}
else
{
dataToFillOut.Background = Resource.DefaultBackground;
dataToFillOut.Banner = Resource.DefaultBanner;
dataToFillOut.BoxArt = Resource.DefaultBoxart;
dataToFillOut.Logo = Resource.DefaultIcon;
}
}
protected override List <RomData> ScraperSpecificSearch(RomData dataToSearchFor)
{
List <RomData> returnList = new List <RomData>();
string nameTerm = GenerateSearchableName(dataToSearchFor);
string searchTerm = String.Format(searchUrl, apiKey, nameTerm, ConvertConsole(dataToSearchFor.Console));
string finalUrl = String.Format("{0}{1}", rootUrl, searchTerm);
string results = MakeTextRequest(finalUrl);
if (!String.IsNullOrEmpty(results))
{
MobyGamesSearchResults searchResults = SerializationUtilities.DeserializeString <MobyGamesSearchResults>(results, DataFormat.JSON);
if (searchResults != null)
{
foreach (var game in searchResults.games)
{
RomData convertedData = dataToSearchFor.Clone();
convertedData.FriendlyName = game.title;
convertedData.ScraperUniqueKey = game.game_id.ToString();
returnList.Add(convertedData);
}
}
}
return(returnList);
}
protected override List <RomData> ScraperSpecificSearch(RomData dataToSearchFor)
{
string nameTerm = GenerateSearchableName(dataToSearchFor);
string searchTerm = string.Format(searchFormat, nameTerm);
string finalUrl = String.Format("{0}{1}", searchRootUrl, searchTerm);
List <RomData> returnData = new List <RomData>();
String results = MakeTextRequest(finalUrl, headers);
if (results != String.Empty)
{
List <IgdbData> resultsData = SerializationUtilities.DeserializeString <List <IgdbData> >(
results, DataFormat.JSON, platformConverter, dateConverter);
foreach (var resultData in resultsData)
{
RomData convertedData = dataToSearchFor.Clone();
convertedData.FriendlyName = resultData.name;
convertedData.ScraperUniqueKey = resultData.id;
if (resultData.release_dates != null && resultData.release_dates.Count() > 0)
{
var releaseData = resultData.release_dates[0];
convertedData.Console = releaseData.platform;
convertedData.ReleaseDate = releaseData.date;
}
returnData.Add(convertedData);
}
}
return(returnData);
}
public void why_is_zscreammagic_making_extra_room_data()
{
RomData romData = Utilities.LoadRom("ALttP - VT_no-glitches-27_normal-open-ganon_521333165 original.sfc");
Random rand = new Random(0);
var originalRooms = new DungeonObjectDataPointerCollection(romData);
//foreach (var r in originalRooms.Rooms)
//{
// output.WriteLine($"RoomId: {r.RoomId}, RoomName: {r.RoomName}, RoomGfx: {r.GraphicsBlockId}, sprite count: {r.Sprites.Count}, sprites: {String.Join(",", r.Sprites.Select(x => (x.IsOverlord ? "1" : "") + x.SpriteId.ToString("X2") + (x.HasAKey ? "(HasKey)" : "")))}");
//}
romData = Utilities.LoadRom("ALttP - VT_no-glitches-27_normal-open-ganon_521333165 mod.sfc");
var bustedRooms = new DungeonObjectDataPointerCollection(romData);
foreach (var r in originalRooms.RoomDungeonObjectDataPointers.Values)
{
var bustedRoom = bustedRooms.RoomDungeonObjectDataPointers.Values.Where(x => x.RoomId == r.RoomId).FirstOrDefault();
if (bustedRoom != null)
{
if (r.Data != bustedRoom.Data)
{
output.WriteLine($"RoomId: {r.RoomId}, original length: {r.Data.Length}, modified length: {bustedRoom.Data.Length}");
}
}
}
}
protected override List <RomData> ScraperSpecificSearch(RomData dataToSearchFor)
{
List <RomData> data = new List <RomData>();
String nameTerm = GenerateSearchableName(dataToSearchFor);
String platformTerm = ConvertConsole(dataToSearchFor.Console);
String searchPage = String.Format(searchPageformat, nameTerm, platformTerm);
String finalUrl = String.Format("{0}{1}", rootUrl, searchPage);
String results = MakeTextRequest(finalUrl);
if (results != String.Empty)
{
Data resultsData = SerializationUtilities.DeserializeString <Data>(results, DataFormat.XML);
foreach (var resultData in resultsData.Game)
{
RomData convertedResultData = dataToSearchFor.Clone();
convertedResultData.FriendlyName = resultData.GameTitle;
convertedResultData.ScraperUniqueKey = resultData.id;
convertedResultData.ReleaseDate = String.IsNullOrEmpty(resultData.ReleaseDate) ? DateTime.MaxValue : DateTime.Parse(resultData.ReleaseDate);
convertedResultData.Console = ConvertConsole(resultData.Platform);
data.Add(convertedResultData);
}
}
return(data);
}
//[InlineData("")]
//[InlineData("")]
//[InlineData("")]
public void randomize_test_roms_10_times_each_chaos(string filename)
{
if (false == File.Exists(filename))
{
output.WriteLine($"File {filename} not found. Skipping test.");
return;
}
byte[] rom_data = LoadRom(filename);
Random rand = new Random(0);
OptionFlags options = MakeOptions();
options.EnemiesAbsorbable = true;
options.RandomizeBosses = true;
options.RandomizeBossesType = RandomizeBossesType.Chaos;
Randomization randomizer = new Randomization();
for (int i = 0; i < 10; i++)
{
RomData romData = new RomData(rom_data);
randomizer.MakeRandomization("", rand.Next(), options, romData);
}
}
private static void ThrowIfAlreadyEnemized(RomData romData)
{
if (romData.IsEnemizerRom)
{
throw new Exception("It appears that the provided base ROM is already enemized. Please ensure you are using an original game ROM.");
}
}
public static RomData InitROM(MachineType machineType, byte[] rom)
{
RomData RD = new RomData();
RD.RomBytes = new byte[rom.Length];
RD.RomBytes = rom;
switch (machineType)
{
case MachineType.ZXSpectrum48:
RD.SaveBytesRoutineAddress = 0x04C2;
RD.SaveBytesResumeAddress = 0x0000;
RD.LoadBytesRoutineAddress = 0x0808; //0x0556; //0x056C;
RD.LoadBytesResumeAddress = 0x05E2;
RD.LoadBytesInvalidHeaderAddress = 0x05B6;
break;
case MachineType.ZXSpectrum128:
RD.SaveBytesRoutineAddress = 0x04C2;
RD.SaveBytesResumeAddress = 0x0000;
RD.LoadBytesRoutineAddress = 0x0808; //0x0556; //0x056C;
RD.LoadBytesResumeAddress = 0x05E2;
RD.LoadBytesInvalidHeaderAddress = 0x05B6;
break;
}
return(RD);
}
/// <summary>
/// par, slp, psn, frz, brn
/// </summary>
/// <param name="pm"></param>
/// <param name="by"></param>
/// <param name="ability"></param>
/// <param name="state"></param>
/// <param name="showFail"></param>
/// <returns></returns>
public static bool CanAddXXX(PokemonProxy pm, PokemonProxy by, bool ability, AttachedState state, bool showFail)
{
if (state == AttachedState.SLP && pm.State == PokemonState.SLP)
{
if (showFail)
{
pm.Controller.ReportBuilder.ShowLog(Ls.Fail0);
}
return(false);
}
if (Safeguard(pm, by, showFail) ||
MistyTerrain(pm, showFail) ||
state == AttachedState.SLP && ETSV(pm, showFail) ||
ability &&
(pm.Controller.Weather == Weather.IntenseSunlight && CheckAbility(As.LEAF_GUARD, pm, by, state, showFail) ||
pm.OnboardPokemon.Form == RomData.GetPokemon(774, 1) && CheckAbility(As.Shields_Down, pm, by, state, showFail) ||
state == AttachedState.PAR && CheckAbility(As.LIMBER, pm, by, state, showFail) ||
state == AttachedState.SLP && (CheckAbility(As.INSOMNIA, pm, by, state, showFail) || CheckAbility(As.VITAL_SPIRIT, pm, by, state, showFail)) ||
state == AttachedState.PSN && CheckAbility(As.IMMUNITY, pm, by, state, showFail) ||
state == AttachedState.FRZ && CheckAbility(As.MAGMA_ARMOR, pm, by, state, showFail) ||
state == AttachedState.BRN && CheckAbility(As.Water_Bubble, pm, by, state, showFail) ||
state == AttachedState.BRN && CheckAbility(As.WATER_VEIL, pm, by, state, showFail)))
{
return(false);
}
return(true);
}
public void get_overworld_sprites_seed_0()
{
Randomization r = new Randomization();
OptionFlags o = new OptionFlags()
{
RandomizeBosses = true,
RandomizeEnemies = true,
GenerateSpoilers = true
};
FileStream fs = new FileStream("alttp - VT_no-glitches-26_normal_open_none_830270265.sfc", FileMode.Open, FileAccess.Read);
byte[] rom_data = new byte[fs.Length];
fs.Read(rom_data, 0, (int)fs.Length);
fs.Close();
RomData romData = new RomData(rom_data);
romData = r.MakeRandomization("", 0, o, romData, "");
//var romData = Utilities.LoadRom("rando.sfc");
OverworldAreaCollection areas = new OverworldAreaCollection(romData, new Random(), new SpriteGroupCollection(romData, new Random(), new SpriteRequirementCollection()), new SpriteRequirementCollection());
foreach (var owArea in areas.OverworldAreas)
{
output.WriteLine($"Map: {owArea.AreaId.ToString("X3")} ({owArea.AreaName})\tGraphics Block: {owArea.GraphicsBlockId} ({owArea.GraphicsBlockAddress.ToString("X4")})");
foreach (var s in owArea.Sprites)
{
output.WriteLine($"Address: {s.SpriteAddress.ToString("X6")}\tSpriteId: {s.SpriteId.ToString("X2")}\t{SpriteConstants.GetSpriteName(s.SpriteId)}\tX: {s.SpriteX}\tY: {s.SpriteY}\tOverlord: {(s.SpriteId >= 0xF3 ? true : false).ToString()}");
}
}
}
public void RunEmulator(RomData rom)
{
var romConsole = rom.Console;
var emulatorsForConsole = GetAvailableEmulators(romConsole);
var selectedEmulator = emulatorsForConsole.First();
RunEmulator(selectedEmulator, rom);
}
static List <PatchObject> GenerateSeed(int seed, byte[] rom_data, OptionFlags optionFlags)
{
RomData romData = new RomData(rom_data);
Randomization randomize = new Randomization();
RomData randomizedRom = randomize.MakeRandomization("", seed, optionFlags, romData, "");
return(randomizedRom.GeneratePatch());
}
internal PokemonProxy(Pokemon pokemon)
{
Controller = pokemon.Controller;
Pokemon = pokemon;
NullOnboardPokemon = new OnboardPokemon(pokemon, -1);
StruggleMove = new MoveProxy(new Move(RomData.GetMove(Ms.STRUGGLE), 1), this);
_moves = new List <MoveProxy>(4);
}
private static RomData RandomizeRom(int seed, byte[] rom_data, OptionFlags optionFlags)
{
RomData romData = new RomData(rom_data);
Randomization randomize = new Randomization();
RomData randomizedRom = randomize.MakeRandomization("", seed, optionFlags, romData, "");
return(randomizedRom);
}
public OverworldSprite(RomData romData, int SpriteAddress)
{
this.romData = romData;
this.SpriteAddress = SpriteAddress;
this.SpriteY = romData[SpriteAddress];
this.SpriteX = romData[SpriteAddress + 1];
this.SpriteId = romData[SpriteAddress + 2];
}
private void GetBanner(RomData dataToFillOut, string baseImgUrl, DataGameImages images)
{
if (images.banner?.Count() > 0)
{
var bannerUrl = images.banner.First().Value;
bannerUrl = String.Format("{0}{1}", baseImgUrl, bannerUrl);
dataToFillOut.Banner = MakeImageRequest(bannerUrl);
}
}
public RomData GetAllData(RomData dataToFillOut)
{
RomData foundData = dataToFillOut.Clone();
foundData.ScrapedBy = FriendlyName;
foundData.IsUpToDate = true;
return(ScraperSpecificGetAllData(foundData));
}
protected String GenerateSearchableName(RomData data)
{
String nameTerm = data.FriendlyName;
nameTerm = nameTerm.Replace('_', ' '); // Seems to have more success without underscores
nameTerm = Uri.EscapeDataString(nameTerm);
return(nameTerm);
}
private void SearchForRomsJob(object sender, DoWorkEventArgs e)
{
String selectedScraper = (String)((object[])e.Argument)[0];
RomData romToSearchFor = (RomData)((object[])e.Argument)[1];
List <RomData> foundRoms = scrapMgr.Search(romToSearchFor, selectedScraper);
e.Result = foundRoms;
backgroundWorker1.DoWork -= SearchForRomsJob;
}
