public override void Render(RenderGrid grid, Stream stream)
{
int width = Settings.CellSize / 2 * (grid.RowCount + grid.ColumnCount) + Settings.Margin * 2;
int height = Settings.CellSize / 4 * (grid.RowCount + grid.ColumnCount) + Settings.Margin * 2;
using (var image = new Image <Rgba32>(width, height))
{
image.Mutate();
image.Mutate(context =>
{
var fullArea = new Rectangle(0, 0, width, height);
foreach (AreaRenderer backgroundRenderer in BackgroundRenderers)
{
backgroundRenderer.Render(context, fullArea);
}
for (int columnIndex = grid.ColumnCount - 1; columnIndex >= 0; --columnIndex)
{
for (int rowIndex = 0; rowIndex < grid.RowCount; ++rowIndex)
{
RenderCell cell = grid[rowIndex, columnIndex];
var cellArea = new Rectangle(
TranslateCoordWithMargin((cell.Column + cell.Row) * Settings.CellSize / 2),
TranslateCoordWithMargin((grid.ColumnCount - cell.Column - 1 + cell.Row) * Settings.CellSize / 4),
Settings.CellSize,
Settings.CellSize / 2);
if (cell.RenderType == RenderType.Ground)
{
foreach (CellRenderer groundRenderer in GroundRenderers)
{
groundRenderer.Render(context, cellArea, cell);
}
}
if (cell.RenderType == RenderType.Wall)
{
foreach (CellRenderer wallRenderer in WallRenderers)
{
wallRenderer.Render(context, cellArea, cell);
}
}
}
}
});
image.Save(stream, ImageFormats.Png);
}
}
static string[,] RenderToArray(RenderGrid renderGrid)
{
var result = new string[renderGrid.RowCount, renderGrid.ColumnCount];
for (int rowIndex = 0; rowIndex < renderGrid.RowCount; ++rowIndex)
{
for (int columnIndex = 0; columnIndex < renderGrid.ColumnCount; ++columnIndex)
{
RenderCell cell = renderGrid[rowIndex, columnIndex];
char renderType = cell.RenderType.ToString().First();
string direction = CreateDirectionString(cell.Direction);
result[rowIndex, columnIndex] = $"{renderType},{direction}";
}
}
return(result);
}
public RefCountedSprite this[int x, int y]
{
get
{
RenderCell cell = _grid[x, y];
if (Equals(cell, default(RenderCell)))
{
return(null);
}
return(cell.GetContent());
}
set
{
RenderCell cell = _grid[x, y];
if (Equals(cell, default(RenderCell)))
{
return;
}
cell.SetContent(value);
}
}
Rgba32?GetRenderingColor(RenderCell cell)
{
object tag = cell.GetTag(_tagKey);
if (tag == null)
{
RenderCell neighborGround = cell.Neighbors
.FirstOrDefault(n => n.RenderType == RenderType.Ground);
return(neighborGround != null?GetRenderingColor(neighborGround) : null);
}
if (!(tag is int))
{
return(null);
}
var value = (int)tag;
Rgba32 theColor;
if (value <= _min)
{
theColor = _gradientStart;
}
else if (value >= _max)
{
theColor = _gradientEnd;
}
else
{
int diff = (value - _min);
theColor = new Rgba32(
(byte)(_gradientStart.R + diff * _stepR),
(byte)(_gradientStart.G + diff * _stepG),
(byte)(_gradientStart.B + diff * _stepB));
}
return(theColor);
}
protected override string GetTextureKey(RenderCell cell)
{
Direction cellDirection = cell.Direction;
var keyBuilder = new StringBuilder();
if ((cellDirection & Direction.North) == Direction.North)
{
keyBuilder.Append("North");
}
if ((cellDirection & Direction.South) == Direction.South)
{
keyBuilder.Append("South");
}
if ((cellDirection & Direction.East) == Direction.East)
{
keyBuilder.Append("East");
}
if ((cellDirection & Direction.West) == Direction.West)
{
keyBuilder.Append("West");
}
return(keyBuilder.Length == 0 ? "Unknown" : keyBuilder.ToString());
}
public override void Render(IImageProcessingContext <Rgba32> context, Rectangle cellArea, RenderCell cell)
{
Rgba32?renderingColor = GetRenderingColor(cell);
if (renderingColor == null)
{
return;
}
context.Fill(renderingColor.Value, cellArea);
}
protected override bool IsSupported(RenderCell cell)
{
return(true);
}
protected abstract string GetTextureKey(RenderCell cell);
protected abstract bool IsSupported(RenderCell cell);
public override void Render(IImageProcessingContext <Rgba32> context, Rectangle cellArea, RenderCell cell)
{
if (!IsSupported(cell))
{
return;
}
string textureKey = GetTextureKey(cell);
Image <Rgba32> texture = _map[textureKey];
if (texture == null)
{
return;
}
var location = new Point(
(cellArea.Left + cellArea.Right) / 2,
cellArea.Bottom);
location.X -= texture.Width / 2;
location.Y -= texture.Height;
context.DrawImage(texture, PixelBlenderMode.Normal, 1.0f, location);
}
public override void Render(IImageProcessingContext <Rgba32> context, Rectangle cellArea, RenderCell cell)
{
if (!IsSupported(cell))
{
return;
}
bool shouldRenderer = _random.Next(100) <= Possibility;
if (shouldRenderer)
{
Image <Rgba32> texture = _textures[_random.Next(_textures.Count)];
int maxX = cellArea.Width - texture.Width;
int maxY = cellArea.Height - texture.Height;
// Will not renderer if texture is too large
if (maxX < 0 || maxY < 0)
{
return;
}
context.DrawImage(
texture,
1.0f,
new Point(cellArea.Left + _random.Next(maxX), cellArea.Top + _random.Next(maxY)));
}
}
protected virtual bool IsSupported(RenderCell cell) => true;
public abstract void Render(
IImageProcessingContext <Rgba32> context,
Rectangle cellArea,
RenderCell cell);
public override void Render(IImageProcessingContext <Rgba32> context, Rectangle cellArea, RenderCell cell)
{
if (!IsSupported(cell))
{
return;
}
Image <Rgba32> texture = _textures[_random.Next(_textures.Count)];
var location = new Point(
(cellArea.Left + cellArea.Right) / 2,
cellArea.Bottom);
location.X -= texture.Width / 2;
location.Y -= texture.Height;
context.DrawImage(texture, PixelBlenderMode.Normal, 1.0f, location);
}
public override void Render(IImageProcessingContext <Rgba32> context, Rectangle cellArea, RenderCell cell)
{
context.Fill(_color, cellArea);
}
