Пример #1
0
        public Ets2PrefabRoute(List <Ets2PrefabCurve> route, Ets2PrefabNode entry, Ets2PrefabNode exit)
        {
            Route = route;

            Entry = entry;
            Exit  = exit;

            // TODO: Interpret indicator signal
        }
Пример #2
0
        public Ets2PrefabRoute(List<Ets2PrefabCurve> route, Ets2PrefabNode entry, Ets2PrefabNode exit)
        {
            Route = route;

            Entry = entry;
            Exit = exit;

            // TODO: Interpret indicator signal

        }
Пример #3
0
        private void Parse21()
        {
            var nodes         = BitConverter.ToInt32(Stream, 4);
            var terrain       = BitConverter.ToInt32(Stream, 12);
            var navCurves     = BitConverter.ToInt32(Stream, 8);
            var signs         = BitConverter.ToInt32(Stream, 16);
            var spawns        = BitConverter.ToInt32(Stream, 20);
            var semaphores    = BitConverter.ToInt32(Stream, 24);
            var mappoints     = BitConverter.ToInt32(Stream, 28);
            var triggers      = BitConverter.ToInt32(Stream, 32);
            var intersections = BitConverter.ToInt32(Stream, 36);

            var nodeOffset = BitConverter.ToInt32(Stream, 44);
            var off2       = BitConverter.ToInt32(Stream, 48);
            var off3       = BitConverter.ToInt32(Stream, 52);
            var off4       = BitConverter.ToInt32(Stream, 56);


            for (int navCurve = 0; navCurve < navCurves; navCurve++)
            {
                var curveOff = off2 + navCurve * 128;

                var nextCurve = new List <int>();
                var prevCurve = new List <int>();
                for (int k = 0; k < 4; k++)
                {
                    nextCurve.Add(BitConverter.ToInt32(Stream, 76 + k * 4 + curveOff));
                    prevCurve.Add(BitConverter.ToInt32(Stream, 92 + k * 4 + curveOff));
                }

                var curve = new Ets2PrefabCurve {
                    Index = navCurve,

                    StartX         = BitConverter.ToSingle(Stream, 16 + curveOff),
                    StartY         = BitConverter.ToSingle(Stream, 20 + curveOff),
                    StartZ         = BitConverter.ToSingle(Stream, 24 + curveOff),
                    EndX           = BitConverter.ToSingle(Stream, 28 + curveOff),
                    EndY           = BitConverter.ToSingle(Stream, 32 + curveOff),
                    EndZ           = BitConverter.ToSingle(Stream, 36 + curveOff),
                    StartRotationX = BitConverter.ToSingle(Stream, 40 + curveOff),
                    StartRotationY = BitConverter.ToSingle(Stream, 44 + curveOff),
                    StartRotationZ = BitConverter.ToSingle(Stream, 48 + curveOff),
                    EndRotationX   = BitConverter.ToSingle(Stream, 52 + curveOff),
                    EndRotationY   = BitConverter.ToSingle(Stream, 56 + curveOff),
                    EndRotationZ   = BitConverter.ToSingle(Stream, 60 + curveOff),

                    StartYaw =
                        Math.Atan2(BitConverter.ToSingle(Stream, 48 + curveOff),
                                   BitConverter.ToSingle(Stream, 40 + curveOff)),
                    EndYaw =
                        Math.Atan2(BitConverter.ToSingle(Stream, 60 + curveOff),
                                   BitConverter.ToSingle(Stream, 52 + curveOff)),

                    Length = BitConverter.ToSingle(Stream, 72 + curveOff),

                    Next = nextCurve.Where(i => i != -1).ToArray(),
                    Prev = prevCurve.Where(i => i != -1).ToArray()
                };

                Curves.Add(curve);
            }

            for (int navCurve = 0; navCurve < navCurves; navCurve++)
            {
                Curves[navCurve].NextCurve = Curves[navCurve].Next.Select(x => Curves[x]).ToList();
                Curves[navCurve].PrevCurve = Curves[navCurve].Prev.Select(x => Curves[x]).ToList();
            }

            for (int node = 0; node < nodes; node++)
            {
                var nodeOff = nodeOffset + 104 * node;

                var inputLanes  = new List <int>();
                var outputLanes = new List <int>();
                for (var k = 0; k < 8; k++)
                {
                    inputLanes.Add(BitConverter.ToInt32(Stream, 40 + k * 4 + nodeOff));
                    outputLanes.Add(BitConverter.ToInt32(Stream, 72 + k * 4 + nodeOff));
                }

                var prefabNode = new Ets2PrefabNode {
                    Node = node,

                    X = BitConverter.ToSingle(Stream, 16 + nodeOff),
                    Y = BitConverter.ToSingle(Stream, 20 + nodeOff),
                    Z = BitConverter.ToSingle(Stream, 24 + nodeOff),

                    RotationX = BitConverter.ToSingle(Stream, 28 + nodeOff),
                    RotationY = BitConverter.ToSingle(Stream, 32 + nodeOff),
                    RotationZ = BitConverter.ToSingle(Stream, 36 + nodeOff),

                    InputCurve  = inputLanes.Where(i => i != -1).Select(x => Curves[x]).ToList(),
                    OutputCurve = outputLanes.Where(i => i != -1).Select(x => Curves[x]).ToList(),

                    Yaw = Math.PI -
                          Math.Atan2(BitConverter.ToSingle(Stream, 36 + nodeOff),
                                     BitConverter.ToSingle(Stream, 28 + nodeOff))
                };
                Nodes.Add(prefabNode);
            }
        }
Пример #4
0
        private void Parse()
        {
            var version = BitConverter.ToInt32(Stream, 0);

            // Made for version 21, however not throwing any errors if mismatched yet
            if (version != 21) 
            {

            }

            var nodes = BitConverter.ToInt32(Stream, 4);
            var terrain = BitConverter.ToInt32(Stream, 12);
            var navCurves = BitConverter.ToInt32(Stream, 8);
            var signs = BitConverter.ToInt32(Stream, 16);
            var spawns = BitConverter.ToInt32(Stream, 20);
            var semaphores = BitConverter.ToInt32(Stream, 24);
            var mappoints = BitConverter.ToInt32(Stream, 28);
            var triggers = BitConverter.ToInt32(Stream, 32);
            var intersections = BitConverter.ToInt32(Stream, 36);

            var nodeOffset = BitConverter.ToInt32(Stream, 44);
            var off2 = BitConverter.ToInt32(Stream, 48);
            var off3 = BitConverter.ToInt32(Stream, 52);
            var off4 = BitConverter.ToInt32(Stream, 56);

            
            for (int navCurve = 0; navCurve < navCurves; navCurve++)
            {
                var curveOff = off2 + navCurve*128;

                var nextCurve = new List<int>();
                var prevCurve = new List<int>();
                for (int k = 0; k < 4; k++)
                {
                    nextCurve.Add(BitConverter.ToInt32(Stream, 76 + k*4 + curveOff));
                    prevCurve.Add(BitConverter.ToInt32(Stream, 92 + k*4 + curveOff));
                }

                var curve = new Ets2PrefabCurve
                {
                    Index = navCurve,

                    StartX = BitConverter.ToSingle(Stream, 16 + curveOff),
                    StartY = BitConverter.ToSingle(Stream, 20 + curveOff),
                    StartZ = BitConverter.ToSingle(Stream, 24 + curveOff),
                    EndX = BitConverter.ToSingle(Stream, 28 + curveOff),
                    EndY = BitConverter.ToSingle(Stream, 32 + curveOff),
                    EndZ = BitConverter.ToSingle(Stream, 36 + curveOff),
                    StartRotationX = BitConverter.ToSingle(Stream, 40 + curveOff),
                    StartRotationY = BitConverter.ToSingle(Stream, 44 + curveOff),
                    StartRotationZ = BitConverter.ToSingle(Stream, 48 + curveOff),
                    EndRotationX = BitConverter.ToSingle(Stream, 52 + curveOff),
                    EndRotationY = BitConverter.ToSingle(Stream, 56 + curveOff),
                    EndRotationZ = BitConverter.ToSingle(Stream, 60 + curveOff),

                    StartYaw = 
                        Math.Atan2(BitConverter.ToSingle(Stream, 48 + curveOff),
                            BitConverter.ToSingle(Stream, 40 + curveOff)),
                    EndYaw = 
                        Math.Atan2(BitConverter.ToSingle(Stream, 60 + curveOff),
                            BitConverter.ToSingle(Stream, 52 + curveOff)),

                    Length = BitConverter.ToSingle(Stream, 72 + curveOff),

                    Next = nextCurve.Where(i => i != -1).ToArray(),
                    Prev = prevCurve.Where(i => i != -1).ToArray()
                };

                Curves.Add(curve);
            }

            for (int navCurve = 0; navCurve < navCurves; navCurve++)
            {
                Curves[navCurve].NextCurve = Curves[navCurve].Next.Select(x => Curves[x]).ToList();
                Curves[navCurve].PrevCurve = Curves[navCurve].Prev.Select(x => Curves[x]).ToList();
            }

            for (int node = 0; node < nodes; node++)
            {
                var nodeOff = nodeOffset + 104*node;

                var inputLanes = new List<int>();
                var outputLanes = new List<int>();
                for (var k = 0; k < 8; k++)
                {
                    inputLanes.Add(BitConverter.ToInt32(Stream, 40 + k*4 + nodeOff));
                    outputLanes.Add(BitConverter.ToInt32(Stream, 72 + k*4 + nodeOff));
                }

                var prefabNode = new Ets2PrefabNode
                {
                    Node = node,

                    X = BitConverter.ToSingle(Stream, 16 + nodeOff),
                    Y = BitConverter.ToSingle(Stream, 20 + nodeOff),
                    Z = BitConverter.ToSingle(Stream, 24 + nodeOff),

                    RotationX = BitConverter.ToSingle(Stream, 28 + nodeOff),
                    RotationY = BitConverter.ToSingle(Stream, 32 + nodeOff),
                    RotationZ = BitConverter.ToSingle(Stream, 36 + nodeOff),

                    InputCurve = inputLanes.Where(i => i != -1).Select(x => Curves[x]).ToList(),
                    OutputCurve = outputLanes.Where(i => i != -1).Select(x => Curves[x]).ToList(),

                    Yaw = Math.PI-
                        Math.Atan2(BitConverter.ToSingle(Stream, 36 + nodeOff),
                            BitConverter.ToSingle(Stream, 28 + nodeOff))
                };
                Nodes.Add(prefabNode);
            }

        }