private static bool HasNullTile(MapState mapState, int tileX, int tileY)
{
for (int layer = 0; layer < 4; layer++)
{
if (mapState.GetTile(layer, tileX, tileY) == null)
{
return(true);
}
}
return(false);
}
private static bool CanPlaceLargeTile(MapState mapState, Tile t, int layer, int x, int y)
{
for (int subX = 0; subX < t.Width; subX++)
{
for (int subY = 0; subY < t.Height; subY++)
{
if (mapState.GetTile(layer, x + subX, y + subY).IsLarge)
{
return(false);
}
}
}
return(true);
}
private Rectangle CalculateUpdateRectangle(MapState oldState, MapState newState)
{
int top = oldState.Height + 1;
int left = oldState.Width + 1;
int right = -1;
int bottom = -1;
for (int x = 0; x < oldState.Width + 1; x++)
{
for (int y = 0; y < oldState.Height + 1; y++)
{
for (int layer = 0; layer < 4; layer++)
{
if (oldState.GetTile(layer, x, y) != newState.GetTile(layer, x, y))
{
if (top > y)
{
top = y;
}
if (left > x)
{
left = x;
}
if (right < x)
{
right = x;
}
if (bottom < y)
{
bottom = y;
}
}
}
}
}
if (right < left)
{
return(new Rectangle());
}
return(new Rectangle(
left * tileSet.TileWidth - tileSet.TileXOffset,
top * tileSet.TileHeight - tileSet.TileYOffset,
(right - left + 1) * tileSet.TileWidth,
(bottom - top + 1) * tileSet.TileHeight));
}
private void ClearLargeTiles(MapState mapState, Random rng, int tileX, int tileY, int tileXLimit, int tileYLimit)
{
#if DEBUG
Console.Out.WriteLine("ClearLargeTiles ({0},{1})-({2},{3})", tileX, tileY, tileXLimit, tileYLimit);
#endif
for (int layer = 0; layer < 4; layer++)
{
for (int y = tileYLimit - 1; y >= tileY; y--)
{
for (int x = tileXLimit - 1; x >= tileX; x--)
{
Tile t = mapState.GetTile(layer, x, y);
if (t != null && t.IsLarge)
{
int baseX = x - t.XPosition;
int baseY = y - t.YPosition;
SelectTilesBase(mapState, rng, baseX, baseY, baseX + t.Width, baseY + t.Height);
}
}
}
}
}
private void SelectLargeTiles(MapState mapState, Random rng, int tileX, int tileY, int tileXLimit, int tileYLimit)
{
if (rng == null)
{
return;
}
int width = mapState.Width;
int height = mapState.Height;
if (tileX < 0)
{
tileX = 0;
}
if (tileY < 0)
{
tileY = 0;
}
if (tileXLimit >= width)
{
tileXLimit = width - 1;
}
if (tileYLimit >= height)
{
tileYLimit = height - 1;
}
for (int layer = 0; layer < 4; layer++)
{
Grid <BorderKind> terrainId = new Grid <BorderKind>(width + 2, height + 2);
for (int y = 0; y < terrainId.Height; y++)
{
for (int x = 0; x < terrainId.Width; x++)
{
terrainId[x, y] = mapState.GetSquareKind(x - 1, y - 1).LayerTerrainId[layer];
}
}
for (int x = 0; x < tileXLimit; x++)
{
for (int y = 0; y < tileYLimit; y++)
{
if (rng.NextDouble() < 0.5)
{
continue;
}
Tile oldTile = mapState.GetTile(layer, x, y);
if (oldTile == null || oldTile.IsLarge)
{
continue;
}
Tile t = GetTile(rng, x, y, terrainId, true, null);
if (t != null)
{
if (x + t.Width - 1 < tileX)
{
continue;
}
if (y + t.Height - 1 < tileY)
{
continue;
}
if (CanPlaceLargeTile(mapState, t, layer, x, y))
{
PlaceLargeTile(mapState, t, layer, x, y);
}
}
}
}
}
}
private void SelectTilesBase(MapState mapState, Random rng, int tileX, int tileY, int tileXLimit, int tileYLimit)
{
#if DEBUG
Console.Out.WriteLine("SelectTilesBase ({0},{1})-({2},{3})", tileX, tileY, tileXLimit, tileYLimit);
#endif
for (int layer = 0; layer < 4; layer++)
{
Grid <BorderKind> terrainMap = Map.MakeTerrainSubMap(mapState, tileX, tileY, tileXLimit, tileYLimit, layer);
for (int y = tileYLimit - 1; y >= tileY; y--)
{
for (int x = tileXLimit - 1; x >= tileX; x--)
{
Tile t = GetTile(rng, x - tileX, y - tileY, terrainMap, false, mapState.GetTile(layer, x, y));
mapState.SetTile(layer, x, y, t);
}
}
}
}
public void DrawToGraphics(Graphics target, Rectangle clipRectangle)
{
Debug.Assert(clipRectangle.Width > 0);
Debug.Assert(clipRectangle.Height > 0);
int tileWidth = tileSet.TileWidth;
int tileHeight = tileSet.TileHeight;
int offsetX = tileSet.TileXOffset;
int offsetY = tileSet.TileYOffset;
for (int y = height; y >= 0; y--)
{
for (int x = width; x >= 0; x--)
{
int destX = tileWidth * x - offsetX;
int destY = tileHeight * y - offsetY;
if (destX > clipRectangle.Right)
{
continue;
}
if (destX + tileWidth < clipRectangle.Left)
{
continue;
}
if (destY > clipRectangle.Bottom)
{
continue;
}
if (destY + tileHeight < clipRectangle.Top)
{
continue;
}
for (int layer = 0; layer < 4; layer++)
{
Tile tile = state.GetTile(layer, x, y);
if (tile != null)
{
tile.DrawToGraphics(target, destX, destY);
}
else
{
#if false
PaintSynthetic(target, layer, x, y, destX, destY);
#endif
}
}
}
}
// Paint hover
for (int y = height; y >= 0; y--)
{
for (int x = width; x >= 0; x--)
{
bool needDraw = false;
for (int layer = 0; layer < 4; layer++)
{
if (state.GetTile(layer, x, y) != stateHover.GetTile(layer, x, y))
{
needDraw = true;
}
}
if (!needDraw)
{
continue;
}
int destX = tileWidth * x - offsetX;
int destY = tileHeight * y - offsetY;
if (destX >= clipRectangle.Right)
{
continue;
}
if (destX + tileWidth <= clipRectangle.Left)
{
continue;
}
if (destY >= clipRectangle.Bottom)
{
continue;
}
if (destY + tileHeight <= clipRectangle.Top)
{
continue;
}
Bitmap hoverBitmap = new Bitmap(tileSet.TileWidth, tileSet.TileHeight);
Graphics hoverGraphics = Graphics.FromImage(hoverBitmap);
for (int layer = 0; layer < 4; layer++)
{
Tile tile = stateHover.GetTile(layer, x, y);
if (tile != null)
{
tile.DrawToGraphics(hoverGraphics, 0, 0);
}
else
{
#if false
PaintSynthetic(hoverGraphics, layer, x, y, 0, 0);
#endif
}
}
for (int px = 0; px < hoverBitmap.Width; px++)
{
for (int py = 0; py < hoverBitmap.Height; py++)
{
Color c = hoverBitmap.GetPixel(px, py);
hoverBitmap.SetPixel(px, py, Color.FromArgb((int)(c.A * 0.67), c.R, c.G, c.B));
}
}
target.DrawImage(hoverBitmap, destX, destY);
}
}
}