void IWorldLoaded.WorldLoaded(World w, WorldRenderer wr)
{
// Cache locations of veinhole actors
// TODO: Add support for monitoring actors placed in the map editor!
w.ActorAdded += ActorAddedToWorld;
w.ActorRemoved += ActorRemovedFromWorld;
foreach (var a in w.Actors)
{
ActorAddedToWorld(a);
}
veinSequence = w.Map.Rules.Sequences.GetSequence(info.Image, info.Sequence);
veinPalette = wr.Palette(info.Palette);
var first = veinSequence.GetSprite(0);
var emptySprite = new Sprite(first.Sheet, Rectangle.Empty, TextureChannel.Alpha);
spriteLayer = new TerrainSpriteLayer(w, wr, emptySprite, first.BlendMode, wr.World.Type != WorldType.Editor);
// Initialize the renderIndices with the initial map state so it is visible
// through the fog with the Explored Map option enabled
foreach (var cell in w.Map.AllCells)
{
var resource = resourceLayer.GetResource(cell);
var cellIndices = CalculateCellIndices(resource, cell);
if (cellIndices != null)
{
renderIndices[cell] = cellIndices;
UpdateRenderedSprite(cell, cellIndices);
}
}
}
public void WorldLoaded(World w, WorldRenderer wr)
{
// Initialize tile cache
// This includes the region outside the visible area to cover any sprites peeking outside the map
foreach (var uv in w.Map.AllCells.MapCoords)
{
var pos = w.Map.CenterOfCell(uv.ToCPos(map));
var screen = wr.Screen3DPosition(pos - new WVec(0, 0, pos.Z));
var variant = (byte)Game.CosmeticRandom.Next(info.ShroudVariants.Length);
tileInfos[uv] = new TileInfo(screen, variant);
}
// Dirty the whole projected space
DirtyCells(map.AllCells.MapCoords.Select(uv => (PPos)uv));
// All tiles are visible in the editor
if (w.Type == WorldType.Editor)
{
visibleUnderShroud = _ => true;
}
else
{
visibleUnderShroud = puv => map.Contains(puv);
}
visibleUnderFog = puv => map.Contains(puv);
var shroudSheet = shroudSprites[0].Sheet2D;
if (shroudSprites.Any(s => s.Sheet2D != shroudSheet))
{
throw new InvalidDataException("Shroud sprites span multiple sheets. Try loading their sequences earlier.");
}
var shroudBlend = shroudSprites[0].BlendMode;
if (shroudSprites.Any(s => s.BlendMode != shroudBlend))
{
throw new InvalidDataException("Shroud sprites must all use the same blend mode.");
}
var fogSheet = fogSprites[0].Sheet2D;
if (fogSprites.Any(s => s.Sheet2D != fogSheet))
{
throw new InvalidDataException("Fog sprites span multiple sheets. Try loading their sequences earlier.");
}
var fogBlend = fogSprites[0].BlendMode;
if (fogSprites.Any(s => s.BlendMode != fogBlend))
{
throw new InvalidDataException("Fog sprites must all use the same blend mode.");
}
shroudLayer = new TerrainSpriteLayer(w, wr, shroudSheet, shroudBlend, wr.Palette(info.ShroudPalette), false, "D2ShroudRenderer.shroudLayer");
fogLayer = new TerrainSpriteLayer(w, wr, fogSheet, fogBlend, wr.Palette(info.FogPalette), false, "D2ShroudRenderer.foglayer");
}
void IWorldLoaded.WorldLoaded(World w, WorldRenderer wr)
{
// Initialize tile cache
// This includes the region outside the visible area to cover any sprites peeking outside the map
foreach (var uv in w.Map.AllCells.MapCoords)
{
var pos = w.Map.CenterOfCell(uv.ToCPos(map));
var screen = wr.Screen3DPosition(pos - new WVec(0, 0, pos.Z));
tileInfos[uv] = new TileInfo(screen);
}
// All tiles are visible in the editor
if (w.Type == WorldType.Editor)
{
visibleUnderShroud = _ => true;
}
else
{
visibleUnderShroud = puv => map.Contains(puv);
}
visibleUnderFog = puv => map.Contains(puv);
var shroudSheet = shroudSprites[0].Sheet;
if (shroudSprites.Any(s => s.Sheet != shroudSheet))
{
throw new InvalidDataException("Shroud sprites span multiple sheets. Try loading their sequences earlier.");
}
var shroudBlend = shroudSprites[0].BlendMode;
if (shroudSprites.Any(s => s.BlendMode != shroudBlend))
{
throw new InvalidDataException("Shroud sprites must all use the same blend mode.");
}
var fogSheet = fogSprites[0].Sheet;
if (fogSprites.Any(s => s.Sheet != fogSheet))
{
throw new InvalidDataException("Fog sprites span multiple sheets. Try loading their sequences earlier.");
}
var fogBlend = fogSprites[0].BlendMode;
if (fogSprites.Any(s => s.BlendMode != fogBlend))
{
throw new InvalidDataException("Fog sprites must all use the same blend mode.");
}
shroudLayer = new TerrainSpriteLayer(w, wr, shroudSheet, shroudBlend, wr.Palette(info.ShroudPalette), false);
fogLayer = new TerrainSpriteLayer(w, wr, fogSheet, fogBlend, wr.Palette(info.FogPalette), false);
WorldOnRenderPlayerChanged(world.RenderPlayer);
}
void IWorldLoaded.WorldLoaded(World world, WorldRenderer wr)
{
worldRenderer = wr;
spriteLayer = new TerrainSpriteLayer(world, wr, tileCache.MissingTile, BlendMode.Alpha, world.Type != WorldType.Editor);
foreach (var cell in map.AllCells)
{
UpdateCell(cell);
}
map.Tiles.CellEntryChanged += UpdateCell;
map.Height.CellEntryChanged += UpdateCell;
}
protected virtual void WorldLoaded(World w, WorldRenderer wr)
{
var sequences = w.Map.Rules.Sequences;
foreach (var kv in Info.ResourceTypes)
{
var resourceInfo = kv.Value;
var resourceVariants = resourceInfo.Sequences
.ToDictionary(v => v, v => sequences.GetSequence(resourceInfo.Image, v));
Variants.Add(kv.Key, resourceVariants);
if (spriteLayer == null)
{
var first = resourceVariants.First().Value.GetSprite(0);
var emptySprite = new Sprite(first.Sheet, Rectangle.Empty, TextureChannel.Alpha);
spriteLayer = new TerrainSpriteLayer(w, wr, emptySprite, first.BlendMode, wr.World.Type != WorldType.Editor);
}
if (shadowLayer == null)
{
var firstWithShadow = resourceVariants.Values.FirstOrDefault(v => v.ShadowStart > 0);
if (firstWithShadow != null)
{
var first = firstWithShadow.GetShadow(0, WAngle.Zero);
var emptySprite = new Sprite(first.Sheet, Rectangle.Empty, TextureChannel.Alpha);
shadowLayer = new TerrainSpriteLayer(w, wr, emptySprite, first.BlendMode, wr.World.Type != WorldType.Editor);
}
}
// All resources must share a blend mode
var sprites = resourceVariants.Values.SelectMany(v => Exts.MakeArray(v.Length, x => v.GetSprite(x)));
if (sprites.Any(s => s.BlendMode != spriteLayer.BlendMode))
{
throw new InvalidDataException("Resource sprites specify different blend modes. "
+ "Try using different ResourceRenderer traits for resource types that use different blend modes.");
}
}
// Initialize the RenderContent with the initial map state so it is visible
// through the fog with the Explored Map option enabled
foreach (var cell in w.Map.AllCells)
{
var resource = ResourceLayer.GetResource(cell);
var rendererCellContents = CreateRenderCellContents(wr, resource, cell);
if (rendererCellContents.Type != null)
{
RenderContents[cell] = rendererCellContents;
UpdateRenderedSprite(cell, rendererCellContents);
}
}
}
void IWorldLoaded.WorldLoaded(World w, WorldRenderer wr)
{
var resources = w.WorldActor.TraitsImplementing <ResourceType>()
.ToDictionary(r => r.Info.ResourceType, r => r);
foreach (var r in resources)
{
if (spriteLayer == null)
{
var first = r.Value.Variants.First().Value.GetSprite(0);
var emptySprite = new Sprite(first.Sheet, Rectangle.Empty, TextureChannel.Alpha);
spriteLayer = new TerrainSpriteLayer(w, wr, emptySprite, first.BlendMode, wr.World.Type != WorldType.Editor);
}
if (shadowLayer == null)
{
var firstWithShadow = r.Value.Variants.Values.FirstOrDefault(v => v.ShadowStart > 0);
if (firstWithShadow != null)
{
var first = firstWithShadow.GetShadow(0, WAngle.Zero);
var emptySprite = new Sprite(first.Sheet, Rectangle.Empty, TextureChannel.Alpha);
shadowLayer = new TerrainSpriteLayer(w, wr, emptySprite, first.BlendMode, wr.World.Type != WorldType.Editor);
}
}
// All resources must share a blend mode
var sprites = r.Value.Variants.Values.SelectMany(v => Exts.MakeArray(v.Length, x => v.GetSprite(x)));
if (sprites.Any(s => s.BlendMode != spriteLayer.BlendMode))
{
throw new InvalidDataException("Resource sprites specify different blend modes. "
+ "Try using different ResourceRenderer traits for resource types that use different blend modes.");
}
}
// Initialize the RenderContent with the initial map state
// because the shroud may not be enabled.
foreach (var cell in w.Map.AllCells)
{
var type = ResourceLayer.GetResource(cell).Type;
if (type != null && Info.RenderTypes.Contains(type.Info.Type))
{
var resourceContent = ResourceLayer.GetResource(cell);
var rendererCellContents = new RendererCellContents(ChooseRandomVariant(resourceContent.Type), resourceContent.Type, resourceContent.Density);
RenderContent[cell] = rendererCellContents;
UpdateRenderedSprite(cell, rendererCellContents);
}
}
}
public void WorldLoaded(World w, WorldRenderer wr)
{
theater = wr.Theater;
bi = w.WorldActor.Trait <BuildingInfluence>();
Sheet2D sh;
if (string.IsNullOrEmpty(theater.tileset.MegaTexture))
{
sh = theater.Sheet;
}
else
{
sh = theater.sbMegaTexture.Current;
}
render = new TerrainSpriteLayer(w, wr, sh, BlendMode.Alpha, wr.Palette(info.Palette), wr.World.Type != WorldType.Editor, "BuildableTerrainLayer");
}
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 IWorldLoaded.WorldLoaded(World w, WorldRenderer wr)
{
render = new TerrainSpriteLayer(w, wr, disabledSprite, BlendMode.Alpha, wr.World.Type != WorldType.Editor);
world.Map.Tiles.CellEntryChanged += UpdateTerrainCell;
world.Map.CustomTerrain.CellEntryChanged += UpdateTerrainCell;
var cells = w.Map.AllCells.Where(c => w.Map.Contains(c) &&
!info.AllowedTerrainTypes.Contains(w.Map.GetTerrainInfo(c).Type)).ToHashSet();
palette = wr.Palette(info.Palette);
foreach (var cell in cells)
{
UpdateTerrainCell(cell);
}
}
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);
}
}
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 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);
}
}
}
}
}
public void WorldLoaded(World w, WorldRenderer wr)
{
theater = wr.Theater;
render = new TerrainSpriteLayer(w, wr, theater.Sheet, BlendMode.Alpha, wr.Palette(info.Palette), wr.World.Type != WorldType.Editor);
}
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 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)
{
theater = wr.Theater;
bi = w.WorldActor.Trait <BuildingInfluence>();
render = new TerrainSpriteLayer(w, wr, theater.Sheet, BlendMode.Alpha, wr.Palette(info.Palette), wr.World.Type != WorldType.Editor);
}
void IWorldLoaded.WorldLoaded(World w, WorldRenderer wr)
{
render = new TerrainSpriteLayer(w, wr, terrainRenderer.MissingTile, BlendMode.Alpha, wr.World.Type != WorldType.Editor);
paletteReference = wr.Palette(info.Palette);
}
