CodeWalker/World/Trains.cs

using CodeWalker.GameFiles;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Xml;
using SharpDX;

namespace CodeWalker.World
{
    public class Trains
    {
        public volatile bool Inited = false;
        public GameFileCache GameFileCache;

        public List<TrainTrack> TrainTracks { get; set; } = new List<TrainTrack>();


        public void Init(GameFileCache gameFileCache, Action<string> updateStatus)
        {
            GameFileCache = gameFileCache;

            var rpfman = gameFileCache.RpfMan;

            string trainsfilename = "common.rpf\\data\\levels\\gta5\\trains.xml";
            XmlDocument trainsxml = rpfman.GetFileXml(trainsfilename);
            XmlElement trainsdata = trainsxml.DocumentElement;
            //TODO: parse train_configs


            string tracksfilename = "common.rpf\\data\\levels\\gta5\\traintracks.xml";
            XmlDocument tracksxml = rpfman.GetFileXml(tracksfilename);
            XmlElement tracksdata = tracksxml.DocumentElement;
            XmlNodeList tracks = tracksdata.SelectNodes("train_track");

            TrainTracks.Clear();
            for (int i = 0; i < tracks.Count; i++)
            {
                var trackxml = tracks[i];
                TrainTrack tt = new TrainTrack();
                tt.Load(gameFileCache, trackxml);
                TrainTracks.Add(tt);
            }


            Inited = true;
        }

    }

    public class TrainTrack : BasePathData
    {
        public string filename { get; set; }
        public string trainConfigName { get; set; }
        public bool isPingPongTrack { get; set; }
        public bool stopsAtStations { get; set; }
        public bool MPstopsAtStations { get; set; }
        public float speed { get; set; }
        public float brakingDist { get; set; }


        public List<TrainTrackNode> Nodes { get; set; }
        public int NodeCount { get; set; }


        public int StationCount
        {
            get
            {
                int sc = 0;
                foreach (var node in Nodes)
                {
                    if ((node.NodeType == 1) || (node.NodeType == 2) || (node.NodeType == 5))
                    {
                        sc++;
                    }
                }
                return sc;
            }
        }


        public EditorVertex[] LinkedVerts { get; set; }
        public Vector4[] NodePositions { get; set; }

        public EditorVertex[] GetPathVertices()
        {
            return LinkedVerts;
        }
        public EditorVertex[] GetTriangleVertices()
        {
            return null;
        }
        public Vector4[] GetNodePositions()
        {
            return NodePositions;
        }

        public PathBVH BVH { get; set; }

        public string NodesString { get; set; }
        public RpfFileEntry RpfFileEntry { get; set; }
        public string Name { get; set; }
        public string FilePath { get; set; }
        public bool HasChanged { get; set; }
        public bool Loaded { get; set; }




        public void Load(GameFileCache gameFileCache, XmlNode node)
        {
            //load from game file cache

            filename = Xml.GetStringAttribute(node, "filename");
            trainConfigName = Xml.GetStringAttribute(node, "trainConfigName");
            isPingPongTrack = Xml.GetBoolAttribute(node, "isPingPongTrack");
            stopsAtStations = Xml.GetBoolAttribute(node, "stopsAtStations");
            MPstopsAtStations = Xml.GetBoolAttribute(node, "MPstopsAtStations");
            speed = Xml.GetFloatAttribute(node, "speed");
            brakingDist = Xml.GetFloatAttribute(node, "brakingDist");

            RpfFileEntry = gameFileCache.RpfMan.GetEntry(filename) as RpfFileEntry;
            NodesString = gameFileCache.RpfMan.GetFileUTF8Text(filename);
            SetNameFromFilename();
            FilePath = Name;

            Load(NodesString);

            BuildVertices();

            BuildBVH();

            Loaded = true;
        }

        public void Load(byte[] data)
        {
            filename = string.Empty;
            trainConfigName = string.Empty;
            RpfFileEntry = new RpfBinaryFileEntry();
            

            string str = Encoding.UTF8.GetString(data);
            Load(str);

            BuildVertices();

            BuildBVH();

            Loaded = true;
        }

        public byte[] Save()
        {
            NodeCount = Nodes.Count;
            StringBuilder sb = new StringBuilder();
            sb.AppendLine(Nodes.Count.ToString());
            foreach (var node in Nodes)
            {
                var nstr = FloatUtil.GetVector3String(node.Position).Replace(",","") + " " + node.NodeType.ToString();
                sb.AppendLine(nstr);
            }
            string str = sb.ToString();
            return Encoding.UTF8.GetBytes(str);
        }


        public void SetNameFromFilename()
        {
            string[] fparts = filename.Replace('\\', '/').Split('/');
            if ((fparts == null) || (fparts.Length == 0))
            {
                Name = filename;
            }
            else
            {
                Name = fparts[fparts.Length - 1];
            }
        }


        public void Load(string trackstr)
        {
            //load nodes from a text string...
            NodesString = trackstr;

            if (!string.IsNullOrEmpty(trackstr))
            {
                string[] trackstrs = trackstr.Split(new[] { "\r\n" }, StringSplitOptions.RemoveEmptyEntries);
                if (trackstrs.Length > 1)
                {
                    int nodecount;
                    int.TryParse(trackstrs[0], out nodecount);
                    NodeCount = nodecount;
                    List<TrainTrackNode> nodes = new List<TrainTrackNode>();
                    for (int i = 1; i < trackstrs.Length; i++)
                    {
                        var nodestr = trackstrs[i].Trim();
                        var nodevals = nodestr.Split(' ');
                        if (nodevals.Length == 4)
                        {
                            TrainTrackNode ttnode = new TrainTrackNode();
                            var x = FloatUtil.Parse(nodevals[0]);
                            var y = FloatUtil.Parse(nodevals[1]);
                            var z = FloatUtil.Parse(nodevals[2]);
                            int nodetype;
                            int.TryParse(nodevals[3], out nodetype);
                            ttnode.Position = new Vector3(x, y, z);
                            ttnode.NodeType = nodetype;
                            ttnode.Track = this;
                            ttnode.Index = nodes.Count;
                            ttnode.Links[0] = (nodes.Count > 0) ? nodes[nodes.Count - 1] : null;
                            if (ttnode.Links[0] != null)
                            {
                                ttnode.Links[0].Links[1] = ttnode;
                            }
                            nodes.Add(ttnode);
                        }
                        else
                        { }
                    }
                    Nodes = nodes;
                }
                else
                { }
            }
            else
            { }

            if (Nodes == null)
            {
                Nodes = new List<TrainTrackNode>();
            }

        }


        public void BuildVertices()
        {
            if ((Nodes != null) && (Nodes.Count > 0))
            {
                var nc = Nodes.Count;
                var lc = nc - 1;
                var lvc = lc * 2;
                var np = new Vector4[nc];
                var lv = new EditorVertex[lvc];
                for (int i = 0; i < nc; i++)
                {
                    np[i] = new Vector4(Nodes[i].Position, 1.0f);
                    if (i > 0)
                    {
                        var l = i - 1;
                        var li = l * 2;
                        var ni = li + 1;
                        lv[li].Position = Nodes[l].Position;
                        lv[ni].Position = Nodes[i].Position;
                        lv[li].Colour = (uint)Nodes[l].GetColour();
                        lv[ni].Colour = (uint)Nodes[i].GetColour();
                    }
                }
                NodePositions = np;
                LinkedVerts = lv;
            }

        }





        public void UpdateBvhForNode(TrainTrackNode node)
        {
            //this needs to be called when a node's position changes...
            //need to recalc the BVH for mouse intersection optimisation purposes.

            //if (BVH == null) return;
            //BVH.UpdateForNode(node);

            BuildBVH();

            //also updates the NodePositions for the visible vertex
            if (Nodes != null)
            {
                for (int i = 0; i < Nodes.Count; i++)
                {
                    if (Nodes[i] == node)
                    {
                        NodePositions[i] = new Vector4(node.Position, 1.0f);
                        break;
                    }
                }
            }

        }

        public void BuildBVH()
        {
            BVH = new PathBVH(Nodes, 10, 10);
        }






        public TrainTrackNode AddNode(TrainTrackNode afternode = null)
        {
            int cnt = Nodes?.Count ?? 0;
            TrainTrackNode tn = new TrainTrackNode();
            tn.Track = this;
            tn.Index = (afternode != null) ? afternode.Index + 1 : cnt;

            if (Nodes == null)
            {
                Nodes = new List<TrainTrackNode>();
            }

            if (afternode != null)
            {
                TrainTrackNode aln = afternode.Links[1];
                if (aln != null) aln.Links[0] = tn;
                afternode.Links[1] = tn;
                tn.Links[0] = afternode;
                tn.Links[1] = aln;

                int idx = tn.Index;
                Nodes.Insert(idx, tn);

                for (int i = 0; i < Nodes.Count; i++)
                {
                    Nodes[i].Index = i;
                }

            }
            else
            {
                if (cnt > 0)
                {
                    TrainTrackNode ln = Nodes[cnt - 1];
                    tn.Links[0] = ln;
                    ln.Links[1] = tn;
                }

                Nodes.Add(tn);
            }


            NodeCount = Nodes.Count;

            return tn;
        }

        public bool RemoveNode(TrainTrackNode node)
        {
            bool r = false;

            r = Nodes.Remove(node);

            NodeCount = Nodes.Count;
            
            if (r)
            {
                var l0 = node.Links[0];
                var l1 = node.Links[1];

                if (l0 != null)
                {
                    l0.Links[1] = l1;
                }
                if (l1 != null)
                {
                    l1.Links[0] = l0;
                }

                for (int i = 0; i < Nodes.Count; i++)
                {
                    Nodes[i].Index = i;
                }

                BuildVertices();
            }

            return r;
        }





        public override string ToString()
        {
            return Name + ": " + filename + " (" + NodeCount.ToString() + " nodes)";
        }
    }

    public class TrainTrackNode : BasePathNode
    {
        public Vector3 Position { get; set; }
        public int NodeType { get; set; }

        public TrainTrack Track { get; set; }
        public int Index { get; set; }
        public TrainTrackNode[] Links { get; set; } = new TrainTrackNode[2];

        public int GetColour()
        {
            switch (NodeType)
            {
                case 0: return new Color4(1.0f, 0.0f, 0.0f, 1.0f).ToRgba();
                case 1: return new Color4(1.0f, 1.0f, 0.0f, 1.0f).ToRgba();
                case 2: return new Color4(0.0f, 1.0f, 0.0f, 1.0f).ToRgba();
                case 3: return new Color4(0.0f, 1.0f, 1.0f, 1.0f).ToRgba();
                case 4: return new Color4(0.0f, 0.0f, 1.0f, 1.0f).ToRgba();
                case 5: return new Color4(1.0f, 0.0f, 1.0f, 1.0f).ToRgba();
                default: return new Color4(1.0f, 1.0f, 1.0f, 1.0f).ToRgba();
            }
        }


        public void SetPosition(Vector3 pos)
        {
            Position = pos;
        }

        public override string ToString()
        {
            return Index.ToString() + ": " + NodeType.ToString();// + ": " + FloatUtil.GetVector3String(Position);
        }
    }

}