// 3. Walking through an edge node array, discarding edge node types 0 and 15 and creating paths from the rest.
// Walk directions (dir): 0 > ; 1 ^ ; 2 < ; 3 v
// Edge node types ( ▓:light or 1; ░:dark or 0 )
// ░░ ▓░ ░▓ ▓▓ ░░ ▓░ ░▓ ▓▓ ░░ ▓░ ░▓ ▓▓ ░░ ▓░ ░▓ ▓▓
// ░░ ░░ ░░ ░░ ░▓ ░▓ ░▓ ░▓ ▓░ ▓░ ▓░ ▓░ ▓▓ ▓▓ ▓▓ ▓▓
// 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
public static IEnumerable <PathPointPath> Scan(RawLayer layer, int pathOmit)
{
var width = layer.Nodes[0].Length;
var height = layer.Nodes.Length;
var isHolePath = false;
// This loop itself is updating nodes as it is looping. Hole paths also update nodes, but do not return paths.
for (var row = 0; row < height; row++)
{
for (var column = 0; column < width; column++)
{
var node = layer.Nodes[row][column];
// Remove completely empty or filled edge nodes.
if ((node == DDDD) || (node == LLLL))
{
continue;
}
// fill paths will be drawn, but hole paths are also required to remove unnecessary edge nodes
var dir = InitializeDirection(node);
isHolePath = CalcHole(node, isHolePath);
// The values in nodes are updated in CreatePath.
var path = CreatePath(layer.Nodes, column, row, dir, isHolePath, pathOmit);
if (path != null)
{
yield return(new PathPointPath {
Points = path.ToList()
});
}
}
}
}
public MainPlannerJob(
RawLayer layer,
PlannerResult previousLayerResult,
PlannerResult currentPlan,
float maxFScore,
RawBlackboardArray datasets,
PlannerResult output)
{
// domain
layer.Break(out _targets, out _actions);
_goal = default;
// layering
_previousLayerResult = previousLayerResult;
// previous run
_currentPlan = currentPlan;
// settings
_maxFScore = maxFScore;
// runtime data
_datasets = datasets;
// output
_output = output;
}
void parseLayers(FormWorld world, Tileset[] tilesets, RawLayer[] layers)
{
var tilesetIndexes = new int[tilesets.Length];
int tileWidth = world.Settings.TileSize.Width,
tileHeight = world.Settings.TileSize.Height;
// calculate the tileset indexes
for (var a = 0; a < tilesets.Length - 1; a++)
{
Tileset set = tilesets[a];
int length = (set.Size.X / tileWidth) *
(set.Size.Y / tileHeight);
if (a != 0)
length += tilesetIndexes[a - 1];
tilesetIndexes[a + 1] = length;
}
for (int b = 0; b < layers.Length; b++)
{
RawLayer raw = layers[b];
world.AddLayer(raw.Name, false);
for (int c = 0; c < raw.Data.Length; c++)
{
int rawTile = raw.Data[c];
// tile is empty
if (rawTile == 0)
continue;
// subtract one because one is added when
// saving the file (allow for null tiles to be 0)
rawTile--;
int setIndex = 0;
// calculate the tileset index for the tile
for (int d = 0; d < tilesets.Length; d++)
{
// the last tileset, or in range tile tileset index [d]
if (d == tilesets.Length - 1 ||
(rawTile >= tilesetIndexes[d] && rawTile < tilesetIndexes[d + 1]))
{
setIndex = d;
break;
}
}
// subtract the tileset index to offset
// the source offset
rawTile -= tilesetIndexes[setIndex];
Tileset set = tilesets[setIndex];
int width = set.Size.X / tileWidth,
worldWidth = world.Settings.WorldSize.Width;
int x = rawTile % width,
y = rawTile / width;
world.SetTile(c % worldWidth, c / worldWidth, new WorldTile(x * tileWidth, y * tileHeight, setIndex), b);
}
}
}
/// <summary>
/// Saves the open world as a file
/// </summary>
void SaveAsFile(string saveLocation)
{
using (var saveSettings = new FormSaveSettings(saveLocation, OpenWorld))
{
if (saveSettings.ShowDialog() == DialogResult.OK)
{
try
{
// TODO: different file types
var settings = OpenWorld.Settings;
var save = new WorldFile()
{
Size = new Point(settings.WorldSize.Width, settings.WorldSize.Height),
TileSize = new Point(settings.TileSize.Width, settings.TileSize.Height),
Properties = OpenWorld.UserProperties,
Tilesets = new Tileset[OpenWorld.Tilesets.Count],
Layers = new RawLayer[OpenWorld.LayerCount - 1],
CollisionData = new int[settings.WorldSize.Width * settings.WorldSize.Height]
};
for (int a = 0; a < OpenWorld.Tilesets.Count; a++)
{
var tileset = OpenWorld.Tilesets[a];
var size = tileset.Bounds.Size.Nearest(settings.TileSize);
save.Tilesets[a] = new Tileset()
{
File = tileset.ShouldBuild ? tileset.BuildLocation : null,
Size = new Point(size.Width, size.Height)
};
}
// convert layers to raw layers
for (int b = 0; b < OpenWorld.LayerCount - 1; b++)
{
var rawLayer = new RawLayer()
{
Name = OpenWorld.GetLayerName(b),
Data = new int[settings.WorldSize.Width * settings.WorldSize.Height]
};
for (int x = 0; x < settings.WorldSize.Width; x++)
{
for (int y = 0; y < settings.WorldSize.Height; y++)
{
WorldTile tile = OpenWorld.GetTile(x, y, b);
int rawValue = (tile == null) ? 0 :
tile.GetIndex(settings.TileSize, save.Tilesets[tile.Tileset].Size) + OpenWorld.TilesetIndexes[tile.Tileset] + 1;
rawLayer.Data[y * settings.WorldSize.Width + x] = rawValue;
}
}
save.Layers[b] = rawLayer;
}
for (int x = 0; x < settings.WorldSize.Width; x++)
{
for (int y = 0; y < settings.WorldSize.Height; y++)
{
WorldTile tile = OpenWorld.GetTile(x, y, OpenWorld.LayerCount - 1);
int rawValue = (tile == null) ? 0 :
tile.GetIndex(settings.TileSize, save.Tilesets[tile.Tileset].Size) + OpenWorld.TilesetIndexes[tile.Tileset] + 1;
save.CollisionData[y * settings.WorldSize.Width + x] = rawValue;
}
}
XmlWriterSettings xmlSettings = new XmlWriterSettings()
{
Indent = true
};
// serialize and save xml data to the save location
using (XmlWriter writer = XmlWriter.Create(saveLocation, xmlSettings))
{
IntermediateSerializer.Serialize(writer, save, null);
}
OpenWorld.SaveLocation = saveLocation;
OpenWorld.ChangesMade = false;
MessageBox.Show("The world has successfully saved.", "World Saved", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
catch (Exception exception)
{
MessageBox.Show("Error saving world\n\n" + exception.Message,
"Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
}
}
void parseLayers(FormWorld world, Tileset[] tilesets, RawLayer[] layers)
{
var tilesetIndexes = new int[tilesets.Length];
int tileWidth = world.Settings.TileSize.Width,
tileHeight = world.Settings.TileSize.Height;
// calculate the tileset indexes
for (var a = 0; a < tilesets.Length - 1; a++)
{
Tileset set = tilesets[a];
int length = (set.Size.X / tileWidth) *
(set.Size.Y / tileHeight);
if (a != 0)
{
length += tilesetIndexes[a - 1];
}
tilesetIndexes[a + 1] = length;
}
for (int b = 0; b < layers.Length; b++)
{
RawLayer raw = layers[b];
world.AddLayer(raw.Name, false);
for (int c = 0; c < raw.Data.Length; c++)
{
int rawTile = raw.Data[c];
// tile is empty
if (rawTile == 0)
{
continue;
}
// subtract one because one is added when
// saving the file (allow for null tiles to be 0)
rawTile--;
int setIndex = 0;
// calculate the tileset index for the tile
for (int d = 0; d < tilesets.Length; d++)
{
// the last tileset, or in range tile tileset index [d]
if (d == tilesets.Length - 1 ||
(rawTile >= tilesetIndexes[d] && rawTile < tilesetIndexes[d + 1]))
{
setIndex = d;
break;
}
}
// subtract the tileset index to offset
// the source offset
rawTile -= tilesetIndexes[setIndex];
Tileset set = tilesets[setIndex];
int width = set.Size.X / tileWidth,
worldWidth = world.Settings.WorldSize.Width;
int x = rawTile % width,
y = rawTile / width;
world.SetTile(c % worldWidth, c / worldWidth, new WorldTile(x * tileWidth, y * tileHeight, setIndex), b);
}
}
}
