public void UpdateCell(CPos cell)
{
var tile = map.Tiles[cell];
var palette = TileSet.TerrainPaletteInternalName;
if (terrainInfo.Templates.TryGetValue(tile.Type, out var template))
{
palette = ((CustomTerrainTemplateInfo)template).Palette ?? palette;
}
var sprite = tileCache.TileSprite(tile);
var paletteReference = worldRenderer.Palette(palette);
spriteLayer.Update(cell, sprite, paletteReference);
}
public void WorldLoaded(World w, WorldRenderer wr)
{
var first = smudges.First().Value.First();
var sheet = first.Sheet;
if (smudges.Values.Any(sprites => sprites.Any(s => s.Sheet != sheet)))
{
throw new InvalidDataException("Resource sprites span multiple sheets. Try loading their sequences earlier.");
}
var blendMode = first.BlendMode;
if (smudges.Values.Any(sprites => sprites.Any(s => s.BlendMode != blendMode)))
{
throw new InvalidDataException("Smudges specify different blend modes. "
+ "Try using different smudge types for smudges that use different blend modes.");
}
render = new TerrainSpriteLayer(w, wr, sheet, blendMode, wr.Palette(Info.Palette), wr.World.Type != WorldType.Editor);
// Add map smudges
foreach (var s in w.Map.SmudgeDefinitions)
{
var name = s.Key;
var vals = name.Split(' ');
var type = vals[0];
if (!smudges.ContainsKey(type))
{
continue;
}
var loc = vals[1].Split(',');
var cell = new CPos(Exts.ParseIntegerInvariant(loc[0]), Exts.ParseIntegerInvariant(loc[1]));
var depth = Exts.ParseIntegerInvariant(vals[2]);
var smudge = new Smudge
{
Type = type,
Depth = depth,
Sprite = smudges[type][depth]
};
tiles.Add(cell, smudge);
render.Update(cell, smudge.Sprite);
}
}
void ITickRender.TickRender(WorldRenderer wr, Actor self)
{
var remove = new List <CPos>();
foreach (var kv in dirty)
{
if (!self.World.FogObscures(kv.Key))
{
render.Update(kv.Key, kv.Value);
remove.Add(kv.Key);
}
}
foreach (var r in remove)
{
dirty.Remove(r);
}
}
public void WorldLoaded(World w, WorldRenderer wr)
{
var first = smudges.First().Value.First();
var sheet = first.Sheet;
if (smudges.Values.Any(sprites => sprites.Any(s => s.Sheet != sheet)))
{
throw new InvalidDataException("Resource sprites span multiple sheets. Try loading their sequences earlier.");
}
var blendMode = first.BlendMode;
if (smudges.Values.Any(sprites => sprites.Any(s => s.BlendMode != blendMode)))
{
throw new InvalidDataException("Smudges specify different blend modes. "
+ "Try using different smudge types for smudges that use different blend modes.");
}
render = new TerrainSpriteLayer(w, wr, sheet, blendMode, wr.Palette(Info.Palette), wr.World.Type != WorldType.Editor);
// Add map smudges
foreach (var kv in Info.InitialSmudges)
{
var s = kv.Value;
if (!smudges.ContainsKey(s.Type))
{
continue;
}
var smudge = new Smudge
{
Type = s.Type,
Depth = s.Depth,
Sprite = smudges[s.Type][s.Depth]
};
tiles.Add(kv.Key, smudge);
render.Update(kv.Key, smudge.Sprite);
}
}
public void WorldLoaded(World w, WorldRenderer wr)
{
var sprites = smudges.Values.SelectMany(v => Exts.MakeArray(v.Length, x => v.GetSprite(x))).ToList();
var sheet = sprites[0].Sheet;
var blendMode = sprites[0].BlendMode;
if (sprites.Any(s => s.Sheet != sheet))
{
throw new InvalidDataException("Resource sprites span multiple sheets. Try loading their sequences earlier.");
}
if (sprites.Any(s => s.BlendMode != blendMode))
{
throw new InvalidDataException("Smudges specify different blend modes. "
+ "Try using different smudge types for smudges that use different blend modes.");
}
render = new TerrainSpriteLayer(w, wr, sheet, blendMode, wr.Palette(Info.Palette), w.Type != WorldType.Editor);
// Add map smudges
foreach (var kv in Info.InitialSmudges)
{
var s = kv.Value;
if (!smudges.ContainsKey(s.Type))
{
continue;
}
var seq = smudges[s.Type];
var smudge = new Smudge
{
Type = s.Type,
Depth = s.Depth,
Sequence = seq
};
tiles.Add(kv.Key, smudge);
render.Update(kv.Key, seq, s.Depth);
}
}
void UpdateShroud(IEnumerable <PPos> region)
{
if (!anyCellDirty)
{
return;
}
foreach (var puv in region)
{
var uv = (MPos)puv;
if (!cellsDirty[uv] || !tileInfos.Contains(uv))
{
continue;
}
cellsDirty[uv] = false;
var tileInfo = tileInfos[uv];
var shroudSprite = GetSprite(shroudSprites, GetEdges(puv, visibleUnderShroud), tileInfo.Variant);
var shroudPos = tileInfo.ScreenPosition;
if (shroudSprite != null)
{
shroudPos += shroudSprite.Offset - 0.5f * shroudSprite.Size;
}
var fogSprite = GetSprite(fogSprites, GetEdges(puv, visibleUnderFog), tileInfo.Variant);
var fogPos = tileInfo.ScreenPosition;
if (fogSprite != null)
{
fogPos += fogSprite.Offset - 0.5f * fogSprite.Size;
}
shroudLayer.Update(uv, shroudSprite, shroudPos, true);
fogLayer.Update(uv, fogSprite, fogPos, true);
}
anyCellDirty = false;
}
public void WorldLoaded(World w, WorldRenderer wr)
{
var sprites = smudges.Values.SelectMany(v => Exts.MakeArray(v.Length, x => v.GetSprite(x))).ToList();
var sheet = sprites[0].Sheet;
var blendMode = sprites[0].BlendMode;
var emptySprite = new Sprite(sheet, Rectangle.Empty, TextureChannel.Alpha);
if (sprites.Any(s => s.BlendMode != blendMode))
{
throw new InvalidDataException("Smudges specify different blend modes. "
+ "Try using different smudge types for smudges that use different blend modes.");
}
paletteReference = wr.Palette(Info.Palette);
render = new TerrainSpriteLayer(w, wr, emptySprite, blendMode, w.Type != WorldType.Editor);
// Add map smudges
foreach (var kv in Info.InitialSmudges)
{
var s = kv.Value;
if (!smudges.ContainsKey(s.Type))
{
continue;
}
var seq = smudges[s.Type];
var smudge = new Smudge
{
Type = s.Type,
Depth = s.Depth,
Sequence = seq
};
tiles.Add(kv.Key, smudge);
render.Update(kv.Key, seq, paletteReference, s.Depth);
}
}
public void RenderShroud(Shroud shroud, WorldRenderer wr)
{
if (currentShroud != shroud)
{
if (currentShroud != null)
{
currentShroud.CellsChanged -= DirtyCells;
}
if (shroud != null)
{
shroud.CellsChanged += DirtyCells;
}
// Needs the anonymous function to ensure the correct overload is chosen
if (shroud != null)
{
visibleUnderShroud = puv => currentShroud.IsExplored(puv);
}
else
{
visibleUnderShroud = puv => map.Contains(puv);
}
if (shroud != null)
{
visibleUnderFog = puv => currentShroud.IsVisible(puv);
}
else
{
visibleUnderFog = puv => map.Contains(puv);
}
currentShroud = shroud;
DirtyCells(map.ProjectedCellBounds);
}
// We need to update newly dirtied areas of the shroud.
// Expand the dirty area to cover the neighboring cells, since shroud is affected by neighboring cells.
foreach (var uv in cellsDirty)
{
cellsAndNeighborsDirty.Add(uv);
var cell = ((MPos)uv).ToCPos(map);
foreach (var direction in CVec.Directions)
{
cellsAndNeighborsDirty.Add((PPos)(cell + direction).ToMPos(map));
}
}
foreach (var puv in cellsAndNeighborsDirty)
{
var uv = (MPos)puv;
if (!tileInfos.Contains(uv))
{
continue;
}
var tileInfo = tileInfos[uv];
var shroudSprite = GetSprite(shroudSprites, GetEdges(puv, visibleUnderShroud), tileInfo.Variant);
var shroudPos = tileInfo.ScreenPosition;
if (shroudSprite != null)
{
shroudPos += shroudSprite.Offset - 0.5f * shroudSprite.Size;
}
var fogSprite = GetSprite(fogSprites, GetEdges(puv, visibleUnderFog), tileInfo.Variant);
var fogPos = tileInfo.ScreenPosition;
if (fogSprite != null)
{
fogPos += fogSprite.Offset - 0.5f * fogSprite.Size;
}
shroudLayer.Update(uv, shroudSprite, shroudPos);
fogLayer.Update(uv, fogSprite, fogPos);
}
cellsDirty.Clear();
cellsAndNeighborsDirty.Clear();
fogLayer.Draw(wr.Viewport);
shroudLayer.Draw(wr.Viewport);
}
public void WorldLoaded(World w, WorldRenderer wr)
{
/* based on SmudgeLayer.cs */
var first = sideSprites.First().Value.First();
var sheet = first.Sheet;
if (sideSprites.Values.Any(sprites => sprites.Any(s => s.Sheet != sheet)))
{
throw new InvalidDataException("Resource sprites span multiple sheets. Try loading their sequences earlier.");
}
var blendMode = first.BlendMode;
if (sideSprites.Values.Any(sprites => sprites.Any(s => s.BlendMode != blendMode)))
{
throw new InvalidDataException("Smudges specify different blend modes. "
+ "Try using different smudge types for smudges that use different blend modes.");
}
render = new TerrainSpriteLayer(w, wr, sheet, blendMode, wr.Palette(Info.Palette), wr.World.Type != WorldType.Editor);
var tilesLayer = w.Map.Tiles;
for (var v = 0; v < tilesLayer.Size.Height; v++)
{
for (var u = 0; u < tilesLayer.Size.Width; u++)
{
var pos = new MPos(u, v);
var tile = tilesLayer[pos];
if (tile.Type == D2MapUtils.RockTile)
{
var index = D2MapUtils.SmoothIndexForPos(tilesLayer, pos);
if (index != 15)
{
CPos cpos = pos.ToCPos(w.Map);
Sprite sprite = sideSprites["rock"][index];
render.Update(cpos, sprite);
}
}
if (tile.Type == D2MapUtils.DuneTile)
{
var index = D2MapUtils.SmoothIndexForPos(tilesLayer, pos);
if (index != 15)
{
CPos cpos = pos.ToCPos(w.Map);
Sprite sprite = sideSprites["dune"][index];
render.Update(cpos, sprite);
}
}
if (tile.Type == D2MapUtils.RoughTile)
{
var index = D2MapUtils.SmoothIndexForPos(tilesLayer, pos);
if (index != 15)
{
CPos cpos = pos.ToCPos(w.Map);
Sprite sprite = sideSprites["rough"][index];
render.Update(cpos, sprite);
}
}
}
}
}
public void WorldLoaded(World w, WorldRenderer wr)
{
/* based on SmudgeLayer.cs */
var first = sideSprites.First().Value.First();
var sheet = first.Sheet;
if (sideSprites.Values.Any(sprites => sprites.Any(s => s.Sheet != sheet)))
{
throw new InvalidDataException("Resource sprites span multiple sheets. Try loading their sequences earlier.");
}
var blendMode = first.BlendMode;
if (sideSprites.Values.Any(sprites => sprites.Any(s => s.BlendMode != blendMode)))
{
throw new InvalidDataException("Smudges specify different blend modes. "
+ "Try using different smudge types for smudges that use different blend modes.");
}
render = new TerrainSpriteLayer(w, wr, sheet, blendMode, wr.Palette(Info.Palette), wr.World.Type != WorldType.Editor);
var tilesLayer = w.Map.Tiles;
for (var v = 0; v < tilesLayer.Size.Height; v++)
{
for (var u = 0; u < tilesLayer.Size.Width; u++)
{
var mpos = new MPos(u, v);
var tile = tilesLayer[mpos];
if (tile.Type == 143)
{
ClearSides clear = ClearSides.None;
if (u > 0)
{
var leftPos = new MPos(u - 1, v);
var leftTile = tilesLayer[leftPos];
if (!(leftTile.Type >= 126 && leftTile.Type <= 143) &&
!(leftTile.Type >= 160 && leftTile.Type <= 175))
{
clear |= ClearSides.Left;
}
}
if (v > 0)
{
var topPos = new MPos(u, v - 1);
var topTile = tilesLayer[topPos];
if (!(topTile.Type >= 126 && topTile.Type <= 143) &&
!(topTile.Type >= 160 && topTile.Type <= 175))
{
clear |= ClearSides.Top;
}
}
if (u < tilesLayer.Size.Width - 1)
{
var rightPos = new MPos(u + 1, v);
var rightTile = tilesLayer[rightPos];
if (!(rightTile.Type >= 126 && rightTile.Type <= 143) &&
!(rightTile.Type >= 160 && rightTile.Type <= 175))
{
clear |= ClearSides.Right;
}
}
if (v < tilesLayer.Size.Height - 1)
{
var bottomPos = new MPos(u, v + 1);
var bottomTile = tilesLayer[bottomPos];
if (!(bottomTile.Type >= 126 && bottomTile.Type <= 143) &&
!(bottomTile.Type >= 160 && bottomTile.Type <= 175))
{
clear |= ClearSides.Bottom;
}
}
if (clear != ClearSides.None)
{
CPos cpos = mpos.ToCPos(w.Map);
Sprite sprite = sideSprites["rock"][SpriteMap[clear]];
render.Update(cpos, sprite);
}
}
if (tile.Type == 175)
{
ClearSides clear = ClearSides.None;
if (u > 0)
{
var leftPos = new MPos(u - 1, v);
var leftTile = tilesLayer[leftPos];
if (!(leftTile.Type >= 160 && leftTile.Type <= 175))
{
clear |= ClearSides.Left;
}
}
if (v > 0)
{
var topPos = new MPos(u, v - 1);
var topTile = tilesLayer[topPos];
if (!(topTile.Type >= 160 && topTile.Type <= 175))
{
clear |= ClearSides.Top;
}
}
if (u < tilesLayer.Size.Width - 1)
{
var rightPos = new MPos(u + 1, v);
var rightTile = tilesLayer[rightPos];
if (!(rightTile.Type >= 160 && rightTile.Type <= 175))
{
clear |= ClearSides.Right;
}
}
if (v < tilesLayer.Size.Height - 1)
{
var bottomPos = new MPos(u, v + 1);
var bottomTile = tilesLayer[bottomPos];
if (!(bottomTile.Type >= 160 && bottomTile.Type <= 175))
{
clear |= ClearSides.Bottom;
}
}
if (clear != ClearSides.None)
{
CPos cpos = mpos.ToCPos(w.Map);
Sprite sprite = sideSprites["rough"][SpriteMap[clear]];
render.Update(cpos, sprite);
}
}
if (tile.Type == 159)
{
ClearSides clear = ClearSides.None;
if (u > 0)
{
var leftPos = new MPos(u - 1, v);
var leftTile = tilesLayer[leftPos];
if (!(leftTile.Type >= 144 && leftTile.Type <= 159))
{
clear |= ClearSides.Left;
}
}
if (v > 0)
{
var topPos = new MPos(u, v - 1);
var topTile = tilesLayer[topPos];
if (!(topTile.Type >= 144 && topTile.Type <= 159))
{
clear |= ClearSides.Top;
}
}
if (u < tilesLayer.Size.Width - 1)
{
var rightPos = new MPos(u + 1, v);
var rightTile = tilesLayer[rightPos];
if (!(rightTile.Type >= 144 && rightTile.Type <= 159))
{
clear |= ClearSides.Right;
}
}
if (v < tilesLayer.Size.Height - 1)
{
var bottomPos = new MPos(u, v + 1);
var bottomTile = tilesLayer[bottomPos];
if (!(bottomTile.Type >= 144 && bottomTile.Type <= 159))
{
clear |= ClearSides.Bottom;
}
}
if (clear != ClearSides.None)
{
CPos cpos = mpos.ToCPos(w.Map);
Sprite sprite = sideSprites["dune"][SpriteMap[clear]];
render.Update(cpos, sprite);
}
}
}
}
}
public void WorldLoaded(World w, WorldRenderer wr)
{
/* based on SmudgeLayer.cs */
var first = sideSprites.First().Value.First();
var sheet2D = first.Sheet2D;
//this check can be removed
//if (sideSprites.Values.Any(sprites => sprites.Any(s => s.Sheet2D != sheet2D)))
// throw new InvalidDataException("Resource sprites span multiple sheets. Try loading their sequences earlier.");
var blendMode = first.BlendMode;
if (sideSprites.Values.Any(sprites => sprites.Any(s => s.BlendMode != blendMode)))
{
throw new InvalidDataException("Smudges specify different blend modes. "
+ "Try using different smudge types for smudges that use different blend modes.");
}
// using base TerrainRenderer to avoid using one more renderer through TerrainSpriteLayer class as it was done.
//var terrainRenderer = w.WorldActor.TraitOrDefault<IRenderTerrain>(); //to get TerrainRenderer.cs class
//TerrainRenderer = terrainRenderer.GetTerrainSpriteLayerRenderer(); //get all Sprites that it has from tileset\*.yaml file
//render = TerrainRenderer[Info.Palette];
// Nowadays way to accomplish task is to add one more renderer through TerrainSpriteLayer class and we get one more Batch for total terrain vertexes
render = new TerrainSpriteLayer(w, wr, sheet2D, blendMode, wr.Palette(Info.Palette), wr.World.Type != WorldType.Editor, "D2TerrainLayer");
MersenneTwister random = new MersenneTwister();
var tilesLayer = w.Map.Tiles;
for (var v = 0; v < tilesLayer.Size.Height; v++)
{
for (var u = 0; u < tilesLayer.Size.Width; u++)
{
var pos = new MPos(u, v);
var tile = tilesLayer[pos];
if (tile.Type == D2MapUtils.RockTile)
{
var index = D2MapUtils.SmoothIndexForPos(tilesLayer, pos);
if (index != 15)
{
CPos cpos = pos.ToCPos(w.Map);
//ushort sdf;
//int ffd = (128 + Convert.ToInt32(index));
//sdf = Convert.ToUInt16(ffd);
//var t = new TerrainTile(sdf, 0);
//Sprite sprite = wr.Theater.TileSprite(t, 0);
Sprite sprite = sideSprites["rock"][index];
render.Update(cpos, sprite);
}
}
if (tile.Type == D2MapUtils.DuneTile)
{
var index = D2MapUtils.SmoothIndexForPos(tilesLayer, pos);
if (index != 15)
{
CPos cpos = pos.ToCPos(w.Map);
//ushort sdf;
//int ffd = (144 + Convert.ToInt32(index)); //158
//sdf = Convert.ToUInt16(ffd);
//var t = new TerrainTile(sdf, 0);
//Sprite sprite = wr.Theater.TileSprite(t, 0);
Sprite sprite = sideSprites["dune"][index];
render.Update(cpos, sprite);
}
}
if (tile.Type == D2MapUtils.RoughTile)
{
var index = D2MapUtils.SmoothIndexForPos(tilesLayer, pos);
if (index != 15)
{
CPos cpos = pos.ToCPos(w.Map);
//ushort sdf;
//int ffd = (160 + Convert.ToInt32(index));
//sdf = Convert.ToUInt16(ffd);
//var t = new TerrainTile(sdf, 0);
//Sprite sprite = wr.Theater.TileSprite(t, 0);
Sprite sprite = sideSprites["rough"][index];
render.Update(cpos, sprite);
}
}
}
}
}