예제 #1
0
        public void getRouteTest()
        {
            Solarsystem A = new Solarsystem();
            A.name = "A";
            Solarsystem B = new Solarsystem();
            B.name = "B";
            Solarsystem C = new Solarsystem();
            C.name = "C";

            Solarsystem D = new Solarsystem();
            D.name = "D";

            List<Solarsystem> systems = new List<Solarsystem>();
            systems.Add(A);
            systems.Add(B);
            systems.Add(C);
            systems.Add(D);

            Node AB = new Node();
            AB.distance = 1;
            AB.pointa = A;
            AB.pointb = B;
            A.nodes.Add(AB);
            B.nodes.Add(AB);

            Node AC = new Node();
            AC.distance = 10;
            AC.pointa = A;
            AC.pointb = C;
            A.nodes.Add(AC);
            C.nodes.Add(AC);

            Node BD = new Node();
            BD.distance = 100;
            BD.pointa = B;
            BD.pointb = D;
            B.nodes.Add(BD);
            D.nodes.Add(BD);

            Node CD = new Node();
            CD.distance = 5;
            CD.pointa = C;
            CD.pointb = D;
            C.nodes.Add(CD);
            D.nodes.Add(CD);

            Main main = null;
            NodeTrackingSystem target = new NodeTrackingSystem(main);

            Solarsystem start = A;
            Solarsystem end = D;
            bool dontUsePing = false;
            Route actual;
            actual = target.getRoute(start, end, dontUsePing);

            Assert.AreEqual(A, actual.start);
            Assert.AreEqual(D, actual.end);
            Assert.AreEqual(15, actual.distance);
        }
예제 #2
0
 public SystemInfo(Solarsystem system, GameData data)
 {
     if (data == null)
     {
         MessageBox.Show("Nur möglich, wenn eine GameData Datei eigelesen wurde!");
         Close();
     }
     this.system = system;
     this.data = data;
     InitializeComponent();
 }
예제 #3
0
파일: Map.cs 프로젝트: MRH4287/GameServer
        public LinkedList<Solarsystem> getSystemsInRange(Solarsystem start, double range)
        {
            LinkedList<Solarsystem> list = new LinkedList<Solarsystem>();

            if (start != null)
            {
                Parallel.ForEach(systemList, system =>
                          {
                              if ((system != null) && (start != system))
                              {
                                  double distance = getDistance(start, system);

                                  if (distance <= range)
                                  {
                                      lock (list)
                                      {
                                          list.AddLast(system);
                                      }
                                  }
                              }
                          });
            }
            return list;
        }
예제 #4
0
        public Route getRoute(Solarsystem start, Solarsystem end, bool dontUsePing = false)
        {
            foreach (Route element in routelist)
            {
                if ((start == element.start) && (end == element.end))
                {
                    return element;
                }
            }

            if (dontUsePing)
            {
                Route startS = new Route();
                startS.systems.Add(start);
                Route result = searchRoute(start, end, startS, 0);

                result.start = start;
                result.end = end;
                routelist.Add(result);

                Route route2 = new Route();
                route2.start = end;
                route2.end = start;
                route2.nodelist = InverseList(result.nodelist);
                route2.systems = InverseList(result.systems);
                routelist.Add(route2);

                return result;
            }
            else
            {
                try
                {
                    this.pingSolarsystem(start, start, end);
                    Route[] results = pingResponse[start][end];

                    Route best = null;
                    foreach (Route rt in results)
                    {
                        double length = 0;
                        foreach (Node nd in rt.nodelist)
                        {
                            length += nd.distance;
                        }

                        rt.distance = length;

                        if ((best == null) || (best.distance > rt.distance))
                        {
                            best = rt;
                        }

                    }

                    best.systems.Add(end);

                    return best;
                }
                catch (TrackingCanceledException)
                {
                    return null;
                }

            }
        }
예제 #5
0
        private Route searchRoute(Solarsystem position, Solarsystem end, Route list, int depth)
        {
            Route result = null;
            //    Console.WriteLine("Bin im System: " + position);

            if (depth < maxdepth)

                //   Parallel.ForEach(position.nodes, node =>
                foreach (Node node in position.nodes)
                {
                    //    Console.WriteLine("Checke Node: " + node);

                    //  bool stop = false;

                    Solarsystem other;
                    other = (node.pointa == position) ? node.pointb : node.pointa;

                    Route VList = new Route();
                    VList.nodelist = CloneList(list.nodelist);
                    VList.nodelist.Add(node);
                    VList.systems = CloneList(list.systems);
                    VList.systems.Add(other);

                    if (list.systems.Contains(other))
                    {
                        //      Console.WriteLine("Bereits besucht");
                        // stop = true;
                        continue;
                    }

                    // if (!stop)
                    //  {

                    if (other == end)
                    {
                        double distance = 0;
                        foreach (Node tmp in VList.nodelist)
                        {
                            distance += tmp.distance;
                        }
                        VList.distance = distance;

                        //    Console.WriteLine("Ergebnis gefunden");
                        // result = VList;
                        return VList;

                    }
                    else
                    {
                        //     Console.WriteLine("Suche Rekursiv");
                        Route search = searchRoute(other, end, VList, depth + 1);
                        if (search.distance != -1)
                        {
                            //  result = search;
                            return search;
                        }
                        else
                        {
                            //            Console.WriteLine("Ergebnis nicht gefunden");
                        }

                        //    }
                    }
                }
            // });

            if (result == null)
            {
                result = new Route();
                result.distance = -1;
            }
            return result;
        }
예제 #6
0
        public void pingSolarsystem(Solarsystem current, Solarsystem source, Solarsystem destination, Solarsystem[] visited = null, Node[] visitedNode = null, int maxResults = 3, int depth = 0)
        {
            if (visited == null || visitedNode == null)
            {
                visited = new Solarsystem[0];
                visitedNode = new Node[0];
                //pingResponse = new Dictionary<Solarsystem, Dictionary<Solarsystem, Route[]>>();
            }

            if ((main != null) && (!main.run()))
            {
                return;
            }

            if (!pingResponse.ContainsKey(source))
            {
                pingResponse.Add(source, new Dictionary<Solarsystem, Route[]>());
            }

            if (pingResponse[source].ContainsKey(destination) && (pingResponse[source][destination].Length >= maxResults))
            {
                return;
            }

            if (depth > maxdepth)
            {
                throw new TrackingCanceledException();
            }

            if (current == destination)
            {
                try
                {
                    Route route = new Route();
                    route.start = source;
                    route.end = destination;
                    route.systems = new List<Solarsystem>();
                    route.nodelist = new List<Node>();

                    foreach (Solarsystem system in visited)
                    {
                        route.systems.Add(system);
                    }

                    foreach (Node node in visitedNode)
                    {
                        route.nodelist.Add(node);
                    }

                    if (!pingResponse[source].ContainsKey(destination))
                    {
                        pingResponse[source].Add(destination, new Route[0]);
                    }

                    Route[] routes = new Route[pingResponse[source][destination].Length + 1];
                    copyArray(pingResponse[source][destination], routes);
                    routes[routes.Length - 1] = route;
                    pingResponse[source][destination] = routes;
                }
                catch
                {
                    // Das ist sehr seltsam, dass hier was fliegt ...
                }

            }
            else if (visited.Contains(current))
            {
                // Das System wurde bereits besucht ...
                return;
            }
            else
            {
                //Trage das aktuelle System in die Liste, der besuchten Systeme ein
                Solarsystem[] visited2 = new Solarsystem[visited.Length + 1];
                copyArray(visited, visited2);
                visited2[visited2.Length - 1] = current;

                List<Node> nodelist = current.nodes;

                bool error = false;

                Parallel.ForEach(nodelist, node =>
                //  foreach (Node node in nodelist)
                {
                    try
                    {

                        Solarsystem other = (node.pointa == current) ? node.pointb : node.pointa;

                        Node[] visitedNode2 = new Node[visitedNode.Length + 1];
                        copyArray(visitedNode, visitedNode2);
                        visitedNode2[visitedNode2.Length - 1] = node;

                        pingSolarsystem(other, source, destination, visited2, visitedNode2, maxResults, depth + 1);
                        //}

                    }
                    catch (TrackingCanceledException)
                    {
                        error = true;
                    }
                });

                if (error)
                {
                    throw new TrackingCanceledException();
                }

            }

            if (depth == 0)
            {
               // if (!pingResponse.ContainsKey(source) || !(pingResponse[source].ContainsKey(destination)) || !(pingResponse[source][destination].Length > 0))
              //  {
              //      throw new TrackingCanceledException();
              //  }
              //  else
              //  {
                    return;
              //  }
            }
            else
            {

                return;
            }
        }
예제 #7
0
파일: Map.cs 프로젝트: MRH4287/GameServer
        public bool isConnection(Solarsystem start, Solarsystem end)
        {
            bool connection = false;
            Parallel.ForEach(start.nodes, node =>
             {
                 if ((node.pointa == end) || (node.pointb == end))
                 {
                     connection = true;
                 }
             });

            return connection;
        }
예제 #8
0
파일: Map.cs 프로젝트: MRH4287/GameServer
 public double getDistance(Solarsystem start, Solarsystem end)
 {
     double distance = Math.Sqrt(Math.Pow((start.x - end.x), 2) + Math.Pow((start.y - end.y), 2));
     return distance;
 }
예제 #9
0
파일: Map.cs 프로젝트: MRH4287/GameServer
 public int getConnectionCount(Solarsystem system)
 {
     return system.nodes.Count;
 }
예제 #10
0
파일: Map.cs 프로젝트: MRH4287/GameServer
        private void generateMapData(int addCount = -1)
        {
            /* Erstellung der Map:

             *  1. Erstellen der Refferenzen der Sonnensystem
             *  2. Berrechnen der Abstände / Koordinaten der Systeme
             *  3. Erstellen der Verbindundungen zwischen den Systemen
             *  4. Überprüfen, ob jedes System mindestens eine Verbindung hat
             *  5. Überprüfen, ob es von jedem Punkt eine Verbindung zu jedem Punkt gibt
             */

            if (loadedMap != null)
            {

                if (loadedMap.randomArea != null)
                {
                    int systemcount = loadedMap.systemcount;
                    int min_distance = loadedMap.min_distance;

                    if (addCount != -1)
                    {
                        systemcount = addCount;
                    }

                    int min_X, min_Y, max_X, max_Y;

                    if (loadedMap.randomArea.x1 > loadedMap.randomArea.x2)
                    {
                        min_X = loadedMap.randomArea.x2;
                        max_X = loadedMap.randomArea.x1;
                    }
                    else
                    {
                        min_X = loadedMap.randomArea.x1;
                        max_X = loadedMap.randomArea.x2;
                    }

                    if (loadedMap.randomArea.y1 > loadedMap.randomArea.y2)
                    {
                        min_Y = loadedMap.randomArea.y2;
                        max_Y = loadedMap.randomArea.y1;
                    }
                    else
                    {
                        min_Y = loadedMap.randomArea.y1;
                        max_Y = loadedMap.randomArea.y2;
                    }

                    int connectrange = 100;
                    int maxconnections = 4;
                    try
                    {
                        connectrange = int.Parse(main.config["Game/Map/ConnectRange"]);
                        maxconnections = int.Parse(main.config["Game/Map/MaxConnections"]);
                    }
                    catch { }

                    //  Parallel.For(0, systemcount, i =>
                    for (int i = 0; i < systemcount; i++)
                    {
                        Random rand = new Random();
                        Solarsystem system = new Solarsystem();

                        int x = rand.Next(min_X, max_X);
                        int y = rand.Next(min_Y, max_Y);

                        system.x = x;
                        system.y = y;

                        system.name = Game.Game.Data.Names.SolarsystemNames[rand.Next(Game.Game.Data.Names.SolarsystemNames.Length - 1)];

                        int count = 0;
                        bool ok = true;
                        while (getSystemsInRange(system, min_distance).Count > 0)
                        {

                            count++;

                            x = rand.Next(min_X, max_X);
                            y = rand.Next(min_Y, max_Y);

                            system.x = x;
                            system.y = y;

                            if (count > 100)
                            {
                                ok = false;
                                break;
                            }
                        }

                        if (ok)
                        {

                            LinkedList<Solarsystem> near = getSystemsInRange(system, connectrange);
                            if (near.Count > 0)
                            {
                                int anzahl = rand.Next(1, near.Count);
                                int j = 0;
                                foreach (Solarsystem nearSystem in near)
                                {
                                    try
                                    {
                                        j++;
                                        if (j > anzahl)
                                        {
                                            break;
                                        }

                                        if ((getConnectionCount(system) < maxconnections) && (getConnectionCount(nearSystem) < maxconnections) && !isConnection(system, nearSystem))
                                        {
                                            Node node = new Node();
                                            node.pointa = system;
                                            node.pointb = nearSystem;
                                            node.distance = getDistance(system, nearSystem);
                                            system.nodes.Add(node);
                                            nearSystem.nodes.Add(node);

                                        }
                                    }
                                    catch { }
                                }
                            }
                            if (system != null)
                                systemList.Add(system);
                        }
                        // });
                    }

                    // Überprüfung der Systeme

                    bool sysok = true;

                    List<Solarsystem> delet = new List<Solarsystem>();
                    Parallel.ForEach(systemList, system =>
                        {

                            if ((system != null) && sysok)
                            {
                                if (getSystemsInRange(system, 0).Count > 0)
                                {
                                    Console.WriteLine("Invalides System endteckt!");

                                    system.nodes.Clear();
                                    foreach (Node node in system.nodes)
                                    {
                                        node.pointa.nodes.Remove(node);
                                        node.pointb.nodes.Remove(node);
                                    }
                                    try
                                    {
                                        delet.Add(system);

                                    }
                                    catch
                                    {
                                    }
                                }
                                else
                                    if (system.nodes.Count == 0)
                                    {

                                        LinkedList<Solarsystem> near = getSystemsInRange(system, connectrange * 2);
                                        if (near.Count > 0)
                                        {
                                            int anzahl = (new Random()).Next(1, near.Count);

                                            int j = 0;
                                            foreach (Solarsystem nearSystem in near)
                                            {
                                                j++;
                                                if (j > anzahl)
                                                {
                                                    break;
                                                }

                                                if ((getConnectionCount(system) < 2) && (getConnectionCount(nearSystem) < maxconnections) && !isConnection(system, nearSystem))
                                                {
                                                    Node node = new Node();
                                                    node.pointa = system;
                                                    node.pointb = nearSystem;
                                                    node.distance = getDistance(system, nearSystem);
                                                    system.nodes.Add(node);
                                                    nearSystem.nodes.Add(node);

                                                }
                                            }

                                        }
                                        if (system.nodes.Count == 0)
                                        {
                                            main.log("Unnereichbares System gefunden! Bitte Passen Sie die Map-Daten oder die AnwendungsKonfiguration an");
                                            sysok = false;
                                        }
                                    }
                            }
                        });

                    if (!sysok)
                    {
                        //  reCreateMap();
                        return;
                    }

                    //  Parallel.ForEach(delet, del => { systemList.Remove(del); });
                    //   Console.WriteLine(delet.Count + " Systeme entfernt");
                    foreach (Solarsystem del in delet)
                    {
                        if (systemList.Contains(del))
                        {

                            del.nodes.Clear();
                            foreach (Node node in del.nodes)
                            {
                                node.pointa.nodes.Remove(node);
                                node.pointb.nodes.Remove(node);
                            }

                            systemList.Remove(del);
                        }

                    }
                    systemList.Remove(null);

                    //  if (delet.Count > 0)
                    // generateMapData(delet.Count);

                }

                //Erstelle Zufalls Planeten
                List<PlanetClass> planetTypes = game.getPlanetTypes();
                if (planetTypes.Count > 0)
                {
                    Random random = new Random(DateTime.Now.Millisecond);
                    Parallel.ForEach(systemList, system =>
                           {

                               for (int i = 0; i < random.Next(15); i++)
                               {

                                   Planet planet = new Planet(Game.Game.Data.Names.PlanetNames[random.Next(Game.Game.Data.Names.PlanetNames.Length - 1)]);
                                   planet.type = planetTypes[random.Next(planetTypes.Count - 1)];

                                   if (system.planets == null)
                                   {
                                       system.planets = new List<Planet>();
                                   }
                                   system.planets.Add(planet);
                                   planet.Solarsystem = system;
                               }

                           });
                }

            }
            else
            {
                throw new GameException("Keine Map-Datei geladen");
            }
        }
예제 #11
0
        private void panel1_MouseClick(object sender, MouseEventArgs e)
        {
            if (tool_systemAdd.Checked)
            {
                PictureBox picture = new PictureBox();
                panel1.Controls.Add(picture);
                picture.Image = getImage("sun");
                picture.Left = e.X;
                picture.Top = e.Y;
                picture.Width = picture.Image.Width;
                picture.Height = picture.Image.Height;
                picture.Visible = true;

                picture.MouseClick += new MouseEventHandler(picture_Click);

                Solarsystem system = new Solarsystem();
                system.x = e.X;
                system.y = e.Y;

                solarsystemMap.Add(system);

                refferenzTable.Add(picture, system);
                refferenzTable2.Add(system, picture);
            }
            else if (tool_randomArea.Checked)
            {
                if (!randomAreaReady)
                {
                    if (randomArea == null)
                    {
                        randomArea = new Area();
                        randomArea.x1 = e.X;
                        randomArea.y1 = e.Y;

                    }
                    else
                    {
                        randomArea.x2 = e.X;
                        randomArea.y2 = e.Y;
                        randomAreaReady = true;
                    }

                }
                else
                {
                    randomArea = null;
                    randomAreaReady = false;
                }

            }
            else if (tool_delRandomArea.Checked)
            {
                randomArea = null;
                randomAreaReady = false;
            }

            printConnections();
        }