public Rectangle TemplateBounds(TerrainTemplateInfo template, Size tileSize, MapGridType mapGrid)
{
Rectangle?templateRect = null;
var i = 0;
for (var y = 0; y < template.Size.Y; y++)
{
for (var x = 0; x < template.Size.X; x++)
{
var tile = new TerrainTile(template.Id, (byte)(i++));
var tileInfo = tileset.GetTileInfo(tile);
// Empty tile
if (tileInfo == null)
{
continue;
}
var sprite = TileSprite(tile);
var u = mapGrid == MapGridType.Rectangular ? x : (x - y) / 2f;
var v = mapGrid == MapGridType.Rectangular ? y : (x + y) / 2f;
var tl = new float2(u * tileSize.Width, (v - 0.5f * tileInfo.Height) * tileSize.Height) - 0.5f * sprite.Size;
var rect = new Rectangle((int)(tl.X + sprite.Offset.X), (int)(tl.Y + sprite.Offset.Y), (int)sprite.Size.X, (int)sprite.Size.Y);
templateRect = templateRect.HasValue ? Rectangle.Union(templateRect.Value, rect) : rect;
}
}
return(templateRect.HasValue ? templateRect.Value : Rectangle.Empty);
}
public LaysTerrain(Actor self, LaysTerrainInfo info)
{
this.info = info;
layer = self.World.WorldActor.Trait <BuildableTerrainLayer>();
bi = self.World.WorldActor.Trait <BuildingInfluence>();
template = self.World.TileSet.Templates[info.Template];
}
public TileSelectorTemplate(TerrainTemplateInfo template)
{
Template = template;
Categories = template.Categories;
Tooltip = template.Id.ToString();
SearchTerms = new[] { Tooltip };
}
public LaysTerrain(Actor self, LaysTerrainInfo info)
{
this.info = info;
layer = self.World.WorldActor.Trait <CustomTerrainLayer>();
template = self.World.Map.Rules.TileSet.Templates[info.Template];
buildingInfo = self.Info.TraitInfo <BuildingInfo>();
}
Rectangle ITiledTerrainRenderer.TemplateBounds(TerrainTemplateInfo template)
{
Rectangle?templateRect = null;
var tileSize = map.Grid.TileSize;
var i = 0;
for (var y = 0; y < template.Size.Y; y++)
{
for (var x = 0; x < template.Size.X; x++)
{
var tile = new TerrainTile(template.Id, (byte)(i++));
if (!terrainInfo.TryGetTileInfo(tile, out var tileInfo))
{
continue;
}
var sprite = tileCache.TileSprite(tile);
var u = map.Grid.Type == MapGridType.Rectangular ? x : (x - y) / 2f;
var v = map.Grid.Type == MapGridType.Rectangular ? y : (x + y) / 2f;
var tl = new float2(u * tileSize.Width, (v - 0.5f * tileInfo.Height) * tileSize.Height) - 0.5f * sprite.Size;
var rect = new Rectangle((int)(tl.X + sprite.Offset.X), (int)(tl.Y + sprite.Offset.Y), (int)sprite.Size.X, (int)sprite.Size.Y);
templateRect = templateRect.HasValue ? Rectangle.Union(templateRect.Value, rect) : rect;
}
}
return(templateRect ?? Rectangle.Empty);
}
public LaysTerrain(Actor self, LaysTerrainInfo info)
: base(info)
{
layer = self.World.WorldActor.Trait <BuildableTerrainLayer>();
template = self.World.Map.Rules.TileSet.Templates[info.Template];
buildingInfo = self.Info.TraitInfo <BuildingInfo>();
}
public D2LaysTerrain(Actor self, D2LaysTerrainInfo info)
{
this.info = info;
layer = self.World.WorldActor.Trait <D2BuildableTerrainLayer>();
bi = self.World.WorldActor.Trait <BuildingInfluence>();
template = self.World.Map.Rules.TileSet.Templates[info.Template];
buildingInfo = self.Info.TraitInfo <BuildingInfo>();
}
protected TerrainTemplatePreviewWidget(TerrainTemplatePreviewWidget other)
: base(other)
{
worldRenderer = other.worldRenderer;
terrainRenderer = other.terrainRenderer;
Template = other.Template;
GetScale = other.GetScale;
}
protected TerrainTemplatePreviewWidget(TerrainTemplatePreviewWidget other)
: base(other)
{
worldRenderer = other.worldRenderer;
tileset = other.worldRenderer.World.Map.Rules.TileSet;
Template = other.Template;
GetScale = other.GetScale;
}
protected TerrainTemplatePreviewWidget(TerrainTemplatePreviewWidget other)
: base(other)
{
worldRenderer = other.worldRenderer;
tileset = other.worldRenderer.World.Map.Rules.TileSets[other.worldRenderer.World.Map.Tileset];
Template = other.Template;
GetScale = other.GetScale;
}
public FloodFillEditorAction(ushort template, Map map, CPos cell)
{
this.template = template;
this.map = map;
this.cell = cell;
var tileset = map.Rules.TileSet;
terrainTemplate = tileset.Templates[template];
Text = "Filled with tile {0}".F(terrainTemplate.Id);
}
public PaintTileEditorAction(ushort template, Map map, CPos cell)
{
this.template = template;
this.map = map;
this.cell = cell;
var tileset = map.Rules.TileSet;
terrainTemplate = tileset.Templates[template];
Text = "Added tile {0}".F(terrainTemplate.Id);
}
public FloodFillEditorAction(ushort template, Map map, CPos cell)
{
this.template = template;
this.map = map;
this.cell = cell;
var terrainInfo = (ITemplatedTerrainInfo)map.Rules.TerrainInfo;
terrainTemplate = terrainInfo.Templates[template];
Text = $"Filled with tile {terrainTemplate.Id}";
}
public PaintTileEditorAction(ushort template, Map map, CPos cell)
{
this.template = template;
this.map = map;
this.cell = cell;
var terrainInfo = (ITemplatedTerrainInfo)map.Rules.TerrainInfo;
terrainTemplate = terrainInfo.Templates[template];
Text = $"Added tile {terrainTemplate.Id}";
}
public int SetTerrainTemplate(WorldRenderer wr, TerrainTemplateInfo template)
{
terrainOrResourceCell = wr.Viewport.ViewToWorld(wr.Viewport.WorldToViewPx(Viewport.LastMousePos));
Type = EditorCursorType.TerrainTemplate;
TerrainTemplate = template;
Actor = null;
Resource = null;
terrainOrResourceDirty = true;
return(++CurrentToken);
}
public LaysTerrain(Actor self, LaysTerrainInfo info)
{
this.info = info;
layer = self.World.WorldActor.Trait <CustomTerrainLayer>();
var terrainInfo = self.World.Map.Rules.TerrainInfo as ITemplatedTerrainInfo;
if (terrainInfo == null)
{
throw new InvalidDataException("LaysTerrain requires a template-based tileset.");
}
template = terrainInfo.Templates[info.Template];
buildingInfo = self.Info.TraitInfo <BuildingInfo>();
}
MiniYaml SaveTemplate(TerrainTemplateInfo t, TileSet tileSet)
{
var defaultTemplate = new TerrainTemplateInfo(0, new string[] { null }, int2.Zero, null);
var root = FieldSaver.SaveDifferences(t, defaultTemplate);
var tileYaml = new List <MiniYamlNode>();
for (var i = 0; i < t.TilesCount; i++)
{
var tileInfo = t[i];
if (tileInfo != null)
{
tileYaml.Add(new MiniYamlNode(i.ToString(), SaveTileInfo(tileInfo, tileSet)));
}
}
root.Nodes.Add(new MiniYamlNode("Tiles", null, tileYaml));
return(root);
}
bool PlacementOverlapsSameTemplate(TerrainTemplateInfo template, CPos cell)
{
var map = world.Map;
var i = 0;
for (var y = 0; y < template.Size.Y; y++)
{
for (var x = 0; x < template.Size.X; x++, i++)
{
if (template.Contains(i) && template[i] != null)
{
var c = cell + new CVec(x, y);
if (map.Contains(c) && map.MapTiles.Value[c].Type == template.Id)
{
return(true);
}
}
}
}
return(false);
}
void Export(string outputDir)
{
var dir = Platform.ResolvePath("^", outputDir);
Directory.CreateDirectory(dir);
var tilesetName = txtTilesetName.Text;
var tilesetID = txtID.Text;
var tilesetExt = txtExt.Text;
if (tilesetName.Length < 1)
{
tilesetName = "Temperat";
}
if (tilesetID.Length < 1)
{
tilesetID = "TEMPERAT";
}
if (tilesetExt.Length < 1)
{
tilesetExt = ".tem";
}
// Create a Tileset definition
// TODO: Pull this info from the GUI
var tilesetFile = tilesetName.ToLower();
if (tilesetFile.Length < 8)
{
tilesetFile = tilesetName.ToLower() + ".yaml";
}
else
{
tilesetFile = tilesetName.ToLower().Substring(0, 8) + ".yaml";
}
var tileset = new TileSet(
name: tilesetName,
id: tilesetID.ToUpper(),
terrainInfo: terrainType);
// List of files to add to the mix file
var fileList = new List <string>();
// Export tile artwork
foreach (var t in surface1.Templates)
{
fileList.Add(ExportTemplate(t, surface1.Templates.IndexOf(t), tilesetExt, dir));
}
// Add the templates
ushort cur = 0;
templates.Clear();
foreach (var tp in surface1.Templates)
{
var tiles = new byte[tp.Width * tp.Height];
foreach (var t in tp.Cells)
{
var ttype = terrainType[surface1.TerrainTypes[t.Key.X, t.Key.Y]].Type;
var idx = (t.Key.X - tp.Left) + tp.Width * (t.Key.Y - tp.Top);
tiles[idx] = tileset.GetTerrainIndex(ttype);
}
var template = new TerrainTemplateInfo(
id: cur,
images: new[] { "{0}{1:00}".F(txtTilesetName.Text, cur) },
size: new int2(tp.Width, tp.Height),
tiles: tiles);
// HACK: This part of the TileSet code is broken upstream
var field = template.GetType()
.GetField("tileInfo", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic);
field.SetValue(template, tiles.Select(t =>
{
var info = new TerrainTileInfo();
info.GetType().GetField("TerrainType").SetValue(info, t);
return(info);
}).ToArray());
templates[cur] = template;
cur++;
}
SaveTileSet(tileset, Path.Combine(dir, tilesetFile));
Console.WriteLine("Finished export");
}
public void Export(string outputDir)
{
var dir = Platform.ResolvePath("^", outputDir);
Directory.CreateDirectory(dir);
var tilesetName = txtTilesetName.Text;
var tilesetID = txtID.Text;
var tilesetPalette = txtPal.Text;
var tilesetExt = txtExt.Text;
if (tilesetName.Length < 1)
{
tilesetName = "Temperat";
}
if (tilesetID.Length < 1)
{
tilesetID = "TEMPERAT";
}
if (tilesetPalette.Length < 1)
{
tilesetPalette = "temperat";
}
if (tilesetExt.Length < 1)
{
tilesetExt = ".tem";
}
// Create a Tileset definition
// TODO: Pull this info from the GUI
var tilesetFile = "";
tilesetFile = tilesetName.ToLower();
if (tilesetFile.Length < 8)
{
tilesetFile = tilesetName.ToLower() + ".yaml";
}
else
{
tilesetFile = tilesetName.ToLower().Substring(0, 8) + ".yaml";
}
var tileset = new TileSet(
name: tilesetName,
id: tilesetID.ToUpper(),
palette: tilesetPalette.ToLower(),
terrainInfo: TerrainType);
// List of files to add to the mix file
var fileList = new List <string>();
// Export palette (use the embedded palette)
var p = surface1.Image.Palette.Entries.ToList();
fileList.Add(ExportPalette(p, Path.Combine(dir, tileset.Palette)));
// Export tile artwork
foreach (var t in surface1.Templates)
{
fileList.Add(ExportTemplate(t, surface1.Templates.IndexOf(t), tilesetExt, dir));
}
// Add the templates
ushort cur = 0;
foreach (var tp in surface1.Templates)
{
var tiles = new byte[tp.Width * tp.Height];
foreach (var t in tp.Cells)
{
var ttype = TerrainType[surface1.TerrainTypes[t.Key.X, t.Key.Y]].Type;
var idx = (t.Key.X - tp.Left) + tp.Width * (t.Key.Y - tp.Top);
tiles[idx] = tileset.GetTerrainIndex(ttype);
}
var template = new TerrainTemplateInfo(
id: cur,
images: new[] { "{0}{1:00}".F(txtTilesetName.Text, cur) },
size: new int2(tp.Width, tp.Height),
tiles: tiles);
tileset.Templates.Add(cur, template);
cur++;
}
tileset.Save(Path.Combine(dir, tilesetFile));
Console.WriteLine("Finished export");
}
void Export(string outputDir)
{
var dir = Platform.ResolvePath("^", outputDir);
Directory.CreateDirectory(dir);
var tilesetName = txtTilesetName.Text;
var tilesetID = txtID.Text;
var tilesetPalette = txtPal.Text;
var tilesetExt = txtExt.Text;
if (tilesetName.Length < 1) tilesetName = "Temperat";
if (tilesetID.Length < 1) tilesetID = "TEMPERAT";
if (tilesetPalette.Length < 1) tilesetPalette = "temperat";
if (tilesetExt.Length < 1) tilesetExt = ".tem";
// Create a Tileset definition
// TODO: Pull this info from the GUI
var tilesetFile = "";
tilesetFile = tilesetName.ToLower();
if (tilesetFile.Length < 8)
tilesetFile = tilesetName.ToLower() + ".yaml";
else
tilesetFile = tilesetName.ToLower().Substring(0, 8) + ".yaml";
var tileset = new TileSet(
name: tilesetName,
id: tilesetID.ToUpper(),
palette: tilesetPalette.ToLower(),
terrainInfo: terrainType);
// List of files to add to the mix file
var fileList = new List<string>();
// Export palette (use the embedded palette)
var p = surface1.Image.Palette.Entries.ToList();
fileList.Add(ExportPalette(p, Path.Combine(dir, tileset.Palette)));
// Export tile artwork
foreach (var t in surface1.Templates)
fileList.Add(ExportTemplate(t, surface1.Templates.IndexOf(t), tilesetExt, dir));
// Add the templates
ushort cur = 0;
foreach (var tp in surface1.Templates)
{
var tiles = new byte[tp.Width * tp.Height];
foreach (var t in tp.Cells)
{
var ttype = terrainType[surface1.TerrainTypes[t.Key.X, t.Key.Y]].Type;
var idx = (t.Key.X - tp.Left) + tp.Width * (t.Key.Y - tp.Top);
tiles[idx] = tileset.GetTerrainIndex(ttype);
}
var template = new TerrainTemplateInfo(
id: cur,
images: new[] { "{0}{1:00}".F(txtTilesetName.Text, cur) },
size: new int2(tp.Width, tp.Height),
tiles: tiles);
tileset.Templates.Add(cur, template);
cur++;
}
tileset.Save(Path.Combine(dir, tilesetFile));
Console.WriteLine("Finished export");
}
IEnumerable <IRenderable> ITiledTerrainRenderer.RenderUIPreview(WorldRenderer wr, TerrainTemplateInfo t, int2 origin, float scale)
{
var template = t as DefaultTerrainTemplateInfo;
if (template == null)
{
yield break;
}
var ts = map.Grid.TileSize;
var gridType = map.Grid.Type;
var i = 0;
for (var y = 0; y < template.Size.Y; y++)
{
for (var x = 0; x < template.Size.X; x++)
{
var tile = new TerrainTile(template.Id, (byte)i++);
if (!terrainInfo.TryGetTileInfo(tile, out var tileInfo))
{
continue;
}
var sprite = tileCache.TileSprite(tile, 0);
var u = gridType == MapGridType.Rectangular ? x : (x - y) / 2f;
var v = gridType == MapGridType.Rectangular ? y : (x + y) / 2f;
var offset = (new float2(u * ts.Width, (v - 0.5f * tileInfo.Height) * ts.Height) - 0.5f * sprite.Size.XY).ToInt2();
var palette = template.Palette ?? TileSet.TerrainPaletteInternalName;
yield return(new UISpriteRenderable(sprite, WPos.Zero, origin + offset, 0, wr.Palette(palette), scale));
}
}
}
public Rectangle TemplateBounds(TerrainTemplateInfo template, Size tileSize, MapGridType mapGrid)
{
Rectangle? templateRect = null;
var i = 0;
for (var y = 0; y < template.Size.Y; y++)
{
for (var x = 0; x < template.Size.X; x++)
{
var tile = new TerrainTile(template.Id, (byte)(i++));
var tileInfo = tileset.GetTileInfo(tile);
// Empty tile
if (tileInfo == null)
continue;
var sprite = TileSprite(tile);
var u = mapGrid == MapGridType.Rectangular ? x : (x - y) / 2f;
var v = mapGrid == MapGridType.Rectangular ? y : (x + y) / 2f;
var tl = new float2(u * tileSize.Width, (v - 0.5f * tileInfo.Height) * tileSize.Height) - 0.5f * sprite.Size;
var rect = new Rectangle((int)(tl.X + sprite.Offset.X), (int)(tl.Y + sprite.Offset.Y), (int)sprite.Size.X, (int)sprite.Size.Y);
templateRect = templateRect.HasValue ? Rectangle.Union(templateRect.Value, rect) : rect;
}
}
return templateRect.HasValue ? templateRect.Value : Rectangle.Empty;
}
bool PlacementOverlapsSameTemplate(TerrainTemplateInfo template, CPos cell)
{
var map = world.Map;
var mapTiles = map.MapTiles.Value;
var i = 0;
for (var y = 0; y < template.Size.Y; y++)
{
for (var x = 0; x < template.Size.X; x++, i++)
{
if (template.Contains(i) && template[i] != null)
{
var c = cell + new CVec(x, y);
if (mapTiles.Contains(c) && mapTiles[c].Type == template.Id)
return true;
}
}
}
return false;
}
IEnumerable <IRenderable> ITiledTerrainRenderer.RenderPreview(WorldRenderer wr, TerrainTemplateInfo t, WPos origin)
{
if (!(t is DefaultTerrainTemplateInfo template))
{
yield break;
}
var i = 0;
for (var y = 0; y < template.Size.Y; y++)
{
for (var x = 0; x < template.Size.X; x++)
{
var tile = new TerrainTile(template.Id, (byte)i++);
if (!terrainInfo.TryGetTileInfo(tile, out var tileInfo))
{
continue;
}
var sprite = tileCache.TileSprite(tile, 0);
var offset = map.Offset(new CVec(x, y), tileInfo.Height);
var palette = wr.Palette(template.Palette ?? TileSet.TerrainPaletteInternalName);
yield return(new SpriteRenderable(sprite, origin, offset, 0, palette, 1, false));
}
}
}
