/*public bool reach(Trajectory.Node origin, LineHandler origin_line, LineHandler destiny, Dictionary<Trajectory.Node, bool> visited_nodes, Dictionary<LineHandler, bool> visited_lines, List<Vector2> route){ * bool reached = true; * if(visited_nodes[origin] == false && !destiny.containsNode(origin)){ * visited_nodes [origin] = true; * foreach (LineHandler line in origin_line.getNeighborLines()) { * if(visited_lines[line] == false && line.containsNode(origin)){ * visited_lines[line.Key] = true; * if (!visited_nodes[line.Key.start] && reach (line.Key.start, destiny, visited_nodes, visited_lines, route)) * route.Add (new Vector2(line.Key.start.getX () / 10f, 60 - line.Key.start.getY () / 10f)); * else if (!visited_nodes[line.Key.end] && reach (line.Key.end, destiny, visited_nodes, visited_lines, route)) * route.Add (new Vector2(line.Key.end.getX () / 10f, 60 - line.Key.end.getY () / 10f)); * else * reached = false; * } * } * } * return reached; * }*/ /*public bool reach(Trajectory.Node origin, LineHandler origin_line, LineHandler destiny, Dictionary<Trajectory.Node, bool> visited_nodes, Dictionary<LineHandler, bool> visited_lines, List<Vector2> route){ * bool reached = true; * if (!destiny.containsNode (origin)) { * visited_nodes [origin] = true; * foreach (LineHandler line in origin_line.getNeighborLines()) { * if (!visited_lines [line] && !visited_nodes [line.getOtherPoint (origin)] && reach (line.getOtherPoint (origin), origin_line, destiny, visited_nodes, visited_lines, route)) { * Trajectory.Node n = line.getOtherPoint (origin); * route.Add (new Vector2(n.getX () / 10f, 60 - n.getY () / 10f)); * } * } * } * return reached; * }*/ public bool reach(LineHandler origin, LineHandler destiny, Dictionary <LineHandler, bool> visited, List <KeyValuePair <Vector2, float> > route) { bool ret = false; if (origin == destiny) { ret = true; } else if (visited[origin]) { ret = false; } else { visited[origin] = true; foreach (LineHandler neighbor in origin.getNeighborLines()) { if (reach(neighbor, destiny, visited, route)) { Trajectory.Node point = LineHandler.commonPoint(origin, neighbor); route.Add(new KeyValuePair <Vector2, float>(LineHandler.nodeToVector2(point), point.getScale())); ret = true; break; } } } return(ret); }
public KeyValuePair <Vector2, float>[] reach(LineHandler origin, LineHandler destiny) { List <KeyValuePair <Vector2, float> > route = new List <KeyValuePair <Vector2, float> >(); //Scene s = (Scene) sd; //WE STORE IN A BOOLEAN IF WE HAVE VISITED OR NOT THAT LINE // Dictionary<LineHandler, bool> visited_lines = new Dictionary<LineHandler, bool>(); // Dictionary<Trajectory.Node, bool> visited_nodes = new Dictionary<Trajectory.Node, bool>(); // // foreach (LineHandler line in lines) // visited_lines.Add (line, false); // // reach (origin, destiny, visited_lines, route); Dictionary <LineHandler, KeyValuePair <float, LineHandler> > stickered = stick(origin); LineHandler current = destiny; while (current != origin) { KeyValuePair <float, LineHandler> node = stickered[current]; Trajectory.Node tmp = LineHandler.commonPoint(current, node.Value); route.Add(new KeyValuePair <Vector2, float>(LineHandler.nodeToVector2(tmp), tmp.getScale())); current = node.Value; } route.Reverse(); return(route.ToArray()); }
public MovementPoint[] route(Vector2 origin, Vector2 destiny) { List <MovementPoint> ret = new List <MovementPoint>(); LineHandler origin_line = containingLine(origin), destiny_line = containingLine(destiny); Vector2 closest = Vector2.zero; if (origin_line == null) { closest = closestPoint(origin); origin_line = containingLine(closest); } if (destiny_line == null) { destiny = closestPoint(destiny); destiny_line = containingLine(destiny); } if (closest != Vector2.zero) { ret.Add(new MovementPoint() { destination = closest, scale = origin_line.getScaleFor(closest), distance = (closest - origin).magnitude }); } if (origin_line != null && destiny_line != null) { //###################################################### // IF ORIGIN_LINE AND DESTINY_LINE ARE THE SAME // Return only the destiny point, dont have to go // to other node //###################################################### if (origin_line == destiny_line) { ret.Add(new MovementPoint() { destination = destiny, scale = destiny_line.getScaleFor(destiny), distance = destiny_line.getSegmentDistance(origin, destiny), }); } else { /*List<KeyValuePair<Vector2, float>> tmpRoute = new List<KeyValuePair<Vector2, float>>(reach(origin_line, destiny_line)); * //tmpRoute.Reverse (); * ret.AddRange(tmpRoute); * ret.Add(new KeyValuePair<Vector2, float>(destiny, destiny_line.getScaleFor(destiny)));*/ ret = route_d(origin, destiny, origin_line, destiny_line); } } return(ret.ToArray()); }
public static Trajectory.Node commonPoint(LineHandler l1, LineHandler l2) { if (l1.containsNode(l2.start)) { return(l2.start); } else { return(l2.end); } }
public Dictionary <LineHandler, KeyValuePair <float, LineHandler> > stick(LineHandler origin) { Dictionary <LineHandler, KeyValuePair <float, LineHandler> > stickered = new Dictionary <LineHandler, KeyValuePair <float, LineHandler> >(); Dictionary <LineHandler, float> costs = new Dictionary <LineHandler, float>(); LineHandler current = origin, previous = origin; stickered.Add(origin, new KeyValuePair <float, LineHandler>(0, null)); float current_cost = 0;// TODO why? , total_cost = 0; while (stickered.Count < lines.Count) { current_cost = current.side.getLength(); //total_cost = stickered[current].Key; foreach (LineHandler line in current.getNeighborLines()) { if (!stickered.ContainsKey(line)) { if (costs.ContainsKey(line)) { if (costs[line] > current_cost) { costs[line] = current_cost; } } else { costs.Add(line, current_cost); } } } //obtenemos la mas corta float min = float.MaxValue; LineHandler selected = origin; foreach (KeyValuePair <LineHandler, float> line in costs) { if (line.Value < min) { selected = line.Key; min = line.Value; } } costs.Remove(selected); //establecemos la mas corta como principal y la añadimos a vecinas stickered.Add(selected, new KeyValuePair <float, LineHandler>(stickered[previous].Key + current.side.getLength(), current)); previous = current; current = selected; } return(stickered); }
public static void DivideSideByRect(Rectangle rect, Trajectory original, Trajectory.Side side, Trajectory outputTrajectory) { var startNode = original.getNodeForId(side.getIDStart()); var endNode = original.getNodeForId(side.getIDEnd()); Math3DFunc scaleFunc = new Math3DFunc( new Vector3(startNode.getX(), startNode.getY(), startNode.getScale()), new Vector3(endNode.getX(), endNode.getY(), endNode.getScale())); Math3DFunc lengthFunc = new Math3DFunc( new Vector3(startNode.getX(), startNode.getY(), 0), new Vector3(endNode.getX(), endNode.getY(), side.getLength())); var startInside = outputTrajectory.getNodeForId(side.getIDStart()) == null; var endInside = outputTrajectory.getNodeForId(side.getIDEnd()) == null; if (startInside && endInside) { return; } Vector2 start = LineHandler.nodeToVector2(startNode), end = LineHandler.nodeToVector2(endNode); Vector2[] intersections; if (LineRectangleIntersections(rect, start, end, out intersections)) { if (!startInside) { var cs = ClosestPoint(start, intersections); var csId = createRandomNodeId(cs.x, cs.y); outputTrajectory.addNode(csId, (int)cs.x, (int)cs.y, scaleFunc.getZ(cs.x, cs.y)); outputTrajectory.addSide(side.getIDStart(), csId, (int)lengthFunc.getZ(cs.x, cs.y)); } if (!endInside) { var ce = ClosestPoint(end, intersections); var ceId = createRandomNodeId(ce.x, ce.y); outputTrajectory.addNode(ceId, (int)ce.x, (int)ce.y, scaleFunc.getZ(ce.x, ce.y)); outputTrajectory.addSide(side.getIDEnd(), ceId, (int)(side.getLength() - lengthFunc.getZ(ce.x, ce.y))); } } else { outputTrajectory.addSide(side.getIDStart(), side.getIDEnd(), (int)side.getLength()); } }
public static bool TrajectoryRectangleIntersections(Rectangle rect, TrajectoryHandler trajectory, out Vector2[] intersections) { List <Vector2> intersectionsList = new List <Vector2>(); Vector2[] currentIntersections; foreach (var side in trajectory.lines) { if (LineRectangleIntersections(rect, LineHandler.nodeToVector2(side.start), LineHandler.nodeToVector2(side.end), out currentIntersections)) { intersectionsList.AddRange(currentIntersections); } } intersections = intersectionsList.ToArray(); return(intersections.Length > 0); }
public static Trajectory CreateBlockedTrajectory(Trajectory original, Rectangle blockingObject) { var trajectory = new Trajectory(); // Fist we add the nodes foreach (var node in original.getNodes()) { if (!Inside(LineHandler.nodeToVector2(node), blockingObject)) { trajectory.addNode(node.getID(), node.getX(), node.getY(), node.getScale()); } } // Then we add the sides foreach (var side in original.getSides()) { //Dividing them with the rect DivideSideByRect(blockingObject, original, side, trajectory); } return(trajectory); }
public bool isNeighbor(LineHandler line) { return(neighbours.Contains(line)); }
public void addNeighbour(LineHandler n) { this.neighbours.Add(n); }
public List <MovementPoint> route_d(Vector2 origin, Vector2 destiny, LineHandler originline, LineHandler destinyline) { Graph <string> g = new Graph <string>(); Dictionary <string, Dictionary <string, float> > d = new Dictionary <string, Dictionary <string, float> >(); Dictionary <string, Dictionary <string, MovementPoint> > ps = new Dictionary <string, Dictionary <string, MovementPoint> >(); foreach (Trajectory.Node n in this.trajectory.getNodes()) { d.Add(n.getID(), new Dictionary <string, float>()); ps.Add(n.getID(), new Dictionary <string, MovementPoint>()); } foreach (Trajectory.Side s in this.trajectory.getSides()) { var start = trajectory.getNodeForId(s.getIDStart()); var end = trajectory.getNodeForId(s.getIDEnd()); d[s.getIDStart()].Add(s.getIDEnd(), s.getLength()); d[s.getIDEnd()].Add(s.getIDStart(), s.getLength()); ps[s.getIDStart()].Add(s.getIDEnd(), new MovementPoint() { distance = s.getLength(), scale = end.getScale(), destination = new Vector2(end.getX(), end.getY()) }); ps[s.getIDEnd()].Add(s.getIDStart(), new MovementPoint() { distance = s.getLength(), scale = start.getScale(), destination = new Vector2(start.getX(), start.getY()) }); } Trajectory.Node no = new Trajectory.Node("origin", Mathf.RoundToInt(origin.x), Mathf.RoundToInt(origin.y), 1f); Trajectory.Node nd = new Trajectory.Node("destiny", Mathf.RoundToInt(destiny.x), Mathf.RoundToInt(destiny.y), 1f); Vector2 oStartV2 = LineHandler.nodeToVector2(originline.start), oEndV2 = LineHandler.nodeToVector2(originline.end), dStartV2 = LineHandler.nodeToVector2(destinyline.start), dEndV2 = LineHandler.nodeToVector2(destinyline.end); float od1 = originline.getSegmentDistance(origin, oStartV2), od2 = originline.getSegmentDistance(origin, oEndV2); float dd1 = destinyline.getSegmentDistance(destiny, dStartV2), dd2 = destinyline.getSegmentDistance(destiny, dEndV2); d[originline.start.getID()].Add(no.getID(), od1); d[originline.end.getID()].Add(no.getID(), od2); d.Add("origin", new Dictionary <string, float>() { { originline.start.getID(), od1 }, { originline.end.getID(), od2 } }); ps[originline.start.getID()].Add(no.getID(), new MovementPoint() { distance = od1, scale = originline.getScaleFor(origin), destination = origin }); ps[originline.end.getID()].Add(no.getID(), new MovementPoint() { distance = od2, scale = originline.getScaleFor(origin), destination = origin }); ps.Add("origin", new Dictionary <string, MovementPoint>() { { originline.start.getID(), new MovementPoint() { distance = od1, scale = originline.getScaleFor(LineHandler.nodeToVector2(originline.start)), destination = LineHandler.nodeToVector2(originline.start) } }, { originline.end.getID(), new MovementPoint() { distance = od2, scale = originline.getScaleFor(LineHandler.nodeToVector2(originline.end)), destination = LineHandler.nodeToVector2(originline.end) } } }); d[destinyline.start.getID()].Add(nd.getID(), dd1); d[destinyline.end.getID()].Add(nd.getID(), dd2); d.Add("destiny", new Dictionary <string, float>() { { destinyline.start.getID(), dd1 }, { destinyline.end.getID(), dd2 } }); ps[destinyline.start.getID()].Add(nd.getID(), new MovementPoint() { distance = dd1, scale = destinyline.getScaleFor(destiny), destination = destiny }); ps[destinyline.end.getID()].Add(nd.getID(), new MovementPoint() { distance = dd2, scale = destinyline.getScaleFor(destiny), destination = destiny }); ps.Add("destiny", new Dictionary <string, MovementPoint>() { { destinyline.start.getID(), new MovementPoint() { distance = dd1, scale = destinyline.getScaleFor(LineHandler.nodeToVector2(destinyline.start)), destination = LineHandler.nodeToVector2(destinyline.start) } }, { destinyline.end.getID(), new MovementPoint() { distance = dd2, scale = destinyline.getScaleFor(LineHandler.nodeToVector2(destinyline.end)), destination = LineHandler.nodeToVector2(destinyline.end) } } }); g.set_vertices(d); List <string> l = g.shortest_path("origin", "destiny"); l.Reverse(); List <MovementPoint> ret = new List <MovementPoint>(); string last = "origin"; foreach (string n in l) { ret.Add(ps[last][n]); last = n; } return(ret); }
public KeyValuePair <Vector2, float>[] route(Vector2 origin, Vector2 destiny) { List <KeyValuePair <Vector2, float> > ret = new List <KeyValuePair <Vector2, float> >(); LineHandler origin_line = null, destiny_line = null; foreach (LineHandler handler in lines) { if (origin_line == null && handler.contains(origin)) { origin_line = handler; } if (destiny_line == null && handler.contains(destiny)) { destiny_line = handler; } if (origin_line != null && destiny_line != null) { break; } } Vector2 closest = Vector2.zero; if (origin_line == null) { closest = closestPoint(PlayerMB.Instance.getPosition()); foreach (LineHandler handler in lines) { if (origin_line == null && handler.contains(closest)) { origin_line = handler; break; } } } if (closest != Vector2.zero) { ret.Add(new KeyValuePair <Vector2, float>(closest, origin_line.getScaleFor(closest))); } if (origin_line != null && destiny_line != null) { //###################################################### // IF ORIGIN_LINE AND DESTINY_LINE ARE THE SAME // Return only the destiny point, dont have to go // to other node //###################################################### if (origin_line == destiny_line) { ret.Add(new KeyValuePair <Vector2, float>(destiny, destiny_line.getScaleFor(destiny))); } else { List <KeyValuePair <Vector2, float> > tmpRoute = new List <KeyValuePair <Vector2, float> >(reach(origin_line, destiny_line)); //tmpRoute.Reverse (); ret.AddRange(tmpRoute); ret.Add(new KeyValuePair <Vector2, float>(destiny, destiny_line.getScaleFor(destiny))); } } return(ret.ToArray()); }