示例#1
0
        /*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);
        }
示例#2
0
        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);
        }