public static PatternReplaceCount FloorPatternRect(VMArchitecture target, Rectangle rect, ushort dir, ushort pattern, sbyte level) //returns floors covered
{
PatternReplaceCount floorsCovered = new PatternReplaceCount(true);
if (rect.Width == 0 && rect.Height == 0)
{
//dot mode, just fill a tile. can be a diagonal.
if (rect.X < 0 || rect.X >= target.Width || rect.Y < 0 || rect.Y >= target.Width)
{
return(floorsCovered);
}
var wall = target.GetWall((short)rect.X, (short)rect.Y, level);
if ((wall.Segments & AnyDiag) > 0 && pattern < 65534)
{
bool side = ((wall.Segments & WallSegments.HorizontalDiag) > 0) ? (dir < 2) : (dir < 1 || dir > 2);
if (side)
{
if (wall.TopLeftStyle != pattern)
{
floorsCovered.Add(wall.TopLeftStyle);
wall.TopLeftStyle = pattern;
}
}
else
{
if (wall.TopLeftPattern != pattern)
{
floorsCovered.Add(wall.TopLeftPattern);
wall.TopLeftPattern = pattern;
}
}
target.SetWall((short)rect.X, (short)rect.Y, level, wall);
}
else if ((wall.Segments & AnyDiag) == 0)
{
var floor = target.GetFloor((short)rect.X, (short)rect.Y, level);
if (floor.Pattern != pattern)
{
var old = floor.Pattern;
floor.Pattern = pattern;
if (target.SetFloor((short)rect.X, (short)rect.Y, level, floor, false))
{
floorsCovered.DAdd(old);
}
}
}
return(floorsCovered);
}
var xEnd = Math.Min(target.Width, rect.X + rect.Width + 1);
var yEnd = Math.Min(target.Height, rect.Y + rect.Height + 1);
for (int y = Math.Max(0, rect.Y); y < yEnd; y++)
{
for (int x = Math.Max(0, rect.X); x < xEnd; x++)
{
var wall = target.GetWall((short)x, (short)y, level);
if ((wall.Segments & AnyDiag) > 0) //diagonal floors are stored in walls
{
if (pattern < 65534)
{
continue;
}
if (wall.TopLeftStyle != pattern)
{
wall.TopLeftStyle = pattern;
floorsCovered.Add(wall.TopLeftStyle);
}
if (wall.TopLeftPattern != pattern)
{
wall.TopLeftPattern = pattern;
floorsCovered.Add(wall.TopLeftPattern);
}
target.SetWall((short)x, (short)y, level, wall);
}
else
{
var floor = target.GetFloor((short)x, (short)y, level);
if (floor.Pattern != pattern)
{
var old = floor.Pattern;
floor.Pattern = pattern;
if (target.SetFloor((short)x, (short)y, level, floor, false))
{
floorsCovered.DAdd(old);
}
}
}
}
}
return(floorsCovered);
}
//returns floors covered
public static PatternReplaceCount FloorPatternRect(VMArchitecture target, Rectangle rect, ushort dir, ushort pattern, sbyte level)
{
PatternReplaceCount floorsCovered = new PatternReplaceCount(true);
if (rect.Width == 0 && rect.Height == 0)
{
//dot mode, just fill a tile. can be a diagonal.
if (rect.X < 0 || rect.X >= target.Width || rect.Y < 0 || rect.Y >= target.Width) return floorsCovered;
var wall = target.GetWall((short)rect.X, (short)rect.Y, level);
if ((wall.Segments & AnyDiag) > 0 && pattern < 65534)
{
bool side = ((wall.Segments & WallSegments.HorizontalDiag) > 0) ? (dir < 2) : (dir < 1 || dir > 2);
if (side)
{
if (wall.TopLeftStyle != pattern)
{
floorsCovered.Add(wall.TopLeftStyle);
wall.TopLeftStyle = pattern;
}
}
else
{
if (wall.TopLeftPattern != pattern)
{
floorsCovered.Add(wall.TopLeftPattern);
wall.TopLeftPattern = pattern;
}
}
target.SetWall((short)rect.X, (short)rect.Y, level, wall);
}
else if ((wall.Segments & AnyDiag) == 0)
{
var floor = target.GetFloor((short)rect.X, (short)rect.Y, level);
if (floor.Pattern != pattern)
{
var old = floor.Pattern;
floor.Pattern = pattern;
if (target.SetFloor((short)rect.X, (short)rect.Y, level, floor, false)) floorsCovered.DAdd(old);
}
}
return floorsCovered;
}
var xEnd = Math.Min(target.Width, rect.X + rect.Width+1);
var yEnd = Math.Min(target.Height, rect.Y + rect.Height+1);
for (int y = Math.Max(0, rect.Y); y < yEnd; y++)
{
for (int x = Math.Max(0, rect.X); x < xEnd; x++)
{
var wall = target.GetWall((short)x, (short)y, level);
if ((wall.Segments & AnyDiag) > 0) //diagonal floors are stored in walls
{
if (pattern < 65534) continue;
if (wall.TopLeftStyle != pattern)
{
wall.TopLeftStyle = pattern;
floorsCovered.Add(wall.TopLeftStyle);
}
if (wall.TopLeftPattern != pattern)
{
wall.TopLeftPattern = pattern;
floorsCovered.Add(wall.TopLeftPattern);
}
target.SetWall((short)x, (short)y, level, wall);
}
else
{
var floor = target.GetFloor((short)x, (short)y, level);
if (floor.Pattern != pattern)
{
var old = floor.Pattern;
floor.Pattern = pattern;
if (target.SetFloor((short)x, (short)y, level, floor, false)) floorsCovered.DAdd(old);
}
}
}
}
return floorsCovered;
}
/// <summary>
/// Fills a room with a certain Floor pattern. Returns floors covered
/// </summary>
public static PatternReplaceCount FloorPatternFill(VMArchitecture target, Point pos, ushort pattern, sbyte level) //for first floor gen, curRoom should be 1. For floors above, it should be the last genmap result
{
if (pattern > 65533 || pos.X < 0 || pos.X >= target.Width || pos.Y < 0 || pos.Y >= target.Height)
{
return(new PatternReplaceCount());
}
pos.X = Math.Max(Math.Min(pos.X, target.Width - 1), 0);
pos.Y = Math.Max(Math.Min(pos.Y, target.Height - 1), 0);
var walls = target.Walls[level - 1];
var width = target.Width;
var height = target.Height;
PatternReplaceCount floorsCovered = new PatternReplaceCount(true);
byte[] Map = new byte[target.Width * target.Height];
//flood fill recursively. Each time choose find and choose the first "0" as the base.
//The first recursion (outside) cannot fill into diagonals.
var spread = new Stack <Point>();
spread.Push(pos);
while (spread.Count > 0)
{
var item = spread.Pop();
var plusX = (item.X + 1) % width;
var minX = (item.X + width - 1) % width;
var plusY = (item.Y + 1) % height;
var minY = (item.Y + height - 1) % height;
var mainWalls = walls[item.X + item.Y * width];
var floor = target.GetFloor((short)item.X, (short)item.Y, level);
if ((byte)mainWalls.Segments > 15)
{
//draw floor onto a diagonal;
var wall = walls[item.X + item.Y * width];
byte flags = Map[item.X + item.Y * width];
if (flags == 3)
{
continue;
}
if ((mainWalls.Segments & WallSegments.HorizontalDiag) > 0)
{
flags = (byte)(3 - flags);
}
if ((flags & 1) == 1 && wall.TopLeftPattern != pattern)
{
floorsCovered.Add(wall.TopLeftPattern);
wall.TopLeftPattern = pattern;
}
else if ((flags & 2) == 2 && wall.TopLeftStyle != pattern)
{
floorsCovered.Add(wall.TopLeftStyle);
wall.TopLeftStyle = pattern;
}
walls[item.X + item.Y * width] = wall;
continue; //don't spread on diagonals for now
}
else
{
//normal tile, draw a floor here.
if (floor.Pattern != pattern)
{
var old = floor.Pattern;
floor.Pattern = pattern;
if (target.SetFloor((short)item.X, (short)item.Y, level, floor, false))
{
floorsCovered.DAdd(old);
}
}
}
if (Map[plusX + item.Y * width] < 3 && (mainWalls.Segments & WallSegments.BottomRight) == 0)
{
SpreadOnto(walls, plusX, item.Y, 0, Map, width, height, spread, pattern, true);
}
if (Map[minX + item.Y * width] < 3 && (mainWalls.Segments & WallSegments.TopLeft) == 0)
{
SpreadOnto(walls, minX, item.Y, 2, Map, width, height, spread, pattern, true);
}
if (Map[item.X + plusY * width] < 3 && (mainWalls.Segments & WallSegments.BottomLeft) == 0)
{
SpreadOnto(walls, item.X, plusY, 1, Map, width, height, spread, pattern, true);
}
if (Map[item.X + minY * width] < 3 && (mainWalls.Segments & WallSegments.TopRight) == 0)
{
SpreadOnto(walls, item.X, minY, 3, Map, width, height, spread, pattern, true);
}
walls[item.X + item.Y * width] = mainWalls;
}
return(floorsCovered);
}
//for first floor gen, curRoom should be 1. For floors above, it should be the last genmap result
/// <summary>
/// Fills a room with a certain Floor pattern. Returns floors covered
/// </summary>
public static PatternReplaceCount FloorPatternFill(VMArchitecture target, Point pos, ushort pattern, sbyte level)
{
if (pattern > 65533 || pos.X < 0 || pos.X >= target.Width || pos.Y < 0 || pos.Y >= target.Height) return new PatternReplaceCount();
pos.X = Math.Max(Math.Min(pos.X, target.Width - 1), 0);
pos.Y = Math.Max(Math.Min(pos.Y, target.Height - 1), 0);
var walls = target.Walls[level-1];
var width = target.Width;
var height = target.Height;
PatternReplaceCount floorsCovered = new PatternReplaceCount(true);
byte[] Map = new byte[target.Width * target.Height];
//flood fill recursively. Each time choose find and choose the first "0" as the base.
//The first recursion (outside) cannot fill into diagonals.
var spread = new Stack<Point>();
spread.Push(pos);
while (spread.Count > 0)
{
var item = spread.Pop();
var plusX = (item.X + 1) % width;
var minX = (item.X + width - 1) % width;
var plusY = (item.Y + 1) % height;
var minY = (item.Y + height - 1) % height;
var mainWalls = walls[item.X + item.Y * width];
var floor = target.GetFloor((short)item.X, (short)item.Y, level);
if ((byte)mainWalls.Segments > 15)
{
//draw floor onto a diagonal;
var wall = walls[item.X + item.Y * width];
byte flags = Map[item.X + item.Y * width];
if (flags == 3) continue;
if ((mainWalls.Segments & WallSegments.HorizontalDiag) > 0) flags = (byte)(3 - flags);
if ((flags & 1) == 1 && wall.TopLeftPattern != pattern)
{
floorsCovered.Add(wall.TopLeftPattern);
wall.TopLeftPattern = pattern;
}
else if ((flags & 2) == 2 && wall.TopLeftStyle != pattern)
{
floorsCovered.Add(wall.TopLeftStyle);
wall.TopLeftStyle = pattern;
}
walls[item.X + item.Y * width] = wall;
continue; //don't spread on diagonals for now
}
else
{
//normal tile, draw a floor here.
if (floor.Pattern != pattern)
{
var old = floor.Pattern;
floor.Pattern = pattern;
if (target.SetFloor((short)item.X, (short)item.Y, level, floor, false)) floorsCovered.DAdd(old);
}
}
if (Map[plusX + item.Y * width] < 3 && (mainWalls.Segments & WallSegments.BottomRight) == 0)
SpreadOnto(walls, plusX, item.Y, 0, Map, width, height, spread, pattern, true);
if (Map[minX + item.Y * width] < 3 && (mainWalls.Segments & WallSegments.TopLeft) == 0)
SpreadOnto(walls, minX, item.Y, 2, Map, width, height, spread, pattern, true);
if (Map[item.X + plusY * width] < 3 && (mainWalls.Segments & WallSegments.BottomLeft) == 0)
SpreadOnto(walls, item.X, plusY, 1, Map, width, height, spread, pattern, true);
if (Map[item.X + minY * width] < 3 && (mainWalls.Segments & WallSegments.TopRight) == 0)
SpreadOnto(walls, item.X, minY, 3, Map, width, height, spread, pattern, true);
walls[item.X + item.Y * width] = mainWalls;
}
return floorsCovered;
}
