public void ConnectTo(RenderedTileInfo incoming)
{
if (!connectedTiles.Contains(incoming))
{
connectedTiles.Add(incoming);
}
sourceNode.AddConnectedNode(incoming.sourceNode);
}
// Returns true if there was a door to occupy (and occupies that door), else returns false.
public bool OccupyNearbyDoor(Vector3 incDoorLoc, RenderedTileInfo incoming)
{
// Check if there is a door to occupy
for (int i = 0; i < tileType.doorLocs.Length; i++)
{
Vector3 doorLoc = placedTile.transform.TransformPoint(tileType.doorLocs[i]);
if ((incDoorLoc - doorLoc).magnitude < 0.5f)
{
ConnectTo(incoming);
GameObject door = GameObject.CreatePrimitive(PrimitiveType.Cube);
door.GetComponent <Collider>().enabled = false;
door.transform.SetParent(graphHolder.transform);
door.transform.position = doorLoc;
doors[i] = true;
return(true);
}
}
return(false);
}
// Sees if there are already-rendered tiles nearby that can be connected.
// If so, connect the rendered tiles and backpropogate the change to the TileNode.
private void CheckForDoors()
{
for (int i = 0; i < tileType.doorLocs.Length; i++)
{
Vector3 doorLoc = placedTile.transform.TransformPoint(tileType.doorLocs[i]);
// project bounding box at door loc
Collider[] overlaps = Physics.OverlapBox(doorLoc, new Vector3(1.5f, 1.5f, 1.5f));
// check the door locs of colliding tiles for a match, excluding this tile
foreach (Collider c in overlaps)
{
RenderedTileInfo other = c.transform.parent.GetComponent <TileLookup>().GetRenderedTileInfo();
if (other != this)
{
if (other.OccupyNearbyDoor(doorLoc, this))
{
ConnectTo(other);
doors[i] = true;
}
}
}
// if there is a match, occupy the door on this tile, occupy the door on the other tile, add connected rendered tiles, and backpropogate connections to tilenodes
}
}
public static Dictionary <TileNode, RenderedTileInfo> RenderNodes(TileGraph g, GameObject parent)
{
renderedGraph = new GameObject();
renderedGraph.transform.position = Vector3.zero;
if (parent != null)
{
renderedGraph.transform.parent = parent.transform;
}
GameObject origin = new GameObject();
origin.name = "Origin";
origin.transform.parent = renderedGraph.transform;
Dictionary <TileNode, RenderedTileInfo> renderedTiles = new Dictionary <TileNode, RenderedTileInfo>();
//List<TileNode> nodesToRemove = new List<TileNode>();
renderedTiles.Add(g.nodes[0], new RenderedTileInfo(g.nodes[0].type, Vector3.zero, 0, g.nodes[0], renderedGraph));
// Unexplored nodes HAVE BEEN RENDERED but have not been explored for connections.
Queue <TileNode> unexploredNodes = new Queue <TileNode>();
// Explored nodes HAVE BEEN RENDERED and have been explored.
List <TileNode> exploredNodes = new List <TileNode>();
unexploredNodes.Enqueue(g.nodes[0]);
while (unexploredNodes.Count > 0)
{
TileNode curr = unexploredNodes.Dequeue();
exploredNodes.Add(curr);
// For each node connected to this one...
foreach (TileNode newTile in curr.connectedNodes)
{
if (renderedTiles.ContainsKey(newTile))
{
continue;
}
Vector3 doorLoc = renderedTiles[curr].GetDoorLoc();
Vector3 firstDoor = doorLoc;
Vector3 tileLoc = Vector3.zero;
float rotation = 0;
bool placeable = true;
for (int d = 0; d < newTile.type.doorLocs.Length; d++)
{
int rotationCount = 0;
for (rotation = (newTile.seed % 4) * 90; rotationCount < 4; rotation += 90, rotationCount++)
{
do
{
tileLoc = doorLoc - Quaternion.Euler(0, rotation, 0) * newTile.type.doorLocs[d];
placeable = true;
for (int k = 0; k < newTile.type.boundingBoxes.Length; k++)
{
if (!newTile.type.boundingBoxes[k].IsPlaceable(tileLoc, rotation))
{
placeable = false;
break;
}
}
if (placeable)
{
break;
}
doorLoc = renderedTiles[curr].GetDoorLoc();
} while (doorLoc != firstDoor);
if (placeable)
{
break;
}
}
if (placeable)
{
break;
}
}
if (!placeable)
{
continue;
}
RenderedTileInfo newRenderedTile = new RenderedTileInfo(newTile.type, tileLoc, rotation, newTile, renderedGraph);
// door detection should do this.
//renderedTiles[connections[j]].OccupyLastDoor(newRenderedTile);
renderedTiles.Add(newTile, newRenderedTile);
unexploredNodes.Enqueue(newTile);
}
}
List <TileNode> nodesToRemove = new List <TileNode>();
foreach (TileNode t in g.nodes)
{
if (!renderedTiles.ContainsKey(t))
{
nodesToRemove.Add(t);
}
}
// Backpropogate removed nodes.
foreach (TileNode t in nodesToRemove)
{
g.nodes.Remove(t);
}
// Backpropogate removed node connections.
foreach (TileNode t in g.nodes)
{
foreach (TileNode r in nodesToRemove)
{
t.connectedNodes.Remove(r);
}
}
// Check for other connections to remove.
foreach (TileNode t in g.nodes)
{
List <TileNode> connsToRemove = new List <TileNode>();
foreach (TileNode c in t.connectedNodes)
{
bool found = false;
foreach (RenderedTileInfo r in renderedTiles[t].connectedTiles)
{
if (c == r.sourceNode)
{
found = true;
}
}
if (!found)
{
connsToRemove.Add(c);
}
}
foreach (TileNode c in connsToRemove)
{
t.RemoveConnectedNode(c);
}
}
return(renderedTiles);
}
public void AddRenderedTileInfo(RenderedTileInfo t)
{
this.t = t;
}
