void OnTriggerEnter2D(Collider2D other)
{
if (hitpointController.isDead)
{
return;
}
// Reverse moving if hit bullets
if (other.CompareTag("Bullet"))
{
moveSpeed *= -1f;
}
// Get edge
EdgeController edgeController = other.GetComponent <EdgeController> ();
// If hit edge with edge controller
if (other.CompareTag("Edge") && edgeController)
{
moveSpeed = edgeController.changeSpeed(moveSpeed);
}
// Collect if hit item
if (other.tag == "Item")
{
// Item name
Item item = other.GetComponent <Item> ();
if (item.type == "Star")
{
stars += item.amount;
}
if (item.type == "Diamond")
{
diamonds += item.amount;
}
if (item.type == "Hitpoint")
{
hitpointController.heal(item.amount);
}
// Update UI
updateResources();
// Destroy item
Destroy(other.gameObject);
}
}
public void TestDeserilaizeOperationException()
{
IStorage storage = new BinaryStorage();
GraphController graphController = new GraphController(null);
EdgeController edgeController = new EdgeController(graphController);
IVisualEdge edge = new VisualEdge(edgeController, 0x30000001, 0x30000002, false);
storage.WriteUnsignedInteger(FieldCode.EdgeSignature, 12);
storage.Seek(0, SeekOrigin.Begin);
Assert.Throws <InvalidOperationException>(() =>
{
edge.Deserialize(storage);
});
}
public void TestSerializeDeserialize()
{
IStorage storage = new BinaryStorage();
GraphController graphController = new GraphController(null);
EdgeController edgeController = new EdgeController(graphController);
IVisualEdge edge00 = new VisualEdge(edgeController, 0x30000001, 0x30000002, false);
edge00.Serialize(storage);
storage.Seek(0, SeekOrigin.Begin);
IVisualEdge edge01 = VisualEdge.Create(edgeController, storage);
Assert.AreEqual(edge00.EdgeId, edge01.EdgeId);
Assert.AreEqual(edge00.StartSlotId, edge01.StartSlotId);
Assert.AreEqual(edge00.EndSlotId, edge01.EndSlotId);
}
bool isAlreadyUsed(NodeController node1, NodeController node2, int id)
{
//regarder chaque edge,
foreach (Transform t in ListeEdges.transform)
{
//si un edge est égal à node1-node2 et que son id est le même alors on retourne true
EdgeController actualEdge = t.GetComponent <EdgeController>();
if ((actualEdge.Node1() == node1 || actualEdge.Node2() == node1) && (actualEdge.Node1() == node2 || actualEdge.Node2() == node2) && actualEdge.idMessage == id)
{
return(true);
}
//sinon, false
}
return(false);
}
public void TestRecordEdgeCreationForUndo00()
{
GraphController graphController = new GraphController(null);
UndoRedoRecorder urr = new UndoRedoRecorder(graphController);
EdgeController edgeController = new EdgeController(graphController);
List <IVisualEdge> edgeList = new List <IVisualEdge>();
VisualEdge edge = new VisualEdge(edgeController, EdgeType.ExplicitConnection);
edgeList.Add(edge);
Assert.Throws <InvalidOperationException>(() =>
{
urr.RecordEdgeCreationForUndo(edgeList);
});
}
private void doJump()
{
if (grabbedEdge != null)
{
becomeHittable();
grabbedEdge = null;
}
if (jumpType == Utilities.jumpType.Small)
{
smallJump();
}
else
{
normalJump();
}
}
public static bool TriangleContainsEdge(NodeController[] triangle, EdgeController edge)
{
if (edge.ContainsBoth(triangle[0], triangle[1]))
{
return(true);
}
if (edge.ContainsBoth(triangle[0], triangle[2]))
{
return(true);
}
if (edge.ContainsBoth(triangle[1], triangle[2]))
{
return(true);
}
return(false);
}
/// <summary>
/// Lets go to specified direction
/// </summary>
/// <param name="dir">The desired direction</param>
protected void letGo(Utilities.direction dir)
{
rbd.gravityScale = gravityAmount;
state = Utilities.state.Air;
grabbedEdge = null;
becomeHittable();
if (dir == Utilities.direction.Down)
{
rbd.velocity = new Vector2(rbd.velocity.x, -1);
}
else if (dir == Utilities.direction.Right)
{
rbd.velocity = new Vector2(1, rbd.velocity.y);
}
else if (dir == Utilities.direction.Left)
{
rbd.velocity = new Vector2(-1, rbd.velocity.y);
}
}
public bool AssessEdgeIntersection(EdgeController edge)
{
foreach (var tri in currentTriangles)
{
Vector3 centroid = (
tri[0].transform.position +
tri[1].transform.position +
tri[2].transform.position) / 3f;
// shift all points by an epsilon inwards, to make sure points aren't erronously said to
// overlap due to floating point errors.
Vector3 pos1 = Vector3.MoveTowards(
tri[0].transform.position, centroid, .01f
);
Vector3 pos2 = Vector3.MoveTowards(
tri[1].transform.position, centroid, .01f
);
Vector3 pos3 = Vector3.MoveTowards(
tri[2].transform.position, centroid, .01f
);
Vector3?intersectionPoint = null;
bool intersects = TriTriOverlap.TriEdgeIntersect(
pos1,
pos2,
pos3,
edge.startNode.transform.position,
edge.endNode.transform.position,
out intersectionPoint
);
if (intersects)
{
return(true);
}
}
return(false);
}
internal VisualEdge(EdgeController edgeController, uint startSlotId, uint endSlotId, bool isImplicit)
{
this.edgeController = edgeController;
if (isImplicit)
{
this.EdgeType = EdgeType.ImplicitConnection;
}
else
{
this.EdgeType = EdgeType.ExplicitConnection;
}
this.version = VisualEdge.Version.Current;
this.StartSlotId = startSlotId;
this.EndSlotId = endSlotId;
// Generate new ID for this visual edge.
GraphController graphController = edgeController.GetGraphController();
IdGenerator idGenerator = graphController.GetIdGenerator();
this.EdgeId = idGenerator.GetNextId(ComponentType.Edge);
controlPoints.Add(new Point());
controlPoints.Add(new Point());
controlPoints.Add(new Point());
controlPoints.Add(new Point());
GraphController controller = edgeController.GetGraphController();
Slot startSlot = controller.GetSlot(this.StartSlotId) as Slot;
Slot endSlot = controller.GetSlot(this.EndSlotId) as Slot;
if (startSlot != null && endSlot != null)
{
Point startPoint = startSlot.GetPosition();
Point endPoint = endSlot.GetPosition();
UpdateControlPoint(startPoint, endPoint, startSlot.SlotType != SlotType.Output);
}
else
{
throw new ArgumentNullException("startSlot or endSlot");
}
}
public void UpdateArrow()
{
EdgeController edgeController = GetComponent <EdgeController>();
float AdaptiveSize = (float)(edgeController.Width * 2 / Vector3.Distance(ArrowOrigin, ArrowTarget));
if (cachedLineRenderer == null)
{
cachedLineRenderer = this.GetComponent <LineRenderer>();
}
cachedLineRenderer.widthCurve = new AnimationCurve(
new Keyframe(0, 0.4f)
, new Keyframe(0.999f - AdaptiveSize, 0.4f) // neck of arrow
, new Keyframe(1 - AdaptiveSize, 1f) // max width of arrow head
, new Keyframe(1, 0f)); // tip of arrow
cachedLineRenderer.SetPositions(new Vector3[] {
ArrowOrigin
, Vector3.Lerp(ArrowOrigin, ArrowTarget, 0.999f - AdaptiveSize)
, Vector3.Lerp(ArrowOrigin, ArrowTarget, 1 - AdaptiveSize)
, ArrowTarget
});
}
public void AddNodeToTrajectory(NodeController node)
{
//vérifier que le node n'a jamais été ajouté, et qu'une trajectoire est en cours
if (actualTrajectory.Count > 0 && /*!actualTrajectory.Contains(node)*/ !isAlreadyUsed(node, actualTrajectory[actualTrajectory.Count - 1], actualTrajectory[0].call.id)) //todo à changer
{
//vérifier si on respecte les edges
if (node.IsConnectedTo(actualTrajectory[actualTrajectory.Count - 1]))
{
actualTrajectory.Add(node);
soundManager.PlaySound(SoundManager.SoundList.LINK_NODE, false);
Debug.Log("Add " + node.name);
Call call = null;
foreach (Call c in callsInTransmission)
{
if (c.caller == actualTrajectory[0] || c.reciever == actualTrajectory[0])
{
call = c;
}
}
EdgeController actualEdge = node.edge(actualTrajectory[actualTrajectory.Count - 2]);
if (actualEdge.IsTaken())
{
alreadyUsedEdges.Add(actualEdge);
idUsedEdges.Add(actualEdge.idMessage);
}
//changer couleur du edge en question
//node.edge(actualTrajectory[actualTrajectory.Count - 2]).ChangeColor(new Color(1,0,0));
actualEdge.TakePath(call.id);
//si c'est un node obligatoire, alors il devient "utilisé"
if (call.node_obligatory == node)
{
node.isUsed = true;
}
}
}
}
/// <summary>
/// Gets a connecting node of two edges. If none, returns null.
/// </summary>
/// <param name="v1"></param>
/// <param name="v2"></param>
public static NodeController GetConnection(EdgeController v1, EdgeController v2)
{
if (v1.startNode == v2.startNode)
{
return(v1.startNode);
}
else if (v1.startNode == v2.endNode)
{
return(v1.startNode);
}
else if (v1.endNode == v2.startNode)
{
return(v1.endNode);
}
else if (v1.endNode == v2.endNode)
{
return(v1.endNode);
}
else
{
return(null);
}
}
/// <summary>
/// Spawn road using prefab, stretch it to match
/// distances and set on the center, between two positions
/// </summary>
/// <param name="positionA"></param>
/// <param name="positionB"></param>
void SpawnRoad(Vector3 positionA, Vector3 positionB)
{
Vector3 targetDirection = positionB - positionA;
targetDirection.y = 0;
Quaternion rotation = Quaternion.LookRotation(targetDirection);
Vector3 center = (positionA + positionB) / 2;
center.y = 0.02f;
GameObject road = Instantiate(WhiteRoadObjectPrefab, center, rotation);
Vector3 currentScale = road.transform.localScale;
float newScale = Vector3.Distance(positionA, positionB);
currentScale.z = newScale / 10;
road.transform.localScale = currentScale;
EdgeController edgeController = road.GetComponent <EdgeController>();
edgeController.StartPosition = positionA;
edgeController.EndPosition = positionB;
}
private void actualizePositionEdges(GameObject liste_edges)
{
foreach (Transform edgeTransform in liste_edges.transform)
{
EdgeController edge = edgeTransform.GetComponent <EdgeController>();
if (edge.gameObject.activeSelf)
{
//pour chaque edge, on récupère les positions des deux bouts
//et on détermine où le edges doit aller
Vector3 pos1 = edge.Node1().GetTransform().position;
Vector3 pos2 = edge.Node2().GetTransform().position;
Vector3 n = pos2 - pos1;
float distance = (n).magnitude;
float alpha = angle(n.x, n.y);
edge.transform.position = (pos1 + pos2) / 2.0f;
edge.transform.localScale = new Vector3(distance * 1 / 8.5f, edge.epaisseur, 1);
edge.transform.localEulerAngles = new Vector3(0, 0, alpha);
}
}
}
public void AddEdge(EdgeController edge)
{
neighborhoodList.Add(edge);
}
/// <summary>
/// Modified the graph, creates or removes edge if valid.
/// </summary>
/// <param name="joinNode">New node we are using to modify</param>
public Outcome AttemptModification(NodeController joinNode, out object outcomeData)
{
outcomeData = null;
if (!creating)
{
return(Outcome.None);
}
EdgeController foundEdge;
if (graphLogicManager.EdgeExists(startNode, joinNode, out foundEdge))
{
Debug.LogFormat("Removing edge between {0} and {1}", startNode.name, joinNode.name);
List <NodeController[]> removedFaces;
graphLogicManager.RemoveEdge(foundEdge, out removedFaces);
counter.EdgeCountChange(-1);
if (removedFaces.Count > 0)
{
outcomeData = new object[] { foundEdge, removedFaces };
return(Outcome.RemovedEdgeAndFaces);
}
else
{
return(Outcome.RemovedEdge);
}
}
if (counter.remaining <= 0)
{
counter.OnCreateWithNoneRemaining();
return(Outcome.NoEdgesRemaining);
}
if (graphLogicManager.IsValidEdge(startNode, joinNode))
{
Debug.LogFormat("Creating edge between {0} and {1}", startNode.name, joinNode.name);
EdgeController newEdge = Create(startNode, joinNode);
// first check if this edge intersects a face directly
bool edgeCreatesEdgeIntersection;
edgeCreatesEdgeIntersection = graphLogicManager.AssessEdgeIntersection(newEdge);
if (edgeCreatesEdgeIntersection)
{
Debug.Log("Edge invalid! Creates edge intersection.");
Destroy(newEdge.gameObject);
return(Outcome.IntersectingEdge);
}
// if it doesnt, check if it creates a face which creates an intersection
bool edgeCreatesFaceIntersection;
var newFaces = graphLogicManager.CheckForNewFaces(newEdge, out edgeCreatesFaceIntersection);
if (edgeCreatesFaceIntersection)
{
Debug.Log("Edge invalid! Creates face intersection.");
Destroy(newEdge.gameObject);
return(Outcome.IntersectingFace);
}
else
{
Debug.Log("Adding edge to graph");
graphLogicManager.AddEdge(newEdge);
counter.EdgeCountChange(1);
if (newFaces.Count > 0)
{
outcomeData = new object[] { newEdge, newFaces };
return(Outcome.CreatedEdgeAndFaces);
}
else
{
outcomeData = newEdge;
return(Outcome.CreatedEdge);
}
}
}
else
{
return(Outcome.InvalidNodePair);
}
}
public void RegisterJoin(NodeController joinNode)
{
if (joinNode != previouslySelectedNode && joinNode != null)
{
object outcomeData;
Outcome outcome = edgeCreator.AttemptModification(joinNode, out outcomeData);
switch (outcome)
{
case Outcome.CreatedEdgeAndFaces:
object[] edgeAndFaces = (object[])outcomeData;
EdgeController createdEdge = (EdgeController)edgeAndFaces[0];
List <NodeController[]> createdFaces = (List <NodeController[]>)edgeAndFaces[1];
createdEdge.nodes
.ForEach(n => n.OnCreateEdge());
createdFaces
.SelectMany(face => face)
.ToList()
.ForEach(node => node.OnCreateFace());
var distinctEdges = graphLogicManager.DistinctEdgesInTriangles(createdFaces).ToList();
distinctEdges.ForEach(e => e.SetEdgeState(EdgeState.Face));
break;
case Outcome.CreatedEdge:
EdgeController newEdge = (EdgeController)outcomeData;
joinNode.OnCreateEdge();
previouslySelectedNode.OnCreateEdge();
newEdge.SetEdgeState(EdgeState.NoFace);
break;
case Outcome.RemovedEdgeAndFaces:
object[] removedEdgesAndFaces = (object[])outcomeData;
EdgeController removedEdge = (EdgeController)removedEdgesAndFaces[0];
List <NodeController[]> removedFaces = (List <NodeController[]>)removedEdgesAndFaces[1];
removedFaces
.SelectMany(face => face)
.ToList()
.ForEach(node => node.OnRemoveFace());
removedEdge.nodes
.ForEach(n => n.OnRemoveEdge());
IEnumerable <EdgeController> edgesToUpdate = graphLogicManager.DistinctEdgesInTriangles(removedFaces);
graphLogicManager.UpdateEdgeStates(edgesToUpdate);
break;
case Outcome.RemovedEdge:
joinNode.OnRemoveEdge();
previouslySelectedNode.OnRemoveEdge();
break;
case Outcome.IntersectingFace:
case Outcome.IntersectingEdge:
feedback.FeedbackIntersectingFace();
break;
case Outcome.InvalidNodePair:
feedback.FeedbackInvalidPair();
break;
}
}
RegisterDeSelect();
edgeCreator.DePointNode();
}
private VisualEdge(EdgeController edgeController)
{
this.edgeController = edgeController;
}
public bool AssessEdgeIntersection(EdgeController newEdge)
{
return(faceCreator.AssessEdgeIntersection(newEdge));
}
private void InsertOneObstacle(int buttonId, bool onPlayerPath)
{
while (true)
{
//Calculates the shortest distance before adding the obstacle.
GameObject algorithmObject = Instantiate(modifiedDijkstraAlgorithmPrefab);
if (MainScript.CurrentLevelCount != -1)
{
MainScript.GarbageCollectorGameObjects.Add(algorithmObject);
}
ModifiedDijkstraAlgorithm algorithm = algorithmObject.GetComponent <ModifiedDijkstraAlgorithm>();
if (onPlayerPath)
{
//path between start and target node
algorithm.Initialize(MainScript.AllNodes[playerStartPosition], MainScript.AllNodes[MainScript.NumberOfNodes - 1]);
}
else
{
//path between the node in the upper right corner and the node in the lower left corner
algorithm.Initialize(MainScript.AllNodes[opponentStartPosition], MainScript.AllNodes[MainScript.Height - 1]);
}
algorithm.CalculateModifiedDijkstraAlgorithm();
List <NodeController> shortestPath = algorithm.ShortestPath;
//Gets randomly a node of the shortest path as obstacle.
int randomNumber = Random.Range((int)Math.Floor((double)shortestPath.Count / 4), (int)(shortestPath.Count - Math.Floor((double)shortestPath.Count / 10)));
NodeController startNode = shortestPath[randomNumber];
NodeController targetNode = shortestPath[randomNumber + 1];
//Sets the new values of the obstacle
EdgeController edge = startNode.GetEdgeToNode(targetNode);
if (edge.Obstacle != -1)
{
continue;
}
TransformEdge(edge, buttonId);
//Calculates the shortest distance after adding the obstacle.
GameObject algorithmObject1 = Instantiate(modifiedDijkstraAlgorithmPrefab);
if (MainScript.CurrentLevelCount != -1)
{
MainScript.GarbageCollectorGameObjects.Add(algorithmObject1);
}
ModifiedDijkstraAlgorithm algorithm1 = algorithmObject1.GetComponent <ModifiedDijkstraAlgorithm>();
if (onPlayerPath)
{
algorithm1.Initialize(MainScript.AllNodes[playerStartPosition], MainScript.AllNodes[MainScript.NumberOfNodes - 1]);
}
else
{
algorithm1.Initialize(MainScript.AllNodes[opponentStartPosition], MainScript.AllNodes[MainScript.Height - 1]);
}
algorithm1.CalculateModifiedDijkstraAlgorithm();
int shortestDistanceWithObstacle = algorithm1.ShortestDistance;
//Tries to insert a valid button
if (InsertButton(shortestDistanceWithObstacle, startNode, shortestPath, buttonId, onPlayerPath, edge))
{
Destroy(algorithmObject);
Destroy(algorithmObject1);
//Changes the color of the obstacle to its initial value.
edge.ChangeColorOfObstacle(0);
break;
}
else
{
//Resets the edge and tries to find another location for the obstacle.
Destroy(algorithmObject);
Destroy(algorithmObject1);
ResetEdge(edge);
}
}
}
public void RemoveEdge(EdgeController edgeToRemove, out List <NodeController[]> removedFaces)
{
removedFaces = faceCreator.RemoveFacesByEdge(edgeToRemove);
Destroy(edgeToRemove.gameObject);
edges.Remove(edgeToRemove);
}
/**
* Tries to insert a button for the corresponding obstacle.
* <param name="shortestDistance">The shortest distance of the path after adding the obstacle.</param>
* <param name="nodeAtObstacle">The node in front of the obstacle.</param>
* <param name="optimalPathWithoutObstacle">The optimal path before adding the obstacle.</param>
* <param name="buttonId">The id of the button.</param>
* <param name="onPlayerPath">The location flag of the obstacle.</param>
* <param name="obstacle">The corresponding obstacle.</param>
* <returns>Whether the operation was successful.</returns>
*/
private bool InsertButton(int shortestDistance, NodeController nodeAtObstacle, List <NodeController> optimalPathWithoutObstacle, int buttonId, bool onPlayerPath, EdgeController obstacle)
{
//Counts the number of tested nodes.
int counter = 0;
while (true)
{
//Breaks if it checked too much nodes. Chooses after that another obstacle.
if (counter == MainScript.NumberOfNodes)
{
return(false);
}
//Gets a random node as button.
NodeController node = GetRandomNode();
//Checks the conditions of the node.
if (optimalPathWithoutObstacle.Contains(node) || node.Button != -1)
{
continue;
}
//Sets the values of the new button.
node.Button = buttonId;
node.States = SetStates(buttonId);
//Calculates the shortest distance after adding the button.
GameObject algorithmObject = Instantiate(modifiedDijkstraAlgorithmPrefab);
if (MainScript.CurrentLevelCount != -1)
{
MainScript.GarbageCollectorGameObjects.Add(algorithmObject);
}
ModifiedDijkstraAlgorithm algorithm = algorithmObject.GetComponent <ModifiedDijkstraAlgorithm>();
if (onPlayerPath)
{
algorithm.Initialize(MainScript.AllNodes[playerStartPosition], MainScript.AllNodes[MainScript.NumberOfNodes - 1]);
}
else
{
algorithm.Initialize(MainScript.AllNodes[opponentStartPosition], MainScript.AllNodes[MainScript.Height - 1]);
}
algorithm.CalculateModifiedDijkstraAlgorithm();
int newShortestDistance = algorithm.ShortestDistance;
//Calculates the distance between button and obstacle.
GameObject algorithmObject1 = Instantiate(modifiedDijkstraAlgorithmPrefab);
if (MainScript.CurrentLevelCount != -1)
{
MainScript.GarbageCollectorGameObjects.Add(algorithmObject1);
}
ModifiedDijkstraAlgorithm algorithm1 = algorithmObject1.GetComponent <ModifiedDijkstraAlgorithm>();
algorithm1.Initialize(node, nodeAtObstacle);
algorithm1.CalculateModifiedDijkstraAlgorithm();
int distanceBetweenButtonAndObstacle = algorithm1.ShortestDistance;
//Checks the conditions.
if (newShortestDistance < shortestDistance && distanceBetweenButtonAndObstacle > (shortestDistance / 10))
{
Destroy(algorithmObject);
Destroy(algorithmObject1);
//Adds the button at the choosen node.
GameObject gameObject = Instantiate(buttonPrefab, node.transform.position, Quaternion.identity);
ButtonController button = gameObject.GetComponent <ButtonController>();
button.Initialize(obstacle, node, buttonId);
MainScript.AllButtons.Add(button);
button.gameObject.transform.localScale = new Vector3(0.25f * MainScript.ScaleMazeSize, 0.25f * MainScript.ScaleMazeSize);
if (MainScript.CurrentLevelCount != -1)
{
MainScript.GarbageCollectorGameObjects.Add(gameObject);
}
break;
}
//Resets the values and checks another node.
Destroy(algorithmObject);
Destroy(algorithmObject1);
node.Button = -1;
node.States = null;
counter++;
}
return(true);
}
public void AddEdge(EdgeController newEdge)
{
edges.Add(newEdge);
}
/**
* Transforms the edge to a obstacle.
* <param name="edge">The edge which should be transformed.</param>
* <param name="buttonId">The id of the corresponding button.</param>
*/
private void TransformEdge(EdgeController edge, int buttonId)
{
edge.Obstacle = buttonId;
edge.Costs = SetCosts(buttonId, GetLengthOfObstacle());
}
public List <NodeController[]> CheckForNewFaces(EdgeController newEdge, out bool edgeCreatesIntersection)
{
// Get all edges that contain either the start or end node from newEdge,
// and is not this edge
var connectedEdges = edges.Where(
e => ((e != this) && (GetConnection(e, newEdge) != null))
).ToList();
int n = connectedEdges.Count;
// now check all pairings with the new edges
edgeCreatesIntersection = false;
List <NodeController[]> facesToCreate = new List <NodeController[]>();
for (int i = 0; i < n - 1; i++)
{
for (int j = i + 1; j < n; j++)
{
List <EdgeController> potentialTriangle = new List <EdgeController>()
{
newEdge,
connectedEdges[i],
connectedEdges[j]
};
// if they share exactly 3 nodes, the three edges form a triangle.
List <NodeController> distinctNodes = DistinctNodesInSubGraph(potentialTriangle).ToList();
Debug.LogFormat("Asessing triangle: {0}-{1}-{2}", distinctNodes.Select(node => node.name).ToArray());
if (distinctNodes.Count() == 3)
{
Debug.Log("Assessing triangle intersection");
// now we know the new edge created a new triangle, we must test if the new triangle would intersect with other existing triangles.
edgeCreatesIntersection = faceCreator.AssessFaceIntersection(
distinctNodes[0],
distinctNodes[1],
distinctNodes[2]
);
if (edgeCreatesIntersection)
{
// one intersection invalidates the edge
facesToCreate.Clear();
return(facesToCreate);
}
else
{
facesToCreate.Add(
new NodeController[] {
distinctNodes[0],
distinctNodes[1],
distinctNodes[2]
}
);
Debug.Log("Successful triangle");
// continue to assess, since a single node can form multiple triangles
}
}
}
}
if (facesToCreate.Count > 0)
{
foreach (var newFace in facesToCreate)
{
faceCreator.CreateFace(
newFace[0],
newFace[1],
newFace[2]
);
}
}
return(facesToCreate);
}
/**
* Resets an obstacle to a normal edge.
* <param name="edge">The edge which should be reseted.</param>
*/
private void ResetEdge(EdgeController edge)
{
edge.Obstacle = -1;
edge.Costs = null;
}