bool allocateBlackSpace(Room room, PropOverlay overlay, Vector3 size, Vector3 p, List <Vector3> tempBlack)
{
var i0 = Math.Sign(size.x);
var j0 = Math.Sign(size.y);
var k0 = Math.Sign(size.z);
for (int i = 0; i < Math.Abs(size.x); i++)
{
for (int j = 0; j < Math.Abs(size.y); j++)
{
for (int k = 0; k < Math.Abs(size.z); k++)
{
var p2 = (p + new Vector3(i0 * i, j0 * j, k0 * k));
if (grid.ContainsKey(p2) && grid[p2].C == Color.grey && (positionSuitableForProp(overlay, p2, room)))
{
tempBlack.Add(p2);
}
else
{
return(false);
}
}
}
}
return(true);
}
public PropUnit(List <Vector3> p, PropOverlay overlay)
{
this.points = p.ToList();
this.overlay = overlay;
b = new Bounds(points[0], Vector3.zero);
foreach (Vector3 v in points)
{
b.Encapsulate(v + Vector3.one / 2);
b.Encapsulate(v - Vector3.one / 2);
}
}
public bool positionSuitableForProp(PropOverlay overlay, Vector3 v, Room room)
{
var cell = room.cells[v];
var walls = cell.findWallWithAttribute(FaceTypes.WALL);
bool containsRightAmountOfWalls = overlay.numberOfWalls.Contains(walls.Count);
bool containsNoExcludedTags = true;
foreach (FaceTypes excludedTag in overlay.excludedTags)
{
var count = cell.findWallWithAttribute(excludedTag).Count;
if (count > 0)
{
containsNoExcludedTags = false;
}
}
return(containsNoExcludedTags && containsRightAmountOfWalls);
}
bool recurse(int iter, Vector3 direction, Vector3 p, Quaternion rotation, PropOverlay overlay, Room room, PropUnitCollection propUnitCollection)
{
if (iter == 0)
{
return(true);
}
var size = rotation * overlay.size;
var points = new List <Vector3>();
var allocateBlackSpaceSucceeded = allocateBlackSpace(room, overlay, size, p, points);
var totalblack = getListOfPointsOfColor(Color.black).ConvertAll(x => x.V).ToList();
totalblack.AddRange(propUnitCollection.getListOfPoints());
var totalWhite = grid.Keys.Except(totalblack).ToList();
var islegal = check(grid.Keys.ToList(), totalWhite, totalblack);
if (!islegal)
{
GameObject.Instantiate(g3).transform.position = p;
grid[p].changeColor(Color.white);
return(false);
}
if (!allocateBlackSpaceSucceeded || points.Count == 0)
{
return(true);
}
var propUnit = new PropUnit(points, overlay);
propUnitCollection.list.Add(propUnit);
recurse(iter - 1, direction, p + direction, rotation, overlay, room, propUnitCollection);
return(true);
}
public List <PropUnitCollection> partitionSpace(Room room)
{
var rects = new Dictionary <Rect, PropOverlay>();
var POG = propOverlays[0].propOverlays;
var propQueue = new Queue <PropOverlay>(POG);
var output = new List <PropUnitCollection>();
var list = getListOfPointsOfColor(Color.grey);
list = list.OrderByDescending(x => x.value).ToList();
var queue = new Queue <GridUnit>(list);
for (int q = 0; q < cutoff; q++)
{
if (list.Count == 0)
{
break;
}
var gU = queue.Dequeue();
var p = gU.V;
queue.Enqueue(gU);
PropOverlay overlay = propQueue.Peek();
if (!overlay.highPriority)
{
propQueue.Dequeue();
propQueue.Enqueue(overlay);
}
int iter = 1;
if (overlay.extendable)
{
iter = r.Next(3, 6);
}
List <PropUnitCollection> possibilities = new List <PropUnitCollection>();
foreach (Vector3 direction in VoxelIterators.VonNeumanNeighbors())
{
var d2 = new Vector3(direction.x * overlay.size.x, direction.y * overlay.size.y, direction.z * overlay.size.z);
var rot = Quaternion.identity;
var black = new PropUnitCollection();
if (recurse(iter, d2, p, rot, overlay, room, black) && black.list.Count > 0)
{
possibilities.Add(black);
}
}
possibilities = possibilities.OrderByDescending(x => x.list.Count).ToList();
if (possibilities.Count > 0)
{
var first = possibilities.First();
var black = first.getListOfPoints();
if (black.Count > 0)
{
output.Add(first);
commitColorChangeToGrid(black, Color.black);
var whitespace = new List <Vector3>();
allocateWhiteSpace(black, whitespace);
commitColorChangeToGrid(whitespace, Color.white);
list = getListOfPointsOfColor(Color.grey);
list = list.OrderByDescending(x => x.value).ToList();
queue = new Queue <GridUnit>(list);
}
if (overlay.highPriority)
{
propQueue.Dequeue();
}
}
}
//foreach (GridUnit v in getListOfPointsOfColor(Color.white)) GameObject.Instantiate(g1).transform.position = v.V;
//foreach (GridUnit v in getListOfPointsOfColor(Color.black)) GameObject.Instantiate(g2).transform.position = v.V;
return(output);
}
