コード例 #1
0
ファイル: NodeSteuerung.cs プロジェクト: chenysh/CTS-Develop
        /// <summary>
        /// Läd eine XML Datei und versucht daraus den gespeicherten Zustand wiederherzustellen
        /// </summary>
        /// <param name="xd">XmlDocument mit den zu ladenden Daten</param>
        /// <param name="lf">LoadingForm für Statusinformationen</param>
        public List<Auftrag> LoadFromFile(XmlDocument xd, LoadingForm.LoadingForm lf)
        {
            lf.SetupLowerProgess("Parsing XML...", 3);

            List<Auftrag> toReturn = new List<Auftrag>();
            int saveVersion = 0;

            // erstma alles vorhandene löschen
            nodes.Clear();
            connections.Clear();
            intersections.Clear();
            _networkLayers.Clear();

            XmlNode mainNode = xd.SelectSingleNode("//CityTrafficSimulator");
            XmlNode saveVersionNode = mainNode.Attributes.GetNamedItem("saveVersion");
            if (saveVersionNode != null)
                saveVersion = Int32.Parse(saveVersionNode.Value);
            else
                saveVersion = 0;

            XmlNode titleNode = xd.SelectSingleNode("//CityTrafficSimulator/Layout/title");
            if (titleNode != null)
                {
                m_title = titleNode.InnerText;
                }

            XmlNode infoNode = xd.SelectSingleNode("//CityTrafficSimulator/Layout/infoText");
            if (infoNode != null)
                {
                _infoText = infoNode.InnerText;
                }

            lf.StepLowerProgress();

            // entsprechenden Node auswählen
            XmlNodeList xnlLineNode = xd.SelectNodes("//CityTrafficSimulator/Layout/LineNode");
            foreach (XmlNode aXmlNode in xnlLineNode)
                {
                // Node in einen TextReader packen
                TextReader tr = new StringReader(aXmlNode.OuterXml);
                // und Deserializen
                XmlSerializer xs = new XmlSerializer(typeof(LineNode));
                LineNode ln = (LineNode)xs.Deserialize(tr);

                // ab in die Liste
                nodes.Add(ln);
                }

            lf.StepLowerProgress();

            // entsprechenden Node auswählen
            XmlNodeList xnlNetworkLayer = xd.SelectNodes("//CityTrafficSimulator/Layout/NetworkLayer");
            foreach (XmlNode aXmlNode in xnlNetworkLayer)
                {
                // Node in einen TextReader packen
                TextReader tr = new StringReader(aXmlNode.OuterXml);
                // und Deserializen
                XmlSerializer xs = new XmlSerializer(typeof(NetworkLayer));
                NetworkLayer nl = (NetworkLayer)xs.Deserialize(tr);

                // ab in die Liste
                _networkLayers.Add(nl);
                }

            lf.StepLowerProgress();

            // entsprechenden NodeConnections auswählen
            XmlNodeList xnlNodeConnection = xd.SelectNodes("//CityTrafficSimulator/Layout/NodeConnection");
            foreach (XmlNode aXmlNode in xnlNodeConnection)
                {
                // Node in einen TextReader packen
                TextReader tr = new StringReader(aXmlNode.OuterXml);
                // und Deserializen
                XmlSerializer xs = new XmlSerializer(typeof(NodeConnection));
                NodeConnection ln = (NodeConnection)xs.Deserialize(tr);
                // ab in die Liste
                connections.Add(ln);
                }

            lf.SetupLowerProgess("Restoring LineNodes...", _nodes.Count);

            // Nodes wiederherstellen
            foreach (LineNode ln in _nodes)
                {
                ln.RecoverFromLoad(saveVersion, _nodes);
                lf.StepLowerProgress();
                }

            lf.SetupLowerProgess("Restoring NetworkLayers...", _networkLayers.Count);

            // restore NetworkLayers
            if (saveVersion >= 6)
                {
                foreach (NetworkLayer nl in _networkLayers)
                    {
                    foreach (int hash in nl._nodeHashes)
                        {
                        LineNode tmp = GetLineNodeByHash(nodes, hash);
                        if (tmp != null)
                            tmp.networkLayer = nl;
                        }
                    nl.TitleChanged += new NetworkLayer.TitleChangedEventHandler(nl_TitleChanged);
                    nl.VisibleChanged +=new NetworkLayer.VisibleChangedEventHandler(nl_VisibleChanged);
                    }
                }
            else
                {
                AddNetworkLayer("Layer 1", true);
                foreach (LineNode ln in _nodes)
                    {
                    ln.networkLayer = _networkLayers[0];
                    }
                }
            InvokeNetworkLayersChanged(new NetworkLayersChangedEventArgs(NetworkLayersChangedEventArgs.InvalidationLevel.COLLECTION_CHANGED));

            lf.SetupLowerProgess("Restoring NodeConnections...", _connections.Count);

            // LineNodes wiederherstellen
            foreach (NodeConnection nc in _connections)
                {
                nc.RecoverFromLoad(saveVersion, nodes);
                TellNodesTheirConnection(nc);
                nc.lineSegment = new LineSegment(0, nc.startNode.position, nc.startNode.outSlopeAbs, nc.endNode.inSlopeAbs, nc.endNode.position);

                lf.StepLowerProgress();
                }

            lf.SetupLowerProgess("Calculate Intersections and Line Change Points...", _connections.Count);

            // Intersections wiederherstellen
            foreach (NodeConnection nc in _connections)
                {
                UpdateNodeConnection(nc);

                lf.StepLowerProgress();
                }

            // Fahraufträge laden
            // entsprechenden Node auswählen
            if (saveVersion < 5)
                {
                XmlNodeList xnlAuftrag = xd.SelectNodes("//CityTrafficSimulator/Traffic/Auftrag");

                lf.SetupLowerProgess("Load Old Traffic Volume...", 2 * xnlAuftrag.Count);

                foreach (XmlNode aXmlNode in xnlAuftrag)
                    {
                    // Node in einen TextReader packen
                    TextReader tr = new StringReader(aXmlNode.OuterXml);
                    // und Deserializen
                    XmlSerializer xs = new XmlSerializer(typeof(Auftrag));
                    Auftrag ln = (Auftrag)xs.Deserialize(tr);

                    // in alten Dateien wurde das Feld häufigkeit statt trafficDensity gespeichert. Da es dieses Feld heute nicht mehr gibt, müssen wir konvertieren:
                    if (saveVersion < 1)
                        {
                        // eigentlich wollte ich hier direkt mit aXmlNode arbeiten, das hat jedoch komische Fehler verursacht (SelectSingleNode) wählt immer den gleichen aus)
                        // daher der Umweg über das neue XmlDocument.
                        XmlDocument doc = new XmlDocument();
                        XmlElement elem = doc.CreateElement("Auftrag");
                        elem.InnerXml = aXmlNode.InnerXml;
                        doc.AppendChild(elem);

                        XmlNode haeufigkeitNode = doc.SelectSingleNode("//Auftrag/häufigkeit");
                        if (haeufigkeitNode != null)
                            {
                            ln.trafficDensity = 72000 / Int32.Parse(haeufigkeitNode.InnerXml);
                            }
                        haeufigkeitNode = null;
                        }

                    // ab in die Liste
                    toReturn.Add(ln);

                    lf.StepLowerProgress();
                    }

                // Nodes wiederherstellen
                foreach (Auftrag a in toReturn)
                    {
                    a.RecoverFromLoad(saveVersion, nodes);

                    lf.StepLowerProgress();
                    }

                }

            return toReturn;
        }
コード例 #2
0
        /// <summary>
        /// Loads the traffic volume setup from the given XML file
        /// </summary>
        /// <param name="xd">XmlDocument to parse</param>
        /// <param name="nodesList">List of all existing LineNodes</param>
        /// <param name="lf">LoadingForm for status updates</param>
        public void LoadFromFile(XmlDocument xd, List<LineNode> nodesList, LoadingForm.LoadingForm lf)
        {
            lf.SetupLowerProgess("Parsing XML...", 3);

            // clear everything first
            _trafficVolumes.Clear();
            _startPoints.Clear();
            _destinationPoints.Clear();

            // parse save file version (currently not needed, but probably in future)
            int saveVersion = 0;
            XmlNode mainNode = xd.SelectSingleNode("//CityTrafficSimulator");
            XmlNode saveVersionNode = mainNode.Attributes.GetNamedItem("saveVersion");
            if (saveVersionNode != null)
                saveVersion = Int32.Parse(saveVersionNode.Value);
            else
                saveVersion = 0;

            // Load start points:
            lf.StepLowerProgress();
            // get corresponding XML nodes
            XmlNodeList xnlStartNodes = xd.SelectNodes("//CityTrafficSimulator/TrafficVolumes/StartPoints/BunchOfNodes");
            foreach (XmlNode aXmlNode in xnlStartNodes)
                {
                // Deserialize each node
                TextReader tr = new StringReader(aXmlNode.OuterXml);
                XmlSerializer xs = new XmlSerializer(typeof(BunchOfNodes));
                BunchOfNodes bof = (BunchOfNodes)xs.Deserialize(tr);
                bof.RecoverFromLoad(saveVersion, nodesList);
                _startPoints.Add(bof);
                }

            // Load destination points:
            lf.StepLowerProgress();
            // get corresponding XML nodes
            XmlNodeList xnlDestinationNodes = xd.SelectNodes("//CityTrafficSimulator/TrafficVolumes/DestinationPoints/BunchOfNodes");
            foreach (XmlNode aXmlNode in xnlDestinationNodes)
                {
                // Deserialize each node
                TextReader tr = new StringReader(aXmlNode.OuterXml);
                XmlSerializer xs = new XmlSerializer(typeof(BunchOfNodes));
                BunchOfNodes bof = (BunchOfNodes)xs.Deserialize(tr);
                bof.RecoverFromLoad(saveVersion, nodesList);
                // ensure that no hashcode is assigned twice
                BunchOfNodes.hashcodeIndex = Math.Max(bof.hashcode + 1, BunchOfNodes.hashcodeIndex);
                _destinationPoints.Add(bof);
                }

            // Load traffic volumes:
            lf.StepLowerProgress();
            // get corresponding XML nodes
            XmlNodeList xnlTrafficVolumes = xd.SelectNodes("//CityTrafficSimulator/TrafficVolumes/TrafficVolume");
            foreach (XmlNode aXmlNode in xnlTrafficVolumes)
                {
                // Deserialize each node
                TextReader tr = new StringReader(aXmlNode.OuterXml);
                XmlSerializer xs = new XmlSerializer(typeof(TrafficVolume));
                TrafficVolume tv = (TrafficVolume)xs.Deserialize(tr);

                tv.RecoverFromLoad(saveVersion, startPoints, destinationPoints);
                if (tv.startNodes != null && tv.destinationNodes != null)
                    {
                    _trafficVolumes.Add(tv);
                    tv.VehicleSpawned += new TrafficVolume.VehicleSpawnedEventHandler(newTV_VehicleSpawned);
                    }
                else
                    {
                    lf.Log("Error during traffic volume deserialization: Could not dereference start-/end nodes. Traffic volume was dismissed.");
                    }
                }

            OnStartPointsChanged(new StartPointsChangedEventArgs());
            OnDestinationPointsChanged(new DestinationPointsChangedEventArgs());
        }
コード例 #3
0
        /// <summary>
        /// Läd eine XML Datei und versucht daraus den gespeicherten Zustand wiederherzustellen
        /// </summary>
        /// <param name="xd">XmlDocument mit den zu ladenden Daten</param>
        /// <param name="nodesList">Liste von allen existierenden LineNodes</param>
        /// <param name="lf">LoadingForm für Statusinformationen</param>
        public void LoadFromFile(XmlDocument xd, List<LineNode> nodesList, LoadingForm.LoadingForm lf)
        {
            lf.SetupLowerProgess("Parsing XML...", 1);

            int saveVersion = 0;

            // erstma alles vorhandene löschen
            foreach (TimelineGroup tg in _groups)
                {
                foreach (TimelineEntry te in tg.entries)
                    {
                    // Löschen vorbereiten
                    te.Dispose();
                    }
                tg.entries.Clear();
                }
            _groups.Clear();

            XmlNode mainNode = xd.SelectSingleNode("//CityTrafficSimulator");
            XmlNode saveVersionNode = mainNode.Attributes.GetNamedItem("saveVersion");
            if (saveVersionNode != null)
                saveVersion = Int32.Parse(saveVersionNode.Value);
            else
                saveVersion = 0;

            lf.StepLowerProgress();

            if (saveVersion >= 4)
                {
                XmlNode xnlTrafficLights = xd.SelectSingleNode("//CityTrafficSimulator/TrafficLights");
                XmlNode cycleTimeNode = xnlTrafficLights.Attributes.GetNamedItem("cycleTime");
                if (cycleTimeNode != null)
                    maxTime = Double.Parse(cycleTimeNode.Value);
                }
            else
                {
                maxTime = 50;
                }

            if (saveVersion >= 3)
                {
                // entsprechenden Node auswählen
                XmlNodeList xnlLineNode = xd.SelectNodes("//CityTrafficSimulator/TrafficLights/TimelineGroup");
                Type[] extraTypes = { typeof(TrafficLight) };
                foreach (XmlNode aXmlNode in xnlLineNode)
                    {
                    // Node in einen TextReader packen
                    TextReader tr = new StringReader(aXmlNode.OuterXml);
                    // und Deserializen
                    XmlSerializer xs = new XmlSerializer(typeof(TimelineGroup), extraTypes);
                    TimelineGroup tg = (TimelineGroup)xs.Deserialize(tr);

                    // ab in die Liste
                    tg.GroupChanged += new TimelineGroup.GroupChangedEventHandler(tg_GroupChanged);
                    _groups.Add(tg);
                    }
                }
            else
                {
                TimelineGroup unsortedGroup = new TimelineGroup("Unsorted Signals", false);

                // entsprechenden Node auswählen
                XmlNodeList xnlLineNode = xd.SelectNodes("//CityTrafficSimulator/Layout/LineNode/tLight");
                foreach (XmlNode aXmlNode in xnlLineNode)
                    {
                    // der XMLNode darf nicht tLight heißen, sondern muss TrafficLight heißen. Das müssen wir mal anpassen:
                    XmlDocument doc = new XmlDocument();
                    XmlElement elem = doc.CreateElement("TrafficLight");
                    elem.InnerXml = aXmlNode.InnerXml;
                    doc.AppendChild(elem);
                    // so, das war nicht wirklich hübsch und schnell, aber es funktioniert ;)

                    // Node in einen TextReader packen
                    StringReader tr = new StringReader(doc.InnerXml);

                    // und Deserializen
                    XmlSerializer xs = new XmlSerializer(typeof(TrafficLight));
                    TrafficLight tl = (TrafficLight)xs.Deserialize(tr);

                    XmlNode pnhNode = doc.SelectSingleNode("//TrafficLight/parentNodeHash");
                    tl.parentNodeHash = Int32.Parse(pnhNode.InnerXml);
                    unsortedGroup.AddEntry(tl);
                    }

                // ab in die Liste
                _groups.Add(unsortedGroup);
                }

            lf.SetupLowerProgess("Restoring Signals...", _groups.Count);

            // Abschließende Arbeiten: Referenzen auflösen
            foreach (TimelineGroup tg in _groups)
                {
                tg.RecoverFromLoad(saveVersion, nodesList);
                lf.StepLowerProgress();
                }

            OnGroupsChanged();
        }