void UpdateRenderedSpriteInner(CPos cell, RendererCellContents content)
{
if (content.Density > 0)
{
var clear = FindClearSides(cell, content.Type);
if (clear == ClearSides.None)
{
var maxDensity = ResourceLayer.GetMaxDensity(content.Type);
var index = content.Density > maxDensity / 2 ? 1 : 0;
UpdateSpriteLayers(cell, content.Sequence, index, content.Palette);
}
else if (SpriteMap.TryGetValue(clear, out var index))
{
UpdateSpriteLayers(cell, content.Sequence, index, content.Palette);
}
else
{
throw new InvalidOperationException($"SpriteMap does not contain an index for ClearSides type '{clear}'");
}
}
else
{
UpdateSpriteLayers(cell, null, 0, null);
}
}
void UpdateRenderedSpriteInner(CPos cell, RendererCellContents content)
{
var density = content.Density;
var renderType = content.Type;
if (density > 0 && renderType != null)
{
// The call chain for this method (that starts with AddDirtyCell()) guarantees
// that the new content type would still be suitable for this renderer,
// but that is a bit too fragile to rely on in case the code starts changing.
if (!Info.RenderTypes.Contains(renderType.Info.Type))
{
return;
}
var clear = FindClearSides(renderType, cell);
int index;
if (SpriteMap.TryGetValue(clear, out index))
{
UpdateSpriteLayers(cell, renderType.Variants.First().Value, index, renderType.Palette);
}
else
{
Log.Write("debug", "{1}: SpriteMap does not contain an index for ClearSides type '{0}'".F(clear, cell));
}
}
else
{
UpdateSpriteLayers(cell, null, 0, null);
}
}
protected virtual void UpdateRenderedSprite(CPos cell, RendererCellContents content)
{
var density = content.Density;
var type = content.Type;
if (content.Density > 0)
{
// The call chain for this method (that starts with AddDirtyCell()) guarantees
// that the new content type would still be suitable for this renderer,
// but that is a bit too fragile to rely on in case the code starts changing.
if (!Info.RenderTypes.Contains(type.Info.Type))
{
return;
}
var sprites = type.Variants[content.Variant];
var maxDensity = type.Info.MaxDensity;
var frame = int2.Lerp(0, sprites.Length - 1, density, maxDensity);
UpdateSpriteLayers(cell, sprites, frame, type.Palette);
}
else
{
UpdateSpriteLayers(cell, null, 0, null);
}
}
protected override void UpdateRenderedSprite(CPos cell, RendererCellContents content)
{
UpdateRenderedSpriteInner(cell, content);
for (var i = 0; i < Directions.Length; i++)
{
UpdateRenderedSpriteInner(cell + Directions[i]);
}
}
public override void UpdateRenderedSprite(CPos cell, RendererCellContents content)
{
UpdateRenderedSpriteInner(cell, content);
var directions = CVec.Directions;
for (var i = 0; i < directions.Length; i++)
{
UpdateRenderedSpriteInner(cell + directions[i]);
}
}
protected override void UpdateRenderedSprite(CPos cell, RendererCellContents content)
{
UpdateRenderedSpriteInner(cell, content);
var directions = CVec.Directions;
for (var i = 0; i < directions.Length; i++)
{
var neighbour = cell + directions[i];
UpdateRenderedSpriteInner(neighbour, RenderContents[neighbour]);
}
}
void UpdateRenderedSpriteInner(CPos cell, RendererCellContents content)
{
var density = content.Density;
var renderType = content.Type;
if (density > 0 && renderType != null)
{
// The call chain for this method (that starts with AddDirtyCell()) guarantees
// that the new content type would still be suitable for this renderer,
// but that is a bit too fragile to rely on in case the code starts changing.
if (!Info.RenderTypes.Contains(renderType.Info.Type))
{
return;
}
var clear = FindClearSides(renderType, cell);
int index;
if (clear == ClearSides.None && CellContainsMaxDensity(cell, renderType))
{
var maxDensityClear = FindMaxDensityClearSides(renderType, cell);
if (SpriteMap.TryGetValue(maxDensityClear, out index))
{
// Max density sprites is right after normal sprites
index += 16;
UpdateSpriteLayers(cell, renderType.Variants.First().Value[index], renderType.Palette);
}
else
{
throw new InvalidOperationException("SpriteMap does not contain an index for Max Densitty ClearSides type '{0}'".F(clear));
}
}
else if (SpriteMap.TryGetValue(clear, out index))
{
UpdateSpriteLayers(cell, renderType.Variants.First().Value[index], renderType.Palette);
}
else
{
throw new InvalidOperationException("SpriteMap does not contain an index for ClearSides type '{0}'".F(clear));
}
}
else
{
UpdateSpriteLayers(cell, null, null);
}
}
void IWorldLoaded.WorldLoaded(World w, WorldRenderer wr)
{
var resources = w.WorldActor.TraitsImplementing <ResourceType>()
.ToDictionary(r => r.Info.ResourceType, r => r);
// Build the sprite layer dictionary for rendering resources
// All resources that have the same palette must also share a sheet and blend mode
foreach (var r in resources)
{
var layer = spriteLayers.GetOrAdd(r.Value.Palette, pal =>
{
var first = r.Value.Variants.First().Value.GetSprite(0);
return(new TerrainSpriteLayer(w, wr, first.Sheet, first.BlendMode, pal, wr.World.Type != WorldType.Editor));
});
// Validate that sprites are compatible with this layer
var sheet = layer.Sheet;
var sprites = r.Value.Variants.Values.SelectMany(v => Exts.MakeArray(v.Length, x => v.GetSprite(x)));
if (sprites.Any(s => s.Sheet != sheet))
{
throw new InvalidDataException("Resource sprites span multiple sheets. Try loading their sequences earlier.");
}
var blendMode = layer.BlendMode;
if (sprites.Any(s => s.BlendMode != blendMode))
{
throw new InvalidDataException("Resource sprites specify different blend modes. "
+ "Try using different palettes 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.GetResourceType(cell);
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);
}
}
}
void UpdateRenderedSpriteInner(CPos cell, RendererCellContents content)
{
var density = content.Density;
var renderType = content.Type;
if (density > 0 && renderType != null)
{
var clear = FindClearSides(cell, content.Type);
if (SpriteMap.TryGetValue(clear, out var index))
{
UpdateSpriteLayers(cell, content.Sequence, index, content.Palette);
}
else
{
Log.Write("debug", "{1}: SpriteMap does not contain an index for ClearSides type '{0}'".F(clear, cell));
}
}
else
{
UpdateSpriteLayers(cell, null, 0, null);
}
}
void ITickRender.TickRender(WorldRenderer wr, Actor self)
{
foreach (var cell in dirty)
{
if (self.World.FogObscures(cell))
{
continue;
}
var resourceContent = ResourceLayer.GetResource(cell);
if (resourceContent.Density > 0)
{
var cellContents = RenderContent[cell];
var variant = cellContents.Variant;
if (cellContents.Variant == null || cellContents.Type != resourceContent.Type)
{
variant = ChooseRandomVariant(resourceContent.Type);
}
var rendererCellContents = new RendererCellContents(variant, resourceContent.Type, resourceContent.Density);
RenderContent[cell] = rendererCellContents;
UpdateRenderedSprite(cell, rendererCellContents);
}
else
{
var rendererCellContents = RendererCellContents.Empty;
RenderContent[cell] = rendererCellContents;
UpdateRenderedSprite(cell, rendererCellContents);
}
cleanDirty.Enqueue(cell);
}
while (cleanDirty.Count > 0)
{
dirty.Remove(cleanDirty.Dequeue());
}
}
