public bool VerifyProjectionScaffoldDoesntIntersect(SuiteProjection projection, SuiteEntity entity, LevelRoom room, Vector3 root, Direction normal, out List <Scaffold_Node> projectionNodes)
{
if (entity.partial)
{
return(VerifyScaffoldsForPartialSpace(projection, entity, room, out projectionNodes));
}
return(VerifyScaffoldsForFullSpace(projection, entity, room, root, normal, out projectionNodes));
}
/// <summary>
/// Renders a normalized projection of this entity in space at root 0 with a normal of North
/// </summary>
/// <param name="normal"></param>
/// <returns></returns>
public SuiteProjection BuildProjection(Vector3 position = new Vector3(), Direction normal = Direction.North)
{
var result = new SuiteProjection();
foreach (var openSpace in spaces)
{
result.spaces.Add(new Vector3(
position.x + openSpace.x * Cellf.CELL_STEP_OFFSET,
position.y + openSpace.y * Cellf.CELL_STEP_OFFSET,
position.z + openSpace.z * Cellf.CELL_STEP_OFFSET).ProjectOffsetToNormal(normal));
}
return(result);
}
public SuiteProjection BuildWallProjection(Vector3 position = new Vector3(), Direction normal = Direction.North)
{
var result = new SuiteProjection();
foreach (var wall in walls)
{
result.spaces.Add(new Vector4(
position.x + wall.x * Cellf.CELL_STEP_OFFSET,
position.y + wall.y * Cellf.CELL_STEP_OFFSET,
position.z + wall.z * Cellf.CELL_STEP_OFFSET,
wall.w).ProjectOffsetToNormal(normal));
}
return(result);
}
private bool VerifyScaffoldsForPartialSpace(SuiteProjection projection, SuiteEntity entity, LevelRoom room, out List <Scaffold_Node> projectionNodes)
{
throw new NotImplementedException();
}
private bool VerifyScaffoldsForFullSpace(SuiteProjection projection, SuiteEntity entity, LevelRoom room, Vector3 root, Direction normal, out List <Scaffold_Node> projectionNodes)
{
projectionNodes = new List <Scaffold_Node>();
var roomScaffold = Level.roomScaffolds[room.roomId];
var projectionSpace = projection.spaces;
var projectionCells = CellCollection.cells.Select(s => s.Value).Where(x => projectionSpace.Contains(x.position));
//Floor + Ceiling, both are handled in the same move when not a partial
var floor_main = roomScaffold.floor.main.Where(x => x.rootCells.All(a => projectionCells.Contains(a)));
if (nextContainerInstance.claimedScaffolds.Any(a => floor_main.Select(s => s.id).Contains(a.id)))
{
return(false);
}
projectionNodes.AddRange(floor_main);
var floor_connectors = roomScaffold.floor.connectors.Where(x => x.rootCells.All(a => projectionCells.Contains(a)));
if (nextContainerInstance.claimedScaffolds.Any(a => floor_connectors.Select(s => s.id).Contains(a.id)))
{
return(false);
}
projectionNodes.AddRange(floor_connectors);
var floor_columns = roomScaffold.floor.columns.Where(x => x.rootCells.All(a => projectionCells.Contains(a)));
if (nextContainerInstance.claimedScaffolds.Any(a => floor_columns.Select(s => s.id).Contains(a.id)))
{
return(false);
}
projectionNodes.AddRange(floor_columns);
var ceiling_main = roomScaffold.ceiling.main.Where(x => x.rootCells.All(a => projectionCells.Contains(a)));
if (nextContainerInstance.claimedScaffolds.Any(a => ceiling_main.Select(s => s.id).Contains(a.id)))
{
return(false);
}
projectionNodes.AddRange(ceiling_main);
var ceiling_connectors = roomScaffold.ceiling.connectors.Where(x => x.rootCells.All(a => projectionCells.Contains(a)));
if (nextContainerInstance.claimedScaffolds.Any(a => ceiling_connectors.Select(s => s.id).Contains(a.id)))
{
return(false);
}
projectionNodes.AddRange(ceiling_connectors);
var ceiling_columns = roomScaffold.ceiling.columns.Where(x => x.rootCells.All(a => projectionCells.Contains(a)));
if (nextContainerInstance.claimedScaffolds.Any(a => ceiling_columns.Select(s => s.id).Contains(a.id)))
{
return(false);
}
projectionNodes.AddRange(ceiling_columns);
//Walls
var wall_main = new List <Node_WallMain>();
var wall_connector = new List <Node_WallConnector>();
var wallProjections = entity.BuildWallProjection(root, normal);
foreach (var wall in wallProjections.spaces)
{
var direction = (Direction)wall.w;
var result = roomScaffold.wall.main.FirstOrDefault(x => x.rootCells.All(a => a.position == (Vector3)wall) && x.direction == direction);
if (result == null)
{
return(false);
}
wall_main.Add(result);
if (nextContainerInstance.claimedScaffolds.Any(a => wall_main.Select(s => s.id).Contains(a.id)))
{
return(false);
}
projectionNodes.AddRange(wall_main);
var result_C = roomScaffold.wall.connectors.FirstOrDefault(x =>
x.rootCells.All(a => a.position == (Vector3)wall) && x.direction == direction);
if (result_C != null)
{
wall_connector.Add(result_C);
}
if (nextContainerInstance.claimedScaffolds.Any(a => wall_connector.Select(s => s.id).Contains(a.id)))
{
return(false);
}
projectionNodes.AddRange(wall_connector);
}
//If we got to this point, all scaffold points are available
return(true);
}
public bool VerifyProjectionDoesNotBlockRoomPathways(SuiteProjection projection)
{
return(Verify_Step(nextContainerInstance.spaces.FirstOrDefault(x => x.w == 0), new List <Vector3>()));
}
public void ClaimProjection(SuiteProjection projection, List <Scaffold_Node> projectionScaffold, Cell root, Direction direction, SuiteEntity entity)
{
nextContainerInstance.spaces.AddRange(projection.spaces);
nextContainerInstance.claimedScaffolds.AddRange(projectionScaffold);
nextContainerInstance.entities.Add(new Tuple <Vector3, Direction>(root.position, direction), entity);
}
