mirror of
https://github.com/haven1433/HexManiacAdvance.git
synced 2026-05-16 01:07:45 -05:00
ff3f2bd3df
given an area of all the same block, replace all those blocks with blocks that match the surrounding non-same blocks based on what blocks should 'match'. Note that this is a single-pass algorithm right now, which means that it creates a bunch of bad blocks as it gets further from the edge and more conflicts are found. We may try to update this more in the future, or we may just go with something simpler like a maze generator using border blocks or 9-grid. But the results of this are tantalizing...
2434 lines
116 KiB
C#
2434 lines
116 KiB
C#
using HavenSoft.HexManiac.Core.Models;
|
|
using HavenSoft.HexManiac.Core.Models.Code;
|
|
using HavenSoft.HexManiac.Core.Models.Map;
|
|
using HavenSoft.HexManiac.Core.Models.Runs;
|
|
using HavenSoft.HexManiac.Core.Models.Runs.Sprites;
|
|
using HavenSoft.HexManiac.Core.ViewModels.DataFormats;
|
|
using HavenSoft.HexManiac.Core.ViewModels.Images;
|
|
using HavenSoft.HexManiac.Core.ViewModels.Tools;
|
|
using HexManiac.Core.Models.Runs.Sprites;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Collections.ObjectModel;
|
|
using System.Linq;
|
|
using static HavenSoft.HexManiac.Core.ViewModels.Map.MapSliderIcons;
|
|
|
|
namespace HavenSoft.HexManiac.Core.ViewModels.Map {
|
|
public record ImageLocation(double X, double Y); // ranges from (0,0) upper-left to (1,1) lower-right
|
|
|
|
public class BlockMapViewModel : ViewModelCore, IPixelViewModel {
|
|
private readonly Format format;
|
|
private readonly IFileSystem fileSystem;
|
|
private readonly MapTutorialsViewModel tutorials;
|
|
private readonly IEditableViewPort viewPort;
|
|
private readonly IDataModel model;
|
|
private readonly Func<ModelDelta> tokenFactory;
|
|
private readonly int group, map;
|
|
|
|
private int PrimaryTiles { get; }
|
|
private int PrimaryBlocks { get; }
|
|
private int TotalBlocks => 1024;
|
|
private int PrimaryPalettes { get; } // 7
|
|
|
|
private int zIndex;
|
|
public int ZIndex { get => zIndex; set => Set(ref zIndex, value); }
|
|
|
|
public event EventHandler RequestClearMapCaches;
|
|
|
|
public IEditableViewPort ViewPort => viewPort;
|
|
|
|
#region SelectedEvent
|
|
|
|
private IEventViewModel selectedEvent;
|
|
public IEventViewModel SelectedEvent {
|
|
get => selectedEvent;
|
|
set {
|
|
var oldValue = selectedEvent;
|
|
selectedEvent = value;
|
|
NotifyPropertyChanged();
|
|
HandleSelectedEventChanged(oldValue);
|
|
}
|
|
}
|
|
|
|
public ObservableCollection<EventSelector> EventSelectors { get; } = new();
|
|
|
|
private void HandleSelectedEventChanged(IEventViewModel old) {
|
|
if (old == selectedEvent) return;
|
|
if (old != null) {
|
|
old.EventVisualUpdated -= RefreshFromEventChange;
|
|
old.CycleEvent -= CycleActiveEvent;
|
|
}
|
|
if (selectedEvent != null) {
|
|
selectedEvent.EventVisualUpdated += RefreshFromEventChange;
|
|
selectedEvent.CycleEvent += CycleActiveEvent;
|
|
}
|
|
RedrawEvents();
|
|
|
|
EventSelectors.Clear();
|
|
if (selectedEvent != null) {
|
|
var parts = selectedEvent.EventIndex.Split("/");
|
|
var index = int.Parse(parts[0]) - 1;
|
|
var count = int.Parse(parts[1]);
|
|
for (int i = 0; i < count; i++) {
|
|
EventSelector selector = new() { IsSelected = i == index, Index = i };
|
|
selector.Bind(nameof(selector.IsSelected), (sender, e) => {
|
|
var events = GetEvents().Where(ev => ev.GetType() == selectedEvent.GetType()).ToList();
|
|
SelectedEvent = events[sender.Index];
|
|
});
|
|
EventSelectors.Add(selector);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void RefreshFromEventChange(object sender, EventArgs e) => RedrawEvents();
|
|
|
|
private void CycleActiveEvent(object sender, EventCycleDirection direction) {
|
|
// organize events into categories
|
|
var events = GetEvents();
|
|
var categories = new List<List<IEventViewModel>> { new(), new(), new(), new(), new() };
|
|
int selectionIndex = -1, selectedCategory = -1;
|
|
for (int i = 0; i < events.Count; i++) {
|
|
int currentCategory =
|
|
events[i] is ObjectEventViewModel ? 0 :
|
|
events[i] is WarpEventViewModel ? 1 :
|
|
events[i] is ScriptEventViewModel ? 2 :
|
|
events[i] is SignpostEventViewModel ? 3 :
|
|
events[i] is FlyEventViewModel ? 4 :
|
|
-1;
|
|
categories[currentCategory].Add(events[i]);
|
|
|
|
if (events[i].Equals(selectedEvent)) {
|
|
selectionIndex = categories[currentCategory].Count - 1;
|
|
selectedCategory = currentCategory;
|
|
};
|
|
}
|
|
|
|
// remove unused categories
|
|
for (int i = 0; i < categories.Count; i++) {
|
|
if (categories[i].Count != 0) continue;
|
|
categories.RemoveAt(i);
|
|
if (selectedCategory > i) selectedCategory--;
|
|
i--;
|
|
}
|
|
|
|
// cycle
|
|
if (direction == EventCycleDirection.PreviousCategory) {
|
|
selectedCategory += categories.Count - 1;
|
|
selectionIndex = 0;
|
|
} else if (direction == EventCycleDirection.NextCategory) {
|
|
selectedCategory += 1;
|
|
selectionIndex = 0;
|
|
} else if (direction == EventCycleDirection.PreviousEvent) {
|
|
selectionIndex += categories[selectedCategory].Count - 1;
|
|
} else if (direction == EventCycleDirection.NextEvent) {
|
|
selectionIndex += 1;
|
|
} else if (direction == EventCycleDirection.None) {
|
|
// we just wanted to regenerate the event object
|
|
} else {
|
|
throw new NotImplementedException();
|
|
}
|
|
if (selectedCategory < 0) {
|
|
SelectedEvent = null;
|
|
return;
|
|
}
|
|
selectedCategory %= categories.Count;
|
|
selectionIndex %= categories[selectedCategory].Count;
|
|
|
|
// update selection
|
|
SelectedEvent = categories[selectedCategory][selectionIndex];
|
|
tutorials.Complete(Tutorial.EventButtons_CycleEvent);
|
|
}
|
|
|
|
#endregion
|
|
|
|
private static int MapSizeLimit => 0x2800; // (x+15)*(y+14) must be less that 0x2800 (5*2048). This can lead to limits like 113x66 or 497x6
|
|
public static bool IsMapWithinSizeLimit(int width, int height) => (width / 16 + 15) * (height / 16 + 14) <= MapSizeLimit;
|
|
|
|
public int MapID => group * 1000 + map;
|
|
|
|
private MapHeaderViewModel header;
|
|
public MapHeaderViewModel Header {
|
|
get {
|
|
if (header == null) {
|
|
header = new MapHeaderViewModel(GetMapModel(), format, tokenFactory);
|
|
header.Bind(nameof(Header.PrimaryIndex), (sender, e) => ClearCaches());
|
|
header.Bind(nameof(Header.SecondaryIndex), (sender, e) => ClearCaches());
|
|
}
|
|
return header;
|
|
}
|
|
}
|
|
|
|
public bool IsValidMap => GetMapModel() != null;
|
|
|
|
#region IPixelViewModel
|
|
|
|
private short transparent;
|
|
public short Transparent { get => transparent; private set => Set(ref transparent, value); }
|
|
|
|
private int pixelWidth, pixelHeight;
|
|
public int PixelWidth { get => pixelWidth; private set => Set(ref pixelWidth, value); }
|
|
public int PixelHeight { get => pixelHeight; private set => Set(ref pixelHeight, value); }
|
|
|
|
private readonly object pixelWriteLock = new();
|
|
private short[] pixelData; // picture of the map
|
|
public short[] PixelData {
|
|
get {
|
|
lock (pixelWriteLock) {
|
|
if (pixelData == null) FillMapPixelData();
|
|
return pixelData;
|
|
}
|
|
}
|
|
}
|
|
|
|
private double spriteScale = 1;
|
|
public double SpriteScale {
|
|
get => spriteScale;
|
|
set => Set(ref spriteScale, value, old => UpdateEdgesFromScale(old, old * pixelWidth / 2, old * pixelHeight / 2));
|
|
}
|
|
|
|
private void UpdateEdgesFromScale(double old, double centerX, double centerY) {
|
|
LeftEdge += (int)(centerX * (1 - SpriteScale / old));
|
|
TopEdge += (int)(centerY * (1 - SpriteScale / old));
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region IsSelected
|
|
|
|
// TODO why is the selection rect not showing up until the first move interaction?
|
|
|
|
private bool isSelected;
|
|
public bool IsSelected {
|
|
get => isSelected;
|
|
set => Set(ref isSelected, value, old => ClearPixelCache());
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Position
|
|
|
|
private int topEdge, leftEdge;
|
|
public int TopEdge { get => topEdge; set => Set(ref topEdge, value); }
|
|
public int LeftEdge { get => leftEdge; set => Set(ref leftEdge, value); }
|
|
|
|
private int BottomEdge => topEdge + (int)(PixelHeight * SpriteScale);
|
|
private int RightEdge => leftEdge + (int)(PixelWidth * SpriteScale);
|
|
|
|
private ImageLocation hoverPoint = new(0, 0);
|
|
public ImageLocation HoverPoint {
|
|
get => hoverPoint;
|
|
set {
|
|
hoverPoint = value;
|
|
NotifyPropertyChanged();
|
|
}
|
|
}
|
|
|
|
public double WidthRatio => 80.0 / PixelWidth / Math.Min(1, SpriteScale);
|
|
public double HeightRatio => 80.0 / PixelHeight / Math.Min(1, SpriteScale);
|
|
private bool showBeneath;
|
|
public bool ShowBeneath { get => showBeneath; set => Set(ref showBeneath, value, old => {
|
|
NotifyPropertiesChanged(nameof(WidthRatio), nameof(HeightRatio));
|
|
tutorials.Complete(Tutorial.SpaceBar_ShowBeneath);
|
|
} ); }
|
|
|
|
#endregion
|
|
|
|
#region Visual Blocks
|
|
|
|
private IPixelViewModel blockPixels; // all the available blocks together in one big image
|
|
public IPixelViewModel BlockPixels {
|
|
get {
|
|
if (blockPixels == null) FillBlockPixelData();
|
|
return blockPixels;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region CollisionHighlight
|
|
|
|
private int collisionHighlight = -1;
|
|
public int CollisionHighlight {
|
|
get => collisionHighlight;
|
|
set {
|
|
Set(ref collisionHighlight, value, old => ClearPixelCache());
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Cache
|
|
|
|
private short[][] palettes;
|
|
private int[][,] tiles;
|
|
private byte[][] blocks;
|
|
private byte[][] blockAttributes;
|
|
private readonly List<IPixelViewModel> blockRenders = new(); // one image per block
|
|
private IReadOnlyList<IEventViewModel> eventRenders;
|
|
public IReadOnlyList<IPixelViewModel> BlockRenders {
|
|
get {
|
|
lock (blockRenders) {
|
|
if (blockRenders.Count == 0) RefreshBlockRenderCache();
|
|
}
|
|
return blockRenders;
|
|
}
|
|
}
|
|
|
|
private void ClearPixelCache() {
|
|
pixelData = null;
|
|
NotifyPropertyChanged(nameof(PixelData));
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Borders
|
|
|
|
private bool includeBorders = true;
|
|
public bool IncludeBorders {
|
|
get => includeBorders;
|
|
set => Set(ref includeBorders, value, IncludeBordersChanged);
|
|
}
|
|
private void IncludeBordersChanged(bool oldValue) {
|
|
var width = PixelWidth;
|
|
var height = PixelHeight;
|
|
RefreshMapSize();
|
|
LeftEdge -= (PixelWidth - width) / 2;
|
|
TopEdge -= (PixelHeight - height) / 2;
|
|
}
|
|
|
|
private IPixelViewModel borderBlock;
|
|
public IPixelViewModel BorderBlock {
|
|
get {
|
|
if (borderBlock == null) RefreshBorderRender();
|
|
return borderBlock;
|
|
}
|
|
set {
|
|
borderBlock = value;
|
|
NotifyPropertyChanged();
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Name
|
|
|
|
public string FullName => MapIDToText(model, MapID);
|
|
public string Name => $"({group}-{map})";
|
|
|
|
private ObservableCollection<string> availableNames;
|
|
public ObservableCollection<string> AvailableNames {
|
|
get {
|
|
if (availableNames != null) return availableNames;
|
|
availableNames = new();
|
|
foreach (var name in viewPort.Model.GetOptions(HardcodeTablesModel.MapNameTable)) {
|
|
availableNames.Add(SanitizeName(name.Trim('"')));
|
|
}
|
|
return availableNames;
|
|
}
|
|
}
|
|
|
|
public int SelectedNameIndex {
|
|
get {
|
|
var offset = model.IsFRLG() ? 0x58 : 0;
|
|
var banks = model.GetTableModel(HardcodeTablesModel.MapBankTable);
|
|
var maps = banks[group].GetSubTable("maps");
|
|
var map = maps[this.map];
|
|
if (map == null) return -1;
|
|
var subTable = map.GetSubTable("map");
|
|
if (subTable == null) return -1;
|
|
var self = subTable[0];
|
|
if (!self.HasField("regionSectionID")) return -1;
|
|
return self.GetValue("regionSectionID") - offset;
|
|
}
|
|
set {
|
|
var offset = model.IsFRLG() ? 0x58 : 0;
|
|
var banks = model.GetTableModel(HardcodeTablesModel.MapBankTable, tokenFactory);
|
|
var maps = banks[group].GetSubTable("maps");
|
|
var mapTable = maps[map];
|
|
var subTable = mapTable.GetSubTable("map");
|
|
if (subTable == null) return;
|
|
var mapElement = subTable[0];
|
|
var self = maps[map].GetSubTable("map")[0];
|
|
if (!self.HasField("regionSectionID")) return;
|
|
self.SetValue("regionSectionID", value + offset);
|
|
NotifyPropertyChanged(nameof(FullName));
|
|
}
|
|
}
|
|
|
|
public static string SanitizeName(string name) {
|
|
return name.Replace("\\CC0000", " ");
|
|
}
|
|
|
|
#endregion
|
|
|
|
public event EventHandler NeighborsChanged;
|
|
public event EventHandler AutoscrollTiles;
|
|
public event EventHandler HideSidePanels;
|
|
public event EventHandler<ChangeMapEventArgs> RequestChangeMap;
|
|
|
|
private BlockEditor blockEditor;
|
|
public BlockEditor BlockEditor {
|
|
get {
|
|
if (blockEditor == null) {
|
|
var layout = GetLayout();
|
|
if (layout == null) return null;
|
|
var blockModel1 = new BlocksetModel(model, layout.GetAddress("blockdata1"));
|
|
var blockModel2 = new BlocksetModel(model, layout.GetAddress("blockdata2"));
|
|
if (palettes == null) RefreshPaletteCache(layout, blockModel1, blockModel2);
|
|
if (tiles == null) RefreshTileCache(layout, blockModel1, blockModel2);
|
|
if (blocks == null) RefreshBlockCache(layout, blockModel1, blockModel2);
|
|
if (blockAttributes == null) RefreshBlockAttributeCache(layout, blockModel1, blockModel2);
|
|
blockEditor = new BlockEditor(viewPort.ChangeHistory, model, tutorials, palettes, tiles, blocks, blockAttributes);
|
|
blockEditor.BlocksChanged += HandleBlocksChanged;
|
|
blockEditor.BlockAttributesChanged += HandleBlockAttributesChanged;
|
|
blockEditor.AutoscrollTiles += HandleAutoscrollTiles;
|
|
BlockEditor.SendMessage += (sender, e) => viewPort.RaiseMessage(e);
|
|
blockEditor.Bind(nameof(blockEditor.ShowTiles), (editor, args) => BorderEditor.ShowBorderPanel &= !editor.ShowTiles);
|
|
blockEditor.Bind(nameof(blockEditor.BlockIndex), (editor, args) => lastDrawX = lastDrawY = -1);
|
|
}
|
|
return blockEditor;
|
|
}
|
|
}
|
|
|
|
private BorderEditor borderEditor;
|
|
public BorderEditor BorderEditor {
|
|
get {
|
|
if (borderEditor == null) {
|
|
borderEditor = new BorderEditor(this, tutorials);
|
|
borderEditor.BorderChanged += HandleBorderChanged;
|
|
borderEditor.Bind(nameof(borderEditor.ShowBorderPanel), (editor, args) => {
|
|
if (BlockEditor == null) return;
|
|
BlockEditor.ShowTiles &= !editor.ShowBorderPanel;
|
|
HideSidePanels.Raise(this);
|
|
});
|
|
}
|
|
return borderEditor;
|
|
}
|
|
}
|
|
|
|
private MapRepointer mapRepointer;
|
|
public MapRepointer MapRepointer => mapRepointer;
|
|
|
|
private MapScriptCollection mapScriptCollection;
|
|
public MapScriptCollection MapScriptCollection {
|
|
get {
|
|
if (mapScriptCollection.Unloaded) {
|
|
var map = GetMapModel();
|
|
mapScriptCollection.Load(map);
|
|
}
|
|
return mapScriptCollection;
|
|
}
|
|
}
|
|
|
|
private WildPokemonViewModel wildPokemon;
|
|
public WildPokemonViewModel WildPokemon {
|
|
get {
|
|
if (wildPokemon == null) wildPokemon = new WildPokemonViewModel(viewPort, tutorials, group, map);
|
|
return wildPokemon;
|
|
}
|
|
}
|
|
|
|
private SurfConnectionViewModel surfConnection;
|
|
public SurfConnectionViewModel SurfConnection {
|
|
get {
|
|
if (surfConnection == null) {
|
|
surfConnection = new SurfConnectionViewModel(viewPort, group, map);
|
|
surfConnection.RequestChangeMap += (sender, e) => RequestChangeMap.Raise(this, e);
|
|
surfConnection.ConnectNewMap += (sender, e) => ConnectNewMap(e);
|
|
surfConnection.ConnectExistingMap += (sender, e) => ConnectExistingMap(e);
|
|
surfConnection.RequestRemoveConnection += (sender, e) => {
|
|
var connections = AllMapsModel.Create(model, tokenFactory)[group][map].Connections;
|
|
var toRemove = connections.Count.Range().Where(i => connections[i].Direction.IsAny(MapDirection.Dive, MapDirection.Emerge)).ToList();
|
|
RemoveConnections(toRemove);
|
|
};
|
|
}
|
|
return surfConnection;
|
|
}
|
|
}
|
|
|
|
public BlockMapViewModel(IFileSystem fileSystem, MapTutorialsViewModel tutorials, IEditableViewPort viewPort, Format format, int group, int map) {
|
|
this.format = format;
|
|
this.fileSystem = fileSystem;
|
|
this.tutorials = tutorials;
|
|
this.viewPort = viewPort;
|
|
this.model = viewPort.Model;
|
|
this.tokenFactory = () => viewPort.ChangeHistory.CurrentChange;
|
|
(this.group, this.map) = (group, map);
|
|
Transparent = -1;
|
|
var mapModel = GetMapModel();
|
|
RefreshMapSize();
|
|
PrimaryTiles = PrimaryBlocks = model.IsFRLG() ? 640 : 512;
|
|
PrimaryPalettes = model.IsFRLG() ? 7 : 6;
|
|
|
|
(LeftEdge, TopEdge) = (-PixelWidth / 2, -PixelHeight / 2);
|
|
|
|
mapScriptCollection = new(viewPort);
|
|
mapScriptCollection.NewMapScriptsCreated += (sender, e) => GetMapModel().SetAddress("mapscripts", e.Address);
|
|
|
|
mapRepointer = new MapRepointer(format, fileSystem, viewPort, viewPort.ChangeHistory, MapID);
|
|
mapRepointer.ChangeMap += (sender, e) => RequestChangeMap.Raise(this, e);
|
|
mapRepointer.DataMoved += (sender, e) => {
|
|
ClearCaches();
|
|
if (e == null) return;
|
|
InformRepoint(e);
|
|
if (e.Type == "Layout") UpdateLayoutID();
|
|
};
|
|
}
|
|
|
|
private BerryInfo berryInfo;
|
|
public BerryInfo BerryInfo {
|
|
get {
|
|
if (berryInfo != null) return berryInfo;
|
|
return berryInfo = SetupBerryInfo();
|
|
}
|
|
set {
|
|
berryInfo = value;
|
|
NotifyPropertyChanged(nameof(BerryInfo));
|
|
}
|
|
}
|
|
|
|
private BerryInfo SetupBerryInfo() {
|
|
var collection = new ObservableCollection<string>();
|
|
var options = model.GetOptions(HardcodeTablesModel.BerryTableName);
|
|
if (options == null) options = 100.Range().Select(i => i.ToString()).ToList();
|
|
foreach (var option in options) collection.Add(option);
|
|
var spots = Flags.GetBerrySpots(model, ViewPort.Tools.CodeTool.ScriptParser);
|
|
return new(spots, collection);
|
|
}
|
|
|
|
public void InformRepoint(DataMovedEventArgs e) {
|
|
viewPort.RaiseMessage($"{e.Type} data was moved to {e.Address:X6}.");
|
|
}
|
|
|
|
public void InformCreate(DataMovedEventArgs e) {
|
|
viewPort.RaiseMessage($"{e.Type} data was created at {e.Address:X6}.");
|
|
}
|
|
|
|
public IReadOnlyList<BlockMapViewModel> GetNeighbors(MapDirection direction) {
|
|
var list = new List<BlockMapViewModel>();
|
|
var border = GetBorderThickness();
|
|
if (border == null) return list;
|
|
foreach (var connection in GetConnections()) {
|
|
if (connection.Direction != direction) continue;
|
|
var vm = GetNeighbor(connection, border);
|
|
list.Add(vm);
|
|
}
|
|
return list;
|
|
}
|
|
|
|
public bool UpdateFrom(BlockMapViewModel other) {
|
|
if (other == null) return false;
|
|
if (other == this) return true;
|
|
if (other.MapID == MapID) {
|
|
IncludeBorders = other.IncludeBorders;
|
|
SpriteScale = other.SpriteScale;
|
|
LeftEdge = other.LeftEdge;
|
|
TopEdge = other.TopEdge;
|
|
ZIndex = other.ZIndex;
|
|
IsSelected = other.IsSelected;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public void GotoData() {
|
|
var map = GetMapModel();
|
|
viewPort.Goto.Execute(map.Start);
|
|
}
|
|
|
|
public void ClearCaches() {
|
|
palettes = null;
|
|
tiles = null;
|
|
blocks = null;
|
|
lock (blockRenders) {
|
|
blockRenders.Clear();
|
|
}
|
|
blockPixels = null;
|
|
eventRenders = null;
|
|
borderBlock = null;
|
|
berryInfo = null;
|
|
WildPokemon.ClearCache();
|
|
RefreshMapSize();
|
|
if (blockEditor != null) {
|
|
blockEditor.BlocksChanged -= HandleBlocksChanged;
|
|
blockEditor.BlockAttributesChanged -= HandleBlockAttributesChanged;
|
|
BlockEditor.AutoscrollTiles -= HandleAutoscrollTiles;
|
|
var oldBlockEditor = blockEditor;
|
|
blockEditor = null;
|
|
if (BlockEditor != null && oldBlockEditor != null) {
|
|
BlockEditor.BlockIndex = oldBlockEditor.BlockIndex;
|
|
(BlockEditor.TileSelectionX, BlockEditor.TileSelectionY) = (oldBlockEditor.TileSelectionX, oldBlockEditor.TileSelectionY);
|
|
BlockEditor.PaletteSelection = oldBlockEditor.PaletteSelection;
|
|
BlockEditor.ShowTiles = oldBlockEditor.ShowTiles;
|
|
BlockEditor.LoadClipboard(oldBlockEditor);
|
|
}
|
|
if (oldBlockEditor != null) oldBlockEditor.ShowTiles = false;
|
|
NotifyPropertyChanged(nameof(BlockEditor));
|
|
}
|
|
if (borderEditor != null) {
|
|
var oldShowBorder = borderEditor.ShowBorderPanel;
|
|
borderEditor.BorderChanged -= HandleBorderChanged;
|
|
var oldBorderEditor = borderEditor;
|
|
borderEditor = null;
|
|
BorderEditor.ShowBorderPanel = oldShowBorder;
|
|
oldBorderEditor.ShowBorderPanel = false;
|
|
NotifyPropertyChanged(nameof(BorderEditor));
|
|
}
|
|
ClearPixelCache();
|
|
NotifyPropertiesChanged(nameof(BlockRenders), nameof(BlockPixels), nameof(BerryInfo));
|
|
if (SelectedEvent != null) CycleActiveEvent(default, EventCycleDirection.None);
|
|
}
|
|
|
|
public void RedrawEvents() {
|
|
eventRenders = null;
|
|
NotifyPropertyChanged(nameof(CanCreateFlyEvent));
|
|
ClearPixelCache();
|
|
}
|
|
|
|
public void Scale(double x, double y, bool enlarge) {
|
|
(lastDrawX, lastDrawY) = (-1, -1);
|
|
var old = spriteScale;
|
|
|
|
if (enlarge && spriteScale < 10) {
|
|
if (spriteScale < 1) spriteScale *= 2;
|
|
else spriteScale += 1;
|
|
} else if (!enlarge && spriteScale > .1) {
|
|
if (spriteScale > 1) spriteScale -= 1;
|
|
else spriteScale /= 2;
|
|
}
|
|
|
|
if (old != spriteScale) UpdateEdgesFromScale(old, x - leftEdge, y - topEdge);
|
|
NotifyPropertyChanged(nameof(SpriteScale));
|
|
}
|
|
|
|
// check for other warps on this same tile and see what primary/secondary blockset is expected for the new map.
|
|
// if no reasonable tileset is found, just use the current map's blocksets
|
|
public BlockMapViewModel CreateMapForWarp(WarpEventViewModel warp) {
|
|
// what bank should the new map go in?
|
|
var option = MapRepointer.GetMapBankForNewMap(
|
|
"Maps are organized into banks. The game doesn't care, so you can use the banks however you like."
|
|
+ Environment.NewLine +
|
|
"Which map bank do you want to use for the new map?");
|
|
if (option == -1) return null;
|
|
var token = tokenFactory();
|
|
MapModel thisMap = new(GetMapModel());
|
|
|
|
// give me this block
|
|
var blockIndex = thisMap.Blocks[warp.X, warp.Y].Tile;
|
|
|
|
// give me all maps that use this blockset
|
|
var borderBlockAddress = thisMap.Layout.BorderBlockAddress;
|
|
var primaryBlocksetAddress = thisMap.Layout.PrimaryBlockset.Start;
|
|
var secondaryBlocksetAddress = thisMap.Layout.SecondaryBlockset.Start;
|
|
|
|
var maps = new List<MapModel>();
|
|
foreach (var map in GetAllMaps()) {
|
|
if (map.Layout.PrimaryBlockset.Start != primaryBlocksetAddress && blockIndex < PrimaryBlocks) continue;
|
|
if (map.Layout.SecondaryBlockset.Start != secondaryBlocksetAddress && blockIndex >= PrimaryBlocks) continue;
|
|
maps.Add(map);
|
|
}
|
|
|
|
// give me all warps in those maps (except for this warp itself)
|
|
// give me all warps that are on this tile
|
|
var warps = new List<WarpEventModel>();
|
|
foreach (var map in maps) {
|
|
var layout = map.Layout;
|
|
foreach (var w in map.Events.Warps) {
|
|
if (w.Element.Start == warp.Element.Start) continue;
|
|
if (map.Blocks[w.X, w.Y].Tile != blockIndex) continue;
|
|
warps.Add(w);
|
|
}
|
|
}
|
|
|
|
// give me maps that those warp to
|
|
// give me all the primary/secondary blocksets for those maps
|
|
// give me all the borders for those maps
|
|
var prototypes = new Dictionary<LayoutPrototype, List<WarpEventModel>>();
|
|
foreach (var w in warps) {
|
|
var m = w.TargetMap;
|
|
if (m == null) continue;
|
|
var (primary, secondary, border) = (m.Layout.PrimaryBlockset, m.Layout.SecondaryBlockset, m.Layout.BorderBlockAddress);
|
|
if (primary == null || secondary == null || border == Pointer.NULL) continue;
|
|
var prototype = new LayoutPrototype(primary.Start, secondary.Start, border);
|
|
if (!prototypes.ContainsKey(prototype)) prototypes.Add(prototype, new());
|
|
prototypes[prototype].Add(w);
|
|
}
|
|
|
|
var orderedPrototypes = prototypes.Keys.ToList();
|
|
var initialBlockmap = new int[9, 9];
|
|
var warpIsBottomSquare = true;
|
|
|
|
if (orderedPrototypes.Count > 1) {
|
|
var initialBlockmaps = new List<int[,]>();
|
|
var warpIsBottomSquareForIndex = new List<bool>();
|
|
|
|
// for each prototype, create an image that represents what that map prototype would look like
|
|
var images = new List<VisualOption>();
|
|
foreach (var prototype in orderedPrototypes) {
|
|
var targets = prototypes[prototype];
|
|
var (render, blockmap, isBottomSquare) = RenderPrototype(targets);
|
|
initialBlockmaps.Add(blockmap);
|
|
warpIsBottomSquareForIndex.Add(isBottomSquare);
|
|
var targetMapName = MapIDToText(model, targets[0].Bank, targets[0].Map);
|
|
var targetLocation = targetMapName.Split('(')[0];
|
|
var targetName = '(' + targetMapName.Split('(')[1];
|
|
var visOption = new VisualOption { Index = orderedPrototypes.IndexOf(prototype), Option = $"Like {targetLocation}", ShortDescription = targetName, Visual = render };
|
|
images.Add(visOption);
|
|
}
|
|
|
|
// create one additional 'blank' prototype
|
|
initialBlockmaps.Add(new int[9, 9]);
|
|
var blank = new LayoutPrototype(primaryBlocksetAddress, secondaryBlocksetAddress, borderBlockAddress);
|
|
orderedPrototypes.Add(blank);
|
|
var blankRender = new CanvasPixelViewModel(9 * 16, 9 * 16) { SpriteScale = images[0].Visual.SpriteScale };
|
|
var blankVisOption = new VisualOption { Index = orderedPrototypes.Count - 1, Option = "Blank", ShortDescription = "Use Current Blocksets", Visual = blankRender };
|
|
warpIsBottomSquareForIndex.Add(true);
|
|
images.Add(blankVisOption);
|
|
|
|
var choice = fileSystem.ShowOptions("Create New Map", "Start from which template?", null, images.ToArray());
|
|
if (choice == -1) return null;
|
|
var chosenPrototype = orderedPrototypes[choice];
|
|
// use the most frequent primary/secondary blockset and border blocks
|
|
primaryBlocksetAddress = chosenPrototype.PrimaryBlockset;
|
|
secondaryBlocksetAddress = chosenPrototype.SecondaryBlockset;
|
|
borderBlockAddress = chosenPrototype.BorderBlock;
|
|
initialBlockmap = initialBlockmaps[choice];
|
|
warpIsBottomSquare = warpIsBottomSquareForIndex[choice];
|
|
} else if (orderedPrototypes.Count == 1) {
|
|
// no dialog, just go with this one
|
|
var chosenPrototype = orderedPrototypes[0];
|
|
primaryBlocksetAddress = chosenPrototype.PrimaryBlockset;
|
|
secondaryBlocksetAddress = chosenPrototype.SecondaryBlockset;
|
|
borderBlockAddress = chosenPrototype.BorderBlock;
|
|
var (render, blockmap, isBottomSquare) = RenderPrototype(prototypes.Values.Single());
|
|
initialBlockmap = blockmap;
|
|
warpIsBottomSquare = isBottomSquare;
|
|
}
|
|
|
|
// create a new 9x9 map
|
|
var newMap = CreateNewMap(token, option, 9, 9);
|
|
var newLayout = newMap.GetLayout();
|
|
newLayout.SetAddress(Format.BorderBlock, borderBlockAddress);
|
|
newLayout.SetAddress(Format.PrimaryBlockset, primaryBlocksetAddress);
|
|
newLayout.SetAddress(Format.SecondaryBlockset, secondaryBlocksetAddress);
|
|
var start = newLayout.GetAddress(Format.BlockMap);
|
|
for (int x = 0; x < 9; x++) {
|
|
for (int y = 0; y < 9; y++) {
|
|
model.WriteMultiByteValue(start + (y * 9 + x) * 2, 2, token, initialBlockmap[x, y]);
|
|
}
|
|
}
|
|
|
|
// place reverse warp at bottom heading back
|
|
(warp.Bank, warp.Map, warp.WarpID) = (newMap.group, newMap.map, 1);
|
|
var returnWarp = newMap.CreateWarpEvent(group, map);
|
|
returnWarp.WarpID = GetEvents().Where(e => e is WarpEventViewModel).Until(e => e.Equals(warp)).Count();
|
|
(returnWarp.X, returnWarp.Y) = (4, 8);
|
|
if (!warpIsBottomSquare) (returnWarp.X, returnWarp.Y) = (4, 7);
|
|
|
|
// repoint border block
|
|
newMap.MapRepointer.RepointBorderBlock.Execute();
|
|
|
|
return newMap;
|
|
}
|
|
|
|
// from the maps that use this blockmap/blockset/border,
|
|
// figure out appropriate wall/floor tiles to make a small prototype map
|
|
private (IPixelViewModel, int[,], bool) RenderPrototype(List<WarpEventModel> warps) {
|
|
// TODO I don't just want to return an image, I want to return the tiles/collisions to use as well
|
|
|
|
// find the edge tiles
|
|
var topTile = warps.Select(warp => warp.TargetMap.Layout).SelectMany(layout => (layout.Width - 2).Range(x => layout.BlockMap[x + 1, 0].Block)).ToHistogram().MostCommonKey();
|
|
var bottomTile = warps.Select(warp => warp.TargetMap.Layout).SelectMany(layout => (layout.Width - 2).Range(x => layout.BlockMap[x + 1, layout.Height - 1].Block)).ToHistogram().MostCommonKey();
|
|
var leftTile = warps.Select(warp => warp.TargetMap.Layout).SelectMany(layout => (layout.Height - 2).Range(y => layout.BlockMap[0, y + 1].Block)).ToHistogram().MostCommonKey();
|
|
var rightTile = warps.Select(warp => warp.TargetMap.Layout).SelectMany(layout => (layout.Height - 2).Range(y => layout.BlockMap[layout.Width - 1, y + 1].Block)).ToHistogram().MostCommonKey();
|
|
var topLeftTile = warps.Select(warp => warp.TargetMap.Layout).Select(layout => layout.BlockMap[0, 0].Block).ToHistogram().MostCommonKey();
|
|
var topRightTile = warps.Select(warp => warp.TargetMap.Layout).Select(layout => layout.BlockMap[layout.Width - 1, 0].Block).ToHistogram().MostCommonKey();
|
|
var bottomLeftTile = warps.Select(warp => warp.TargetMap.Layout).Select(layout => layout.BlockMap[0, layout.Height - 1].Block).ToHistogram().MostCommonKey();
|
|
var bottomRightTile = warps.Select(warp => warp.TargetMap.Layout).Select(layout => layout.BlockMap[layout.Width - 1, layout.Height - 1].Block).ToHistogram().MostCommonKey();
|
|
|
|
// find the floor tile
|
|
var centerTiles = new List<int>();
|
|
foreach (var warp in warps) {
|
|
var layout = warp.TargetMap.Layout;
|
|
for (int x = 1; x < layout.Width - 1; x++) {
|
|
for (int y = 1; y < layout.Height - 1; y++) {
|
|
centerTiles.Add(layout.BlockMap[x, y].Block);
|
|
}
|
|
}
|
|
}
|
|
var floorTile = centerTiles.ToHistogram().MostCommonKey();
|
|
|
|
// build the map image data
|
|
var blockMap = new int[9, 9];
|
|
for (int i = 1; i < 8; i++) {
|
|
blockMap[0, i] = leftTile;
|
|
blockMap[8, i] = rightTile;
|
|
blockMap[i, 0] = topTile;
|
|
blockMap[i, 8] = bottomTile;
|
|
for (int j = 1; j < 8; j++) blockMap[i, j] = floorTile;
|
|
}
|
|
(blockMap[0, 0], blockMap[8, 0], blockMap[0, 8], blockMap[8, 8]) = (topLeftTile, topRightTile, bottomLeftTile, bottomRightTile);
|
|
|
|
// find the door tile
|
|
var map0 = warps[0].TargetMap;
|
|
var matchingWarp0 = map0.Events.Warps[warps[0].WarpID];
|
|
var warpIsAgainstWall = matchingWarp0.Y == map0.Layout.Height - 1;
|
|
if (warpIsAgainstWall) {
|
|
blockMap[3, 7] = map0.Blocks[matchingWarp0.X - 1, matchingWarp0.Y - 1].Tile;
|
|
blockMap[4, 7] = map0.Blocks[matchingWarp0.X, matchingWarp0.Y - 1].Tile;
|
|
blockMap[5, 7] = map0.Blocks[matchingWarp0.X + 1, matchingWarp0.Y - 1].Tile;
|
|
|
|
blockMap[3, 8] = map0.Blocks[matchingWarp0.X - 1, matchingWarp0.Y].Tile;
|
|
blockMap[4, 8] = map0.Blocks[matchingWarp0.X, matchingWarp0.Y].Tile;
|
|
blockMap[5, 8] = map0.Blocks[matchingWarp0.X + 1, matchingWarp0.Y].Tile;
|
|
} else {
|
|
blockMap[3, 7] = map0.Blocks[matchingWarp0.X - 1, matchingWarp0.Y].Tile;
|
|
blockMap[4, 7] = map0.Blocks[matchingWarp0.X, matchingWarp0.Y].Tile;
|
|
blockMap[5, 7] = map0.Blocks[matchingWarp0.X + 1, matchingWarp0.Y].Tile;
|
|
|
|
blockMap[3, 8] = map0.Blocks[matchingWarp0.X - 1, matchingWarp0.Y + 1].Tile;
|
|
blockMap[4, 8] = map0.Blocks[matchingWarp0.X, matchingWarp0.Y + 1].Tile;
|
|
blockMap[5, 8] = map0.Blocks[matchingWarp0.X + 1, matchingWarp0.Y + 1].Tile;
|
|
}
|
|
|
|
// draw the map
|
|
var viewModel = new BlockMapViewModel(fileSystem, tutorials, viewPort, format, warps[0].Bank, warps[0].Map) { BerryInfo = BerryInfo };
|
|
var canvas = new CanvasPixelViewModel(9 * 16, 9 * 16);
|
|
for (int y = 0; y < 9; y++) {
|
|
for (int x = 0; x < 9; x++) {
|
|
canvas.Draw(viewModel.BlockRenders[blockMap[x, y] & 0x3FF], x * 16, y * 16);
|
|
}
|
|
}
|
|
|
|
canvas.SpriteScale = .5;
|
|
return (canvas, blockMap, warpIsAgainstWall);
|
|
}
|
|
|
|
#region Draw / Paint
|
|
|
|
/// <summary>
|
|
/// Gets the block index and collision index.
|
|
/// </summary>
|
|
public (int blockIndex, int collisionIndex) GetBlock(double x, double y) {
|
|
(lastDrawX, lastDrawY) = (-1, -1);
|
|
(x, y) = ((x - leftEdge) / spriteScale, (y - topEdge) / spriteScale);
|
|
(x, y) = (x / 16, y / 16);
|
|
|
|
var layout = GetLayout();
|
|
var (width, height) = (layout.GetValue("width"), layout.GetValue("height"));
|
|
var border = GetBorderThickness(layout);
|
|
var (xx, yy) = ((int)x - border.West, (int)y - border.North);
|
|
if (xx < 0 || yy < 0 || xx > width || yy > height) return (-1, -1);
|
|
var start = layout.GetAddress("blockmap");
|
|
|
|
var modelAddress = start + (yy * width + xx) * 2;
|
|
var data = model.ReadMultiByteValue(modelAddress, 2);
|
|
return (data & 0x3FF, data >> 10);
|
|
}
|
|
|
|
private int lastDrawVal, lastDrawX, lastDrawY;
|
|
|
|
/// <summary>
|
|
/// If collisionIndex is not valid, it's ignored.
|
|
/// If blockIndex is not valid, it's ignored.
|
|
/// </summary>
|
|
public void DrawBlock(ModelDelta token, int blockIndex, int collisionIndex, double x, double y) {
|
|
(x, y) = ((x - leftEdge) / spriteScale, (y - topEdge) / spriteScale);
|
|
(x, y) = (x / 16, y / 16);
|
|
|
|
var layout = GetLayout();
|
|
var border = GetBorderThickness(layout);
|
|
var (xx, yy) = ((int)x - border.West, (int)y - border.North);
|
|
DrawBlock(token, blockIndex, collisionIndex, xx, yy);
|
|
}
|
|
|
|
public void DrawBlock(ModelDelta token, int blockIndex, int collisionIndex, int xx, int yy) {
|
|
var layout = GetLayout();
|
|
var (width, height) = (layout.GetValue("width"), layout.GetValue("height"));
|
|
var border = GetBorderThickness(layout);
|
|
|
|
xx = xx.LimitToRange(0, width - 1);
|
|
yy = yy.LimitToRange(0, height - 1);
|
|
if (lastDrawX == xx && lastDrawY == yy) return;
|
|
var start = layout.GetAddress("blockmap");
|
|
|
|
var modelAddress = start + (yy * width + xx) * 2;
|
|
var data = model.ReadMultiByteValue(modelAddress, 2);
|
|
var high = data >> 10;
|
|
var low = data & 0x3FF;
|
|
if (blockIndex >= 0 && blockIndex < blockRenders.Count) low = blockIndex;
|
|
if (collisionIndex >= 0 && collisionIndex < 0x3F) high = collisionIndex;
|
|
lastDrawVal = model.ReadMultiByteValue(modelAddress, 2);
|
|
(lastDrawX, lastDrawY) = (xx, yy);
|
|
model.WriteMultiByteValue(modelAddress, 2, token, (high << 10) | low);
|
|
|
|
var canvas = new CanvasPixelViewModel(pixelWidth, pixelHeight, PixelData);
|
|
bool updateBlock = blockIndex >= 0 && blockIndex < blockRenders.Count;
|
|
bool updateHighlight = collisionIndex == collisionHighlight && collisionHighlight != -1;
|
|
(xx, yy) = ((xx + border.West) * 16, (yy + border.North) * 16);
|
|
if (updateBlock) canvas.Draw(blockRenders[blockIndex], xx, yy);
|
|
if (updateHighlight && xx < pixelWidth && yy < pixelHeight) HighlightCollision(PixelData, xx, yy);
|
|
if (updateBlock || updateHighlight) NotifyPropertyChanged(nameof(PixelData));
|
|
tutorials.Complete(Tutorial.LeftClickMap_DrawBlock);
|
|
}
|
|
|
|
public void Draw9Grid(ModelDelta token, int blockIndex, int collisionIndex, double x, double y) {
|
|
(x, y) = ((x - leftEdge) / spriteScale, (y - topEdge) / spriteScale);
|
|
(x, y) = (x / 16, y / 16);
|
|
|
|
var layout = GetLayout();
|
|
var border = GetBorderThickness(layout);
|
|
var (xx, yy) = ((int)x - border.West, (int)y - border.North);
|
|
Draw9Grid(token, blockIndex, collisionIndex, xx, yy);
|
|
}
|
|
|
|
public void Draw9Grid(ModelDelta token, int blockIndex, int collisionIndex, int xx, int yy) {
|
|
var blockHeight = (int)Math.Ceiling((double)blockRenders.Count / BlocksPerRow);
|
|
|
|
// find all neighbor blocks with blockIndex +/- 1 +/- BlocksPerRow
|
|
// arrange these blocks into a grid so we can use them
|
|
var grid = new int[3, 3]; // TODO fill the grid
|
|
var targets = new List<int> { blockIndex };
|
|
if (blockIndex >= BlocksPerRow) {
|
|
if (blockIndex % BlocksPerRow > 0) targets.Add(blockIndex - 1 - BlocksPerRow);
|
|
grid[0, 0] = blockIndex % BlocksPerRow > 0 ? blockIndex - 1 - BlocksPerRow : blockIndex - BlocksPerRow;
|
|
targets.Add(blockIndex - BlocksPerRow);
|
|
grid[0, 1] = blockIndex - BlocksPerRow;
|
|
if (blockIndex % BlocksPerRow != BlocksPerRow - 1) targets.Add(blockIndex + 1 - BlocksPerRow);
|
|
grid[0, 2] = blockIndex % BlocksPerRow != BlocksPerRow - 1 ? blockIndex + 1 - BlocksPerRow : blockIndex - BlocksPerRow;
|
|
} else {
|
|
grid[0, 0] = blockIndex % BlocksPerRow > 0 ? blockIndex - 1 : blockIndex;
|
|
grid[0, 1] = blockIndex;
|
|
grid[0, 2] = blockIndex % BlocksPerRow != BlocksPerRow - 1 ? blockIndex + 1 : blockIndex;
|
|
}
|
|
if (blockIndex % BlocksPerRow > 0) targets.Add(blockIndex - 1);
|
|
grid[1, 0] = blockIndex % BlocksPerRow > 0 ? blockIndex - 1 : blockIndex;
|
|
grid[1, 1] = blockIndex;
|
|
if (blockIndex % BlocksPerRow != BlocksPerRow - 1) targets.Add(blockIndex + 1);
|
|
grid[1, 2] = blockIndex % BlocksPerRow != BlocksPerRow - 1 ? blockIndex + 1 : blockIndex;
|
|
if (blockIndex / BlocksPerRow < blockHeight - 1) {
|
|
if (blockIndex % BlocksPerRow > 0) targets.Add(blockIndex - 1 + BlocksPerRow);
|
|
grid[2, 0] = blockIndex % BlocksPerRow > 0 ? blockIndex - 1 + BlocksPerRow : blockIndex + BlocksPerRow;
|
|
targets.Add(blockIndex + BlocksPerRow);
|
|
grid[2, 1] = blockIndex + BlocksPerRow;
|
|
if (blockIndex % BlocksPerRow != BlocksPerRow - 1) targets.Add(blockIndex + 1 + BlocksPerRow);
|
|
grid[2, 2] = blockIndex % BlocksPerRow > 0 ? blockIndex + 1 + BlocksPerRow : blockIndex + BlocksPerRow;
|
|
} else {
|
|
grid[2, 0] = blockIndex % BlocksPerRow > 0 ? blockIndex - 1 : blockIndex;
|
|
grid[2, 1] = blockIndex;
|
|
grid[2, 2] = blockIndex % BlocksPerRow != BlocksPerRow - 1 ? blockIndex + 1 : blockIndex;
|
|
}
|
|
|
|
var layout = GetLayout();
|
|
var (width, height) = (layout.GetValue("width"), layout.GetValue("height"));
|
|
var start = layout.GetAddress("blockmap");
|
|
|
|
int get(Point p) => p.X < 0 || p.Y < 0 || p.X >= width || p.Y >= height ? -1 : model.ReadMultiByteValue(start + (p.Y * width + p.X) * 2, 2) & 0x3FF;
|
|
void set(Point p, int block) => model.WriteMultiByteValue(start + (p.Y * width + p.X) * 2, 2, token, (block & 0x3FF) + (collisionIndex << 10));
|
|
|
|
// change all connected blocks based on the grid
|
|
var todo = new List<Point> { new(xx, yy), new(xx - 1, yy), new(xx + 1, yy), new(xx, yy - 1), new(xx, yy + 1) };
|
|
lock (pixelWriteLock) {
|
|
set(todo[0], blockIndex);
|
|
foreach (var cell in todo) {
|
|
var cellValue = get(cell);
|
|
if (!targets.Contains(cellValue)) continue;
|
|
|
|
var north = targets.Contains(get(new(cell.X, cell.Y - 1)));
|
|
var south = targets.Contains(get(new(cell.X, cell.Y + 1)));
|
|
var west = targets.Contains(get(new(cell.X - 1, cell.Y)));
|
|
var east = targets.Contains(get(new(cell.X + 1, cell.Y)));
|
|
var aggregate = (north ? "N" : " ") + (east ? "E" : " ") + (south ? "S" : " ") + (west ? "W" : " ");
|
|
|
|
var block = aggregate switch {
|
|
" ES " => grid[0, 0],
|
|
" ESW" => grid[0, 1],
|
|
" SW" => grid[0, 2],
|
|
"NES " => grid[1, 0],
|
|
"NESW" => grid[1, 1],
|
|
"N SW" => grid[1, 2],
|
|
"NE " => grid[2, 0],
|
|
"NE W" => grid[2, 1],
|
|
"N W" => grid[2, 2],
|
|
_ => grid[1, 1],
|
|
};
|
|
set(cell, block);
|
|
}
|
|
}
|
|
|
|
ClearPixelCache();
|
|
}
|
|
|
|
public void DrawBlocks(ModelDelta token, int[,] tiles, Point source, Point destination) {
|
|
while (Math.Abs(destination.X - source.X) % tiles.GetLength(0) != 0) destination -= new Point(1, 0);
|
|
while (Math.Abs(destination.Y - source.Y) % tiles.GetLength(1) != 0) destination -= new Point(0, 1);
|
|
|
|
var layout = GetLayout();
|
|
var (width, height) = (layout.GetValue("width"), layout.GetValue("height"));
|
|
var start = layout.GetAddress("blockmap");
|
|
int changeCount = 0;
|
|
lock (pixelWriteLock) {
|
|
for (int x = 0; x < tiles.GetLength(0); x++) {
|
|
for (int y = 0; y < tiles.GetLength(1); y++) {
|
|
if (destination.X + x < 0 || destination.Y + y < 0 || destination.X + x >= width || destination.Y + y >= height) continue;
|
|
var address = start + ((destination.Y + y) * width + destination.X + x) * 2;
|
|
if (model.ReadMultiByteValue(address, 2) != tiles[x, y]) {
|
|
model.WriteMultiByteValue(address, 2, token, tiles[x, y]);
|
|
changeCount++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (changeCount > 0) ClearPixelCache();
|
|
}
|
|
|
|
public void RepeatBlock(Func<ModelDelta> futureToken, int block, int collision, int x, int y, int w, int h, bool refreshScreen) {
|
|
var layout = GetLayout();
|
|
var (width, height) = (layout.GetValue("width"), layout.GetValue("height"));
|
|
var start = layout.GetAddress("blockmap");
|
|
int changeCount = 0;
|
|
lock (pixelWriteLock) {
|
|
for (int xx = 0; xx < w; xx++) {
|
|
for (int yy = 0; yy < h; yy++) {
|
|
if (x + xx < 0 || y + yy < 0 || x + xx >= width || y + yy >= height) continue;
|
|
var address = start + ((yy + y) * width + xx + x) * 2;
|
|
// var block = blockValues[xx % blockValues.GetLength(0), yy % blockValues.GetLength(1)];
|
|
var blockValue = model.ReadMultiByteValue(address, 2);
|
|
lastDrawVal = blockValue;
|
|
if (block >= 0) blockValue = (blockValue & 0xFC00) + block;
|
|
if (collision >= 0) blockValue = (blockValue & 0x3FF) + (collision << 10);
|
|
if (blockValue != lastDrawVal) {
|
|
model.WriteMultiByteValue(address, 2, futureToken(), blockValue);
|
|
changeCount++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (changeCount > 0 && refreshScreen) ClearPixelCache();
|
|
}
|
|
|
|
public void RepeatBlocks(Func<ModelDelta> futureToken, int[,] blockValues, int x, int y, int w, int h, bool refreshScreen) {
|
|
var layout = GetLayout();
|
|
var (width, height) = (layout.GetValue("width"), layout.GetValue("height"));
|
|
var start = layout.GetAddress("blockmap");
|
|
int changeCount = 0;
|
|
lock (pixelWriteLock) {
|
|
for (int xx = 0; xx < w; xx++) {
|
|
for (int yy = 0; yy < h; yy++) {
|
|
if (x + xx < 0 || y + yy < 0 || x + xx >= width || y + yy >= height) continue;
|
|
var address = start + ((yy + y) * width + xx + x) * 2;
|
|
var block = blockValues[xx % blockValues.GetLength(0), yy % blockValues.GetLength(1)];
|
|
if (model.ReadMultiByteValue(address, 2) != block) {
|
|
model.WriteMultiByteValue(address, 2, futureToken(), block);
|
|
changeCount++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (changeCount > 0 && refreshScreen) ClearPixelCache();
|
|
}
|
|
|
|
public int[,] ReadRectangle(int x, int y, int w, int h) {
|
|
var results = new int[w, h];
|
|
var layout = GetLayout();
|
|
var (width, height) = (layout.GetValue("width"), layout.GetValue("height"));
|
|
var start = layout.GetAddress("blockmap");
|
|
for (int xx = 0; xx < w; xx++) {
|
|
for (int yy = 0; yy < h; yy++) {
|
|
if (x + xx < 0 || y + yy < 0 || x + xx >= width || y + yy >= height) continue;
|
|
var address = start + ((yy + y) * width + xx + x) * 2;
|
|
results[xx, yy] = model.ReadMultiByteValue(address, 2);
|
|
}
|
|
}
|
|
return results;
|
|
}
|
|
|
|
public void PaintBlock(ModelDelta token, int blockIndex, int collisionIndex, double x, double y) {
|
|
if (blockIndex == -1) return;
|
|
(x, y) = ((x - leftEdge) / spriteScale, (y - topEdge) / spriteScale);
|
|
(x, y) = (x / 16, y / 16);
|
|
var layout = GetLayout();
|
|
var (width, height) = (layout.GetValue("width"), layout.GetValue("height"));
|
|
var border = GetBorderThickness(layout);
|
|
var (xx, yy) = ((int)x - border.West, (int)y - border.North);
|
|
if (xx < 0 || yy < 0 || xx > width || yy > height) return;
|
|
var start = layout.GetAddress("blockmap");
|
|
|
|
var size = new Point(width, height);
|
|
if (collisionIndex < 0) collisionIndex = lastDrawVal >> 10;
|
|
var (before, after) = (lastDrawVal, (collisionIndex << 10) | blockIndex);
|
|
lock (pixelWriteLock) {
|
|
PaintBlock(token, new(xx - 1, yy), size, start, before, after);
|
|
PaintBlock(token, new(xx + 1, yy), size, start, before, after);
|
|
PaintBlock(token, new(xx, yy - 1), size, start, before, after);
|
|
PaintBlock(token, new(xx, yy + 1), size, start, before, after);
|
|
}
|
|
ClearPixelCache();
|
|
}
|
|
|
|
private void PaintBlock(ModelDelta token, Point p, Point size, int start, int before, int after) {
|
|
if (before == after) return;
|
|
if (p.X < 0 || p.Y < 0 || p.X >= size.X || p.Y >= size.Y) return;
|
|
var address = start + (p.Y * size.X + p.X) * 2;
|
|
if (model.ReadMultiByteValue(address, 2) != before) return;
|
|
model.WriteMultiByteValue(address, 2, token, after);
|
|
PaintBlock(token, p + new Point(-1, 0), size, start, before, after);
|
|
PaintBlock(token, p + new Point(1, 0), size, start, before, after);
|
|
PaintBlock(token, p + new Point(0, -1), size, start, before, after);
|
|
PaintBlock(token, p + new Point(0, 1), size, start, before, after);
|
|
}
|
|
|
|
public void PaintBlockBag(ModelDelta token, List<int> blockIndexes, int collisionIndex, double x, double y) {
|
|
if (blockIndexes.Count < 1) return;
|
|
(x, y) = ((x - leftEdge) / spriteScale, (y - topEdge) / spriteScale);
|
|
(x, y) = (x / 16, y / 16);
|
|
var layout = GetLayout();
|
|
var (width, height) = (layout.GetValue("width"), layout.GetValue("height"));
|
|
var border = GetBorderThickness(layout);
|
|
var (xx, yy) = ((int)x - border.West, (int)y - border.North);
|
|
if (xx < 0 || yy < 0 || xx > width || yy > height) return;
|
|
var start = layout.GetAddress("blockmap");
|
|
|
|
var complete = new HashSet<Point> { new(xx, yy) };
|
|
var check = new List<Point> { new(xx - 1, yy), new(xx + 1, yy), new(xx, yy - 1), new(xx, yy + 1) };
|
|
var targets = blockIndexes.Select(bi => (collisionIndex << 10) | bi).ToList();
|
|
var rnd = new Random();
|
|
lock (pixelWriteLock) {
|
|
while (check.Count > 0) {
|
|
var p = check[check.Count - 1];
|
|
check.RemoveAt(check.Count - 1);
|
|
if (p.X < 0 || p.Y < 0 || p.X >= width || p.Y >= height) continue;
|
|
if (complete.Contains(p)) continue;
|
|
complete.Add(p);
|
|
|
|
var address = start + (p.Y * width + p.X) * 2;
|
|
if (model.ReadMultiByteValue(address, 2) != lastDrawVal) continue;
|
|
model.WriteMultiByteValue(address, 2, token, rnd.From(targets));
|
|
|
|
check.AddRange(new Point[] { new(p.X - 1, p.Y), new(p.X + 1, p.Y), new(p.X, p.Y - 1), new(p.X, p.Y + 1) });
|
|
}
|
|
}
|
|
ClearPixelCache();
|
|
}
|
|
|
|
public void PaintWaveFunction(ModelDelta token, double x, double y, Func<int, int, int> wave) {
|
|
(x, y) = ((x - leftEdge) / spriteScale, (y - topEdge) / spriteScale);
|
|
(x, y) = (x / 16, y / 16);
|
|
var layout = GetLayout();
|
|
var (width, height) = (layout.GetValue("width"), layout.GetValue("height"));
|
|
var border = GetBorderThickness(layout);
|
|
var (xx, yy) = ((int)x - border.West, (int)y - border.North);
|
|
if (xx < 0 || yy < 0 || xx > width || yy > height) return;
|
|
var start = layout.GetAddress("blockmap");
|
|
|
|
// first pass: set all the effected spaces to 0 so they won't count
|
|
var toDraw = new Queue<Point>();
|
|
toDraw.Enqueue(new(xx, yy));
|
|
var drawn = new List<Point>();
|
|
lock (pixelWriteLock) {
|
|
while (toDraw.Count > 0) {
|
|
var p = toDraw.Dequeue();
|
|
if (drawn.Contains(p)) continue;
|
|
var address = start + (p.Y * width + (p.X - 1)) * 2;
|
|
if (p.X - 1 > 0 && model.ReadMultiByteValue(address, 2) == lastDrawVal) toDraw.Enqueue(new(p.X - 1, p.Y));
|
|
address = start + (p.Y * width + (p.X + 1)) * 2;
|
|
if (p.X - 1 > 0 && model.ReadMultiByteValue(address, 2) == lastDrawVal) toDraw.Enqueue(new(p.X + 1, p.Y));
|
|
address = start + ((p.Y - 1) * width + p.X) * 2;
|
|
if (p.X - 1 > 0 && model.ReadMultiByteValue(address, 2) == lastDrawVal) toDraw.Enqueue(new(p.X, p.Y - 1));
|
|
address = start + ((p.Y + 1) * width + p.X) * 2;
|
|
if (p.X - 1 > 0 && model.ReadMultiByteValue(address, 2) == lastDrawVal) toDraw.Enqueue(new(p.X, p.Y + 1));
|
|
address = start + (p.Y * width + p.X) * 2;
|
|
model.WriteMultiByteValue(address, 2, token, 0);
|
|
drawn.Add(p);
|
|
}
|
|
|
|
// second pass: wave-fill in the reverse order (outside in)
|
|
drawn.Reverse();
|
|
foreach (var p in drawn) {
|
|
var targetVal = wave(p.X, p.Y);
|
|
var address = start + (p.Y * width + p.X) * 2;
|
|
model.WriteMultiByteValue(address, 2, token, targetVal);
|
|
}
|
|
}
|
|
|
|
ClearPixelCache();
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Events
|
|
|
|
public void UpdateEventLocation(IEventViewModel ev, double x, double y) {
|
|
(lastDrawX, lastDrawY) = (-1, -1);
|
|
var layout = GetLayout();
|
|
var border = GetBorderThickness(layout);
|
|
if (border == null) return;
|
|
(x, y) = ((x - leftEdge) / spriteScale, (y - topEdge) / spriteScale);
|
|
var (xx, yy) = ((int)(x / 16) - border.West, (int)(y / 16) - border.North);
|
|
if (ev.X == xx && ev.Y == yy) return;
|
|
if (xx < 0 || yy < 0) return;
|
|
var (width, height) = (layout.GetValue("width"), layout.GetValue("height"));
|
|
if (xx >= width || yy >= height) return;
|
|
ev.X = xx;
|
|
ev.Y = yy;
|
|
SelectedEvent = ev;
|
|
ClearPixelCache();
|
|
}
|
|
|
|
public IEventViewModel EventUnderCursor(double x, double y, bool autoSelect = true) {
|
|
var layout = GetLayout();
|
|
var border = GetBorderThickness(layout);
|
|
var tileX = (int)((x - LeftEdge) / SpriteScale / 16) - border.West;
|
|
var tileY = (int)((y - TopEdge) / SpriteScale / 16) - border.North;
|
|
IEventViewModel last = null;
|
|
foreach (var e in GetEvents()) {
|
|
if (e.X == tileX && e.Y == tileY) last = e;
|
|
}
|
|
if (autoSelect && SelectedEvent != last) {
|
|
SelectedEvent = last;
|
|
ClearPixelCache();
|
|
}
|
|
return last;
|
|
}
|
|
|
|
public IPixelViewModel AutoCrop(int warpID) {
|
|
if (allOverworldSprites == null) allOverworldSprites = RenderOWs(model);
|
|
if (defaultOverworldSprite == null) defaultOverworldSprite = GetDefaultOW(model);
|
|
const int SizeX = 7, SizeY = 7;
|
|
var map = GetMapModel();
|
|
if (map == null) return null;
|
|
var layout = GetLayout(map);
|
|
if (layout == null) return null;
|
|
var (width, height) = (layout.GetValue("width"), layout.GetValue("height"));
|
|
var events = new EventGroupModel(ViewPort.Tools.CodeTool.ScriptParser, GotoAddress, map.GetSubTable("events")[0], allOverworldSprites, defaultOverworldSprite, BerryInfo, group, this.map);
|
|
if (events.Warps.Count <= warpID) return null;
|
|
var warp = events.Warps[warpID];
|
|
var startX = warp.X - SizeX / 2;
|
|
var startY = warp.Y - SizeY / 2;
|
|
while (startX < 0) startX += 1;
|
|
while (startY < 0) startY += 1;
|
|
while (startX + SizeX > width) startX--;
|
|
while (startY + SizeY > height) startY--;
|
|
|
|
return ReadonlyPixelViewModel.Crop(this, startX * 16, startY * 16, SizeX * 16, SizeY * 16);
|
|
}
|
|
|
|
public void DeselectEvent() {
|
|
if (selectedEvent == null) return;
|
|
SelectedEvent = null;
|
|
ClearPixelCache();
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Connections
|
|
|
|
public IEnumerable<MapSlider> GetMapSliders() {
|
|
var connections = GetConnections();
|
|
if (connections == null) yield break;
|
|
var border = GetBorderThickness();
|
|
if (border == null) yield break;
|
|
var tileSize = (int)(16 * spriteScale);
|
|
int id = 0;
|
|
|
|
// get sliders for up/down/left/right connections
|
|
var connectionCount = (down: 0, up: 0, left: 0, right: 0);
|
|
foreach (var connection in connections) {
|
|
void Notify() => NeighborsChanged.Raise(this);
|
|
var map = GetNeighbor(connection, border);
|
|
var sourceMapInfo = (group, this.map);
|
|
|
|
if (connection.Direction == MapDirection.Up) {
|
|
connectionCount.up++;
|
|
yield return new ConnectionSlider(connection, sourceMapInfo, Notify, id, LeftRight, tutorials, right: map.LeftEdge, bottom: map.BottomEdge - tileSize);
|
|
yield return new ConnectionSlider(connection, sourceMapInfo, Notify, id + 1, LeftRight, tutorials, left: map.RightEdge, bottom: map.BottomEdge - tileSize);
|
|
}
|
|
|
|
if (connection.Direction == MapDirection.Down) {
|
|
connectionCount.down++;
|
|
yield return new ConnectionSlider(connection, sourceMapInfo, Notify, id, LeftRight, tutorials, right: map.LeftEdge, top: map.TopEdge + tileSize);
|
|
yield return new ConnectionSlider(connection, sourceMapInfo, Notify, id + 1, LeftRight, tutorials, left: map.RightEdge, top: map.TopEdge + tileSize);
|
|
}
|
|
|
|
if (connection.Direction == MapDirection.Left) {
|
|
connectionCount.left++;
|
|
yield return new ConnectionSlider(connection, sourceMapInfo, Notify, id, UpDown, tutorials, right: map.RightEdge - tileSize, bottom: map.TopEdge);
|
|
yield return new ConnectionSlider(connection, sourceMapInfo, Notify, id + 1, UpDown, tutorials, right: map.RightEdge - tileSize, top: map.BottomEdge);
|
|
}
|
|
|
|
if (connection.Direction == MapDirection.Right) {
|
|
connectionCount.right++;
|
|
yield return new ConnectionSlider(connection, sourceMapInfo, Notify, id, UpDown, tutorials, left: map.LeftEdge + tileSize, bottom: map.TopEdge);
|
|
yield return new ConnectionSlider(connection, sourceMapInfo, Notify, id + 1, UpDown, tutorials, left: map.LeftEdge + tileSize, top: map.BottomEdge);
|
|
}
|
|
|
|
id += 2;
|
|
}
|
|
|
|
// get sliders for size expansion
|
|
var centerX = (LeftEdge + RightEdge - MapSlider.SliderSize) / 2;
|
|
var centerY = (TopEdge + BottomEdge - MapSlider.SliderSize) / 2;
|
|
yield return new ExpansionSlider(ResizeMapData, id + 0, ExtendUp, GetConnectionCommands(connections, MapDirection.Up), left: centerX, bottom: TopEdge);
|
|
yield return new ExpansionSlider(ResizeMapData, id + 1, ExtendDown, GetConnectionCommands(connections, MapDirection.Down), left: centerX, top: BottomEdge);
|
|
yield return new ExpansionSlider(ResizeMapData, id + 2, ExtendLeft, GetConnectionCommands(connections, MapDirection.Left), right: LeftEdge, top: centerY);
|
|
yield return new ExpansionSlider(ResizeMapData, id + 3, ExtendRight, GetConnectionCommands(connections, MapDirection.Right), left: RightEdge, top: centerY);
|
|
}
|
|
|
|
private IEnumerable<IMenuCommand> GetConnectionCommands(IReadOnlyList<ConnectionModel> connections, MapDirection direction) {
|
|
var toRemove = new List<int>();
|
|
|
|
var info = CanConnect(direction);
|
|
if (info != null) {
|
|
if (info.Size > 3) {
|
|
// we can make a map here of width/height longestSpanLength
|
|
// and the offset is availableSpace[longestSpanStart]
|
|
yield return new MenuCommand<ConnectionInfo>("Create New Map", ConnectNewMap) { Parameter = info };
|
|
yield return new MenuCommand<ConnectionInfo>("Connect Existing Map", ConnectExistingMap) { Parameter = info };
|
|
} else if (info.Offset < 0) {
|
|
// we can make a map here of width/height 4
|
|
// and the offset is -3
|
|
yield return new MenuCommand<ConnectionInfo>("Create New Map", ConnectNewMap) { Parameter = info };
|
|
yield return new MenuCommand<ConnectionInfo>("Connect Existing Map", ConnectExistingMap) { Parameter = info };
|
|
} else {
|
|
// we can make a map here of width/height 4
|
|
// and the offset is dimensionLength-1
|
|
yield return new MenuCommand<ConnectionInfo>("Create New Map", ConnectNewMap) { Parameter = info };
|
|
yield return new MenuCommand<ConnectionInfo>("Connect Existing Map", ConnectExistingMap) { Parameter = info };
|
|
}
|
|
}
|
|
|
|
for (int i = 0; i < connections.Count; i++) {
|
|
if (connections[i].Direction != direction) continue;
|
|
toRemove.Add(i);
|
|
}
|
|
if (toRemove.Count > 0) {
|
|
// we can remove these connections
|
|
yield return new MenuCommand<IReadOnlyList<int>>("Remove Connections", RemoveConnections) { Parameter = toRemove };
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Work Methods
|
|
|
|
private IEnumerable<MapModel> GetAllMaps() {
|
|
foreach (var bank in model.GetTableModel(HardcodeTablesModel.MapBankTable)) {
|
|
if (bank == null) continue;
|
|
foreach (var mapList in bank.GetSubTable("maps")) {
|
|
if (mapList == null) continue;
|
|
var mapTable = mapList.GetSubTable("map");
|
|
if (mapTable == null) continue;
|
|
var map = mapTable[0];
|
|
yield return new(map);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void ResizeMapData(MapDirection direction, int amount) {
|
|
if (amount == 0) return;
|
|
var token = tokenFactory();
|
|
var map = GetMapModel();
|
|
var layout = GetLayout(map);
|
|
if (layout == null) return;
|
|
var run = model.GetNextRun(layout.GetAddress("blockmap")) as BlockmapRun;
|
|
if (run == null) return;
|
|
var borderWidth = layout.HasField("borderwidth") ? layout.GetValue("borderwidth") : 2;
|
|
var borderHeight = layout.HasField("borderheight") ? layout.GetValue("borderheight") : 2;
|
|
var newRun = run.TryChangeSize(tokenFactory, direction, amount, borderWidth, borderHeight);
|
|
if (newRun != null) {
|
|
var tileSize = (int)(16 * spriteScale);
|
|
if (direction == MapDirection.Left) LeftEdge -= amount * tileSize;
|
|
if (direction == MapDirection.Up) TopEdge -= amount * tileSize;
|
|
foreach (var connection in GetConnections(map, group, this.map)) {
|
|
if (direction == MapDirection.Left) {
|
|
if (connection.Direction == MapDirection.Down || connection.Direction == MapDirection.Up) {
|
|
connection.Offset += amount;
|
|
var inverse = connection.GetInverse();
|
|
if (inverse != null) inverse.Offset -= amount;
|
|
}
|
|
} else if (direction == MapDirection.Up) {
|
|
if (connection.Direction == MapDirection.Left || connection.Direction == MapDirection.Right) {
|
|
connection.Offset += amount;
|
|
var inverse = connection.GetInverse();
|
|
if (inverse != null) inverse.Offset -= amount;
|
|
}
|
|
}
|
|
}
|
|
foreach (var e in GetEvents()) {
|
|
if (direction == MapDirection.Left) {
|
|
e.X += amount;
|
|
} else if (direction == MapDirection.Up) {
|
|
e.Y += amount;
|
|
}
|
|
}
|
|
RefreshMapSize();
|
|
NeighborsChanged.Raise(this);
|
|
if (newRun.Start != run.Start) InformRepoint(new("Map", newRun.Start));
|
|
tutorials.Complete(Tutorial.DragConnectionButtons_ResizeMap);
|
|
}
|
|
}
|
|
|
|
private void ConnectNewMap(ConnectionInfo info) {
|
|
using (viewPort.ChangeHistory.ContinueCurrentTransaction()) {
|
|
var token = tokenFactory();
|
|
var mapBanks = new ModelTable(model, model.GetTable(HardcodeTablesModel.MapBankTable).Start, tokenFactory);
|
|
tutorials.Complete(Tutorial.RightClick_CreateConnection);
|
|
var option = MapRepointer.GetMapBankForNewMap(
|
|
"Maps are organized into banks. The game doesn't care, so you can use the banks however you like."
|
|
+ Environment.NewLine +
|
|
"Which map bank do you want to use for the new map?");
|
|
if (option == -1) return;
|
|
|
|
var map = GetMapModel();
|
|
|
|
var connections = GetOrCreateConnections(map, token);
|
|
var connectionsAndCount = map.GetSubTable("connections")[0];
|
|
|
|
var originalConnectionStart = connections.Start;
|
|
connections = model.RelocateForExpansion(token, connections, connections.Length + connections.ElementLength);
|
|
if (connections.Start != originalConnectionStart) InformRepoint(new("Connections", connections.Start));
|
|
connectionsAndCount.SetValue("count", connections.ElementCount + 1);
|
|
var table = new ModelTable(model, connections.Start, tokenFactory, connections);
|
|
var newConnection = new ConnectionModel(table[connections.ElementCount], group, this.map);
|
|
newConnection.Offset = info.Offset;
|
|
newConnection.Direction = info.Direction;
|
|
|
|
var (width, height) = (info.Size, info.Size);
|
|
var isZConnection = info.Direction.IsAny(MapDirection.Dive, MapDirection.Emerge);
|
|
if (isZConnection) height = info.Offset;
|
|
var otherMap = CreateNewMap(token, option, width, height);
|
|
|
|
newConnection.MapGroup = otherMap.group;
|
|
newConnection.MapNum = otherMap.map;
|
|
info = new ConnectionInfo(info.Size, isZConnection ? 0 : -info.Offset, info.OppositeDirection);
|
|
newConnection = otherMap.AddConnection(info);
|
|
newConnection.Offset = isZConnection ? 0 : info.Offset;
|
|
newConnection.MapGroup = MapID / 1000;
|
|
newConnection.MapNum = MapID % 1000;
|
|
|
|
RefreshMapSize();
|
|
NeighborsChanged.Raise(this);
|
|
}
|
|
viewPort.ChangeHistory.ChangeCompleted();
|
|
}
|
|
|
|
private BlockMapViewModel CreateNewMap(ModelDelta token, int bank, int width, int height) {
|
|
var mapTable = MapRepointer.AddNewMapToBank(bank);
|
|
var newMap = MapRepointer.CreateNewMap(token);
|
|
var layout = MapRepointer.CreateNewLayout(token);
|
|
|
|
// update width / height
|
|
model.WriteValue(token, layout.Element.Start + 0, width);
|
|
model.WriteValue(token, layout.Element.Start + 4, height);
|
|
|
|
layout.Element.SetAddress(Format.BlockMap, MapRepointer.CreateNewBlockMap(token, width, height));
|
|
|
|
newMap.Element.SetAddress(Format.Layout, layout.Element.Start);
|
|
model.UpdateArrayPointer(token, null, null, -1, mapTable.Start + mapTable.Length - 4, newMap.Element.Start);
|
|
|
|
var otherMap = new BlockMapViewModel(fileSystem, tutorials, viewPort, format, bank, mapTable.ElementCount - 1) {
|
|
allOverworldSprites = allOverworldSprites,
|
|
BerryInfo = BerryInfo,
|
|
};
|
|
otherMap.UpdateLayoutID();
|
|
return otherMap;
|
|
}
|
|
|
|
private void ConnectExistingMap(ConnectionInfo info) {
|
|
var token = tokenFactory();
|
|
|
|
// find available maps
|
|
var options = new Dictionary<int, ConnectionInfo>();
|
|
var table = model.GetTable(HardcodeTablesModel.MapBankTable);
|
|
var mapBanks = new ModelTable(model, table.Start, tokenFactory);
|
|
for (int group = 0; group < mapBanks.Count; group++) {
|
|
var bank = mapBanks[group];
|
|
var maps = bank.GetSubTable("maps");
|
|
for (int map = 0; map < maps.Count; map++) {
|
|
var mapVM = new BlockMapViewModel(fileSystem, tutorials, viewPort, format, group, map) {
|
|
allOverworldSprites = allOverworldSprites,
|
|
BerryInfo = BerryInfo,
|
|
};
|
|
var newInfo = mapVM.CanConnect(info.OppositeDirection);
|
|
if (newInfo != null) options[mapVM.MapID] = newInfo;
|
|
}
|
|
}
|
|
|
|
// select which map to add
|
|
var keys = options.Keys.ToList();
|
|
var enumViewModel = new EnumViewModel(keys.Select(key => MapIDToText(model, key)).ToArray());
|
|
|
|
tutorials.Complete(Tutorial.RightClick_CreateConnection);
|
|
var option = fileSystem.ShowOptions(
|
|
"Pick a map",
|
|
"Which map do you want to connect to?",
|
|
new[] { new[] { enumViewModel } },
|
|
new VisualOption { Index = 1, Option = "OK", ShortDescription = "Connect Existing Map" });
|
|
if (option == -1) return;
|
|
var choice = keys[enumViewModel.Choice];
|
|
|
|
var otherMap = new BlockMapViewModel(fileSystem, tutorials, viewPort, format, choice / 1000, choice % 1000) {
|
|
allOverworldSprites = allOverworldSprites,
|
|
BerryInfo = BerryInfo,
|
|
};
|
|
var size = GetBlockSize();
|
|
var otherSize = otherMap.GetBlockSize();
|
|
if (info.Direction.IsAny(MapDirection.Left, MapDirection.Right)) {
|
|
info = info with { Offset = info.Offset - (otherSize.height - info.Size) / 2 };
|
|
} else if (info.Direction.IsAny(MapDirection.Up, MapDirection.Down)) {
|
|
info = info with { Offset = info.Offset - (otherSize.width - info.Size) / 2 };
|
|
} else if (info.Direction.IsAny(MapDirection.Dive, MapDirection.Emerge)) {
|
|
info = info with { Offset = 0 };
|
|
}
|
|
|
|
var newConnection = AddConnection(info);
|
|
if (newConnection == null) return;
|
|
newConnection.Offset = info.Offset;
|
|
newConnection.Direction = info.Direction;
|
|
newConnection.MapGroup = choice / 1000;
|
|
newConnection.MapNum = choice % 1000;
|
|
|
|
info = options[choice];
|
|
if (info.Direction.IsAny(MapDirection.Dive, MapDirection.Emerge)) info = info with { Offset = 0 };
|
|
newConnection = otherMap.AddConnection(info);
|
|
newConnection.Offset = info.Offset;
|
|
newConnection.MapGroup = MapID / 1000;
|
|
newConnection.MapNum = MapID % 1000;
|
|
|
|
RefreshMapSize();
|
|
NeighborsChanged.Raise(this);
|
|
viewPort.ChangeHistory.ChangeCompleted();
|
|
}
|
|
|
|
private void RemoveConnections(IReadOnlyList<int> toRemove) {
|
|
var token = tokenFactory();
|
|
var map = GetMapModel();
|
|
var connections = GetConnections(map, group, this.map);
|
|
for (int i = 0; i < toRemove.Count; i++) {
|
|
for (int j = toRemove[i] - i + 1; j < connections.Count - i; j++) {
|
|
connections[j - 1].Direction = connections[j].Direction;
|
|
connections[j - 1].Offset = connections[j].Offset;
|
|
connections[j - 1].MapGroup = connections[j].MapGroup;
|
|
connections[j - 1].MapNum = connections[j].MapNum;
|
|
}
|
|
var connectionsTable = connections[0].Table;
|
|
if (connectionsTable.ElementCount == 1) {
|
|
Erase(connectionsTable, token);
|
|
} else {
|
|
var shorterTable = connectionsTable.Append(token, -1);
|
|
model.ObserveRunWritten(token, shorterTable);
|
|
}
|
|
}
|
|
var connectionsAndCount = map.GetSubTable("connections")[0];
|
|
connectionsAndCount.SetValue("count", connections.Count - toRemove.Count);
|
|
|
|
RefreshMapSize();
|
|
NeighborsChanged.Raise(this);
|
|
viewPort.ChangeHistory.ChangeCompleted();
|
|
}
|
|
|
|
private ConnectionModel AddConnection(ConnectionInfo info) {
|
|
var token = tokenFactory();
|
|
var map = GetMapModel();
|
|
|
|
var connections = GetOrCreateConnections(map, token);
|
|
if (connections == null) return null;
|
|
|
|
var count = connections.ElementCount;
|
|
connections = connections.Append(token, 1);
|
|
model.ObserveRunWritten(token, connections);
|
|
|
|
var table = new ModelTable(model, connections.Start, tokenFactory, connections);
|
|
var newConnection = new ConnectionModel(table[count], group, this.map);
|
|
token.ChangeData(model, table[count].Start, new byte[12]);
|
|
newConnection.Direction = info.Direction;
|
|
return newConnection;
|
|
}
|
|
|
|
private ITableRun GetOrCreateConnections(ModelArrayElement map, ModelDelta token) {
|
|
if (map == null) return null;
|
|
var connectionsAndCountTable = map.GetSubTable("connections");
|
|
if (connectionsAndCountTable == null) {
|
|
var newConnectionsAndCountTable = MapRepointer.CreateNewConnections(token);
|
|
model.UpdateArrayPointer(token, null, null, -1, map.Start + 12, newConnectionsAndCountTable);
|
|
connectionsAndCountTable = map.GetSubTable("connections");
|
|
}
|
|
var connectionsAndCount = connectionsAndCountTable[0];
|
|
|
|
ITableRun connections;
|
|
|
|
if (connectionsAndCount.GetValue("count") == 0) {
|
|
var newConnectionTableStart = model.FindFreeSpace(model.FreeSpaceStart, 12);
|
|
var childContent = ConnectionInfo.SingleConnectionContent;
|
|
var lengthToken = ConnectionInfo.SingleConnectionLength;
|
|
var childSegments = ArrayRun.ParseSegments(childContent, model);
|
|
var parentStrategy = TableStreamRun.ParseEndStream(model, "connections", lengthToken, childSegments, connectionsAndCountTable.Run.ElementContent);
|
|
connections = new TableStreamRun(model, newConnectionTableStart, SortedSpan.One(connectionsAndCount.Start + 4), $"[{childContent}]{lengthToken}", childSegments, parentStrategy, 0);
|
|
connectionsAndCount.SetAddress("connections", newConnectionTableStart);
|
|
InformCreate(new("Connection", newConnectionTableStart));
|
|
} else {
|
|
connections = connectionsAndCount.GetSubTable("connections").Run;
|
|
}
|
|
|
|
return connections;
|
|
}
|
|
|
|
public ObjectEventViewModel CreateObjectEvent(int graphics, int scriptAddress) {
|
|
var token = tokenFactory();
|
|
var map = GetMapModel();
|
|
if (map == null) return null;
|
|
var events = map.GetSubTable("events")[0];
|
|
var element = AddEvent(events, tokenFactory, "objectCount", "objects");
|
|
if (allOverworldSprites == null) allOverworldSprites = RenderOWs(model);
|
|
if (defaultOverworldSprite == null) defaultOverworldSprite = GetDefaultOW(model);
|
|
var newEvent = new ObjectEventViewModel(ViewPort.Tools.CodeTool.ScriptParser, GotoAddress, element, allOverworldSprites, defaultOverworldSprite, BerryInfo) {
|
|
X = 0, Y = 0,
|
|
Elevation = 0,
|
|
ObjectID = element.Table.ElementCount,
|
|
ScriptAddress = scriptAddress,
|
|
Graphics = graphics,
|
|
RangeX = 0,
|
|
RangeY = 0,
|
|
Flag = 0,
|
|
MoveType = 0,
|
|
TrainerType = 0,
|
|
TrainerRangeOrBerryID = 0,
|
|
};
|
|
newEvent.ClearUnused();
|
|
SelectedEvent = newEvent;
|
|
return newEvent;
|
|
}
|
|
|
|
public WarpEventViewModel CreateWarpEvent(int bank, int map) {
|
|
var mapModel = GetMapModel();
|
|
if (mapModel == null) return null;
|
|
var events = mapModel.GetSubTable("events")[0];
|
|
var element = AddEvent(events, tokenFactory, "warpCount", "warps");
|
|
var newEvent = new WarpEventViewModel(element) { X = 0, Y = 0, Elevation = 0, Bank = bank, Map = map, WarpID = element.ArrayIndex + 1 };
|
|
SelectedEvent = newEvent;
|
|
return newEvent;
|
|
}
|
|
|
|
public ScriptEventViewModel CreateScriptEvent() {
|
|
var map = GetMapModel();
|
|
if (map == null) return null;
|
|
var events = map.GetSubTable("events")[0];
|
|
var element = AddEvent(events, tokenFactory, "scriptCount", "scripts");
|
|
var newEvent = new ScriptEventViewModel(GotoAddress, element) { X = 0, Y = 0, Elevation = 0, Index = 0, Trigger = 0, ScriptAddress = Pointer.NULL };
|
|
SelectedEvent = newEvent;
|
|
return newEvent;
|
|
}
|
|
|
|
public SignpostEventViewModel CreateSignpostEvent() {
|
|
var map = GetMapModel();
|
|
if (map == null) return null;
|
|
var events = map.GetSubTable("events")[0];
|
|
var element = AddEvent(events, tokenFactory, "signpostCount", "signposts");
|
|
var newEvent = new SignpostEventViewModel(element, GotoAddress) { X = 0, Y = 0, Elevation = 0, Kind = 0, Pointer = Pointer.NULL };
|
|
SelectedEvent = newEvent;
|
|
return newEvent;
|
|
}
|
|
|
|
public bool CanCreateFlyEvent {
|
|
get {
|
|
var map = GetMapModel();
|
|
if (map == null) return false;
|
|
var region = map.GetValue(Format.RegionSection);
|
|
if (model.IsFRLG()) region -= 88;
|
|
var connections = model.GetTableModel(HardcodeTablesModel.FlyConnections);
|
|
if (region < 0 || region >= connections.Count) return false;
|
|
return connections[region].GetValue("flight") == 0;
|
|
}
|
|
}
|
|
|
|
public FlyEventViewModel CreateFlyEvent() {
|
|
var map = GetMapModel();
|
|
var region = map.GetValue(Format.RegionSection);
|
|
if (model.IsFRLG()) region -= 88;
|
|
var connections = model.GetTableModel(HardcodeTablesModel.FlyConnections, tokenFactory);
|
|
if (region < 0 || region >= connections.Count) return null;
|
|
var flight = connections[region].GetValue("flight");
|
|
if (flight != 0) return null;
|
|
var spawns = model.GetTableModel(HardcodeTablesModel.FlySpawns, tokenFactory);
|
|
|
|
// hunt for an available spawn location
|
|
var emptySpawn = -1;
|
|
for (int i = 0; i < spawns.Count; i++) {
|
|
if (spawns[i].GetValue("x") == 0 && spawns[i].GetValue("y") == 0 && spawns[i].GetValue("bank") == 0 && spawns[i].GetValue("map") == 0) {
|
|
emptySpawn = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// if there were no empty entries in the table, add a new one
|
|
if (emptySpawn == -1) {
|
|
var newSpawns = model.RelocateForExpansion(tokenFactory(), spawns.Run, spawns.Run.Length + spawns.Run.ElementLength);
|
|
newSpawns = newSpawns.Append(tokenFactory(), 1);
|
|
model.ObserveRunWritten(tokenFactory(), newSpawns);
|
|
if (newSpawns.Start != spawns.Run.Start) InformRepoint(new("Fly Spawns", newSpawns.Start));
|
|
spawns = new ModelTable(model, newSpawns, tokenFactory);
|
|
emptySpawn = spawns.Count - 1;
|
|
}
|
|
|
|
// update the connections and spawn table
|
|
connections[region].SetValue("flight", emptySpawn + 1);
|
|
connections[region].SetValue("bank", group);
|
|
connections[region].SetValue("map", this.map);
|
|
spawns[emptySpawn].SetValue("bank", group);
|
|
spawns[emptySpawn].SetValue("map", this.map);
|
|
|
|
NotifyPropertyChanged(nameof(CanCreateFlyEvent));
|
|
return new FlyEventViewModel(spawns[emptySpawn], group, this.map, emptySpawn + 1);
|
|
}
|
|
|
|
// TODO use this for connections as well, since the structure is the same
|
|
public ModelArrayElement AddEvent(ModelArrayElement events, Func<ModelDelta> tokenFactory, string countName, string fieldName) {
|
|
var model = events.Model;
|
|
var count = events.GetValue(countName);
|
|
var elementTable = events.GetSubTable(fieldName)?.Run;
|
|
if (count == 0 || elementTable == null) {
|
|
var segment = (ArrayRunPointerSegment)events.Table.ElementContent.Single(seg => seg.Name == fieldName);
|
|
var divider = segment.InnerFormat.LastIndexOf("/");
|
|
var newTableStart = model.FindFreeSpace(model.FreeSpaceStart, 24);
|
|
var childContent = segment.InnerFormat.Substring(0, divider);
|
|
childContent = childContent.Substring(1, childContent.Length - 2);
|
|
var lengthToken = segment.InnerFormat.Substring(divider);
|
|
var childSegments = ArrayRun.ParseSegments(childContent, model);
|
|
var parentStrategy = TableStreamRun.ParseEndStream(model, fieldName, lengthToken, childSegments, events.Table.ElementContent);
|
|
elementTable = new TableStreamRun(model, newTableStart, SortedSpan.One(events.Table.ElementContent.Until(seg => seg.Name == fieldName).Sum(seg => seg.Length) + events.Table.Start), segment.InnerFormat, childSegments, parentStrategy, 0);
|
|
events.SetAddress(fieldName, newTableStart);
|
|
}
|
|
var token = tokenFactory();
|
|
var newRun = elementTable.Append(token, 1);
|
|
model.ObserveRunWritten(token, newRun);
|
|
if (newRun.Start != elementTable.Start) InformRepoint(new(fieldName, newRun.Start));
|
|
return new ModelArrayElement(model, newRun.Start, newRun.ElementCount - 1, tokenFactory, newRun);
|
|
}
|
|
|
|
private void Erase(ITableRun table, ModelDelta token) {
|
|
foreach (var source in table.PointerSources) {
|
|
model.ClearPointer(token, source, table.Start);
|
|
model.WritePointer(token, source, Pointer.NULL);
|
|
}
|
|
model.ClearData(token, table.Start, table.Length);
|
|
}
|
|
|
|
private void UpdateLayoutID() {
|
|
// step 1: test if we need to update the layout id
|
|
var layoutTable = model.GetTable(HardcodeTablesModel.MapLayoutTable);
|
|
var map = GetMapModel();
|
|
var layoutID = map.GetValue("layoutID") - 1;
|
|
var addressFromMap = map.GetAddress("layout");
|
|
var addressFromTable = model.ReadPointer(layoutTable.Start + layoutTable.ElementLength * layoutID);
|
|
if (addressFromMap == addressFromTable) return;
|
|
|
|
var matches = layoutTable.ElementCount.Range().Where(i => model.ReadPointer(layoutTable.Start + layoutTable.ElementLength * i) == addressFromMap).ToList();
|
|
var token = tokenFactory();
|
|
if (matches.Count == 0) {
|
|
var originalLayoutTableStart = layoutTable.Start;
|
|
layoutTable = model.RelocateForExpansion(token, layoutTable, layoutTable.Length + 4);
|
|
layoutTable = layoutTable.Append(token, 1);
|
|
model.ObserveRunWritten(token, layoutTable);
|
|
model.UpdateArrayPointer(token, layoutTable.ElementContent[0], layoutTable.ElementContent, -1, layoutTable.Start + layoutTable.ElementLength * (layoutTable.ElementCount - 1), addressFromMap);
|
|
if (originalLayoutTableStart != layoutTable.Start) InformRepoint(new("Layout Table", layoutTable.Start));
|
|
matches.Add(layoutTable.ElementCount - 1);
|
|
}
|
|
map.SetValue("layoutID", matches[0] + 1);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Helper Methods
|
|
|
|
private (int width, int height) GetBlockSize(ModelArrayElement layout = null) {
|
|
var border = GetBorderThickness(layout);
|
|
if (border == null) return (0, 0);
|
|
return (pixelWidth / 16 - border.West - border.East, pixelHeight / 16 - border.North - border.South);
|
|
}
|
|
|
|
private BlockMapViewModel GetNeighbor(ConnectionModel connection, Border border) {
|
|
var vm = new BlockMapViewModel(fileSystem, tutorials, viewPort, format, connection.MapGroup, connection.MapNum) {
|
|
IncludeBorders = IncludeBorders,
|
|
SpriteScale = SpriteScale,
|
|
allOverworldSprites = allOverworldSprites,
|
|
BerryInfo = BerryInfo,
|
|
CollisionHighlight = CollisionHighlight,
|
|
};
|
|
var (n, _, _, w) = vm.GetBorderThickness();
|
|
vm.TopEdge = TopEdge + (connection.Offset + border.North - n) * (int)(16 * SpriteScale);
|
|
vm.LeftEdge = LeftEdge + (connection.Offset + border.West - w) * (int)(16 * SpriteScale);
|
|
if (connection.Direction == MapDirection.Left) vm.LeftEdge = LeftEdge - (int)(vm.PixelWidth * SpriteScale);
|
|
if (connection.Direction == MapDirection.Right) vm.LeftEdge = LeftEdge + (int)(PixelWidth * SpriteScale);
|
|
if (connection.Direction == MapDirection.Up) vm.TopEdge = TopEdge - (int)(vm.PixelHeight * SpriteScale);
|
|
if (connection.Direction == MapDirection.Down) vm.TopEdge = TopEdge + (int)(PixelHeight * SpriteScale);
|
|
vm.ZIndex = ZIndex;
|
|
if (connection.Direction.IsAny(MapDirection.Dive, MapDirection.Emerge)) vm.ZIndex = ZIndex - 1;
|
|
return vm;
|
|
}
|
|
|
|
private void RefreshPaletteCache(ModelArrayElement layout = null, BlocksetModel blockModel1 = null, BlocksetModel blockModel2 = null) {
|
|
if (blockModel1 == null || blockModel2 == null) {
|
|
if (layout == null) layout = GetLayout();
|
|
if (blockModel1 == null) blockModel1 = new BlocksetModel(model, layout.GetAddress(Format.PrimaryBlockset));
|
|
if (blockModel2 == null) blockModel2 = new BlocksetModel(model, layout.GetAddress(Format.SecondaryBlockset));
|
|
}
|
|
|
|
palettes = BlockmapRun.ReadPalettes(blockModel1, blockModel2, PrimaryPalettes);
|
|
}
|
|
|
|
private void RefreshTileCache(ModelArrayElement layout = null, BlocksetModel blockModel1 = null, BlocksetModel blockModel2 = null) {
|
|
if (blockModel1 == null || blockModel2 == null) {
|
|
if (layout == null) layout = GetLayout();
|
|
if (blockModel1 == null) blockModel1 = new BlocksetModel(model, layout.GetAddress("blockdata1"));
|
|
if (blockModel2 == null) blockModel2 = new BlocksetModel(model, layout.GetAddress("blockdata2"));
|
|
}
|
|
|
|
tiles = BlockmapRun.ReadTiles(blockModel1, blockModel2, PrimaryTiles);
|
|
}
|
|
|
|
private void RefreshBlockCache(ModelArrayElement layout = null, BlocksetModel blockModel1 = null, BlocksetModel blockModel2 = null) {
|
|
if (layout == null) layout = GetLayout();
|
|
if (blockModel1 == null || blockModel2 == null) {
|
|
if (blockModel1 == null) blockModel1 = new BlocksetModel(model, layout.GetAddress(Format.PrimaryBlockset));
|
|
if (blockModel2 == null) blockModel2 = new BlocksetModel(model, layout.GetAddress(Format.SecondaryBlockset));
|
|
}
|
|
int width = layout.GetValue("width"), height = layout.GetValue("height");
|
|
int start = layout.GetAddress(Format.BlockMap);
|
|
var maxUsedPrimary = BlockmapRun.GetMaxUsedBlock(model, start, width, height, PrimaryBlocks);
|
|
var maxUsedSecondary = BlockmapRun.GetMaxUsedBlock(model, start, width, height, 1024) - PrimaryBlocks;
|
|
|
|
blocks = BlockmapRun.ReadBlocks(maxUsedPrimary, maxUsedSecondary, blockModel1, blockModel2);
|
|
}
|
|
|
|
private void RefreshBlockAttributeCache(ModelArrayElement layout = null, BlocksetModel blockModel1 = null, BlocksetModel blockModel2 = null) {
|
|
if (blockModel1 == null || blockModel2 == null) {
|
|
if (layout == null) layout = GetLayout();
|
|
if (blockModel1 == null) blockModel1 = new BlocksetModel(model, layout.GetAddress("blockdata1"));
|
|
if (blockModel2 == null) blockModel2 = new BlocksetModel(model, layout.GetAddress("blockdata2"));
|
|
}
|
|
int width = layout.GetValue("width"), height = layout.GetValue("height");
|
|
int start = layout.GetAddress(Format.BlockMap);
|
|
var maxUsedPrimary = BlockmapRun.GetMaxUsedBlock(model, start, width, height, PrimaryBlocks);
|
|
var maxUsedSecondary = BlockmapRun.GetMaxUsedBlock(model, start, width, height, 1024) - PrimaryBlocks;
|
|
|
|
blockAttributes = BlockmapRun.ReadBlockAttributes(maxUsedPrimary, maxUsedSecondary, blockModel1, blockModel2);
|
|
}
|
|
|
|
private void RefreshBlockRenderCache(ModelArrayElement layout = null, BlocksetModel blockModel1 = null, BlocksetModel blockModel2 = null) {
|
|
if (blocks == null || tiles == null || palettes == null) {
|
|
if (layout == null) layout = GetLayout();
|
|
if (layout == null) return;
|
|
if (blockModel1 == null) blockModel1 = new BlocksetModel(model, layout.GetAddress(Format.PrimaryBlockset));
|
|
if (blockModel2 == null) blockModel2 = new BlocksetModel(model, layout.GetAddress(Format.SecondaryBlockset));
|
|
}
|
|
if (blocks == null) RefreshBlockCache(layout, blockModel1, blockModel2);
|
|
if (tiles == null) RefreshTileCache(layout, blockModel1, blockModel2);
|
|
if (palettes == null) RefreshPaletteCache(layout, blockModel1, blockModel2);
|
|
|
|
lock (blockRenders) {
|
|
blockRenders.Clear();
|
|
blockRenders.AddRange(BlockmapRun.CalculateBlockRenders(blocks, tiles, palettes));
|
|
}
|
|
}
|
|
|
|
private void RefreshMapSize() {
|
|
var layout = GetLayout();
|
|
if (layout == null) return;
|
|
var (width, height) = (layout.GetValue("width"), layout.GetValue("height"));
|
|
var border = GetBorderThickness(layout);
|
|
(pixelWidth, pixelHeight) = ((width + border.West + border.East) * 16, (height + border.North + border.South) * 16);
|
|
ClearPixelCache();
|
|
}
|
|
|
|
private void RefreshMapEvents() {
|
|
if (eventRenders != null) return;
|
|
var list = new List<IEventViewModel>();
|
|
var events = GetEvents();
|
|
foreach (var obj in events) {
|
|
obj.Render(model);
|
|
list.Add(obj);
|
|
}
|
|
eventRenders = list;
|
|
}
|
|
|
|
private void FillMapPixelData() {
|
|
var layout = GetLayout();
|
|
if (layout == null) return;
|
|
lock (blockRenders) {
|
|
if (blockRenders.Count == 0) RefreshBlockRenderCache(layout);
|
|
}
|
|
if (borderBlock == null) RefreshBorderRender();
|
|
var (width, height) = (layout.GetValue("width"), layout.GetValue("height"));
|
|
var border = GetBorderThickness(layout);
|
|
var start = layout.GetAddress("blockmap");
|
|
|
|
var canvas = new CanvasPixelViewModel(pixelWidth, pixelHeight);
|
|
var (borderWidth, borderHeight) = (borderBlock.PixelWidth / 16, borderBlock.PixelHeight / 16);
|
|
for (int y = 0; y < height + border.North + border.South; y++) {
|
|
for (int x = 0; x < width + border.West + border.East; x++) {
|
|
if (y < border.North || x < border.West || y >= border.North + height || x >= border.West + width) {
|
|
var (xEdge, yEdge) = (x - border.West - width, y - border.North - height);
|
|
var (rightEdge, bottomEdge) = (xEdge >= 0, yEdge >= 0);
|
|
// top/left
|
|
if (!rightEdge && !bottomEdge && x % borderWidth == 0 && y % borderHeight == 0) canvas.Draw(borderBlock, x * 16, y * 16);
|
|
// right edge
|
|
if (rightEdge && !bottomEdge && xEdge % borderWidth == 0 && y % borderHeight == 0) canvas.Draw(borderBlock, x * 16, y * 16);
|
|
// bottom edge
|
|
if (!rightEdge && bottomEdge && x % borderWidth == 0 && yEdge % borderHeight == 0) canvas.Draw(borderBlock, x * 16, y * 16);
|
|
// bottom right corner
|
|
if (rightEdge && bottomEdge && xEdge % borderWidth == 0 && yEdge % borderHeight == 0) canvas.Draw(borderBlock, x * 16, y * 16);
|
|
continue;
|
|
}
|
|
var data = model.ReadMultiByteValue(start + ((y - border.North) * width + x - border.West) * 2, 2);
|
|
var collision = data >> 10;
|
|
data &= 0x3FF;
|
|
if (blockRenders.Count > data) canvas.Draw(blockRenders[data], x * 16, y * 16);
|
|
if (collision == collisionHighlight) HighlightCollision(canvas.PixelData, x * 16, y * 16);
|
|
if (collisionHighlight == -1 && selectedEvent is ObjectEventViewModel obj && obj.ShouldHighlight(x - border.West, y - border.North)) {
|
|
HighlightCollision(canvas.PixelData, x * 16, y * 16);
|
|
}
|
|
}
|
|
}
|
|
|
|
// draw the box for the selected event
|
|
var gray = UncompressedPaletteColor.Pack(6, 6, 6);
|
|
if (selectedEvent != null && selectedEvent.X >= 0 && selectedEvent.X < width && selectedEvent.Y >= 0 && SelectedEvent.Y < height) {
|
|
canvas.DrawBox((selectedEvent.X + border.West) * 16, (selectedEvent.Y + border.North) * 16, 16, gray);
|
|
}
|
|
|
|
// now draw the events on top
|
|
if (eventRenders == null) RefreshMapEvents();
|
|
if (eventRenders != null) {
|
|
foreach (var obj in eventRenders) {
|
|
if (obj.EventRender != null) {
|
|
var (x, y) = ((obj.X + border.West) * 16 + obj.LeftOffset, (obj.Y + border.North) * 16 + obj.TopOffset);
|
|
canvas.Draw(obj.EventRender, x, y);
|
|
}
|
|
}
|
|
}
|
|
|
|
// finally, draw a one-pixel border around the entire map (but not the border blocks)
|
|
if (isSelected) {
|
|
var (borderW, borderH) = (border.West + border.East, border.North + border.South);
|
|
canvas.DarkenRect(border.West * 16, border.North * 16, pixelWidth - borderW * 16, pixelHeight - borderH * 16, 12);
|
|
}
|
|
|
|
pixelData = canvas.PixelData;
|
|
}
|
|
|
|
private void HighlightCollision(short[] pixelData, int x, int y) {
|
|
void Transform(int xx, int yy) {
|
|
var p = (y + yy) * PixelWidth + x + xx;
|
|
pixelData[p] = CanvasPixelViewModel.Darken(pixelData[p], 8);
|
|
}
|
|
for (int i = 0; i < 15; i++) {
|
|
Transform(i, 0);
|
|
Transform(15 - i, 15);
|
|
Transform(0, 15 - i);
|
|
Transform(15, i);
|
|
}
|
|
}
|
|
|
|
public const int BlocksPerRow = 8;
|
|
private void FillBlockPixelData() {
|
|
var layout = GetLayout();
|
|
lock (blockRenders) {
|
|
if (blockRenders.Count == 0) RefreshBlockRenderCache(layout);
|
|
}
|
|
|
|
var blockHeight = (int)Math.Ceiling((double)blockRenders.Count / BlocksPerRow);
|
|
var canvas = new CanvasPixelViewModel(BlocksPerRow * 16, blockHeight * 16) { SpriteScale = 2 };
|
|
|
|
for (int y = 0; y < blockHeight; y++) {
|
|
for (int x = 0; x < BlocksPerRow; x++) {
|
|
if (blockRenders.Count <= y * BlocksPerRow + x) break;
|
|
canvas.Draw(blockRenders[y * BlocksPerRow + x], x * 16, y * 16);
|
|
}
|
|
}
|
|
|
|
blockPixels = canvas;
|
|
}
|
|
|
|
private void RefreshBorderRender(ModelArrayElement layout = null) {
|
|
if (layout == null) layout = GetLayout();
|
|
lock (blockRenders) {
|
|
if (blockRenders.Count == 0) RefreshBlockRenderCache(layout);
|
|
}
|
|
var width = layout.HasField("borderwidth") ? layout.GetValue("borderwidth") : 2;
|
|
var height = layout.HasField("borderheight") ? layout.GetValue("borderheight") : 2;
|
|
|
|
var start = layout.GetAddress("borderblock");
|
|
var canvas = new CanvasPixelViewModel(width * 16, height * 16);
|
|
for (int y = 0; y < height; y++) {
|
|
for (int x = 0; x < width; x++) {
|
|
var data = model.ReadMultiByteValue(start + (y * width + x) * 2, 2);
|
|
data &= 0x3FF;
|
|
canvas.Draw(blockRenders[data], x * 16, y * 16);
|
|
}
|
|
}
|
|
|
|
BorderBlock = canvas;
|
|
}
|
|
|
|
private ModelArrayElement GetMapModel() => GetMapModel(model, group, map, tokenFactory);
|
|
public static ModelArrayElement GetMapModel(IDataModel model, int group, int map, Func<ModelDelta> tokenFactory) {
|
|
var table = model.GetTable(HardcodeTablesModel.MapBankTable);
|
|
if (table == null) return null;
|
|
var mapBanks = new ModelTable(model, table.Start, tokenFactory);
|
|
if (mapBanks.Count <= group) return null;
|
|
var bank = mapBanks[group]?.GetSubTable("maps");
|
|
if (bank == null) return null;
|
|
if (bank.Count <= map) return null;
|
|
var mapTable = bank[map]?.GetSubTable("map");
|
|
if (mapTable == null) return null;
|
|
return mapTable[0];
|
|
}
|
|
|
|
public ModelArrayElement GetLayout(ModelArrayElement map = null) {
|
|
if (map == null) map = GetMapModel();
|
|
if (map == null) return null;
|
|
var layout = map.GetSubTable("layout");
|
|
if (layout == null) return null;
|
|
return layout[0];
|
|
}
|
|
|
|
private IReadOnlyList<ConnectionModel> GetConnections() {
|
|
var map = GetMapModel(model, group, this.map, tokenFactory);
|
|
return GetConnections(map, group, this.map);
|
|
}
|
|
public static IReadOnlyList<ConnectionModel> GetConnections(ModelArrayElement map, int bankNum, int mapNum) {
|
|
if (map == null) return null;
|
|
var connectionsAndCountTable = map.GetSubTable("connections");
|
|
var list = new List<ConnectionModel>();
|
|
if (connectionsAndCountTable == null) return list;
|
|
var connectionsAndCount = connectionsAndCountTable[0];
|
|
var count = connectionsAndCount.GetValue("count");
|
|
if (count == 0) return list;
|
|
var connections = connectionsAndCount.GetSubTable("connections");
|
|
if (connections == null) return new ConnectionModel[0];
|
|
for (int i = 0; i < count; i++) list.Add(new(connections[i], bankNum, mapNum));
|
|
return list;
|
|
}
|
|
|
|
private IPixelViewModel defaultOverworldSprite;
|
|
private IReadOnlyList<IPixelViewModel> allOverworldSprites;
|
|
public IReadOnlyList<IPixelViewModel> AllOverworldSprites {
|
|
get {
|
|
if (allOverworldSprites == null) allOverworldSprites = RenderOWs(model);
|
|
return allOverworldSprites;
|
|
}
|
|
init => allOverworldSprites = value;
|
|
}
|
|
public static IPixelViewModel GetDefaultOW(IDataModel model) {
|
|
var defaultSpriteAddress = model.GetAddressFromAnchor(new NoDataChangeDeltaModel(), -1, HardcodeTablesModel.PokeIconsTable + "/0/icon/");
|
|
var defaultSpriteRun = model.GetNextRun(defaultSpriteAddress) as ISpriteRun;
|
|
var defaultImage = defaultSpriteRun == null ? new ReadonlyPixelViewModel(16, 16) : model.CurrentCacheScope.GetImage(defaultSpriteRun);
|
|
if (defaultImage.PixelHeight > 24) {
|
|
var canvas = new CanvasPixelViewModel(defaultImage.PixelWidth, 24) { Transparent = defaultImage.PixelData[0] };
|
|
canvas.Draw(defaultImage, 0, 24 - Math.Min(32, defaultImage.PixelHeight));
|
|
defaultImage = canvas;
|
|
}
|
|
return defaultImage;
|
|
}
|
|
public static List<IPixelViewModel> RenderOWs(IDataModel model) {
|
|
var list = new List<IPixelViewModel>();
|
|
var run = model.GetTable(HardcodeTablesModel.OverworldSprites);
|
|
var ows = new ModelTable(model, run.Start, null, run);
|
|
var defaultImage = GetDefaultOW(model);
|
|
for (int i = 0; i < ows.Count; i++) {
|
|
list.Add(ObjectEventViewModel.Render(model, ows, defaultImage, i, 0));
|
|
}
|
|
return list;
|
|
}
|
|
|
|
private IReadOnlyList<IEventViewModel> GetEvents() {
|
|
if (allOverworldSprites == null) allOverworldSprites = RenderOWs(model);
|
|
if (defaultOverworldSprite == null) defaultOverworldSprite = GetDefaultOW(model);
|
|
var map = GetMapModel();
|
|
var results = new List<IEventViewModel>();
|
|
var eventsTable = map.GetSubTable("events");
|
|
if (eventsTable == null) return results;
|
|
var eventElements = eventsTable[0];
|
|
if (eventElements == null) return results;
|
|
var events = new EventGroupModel(ViewPort.Tools.CodeTool.ScriptParser, GotoAddress, eventElements, allOverworldSprites, defaultOverworldSprite, BerryInfo, group, this.map);
|
|
events.DataMoved += HandleEventDataMoved;
|
|
results.AddRange(events.Objects);
|
|
results.AddRange(events.Warps);
|
|
results.AddRange(events.Scripts);
|
|
results.AddRange(events.Signposts);
|
|
results.AddRange(events.FlyEvents);
|
|
return results;
|
|
}
|
|
|
|
public Border GetBorderThickness(ModelArrayElement layout = null) {
|
|
if (!includeBorders) return new(0, 0, 0, 0);
|
|
var connections = GetConnections();
|
|
if (connections == null) return null;
|
|
if (layout == null) layout = GetLayout();
|
|
var width = layout.HasField("borderwidth") ? layout.GetValue("borderwidth") : 2;
|
|
var height = layout.HasField("borderheight") ? layout.GetValue("borderheight") : 2;
|
|
var (east, west) = (width, width);
|
|
var (north, south) = (height, height);
|
|
var directions = connections.Select(c => c.Direction).ToList();
|
|
if (directions.Contains(MapDirection.Down)) south = 0;
|
|
if (directions.Contains(MapDirection.Up)) north = 0;
|
|
if (directions.Contains(MapDirection.Left)) west = 0;
|
|
if (directions.Contains(MapDirection.Right)) east = 0;
|
|
return new(north, east, south, west);
|
|
}
|
|
|
|
private ConnectionInfo CanConnect(MapDirection direction) {
|
|
var connections = GetConnections();
|
|
var (width, height) = (pixelWidth / 16, pixelHeight / 16);
|
|
var dimensionLength = (direction switch {
|
|
MapDirection.Up => width,
|
|
MapDirection.Down => width,
|
|
MapDirection.Left => height,
|
|
MapDirection.Right => height,
|
|
MapDirection.Dive => 0,
|
|
MapDirection.Emerge => 0,
|
|
_ => throw new NotImplementedException(),
|
|
});
|
|
var availableSpace = dimensionLength.Range().ToList();
|
|
|
|
// can't add a connection where there already is one
|
|
for (int i = 0; i < (connections?.Count ?? 0); i++) {
|
|
if (connections[i].Direction != direction) continue;
|
|
if (direction == MapDirection.Up || direction == MapDirection.Down) {
|
|
var map = new BlockMapViewModel(fileSystem, tutorials, viewPort, format, connections[i].MapGroup, connections[i].MapNum) {
|
|
allOverworldSprites = allOverworldSprites,
|
|
BerryInfo = BerryInfo,
|
|
};
|
|
var removeWidth = map.pixelWidth / 16;
|
|
var removeOffset = connections[i].Offset;
|
|
foreach (int j in removeWidth.Range()) availableSpace.Remove(j + removeOffset);
|
|
} else if (direction == MapDirection.Left || direction == MapDirection.Right) {
|
|
var map = new BlockMapViewModel(fileSystem, tutorials, viewPort, format, connections[i].MapGroup, connections[i].MapNum) {
|
|
allOverworldSprites = allOverworldSprites,
|
|
BerryInfo = BerryInfo,
|
|
};
|
|
var removeHeight = map.pixelHeight / 16;
|
|
var removeOffset = connections[i].Offset;
|
|
foreach (int j in removeHeight.Range()) availableSpace.Remove(j + removeOffset);
|
|
} else if (direction.IsAny(MapDirection.Dive, MapDirection.Emerge)) {
|
|
// can't dive or emerge to a map that already has a dive/emerge
|
|
var map = AllMapsModel.Create(model, tokenFactory)[connections[i].MapGroup][connections[i].MapNum];
|
|
if (map.Connections.Any(c => c.Direction.IsAny(MapDirection.Emerge, MapDirection.Dive))) return null;
|
|
}
|
|
}
|
|
|
|
if (direction.IsAny(MapDirection.Dive, MapDirection.Emerge)) {
|
|
var layout = AllMapsModel.Create(model, tokenFactory)[group][map].Layout;
|
|
return new ConnectionInfo(layout.Width, layout.Height, direction);
|
|
}
|
|
|
|
// find the longest stretch of available space
|
|
var longestSpanLength = 0;
|
|
var longestSpanStart = -1;
|
|
var spanLength = 0;
|
|
var spanStart = -1;
|
|
for (int j = 0; j < availableSpace.Count; j++) {
|
|
if (spanStart == -1) {
|
|
(spanStart, spanLength) = (j, 1);
|
|
} else if (availableSpace[j - 1] + 1 == availableSpace[j]) {
|
|
spanLength++;
|
|
} else {
|
|
if (spanLength > longestSpanLength) (longestSpanStart, longestSpanLength) = (spanStart, spanLength);
|
|
(spanStart, spanLength) = (j, 1);
|
|
}
|
|
}
|
|
|
|
if (spanLength > longestSpanLength) (longestSpanStart, longestSpanLength) = (spanStart, spanLength);
|
|
|
|
// if a long space is availabe, we can connect to it
|
|
// otherwise, we could technically connect to an edge
|
|
if (longestSpanLength > 3) {
|
|
// we can make a map here of width/height longestSpanLength
|
|
// and the offset is availableSpace[longestSpanStart]
|
|
return new ConnectionInfo(longestSpanLength, availableSpace[longestSpanStart], direction);
|
|
} else if (availableSpace.Contains(0)) {
|
|
// we can make a map here of width/height 4
|
|
// and the offset is -3
|
|
return new ConnectionInfo(4, -3, direction);
|
|
} else if (availableSpace.Contains(dimensionLength - 1)) {
|
|
// we can make a map here of width/height 4
|
|
// and the offset is dimensionLength-1
|
|
return new ConnectionInfo(4, dimensionLength - 1, direction);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
private void WritePointerAndSource(ModelDelta token, int source, int destination) {
|
|
model.WritePointer(token, source, destination);
|
|
model.ObserveRunWritten(token, NoInfoRun.FromPointer(model, source));
|
|
}
|
|
|
|
private void GotoAddress(int address) {
|
|
if (model.GetNextRun(address).Start > address) {
|
|
viewPort.Tools.SelectedTool = viewPort.Tools.CodeTool;
|
|
viewPort.Tools.CodeTool.Mode = CodeMode.Script;
|
|
}
|
|
viewPort.Goto.Execute(address);
|
|
}
|
|
|
|
private void HandleBlocksChanged(object sender, byte[][] blocks) {
|
|
var layout = GetLayout();
|
|
var blockModel1 = new BlocksetModel(model, layout.GetAddress("blockdata1"));
|
|
var blockModel2 = new BlocksetModel(model, layout.GetAddress("blockdata2"));
|
|
BlockmapRun.WriteBlocks(tokenFactory(), blockModel1, blockModel2, blocks);
|
|
viewPort.ChangeHistory.ChangeCompleted();
|
|
RequestClearMapCaches.Raise(this);
|
|
}
|
|
|
|
private void HandleBorderChanged(object sender, EventArgs e) {
|
|
blocks = null;
|
|
lock (blockRenders) {
|
|
blockRenders.Clear();
|
|
}
|
|
blockPixels = null;
|
|
borderBlock = null;
|
|
ClearPixelCache();
|
|
NotifyPropertiesChanged(nameof(BlockPixels), nameof(BlockRenders), nameof(BorderBlock));
|
|
}
|
|
|
|
private void HandleBlockAttributesChanged(object sender, byte[][] attributes) {
|
|
var layout = GetLayout();
|
|
var blockModel1 = new BlocksetModel(model, layout.GetAddress("blockdata1"));
|
|
var blockModel2 = new BlocksetModel(model, layout.GetAddress("blockdata2"));
|
|
BlockmapRun.WriteBlockAttributes(tokenFactory(), blockModel1, blockModel2, attributes);
|
|
}
|
|
|
|
private void HandleAutoscrollTiles(object sender, EventArgs e) => AutoscrollTiles.Raise(this);
|
|
|
|
private void HandleEventDataMoved(object sender, DataMovedEventArgs e) => InformRepoint(e);
|
|
|
|
public static string MapIDToText(IDataModel model, int id) {
|
|
var group = id / 1000;
|
|
var map = id % 1000;
|
|
return MapIDToText(model, group, map);
|
|
}
|
|
|
|
public static string MapIDToText(IDataModel model, int group, int map){
|
|
var offset = model.IsFRLG() ? 0x58 : 0;
|
|
|
|
var mapBanks = new ModelTable(model, model.GetTable(HardcodeTablesModel.MapBankTable).Start);
|
|
var bank = mapBanks[group].GetSubTable("maps");
|
|
if (bank == null) return $"{group}-{map}";
|
|
if (bank.Count <= map) return $"{group}-{map}";
|
|
var mapTable = bank[map]?.GetSubTable("map");
|
|
if (mapTable == null) return $"{group}-{map}";
|
|
if (!mapTable[0].HasField("regionSectionID")) return $"{group}-{map}";
|
|
var key = mapTable[0].GetValue("regionSectionID") - offset;
|
|
|
|
var names = model.GetTableModel(HardcodeTablesModel.MapNameTable);
|
|
var name = names == null ? string.Empty : names[key].GetStringValue("name");
|
|
name = SanitizeName(name);
|
|
|
|
return $"{group}-{map} ({name})";
|
|
}
|
|
|
|
#endregion
|
|
|
|
/*
|
|
ruby: data.maps.banks, layout<[
|
|
width:: height:: borderblock<[border:|h]4> blockmap<`blm`>
|
|
blockdata1<[isCompressed. isSecondary. padding: tileset<> pal<`ucp4:0123456789ABCDEF`> block<> attributes<> animation<>]1>
|
|
blockdata2<[isCompressed. isSecondary. padding: tileset<> pal<`ucp4:0123456789ABCDEF`> block<> attributes<> animation<>]1>
|
|
events<[e1 e2 e3 e4 ee1<> ee2<> ee3<> ee4<>]1>
|
|
mapscripts<[type. pointer<>]!00>
|
|
connections<>
|
|
music: layoutID: regionSectionID. cave. weather. mapType. padding. escapeRope. flags. battleType.
|
|
|
|
firered: data.maps.banks, layout<[
|
|
width:: height:: borderblock<>
|
|
blockmap<`blm`>
|
|
blockdata1<[isCompressed. isSecondary. padding: tileset<> pal<`ucp4:0123456789ABCDEF`> block<> animation<> attributes<>]1>
|
|
blockdata2<[isCompressed. isSecondary. padding: tileset<> pal<`ucp4:0123456789ABCDEF`> block<> animation<> attributes<>]1>
|
|
borderwidth. borderheight. unused:]1>
|
|
events<[objectCount. warpCount. scriptCount. signpostCount.
|
|
objects<[id. graphics. kind: x:500 y:500 elevation. moveType. range:|t|x::|y:: trainerType: trainerRangeOrBerryID: script<`xse`> flag: unused:]/objectCount>
|
|
warps<[x:500 y:500 elevation. warpID. map. bank.]/warps>
|
|
scripts<[x:500 y:500 elevation: trigger: index:: script<`xse`>]/scriptCount>
|
|
signposts<[x:500 y:500 elevation. kind. unused: arg::|h]/signposts>]1>
|
|
mapscripts<[type. pointer<>]!00>
|
|
connections<[count:: connections<[direction:: offset:: mapGroup. mapNum. unused:]/count>]>
|
|
music: layoutID: regionSectionID. cave. weather. mapType. allowBiking. flags.|t|allowEscaping.|allowRunning.|showMapName::: floorNum. battleType.
|
|
|
|
emerald: data.maps.banks, layout<[width:: height:: borderblock<[border:|h]4> blockmap<`blm`>
|
|
blockdata1<[isCompressed. isSecondary. padding: tileset<> pal<`ucp4:0123456789ABCDEF`> block<> attributes<> animation<>]1>
|
|
blockdata2<[isCompressed. isSecondary. padding: tileset<> pal<`ucp4:0123456789ABCDEF`> block<> attributes<> animation<>]1>
|
|
events<[objects. warps. scripts. signposts.
|
|
objectP<[id. graphics. unused: x:500 y:500 elevation. moveType. range:|t|x::|y:: trainerType: trainerRangeOrBerryID: script<`xse`> flag: unused:]/objects>
|
|
warpP<[x:500 y:500 elevation. warpID. map. bank.]/warps>
|
|
scriptP<[x:500 y:500 elevation: trigger: index: unused: script<`xse`>]/scripts>
|
|
signpostP<[x:500 y:500 elevation. kind. unused: arg::|h]/signposts>]1>
|
|
mapscripts<[type. pointer<>]!00>
|
|
connections<>
|
|
music: layoutID: regionSectionID. cave. weather. mapType. padding: flags.|t|allowCycling.|allowEscaping.|allowRunning.|showMapName::. battleType.
|
|
*/
|
|
}
|
|
|
|
public class EventSelector : ViewModelCore {
|
|
private bool isSelected;
|
|
public bool IsSelected { get => isSelected; set => Set(ref isSelected, value); }
|
|
|
|
private int index;
|
|
public int Index { get => index; set => Set(ref index, value); }
|
|
|
|
public void Select() => IsSelected = true;
|
|
}
|
|
|
|
public record Border(int North, int East, int South, int West);
|
|
|
|
public record ConnectionInfo(int Size, int Offset, MapDirection Direction) {
|
|
public const string SingleConnectionContent = "direction:: offset:: mapGroup. mapNum. unused:";
|
|
public const string SingleConnectionLength = "/count";
|
|
public static readonly string SingleConnectionFormat = $"[{SingleConnectionContent}]{SingleConnectionLength}";
|
|
public static readonly string ConnectionTableContent = $"count:: connections<{SingleConnectionFormat}>";
|
|
public MapDirection OppositeDirection => Direction.Reverse();
|
|
}
|
|
|
|
public record BerryInfo(IDictionary<int, BerrySpot> BerryMap, ObservableCollection<string> BerryOptions);
|
|
|
|
public class ConnectionModel {
|
|
private readonly ModelArrayElement connection;
|
|
private readonly int sourceGroup, sourceMap;
|
|
public IDataModel Model => connection.Model;
|
|
public Func<ModelDelta> Tokens => () => connection.Token;
|
|
public ConnectionModel(ModelArrayElement connection, int sourceGroup, int sourceMap) => (this.connection, this.sourceGroup, this.sourceMap) = (connection, sourceGroup, sourceMap);
|
|
|
|
public MapDirection Direction {
|
|
get => (MapDirection)connection.GetValue("direction");
|
|
set => connection.SetValue("direction", (int)value);
|
|
}
|
|
|
|
public ITableRun Table => connection.Table;
|
|
|
|
public int Offset {
|
|
get => connection.GetValue("offset");
|
|
set => connection.SetValue("offset", value);
|
|
}
|
|
|
|
public int MapGroup {
|
|
get => connection.GetValue("mapGroup");
|
|
set => connection.SetValue("mapGroup", value);
|
|
}
|
|
|
|
public int MapNum {
|
|
get => connection.GetValue("mapNum");
|
|
set => connection.SetValue("mapNum", value);
|
|
}
|
|
|
|
public ConnectionModel GetInverse() {
|
|
var direction = Direction.Reverse();
|
|
var map = BlockMapViewModel.GetMapModel(Model, MapGroup, MapNum, Tokens);
|
|
var neighbors = BlockMapViewModel.GetConnections(map, MapGroup, MapNum);
|
|
return neighbors.FirstOrDefault(c => c.MapGroup == sourceGroup && c.MapNum == sourceMap && c.Direction == direction);
|
|
}
|
|
|
|
public void Clear(IDataModel model, ModelDelta token) {
|
|
token.ChangeData(model, connection.Start, connection.Length.Range(i => (byte)0xFF).ToList());
|
|
}
|
|
}
|
|
|
|
public class EventGroupModel {
|
|
private readonly ModelArrayElement events;
|
|
|
|
public event EventHandler<DataMovedEventArgs> DataMoved;
|
|
|
|
public EventGroupModel(ScriptParser parser, Action<int> gotoAddress, ModelArrayElement events, IReadOnlyList<IPixelViewModel> ows, IPixelViewModel defaultOW, BerryInfo berries, int bank, int map) {
|
|
this.events = events;
|
|
|
|
var objectCount = events.GetValue("objectCount");
|
|
var objects = events.GetSubTable("objects");
|
|
var objectList = new List<ObjectEventViewModel>();
|
|
if (objects != null) {
|
|
for (int i = 0; i < objectCount; i++) {
|
|
var newEvent = new ObjectEventViewModel(parser, gotoAddress, objects[i], ows, defaultOW, berries);
|
|
newEvent.DataMoved += (sender, e) => DataMoved.Raise(this, e);
|
|
objectList.Add(newEvent);
|
|
}
|
|
}
|
|
Objects = objectList;
|
|
|
|
var warpCount = events.GetValue("warpCount");
|
|
var warps = events.GetSubTable("warps");
|
|
var warpList = new List<WarpEventViewModel>();
|
|
if (warps != null) {
|
|
for (int i = 0; i < warpCount; i++) warpList.Add(new WarpEventViewModel(warps[i]));
|
|
}
|
|
Warps = warpList;
|
|
|
|
var scriptCount = events.GetValue("scriptCount");
|
|
var scripts = events.GetSubTable("scripts");
|
|
var scriptList = new List<ScriptEventViewModel>();
|
|
if (scripts != null) {
|
|
for (int i = 0; i < scriptCount; i++) scriptList.Add(new ScriptEventViewModel(gotoAddress, scripts[i]));
|
|
}
|
|
Scripts = scriptList;
|
|
|
|
var signpostCount = events.GetValue("signpostCount");
|
|
var signposts = events.GetSubTable("signposts");
|
|
var signpostList = new List<SignpostEventViewModel>();
|
|
if (signposts != null) {
|
|
for (int i = 0; i < signpostCount; i++) {
|
|
var newEvent = new SignpostEventViewModel(signposts[i], gotoAddress);
|
|
newEvent.DataMoved += (sender, e) => DataMoved.Raise(this, e);
|
|
signpostList.Add(newEvent);
|
|
}
|
|
}
|
|
Signposts = signpostList;
|
|
|
|
var flyList = new List<FlyEventViewModel>();
|
|
foreach (var flyEvent in FlyEventViewModel.Create(events.Model, bank, map, () => events.Token)) {
|
|
if (flyEvent.Valid) flyList.Add(flyEvent);
|
|
}
|
|
FlyEvents = flyList;
|
|
}
|
|
|
|
public IReadOnlyList<ObjectEventViewModel> Objects { get; }
|
|
public IReadOnlyList<WarpEventViewModel> Warps { get; }
|
|
public IReadOnlyList<ScriptEventViewModel> Scripts { get; }
|
|
public IReadOnlyList<SignpostEventViewModel> Signposts { get; }
|
|
public IReadOnlyList<FlyEventViewModel> FlyEvents { get; }
|
|
|
|
/*
|
|
* events<[objectCount. warpCount. scriptCount. signpostCount.
|
|
objects<[id. graphics. unused: x:500 y:500 elevation. moveType. range:|t|x::|y:: trainerType: trainerRangeOrBerryID: script<`xse`> flag: unused:]/objectCount>
|
|
warps<[x:500 y:500 elevation. warpID. map. bank.]/warps>
|
|
scripts<[x:500 y:500 elevation: trigger: index:: script<`xse`>]/scriptCount>
|
|
signposts<[x:500 y:500 elevation. kind. unused: arg::|h]/signposts>]1>
|
|
*/
|
|
}
|
|
|
|
public enum MapDirection {
|
|
None = 0,
|
|
Down = 1,
|
|
Up = 2,
|
|
Left = 3,
|
|
Right = 4,
|
|
Dive = 5,
|
|
Emerge = 6,
|
|
}
|
|
|
|
public static class MapDirectionExtensions {
|
|
public static MapDirection Reverse(this MapDirection direction) => direction switch {
|
|
MapDirection.Up => MapDirection.Down,
|
|
MapDirection.Down => MapDirection.Up,
|
|
MapDirection.Left => MapDirection.Right,
|
|
MapDirection.Right => MapDirection.Left,
|
|
MapDirection.Dive => MapDirection.Emerge,
|
|
MapDirection.Emerge => MapDirection.Dive,
|
|
_ => throw new NotImplementedException(),
|
|
};
|
|
}
|
|
|
|
public enum ZoomDirection {
|
|
None = 0,
|
|
Shrink = 1,
|
|
Enlarge = 2,
|
|
}
|
|
}
|