예제 #1
0
 public static void CalculateMiddlePoints(Vector3 startPos, Vector3 startDir, Vector3 endPos, Vector3 endDir, bool smoothStart, bool smoothEnd, out Vector3 middlePos1, out Vector3 middlePos2, out float distance)
 {
     if (NetSegment.IsStraight(startPos, startDir, endPos, endDir, out distance))
     {
         middlePos1 = startPos + startDir * (distance * ((!smoothStart) ? 0.15f : 0.3f));
         middlePos2 = endPos + endDir * (distance * ((!smoothEnd) ? 0.15f : 0.3f));
     }
     else
     {
         float dotxz = VectorUtils.DotXZ(startDir, endDir);
         if (dotxz >= -0.999f &&
             Line2.Intersect(
                 VectorUtils.XZ(startPos),
                 VectorUtils.XZ(startPos + startDir),
                 VectorUtils.XZ(endPos),
                 VectorUtils.XZ(endPos + endDir),
                 out float u,
                 out float v))
         {
             u = Mathf.Clamp(u, distance * 0.1f, distance);
             v = Mathf.Clamp(v, distance * 0.1f, distance);
             float uv = u + v;
             middlePos1 = startPos + startDir * Mathf.Min(u, uv * 0.3f);
             middlePos2 = endPos + endDir * Mathf.Min(v, uv * 0.3f);
         }
예제 #2
0
        private void GetIntersectionPoints()
        {
            IntersectionResultArray iresArray1;
            SetComparisonResult     result1 = Line1.Intersect(Line3, out iresArray1);
            IntersectionResult      ires1   = iresArray1.get_Item(0);

            Point1 = ires1.XYZPoint;

            IntersectionResultArray iresArray2;
            SetComparisonResult     result2 = Line1.Intersect(Line4, out iresArray2);
            IntersectionResult      ires2   = iresArray2.get_Item(0);

            Point2 = ires2.XYZPoint;

            IntersectionResultArray iresArray3;
            SetComparisonResult     result3 = Line2.Intersect(Line3, out iresArray3);
            IntersectionResult      ires3   = iresArray3.get_Item(0);

            Point3 = ires3.XYZPoint;

            IntersectionResultArray iresArray4;
            SetComparisonResult     result4 = Line2.Intersect(Line4, out iresArray4);
            IntersectionResult      ires4   = iresArray4.get_Item(0);

            Point4 = ires4.XYZPoint;
        }
예제 #3
0
        private void OnPointDrag(MarkupPoint point)
        {
            var normal = point.Enter.CornerDir.Turn90(true);

            Line2.Intersect(point.Position.XZ(), (point.Position + point.Enter.CornerDir).XZ(), MouseWorldPosition.XZ(), (MouseWorldPosition + normal).XZ(), out float offsetChange, out _);

            point.Offset = (point.Offset + offsetChange * Mathf.Sin(point.Enter.CornerAndNormalAngle)).RoundToNearest(0.01f);
        }
예제 #4
0
        public override void OnMouseDrag(Event e)
        {
            var normal = DragPoint.Enter.CornerDir.Turn90(true);

            Line2.Intersect(DragPoint.Position.XZ(), (DragPoint.Position + DragPoint.Enter.CornerDir).XZ(), NodeMarkupTool.MouseWorldPosition.XZ(), (NodeMarkupTool.MouseWorldPosition + normal).XZ(), out float offsetChange, out _);
            DragPoint.Offset = (DragPoint.Offset + offsetChange * Mathf.Sin(DragPoint.Enter.CornerAndNormalAngle)).RoundToNearest(0.01f);
            Panel.EditPoint(DragPoint);
        }
예제 #5
0
        public override void OnMouseDrag(Event e)
        {
            var normal   = DragPoint.Enter.CornerDir.Turn90(true);
            var position = SingletonTool <NodeMarkupTool> .Instance.Ray.GetRayPosition(Markup.Position.y, out _);

            Line2.Intersect(XZ(DragPoint.Position), XZ(DragPoint.Position + DragPoint.Enter.CornerDir), XZ(position), XZ(position + normal), out float offsetChange, out _);
            DragPoint.Offset.Value = (DragPoint.Offset + offsetChange * Mathf.Sin(DragPoint.Enter.CornerAndNormalAngle)).RoundToNearest(0.01f);
            Panel.SelectPoint(DragPoint);
        }
예제 #6
0
        private void OnPointDrag(MarkupPoint point)
        {
            RaycastInput input = new RaycastInput(MouseRay, MouseRayLength);

            RayCast(input, out RaycastOutput output);

            var normal = point.Enter.CornerDir.Turn90(true);

            Line2.Intersect(VectorUtils.XZ(point.Position), VectorUtils.XZ(point.Position + point.Enter.CornerDir), VectorUtils.XZ(output.m_hitPos), VectorUtils.XZ(output.m_hitPos + normal), out float offsetChange, out _);

            point.Offset = (point.Offset + offsetChange).RoundToNearest(0.01f);
        }
예제 #7
0
        private void RenderNotConnectLine(RenderManager.CameraInfo cameraInfo)
        {
            var bezier = new Bezier3()
            {
                a = SelectPoint.Position,
                b = SelectPoint.Direction,
                c = SelectPoint.Direction.Turn90(true),
                d = MouseWorldPosition,
            };

            Line2.Intersect(VectorUtils.XZ(bezier.a), VectorUtils.XZ(bezier.a + bezier.b), VectorUtils.XZ(bezier.d), VectorUtils.XZ(bezier.d + bezier.c), out _, out float v);
            bezier.c = v >= 0 ? bezier.c : -bezier.c;

            NetSegment.CalculateMiddlePoints(bezier.a, bezier.b, bezier.d, bezier.c, true, true, out bezier.b, out bezier.c);
            RenderBezier(cameraInfo, MarkupColors.White, bezier);
        }
예제 #8
0
 public static void CalculateMiddlePoints(Vector3 startPos, Vector3 startDir, Vector3 endPos, Vector3 endDir, bool smoothStart, bool smoothEnd, out Vector3 middlePos1, out Vector3 middlePos2)
 {
     if (IsStraight(startPos, startDir, endPos, endDir, out float distance))
     {
         middlePos1 = startPos + startDir * (distance * ((!smoothStart) ? 0.15f : 0.276f));
         middlePos2 = endPos + endDir * (distance * ((!smoothEnd) ? 0.15f : 0.276f));
     }
     else
     {
         float num = startDir.x * endDir.x + startDir.z * endDir.z;
         if (num >= -0.999f && Line2.Intersect(VectorUtils.XZ(startPos), VectorUtils.XZ(startPos + startDir), VectorUtils.XZ(endPos), VectorUtils.XZ(endPos + endDir), out float u, out float v))
         {
             u = Mathf.Clamp(u, distance * 0.1f, distance);
             v = Mathf.Clamp(v, distance * 0.1f, distance);
             float num2 = u + v;
             middlePos1 = startPos + startDir * Mathf.Min(u, num2 * 0.276f);
             middlePos2 = endPos + endDir * Mathf.Min(v, num2 * 0.276f);
         }
예제 #9
0
        private Vector3 GetControlPoint(ushort segment)
        {
            Vector3 position       = NodeBuffer[SegmentBuffer[segment].m_startNode].m_position;
            Vector3 startDirection = SegmentBuffer[segment].m_startDirection;
            Vector3 position2      = NodeBuffer[SegmentBuffer[segment].m_endNode].m_position;
            Vector3 endDirection   = SegmentBuffer[segment].m_endDirection;

            if (!NetSegment.IsStraight(position, startDirection, position2, endDirection, out _))
            {
                var num2 = (startDirection.x * endDirection.x) + (startDirection.z * endDirection.z);
                if (num2 >= -0.999f && Line2.Intersect(VectorUtils.XZ(position), VectorUtils.XZ(position + startDirection), VectorUtils.XZ(position2), VectorUtils.XZ(position2 + endDirection), out var d, out _))
                {
                    return(position + (startDirection * d));
                }
                LogUtils.DoErrorLog("Warning! Invalid segment directions!");
            }
            return((position + position2) / 2f);
        }
예제 #10
0
        private Vector3 GetControlPoint(ushort segment)
        {
            Vector3 position       = nodeBuffer[(int)segmentBuffer[(int)segment].m_startNode].m_position;
            Vector3 startDirection = segmentBuffer[(int)segment].m_startDirection;
            Vector3 position2      = nodeBuffer[(int)segmentBuffer[(int)segment].m_endNode].m_position;
            Vector3 endDirection   = segmentBuffer[(int)segment].m_endDirection;

            if (!NetSegment.IsStraight(position, startDirection, position2, endDirection, out float num))
            {
                float num2 = startDirection.x * endDirection.x + startDirection.z * endDirection.z;
                if (num2 >= -0.999f && Line2.Intersect(VectorUtils.XZ(position), VectorUtils.XZ(position + startDirection), VectorUtils.XZ(position2), VectorUtils.XZ(position2 + endDirection), out float d, out float num3))
                {
                    return(position + startDirection * d);
                }
                KlyteUtils.doErrorLog("Warning! Invalid segment directions!");
            }
            return((position + position2) / 2f);
        }
예제 #11
0
        private Vector3 GetControlPoint(ushort segment)
        {
            Vector3 startPos = nodeBuffer[segmentBuffer[segment].m_startNode].m_position;
            Vector3 startDir = segmentBuffer[segment].m_startDirection;
            Vector3 endPos   = nodeBuffer[segmentBuffer[segment].m_endNode].m_position;
            Vector3 endDir   = segmentBuffer[segment].m_endDirection;

            if (!NetSegment.IsStraight(startPos, startDir, endPos, endDir, out float num))
            {
                float dot = startDir.x * endDir.x + startDir.z * endDir.z;
                if (dot >= -0.999f && Line2.Intersect(VectorUtils.XZ(startPos), VectorUtils.XZ(startPos + startDir), VectorUtils.XZ(endPos), VectorUtils.XZ(endPos + endDir), out float u, out float v))
                {
                    return(startPos + startDir * u);
                }
                else
                {
                    DebugUtils.Warning("Invalid segment directions!");
                }
            }
예제 #12
0
        private void RenderNotConnectLine(RenderManager.CameraInfo cameraInfo)
        {
            var bezier = new Bezier3()
            {
                a = SelectPoint.Position,
                b = SelectPoint.Direction,
                c = SelectPoint.Direction.Turn90(true),
                d = NodeMarkupTool.Ray.GetRayPosition(Markup.Position.y, out _),
            };

            Line2.Intersect(VectorUtils.XZ(bezier.a), VectorUtils.XZ(bezier.a + bezier.b), VectorUtils.XZ(bezier.d), VectorUtils.XZ(bezier.d + bezier.c), out _, out float v);
            bezier.c = v >= 0 ? bezier.c : -bezier.c;

            NetSegment.CalculateMiddlePoints(bezier.a, bezier.b, bezier.d, bezier.c, true, true, out bezier.b, out bezier.c);
            bezier.RenderBezier(new OverlayData(cameraInfo)
            {
                Color = Colors.Hover
            });
        }
예제 #13
0
        internal override bool Cross(Bounding selectBound, Entity entity)
        {
            Polyline polyline = entity as Polyline;

            if (polyline == null)
            {
                return(false);
            }

            Bounding polylineBound = polyline.Bounding;

            if (selectBound.Contains(polylineBound))
            {
                return(true);
            }

            Rectangle2 selRect = new Rectangle2(
                new CADPoint(selectBound.left, selectBound.bottom),
                new CADPoint(selectBound.right, selectBound.top));

            Line2 rectLine1 = new Line2(selRect.leftBottom, selRect.leftTop);
            Line2 rectLine2 = new Line2(selRect.leftTop, selRect.rightTop);
            Line2 rectLine3 = new Line2(selRect.rightTop, selRect.rightBottom);
            Line2 rectLine4 = new Line2(selRect.rightBottom, selRect.leftBottom);

            for (int i = 1; i < polyline.NumberOfVertices; ++i)
            {
                CADPoint spnt         = polyline.GetPointAt(i - 1);
                CADPoint epnt         = polyline.GetPointAt(i);
                Line2    line2        = new Line2(spnt, epnt);
                CADPoint intersection = new CADPoint();
                if (Line2.Intersect(rectLine1, line2, ref intersection) ||
                    Line2.Intersect(rectLine2, line2, ref intersection) ||
                    Line2.Intersect(rectLine3, line2, ref intersection) ||
                    Line2.Intersect(rectLine4, line2, ref intersection))
                {
                    return(true);
                }
            }

            return(false);
        }
예제 #14
0
        internal override bool Cross(Bounding selectBound, Entity entity)
        {
            Line line = entity as Line;

            if (line == null)
            {
                return(false);
            }

            Bounding lineBound = line.Bounding;

            if (selectBound.Contains(lineBound))
            {
                return(true);
            }

            Rectangle2 selRect = new Rectangle2(
                new CADPoint(selectBound.left, selectBound.bottom),
                new CADPoint(selectBound.right, selectBound.top));

            Line2 rectLine1 = new Line2(selRect.leftBottom, selRect.leftTop);
            Line2 rectLine2 = new Line2(selRect.leftTop, selRect.rightTop);
            Line2 rectLine3 = new Line2(selRect.rightTop, selRect.rightBottom);
            Line2 rectLine4 = new Line2(selRect.rightBottom, selRect.leftBottom);
            Line2 line2     = new Line2(line.startPoint, line.endPoint);

            CADPoint intersection = new CADPoint();

            if (Line2.Intersect(rectLine1, line2, ref intersection) ||
                Line2.Intersect(rectLine2, line2, ref intersection) ||
                Line2.Intersect(rectLine3, line2, ref intersection) ||
                Line2.Intersect(rectLine4, line2, ref intersection))
            {
                return(true);
            }
            else
            {
                return(false);
            }
        }
예제 #15
0
        private void RenderConnectLineOverlay(RenderManager.CameraInfo cameraInfo)
        {
            if (!IsSelectPoint)
            {
                return;
            }

            var   bezier = new Bezier3();
            Color color;

            if (IsHoverPoint)
            {
                var pointPair = new MarkupPointPair(SelectPoint, HoverPoint);
                color = EditMarkup.ExistConnection(pointPair) ? Color.red : Color.green;

                bezier.a = SelectPoint.Position;
                bezier.b = HoverPoint.Enter == SelectPoint.Enter ? HoverPoint.Position - SelectPoint.Position : SelectPoint.Direction;
                bezier.c = HoverPoint.Enter == SelectPoint.Enter ? SelectPoint.Position - HoverPoint.Position : HoverPoint.Direction;
                bezier.d = HoverPoint.Position;
            }
            else
            {
                color = Color.white;

                RaycastInput input = new RaycastInput(MouseRay, MouseRayLength);
                RayCast(input, out RaycastOutput output);

                bezier.a = SelectPoint.Position;
                bezier.b = SelectPoint.Direction;
                bezier.c = SelectPoint.Direction.Turn90(true);
                bezier.d = output.m_hitPos;

                Line2.Intersect(VectorUtils.XZ(bezier.a), VectorUtils.XZ(bezier.a + bezier.b), VectorUtils.XZ(bezier.d), VectorUtils.XZ(bezier.d + bezier.c), out _, out float v);
                bezier.c = v >= 0 ? bezier.c : -bezier.c;
            }

            NetSegment.CalculateMiddlePoints(bezier.a, bezier.b, bezier.d, bezier.c, true, true, out bezier.b, out bezier.c);
            RenderManager.OverlayEffect.DrawBezier(cameraInfo, color, bezier, 0.5f, 0f, 0f, -1f, 1280f, false, true);
        }
예제 #16
0
        private void GetCircle3Points(Vector3[] points, int i, int j, int k, ref Vector3 centre, ref float radius)
        {
            var pos1 = (points[i] + points[j]) / 2;
            var pos2 = (points[j] + points[k]) / 2;

            var dir1 = (points[i] - points[j]).Turn90(true).normalized;
            var dir2 = (points[j] - points[k]).Turn90(true).normalized;

            Line2.Intersect(pos1.XZ(), (pos1 + dir1).XZ(), pos2.XZ(), (pos2 + dir2).XZ(), out float p, out _);
            var newCentre = pos1 + dir1 * p;
            var newRadius = (newCentre - points[i]).magnitude;

            if (newRadius >= radius)
            {
                return;
            }

            if (AllPointsInCircle(points, newCentre, newRadius, i, j, k))
            {
                centre = newCentre;
                radius = newRadius;
            }
        }
        private static void CreateZoneBlocksVanilla_Curve(NetInfo info, Randomizer randomizer, ref NetSegment segment)
        {
            var minHalfWidth = MIN_HALFWIDTH_DEFAULT;

            NetManager instance       = Singleton <NetManager> .instance;
            Vector3    startPosition  = instance.m_nodes.m_buffer[(int)segment.m_startNode].m_position;
            Vector3    endPosition    = instance.m_nodes.m_buffer[(int)segment.m_endNode].m_position;
            Vector3    startDirection = segment.m_startDirection;
            Vector3    endDirection   = segment.m_endDirection;
            float      num            = startDirection.x * endDirection.x + startDirection.z * endDirection.z;
            float      num2           = Mathf.Max(minHalfWidth, info.m_halfWidth);
            float      num3           = 32f;

            float num4  = VectorUtils.LengthXZ(endPosition - startPosition);
            bool  flag2 = startDirection.x * endDirection.z - startDirection.z * endDirection.x > 0f;
            bool  flag3 = num <-0.8f || num4> 50f;

            if (flag2)
            {
                num2 = -num2;
                num3 = -num3;
            }
            Vector3 vector  = startPosition - new Vector3(startDirection.z, 0f, -startDirection.x) * num2;
            Vector3 vector2 = endPosition + new Vector3(endDirection.z, 0f, -endDirection.x) * num2;
            Vector3 vector3;
            Vector3 vector4;

            NetSegment.CalculateMiddlePoints(vector, startDirection, vector2, endDirection, true, true, out vector3, out vector4);
            if (flag3)
            {
                float num5 = num * 0.025f + 0.04f;
                float num6 = num * 0.025f + 0.06f;
                if (num < -0.9f)
                {
                    num6 = num5;
                }
                Bezier3 bezier = new Bezier3(vector, vector3, vector4, vector2);
                vector  = bezier.Position(num5);
                vector3 = bezier.Position(0.5f - num6);
                vector4 = bezier.Position(0.5f + num6);
                vector2 = bezier.Position(1f - num5);
            }
            else
            {
                Bezier3 bezier2 = new Bezier3(vector, vector3, vector4, vector2);
                vector3 = bezier2.Position(0.86f);
                vector  = bezier2.Position(0.14f);
            }
            float   num7;
            Vector3 vector5 = VectorUtils.NormalizeXZ(vector3 - vector, out num7);
            int     num8    = Mathf.FloorToInt(num7 / 8f + 0.01f);
            float   num9    = num7 * 0.5f + (float)(num8 - 8) * ((!flag2) ? -4f : 4f);

            if (num8 != 0)
            {
                float   angle     = (!flag2) ? Mathf.Atan2(vector5.x, -vector5.z) : Mathf.Atan2(-vector5.x, vector5.z);
                Vector3 position3 = vector + new Vector3(vector5.x * num9 - vector5.z * num3, 0f, vector5.z * num9 + vector5.x * num3);
                if (flag2)
                {
                    Singleton <ZoneManager> .instance.CreateBlock(
                        out segment.m_blockStartRight,
                        ref randomizer,
                        position3,
                        angle,
                        num8,
                        segment.m_buildIndex);
                }
                else
                {
                    Singleton <ZoneManager> .instance.CreateBlock(
                        out segment.m_blockStartLeft,
                        ref randomizer,
                        position3,
                        angle,
                        num8,
                        segment.m_buildIndex);
                }
            }
            if (flag3)
            {
                vector5 = VectorUtils.NormalizeXZ(vector2 - vector4, out num7);
                num8    = Mathf.FloorToInt(num7 / 8f + 0.01f);
                num9    = num7 * 0.5f + (float)(num8 - 8) * ((!flag2) ? -4f : 4f);
                if (num8 != 0)
                {
                    float   angle2    = (!flag2) ? Mathf.Atan2(vector5.x, -vector5.z) : Mathf.Atan2(-vector5.x, vector5.z);
                    Vector3 position4 = vector4 + new Vector3(vector5.x * num9 - vector5.z * num3, 0f, vector5.z * num9 + vector5.x * num3);
                    if (flag2)
                    {
                        Singleton <ZoneManager> .instance.CreateBlock(
                            out segment.m_blockEndRight,
                            ref randomizer,
                            position4,
                            angle2,
                            num8,
                            segment.m_buildIndex + 1u);
                    }
                    else
                    {
                        Singleton <ZoneManager> .instance.CreateBlock(
                            out segment.m_blockEndLeft,
                            ref randomizer,
                            position4,
                            angle2,
                            num8,
                            segment.m_buildIndex + 1u);
                    }
                }
            }
            Vector3 vector6 = startPosition + new Vector3(startDirection.z, 0f, -startDirection.x) * num2;
            Vector3 vector7 = endPosition - new Vector3(endDirection.z, 0f, -endDirection.x) * num2;
            Vector3 b;
            Vector3 c;

            NetSegment.CalculateMiddlePoints(vector6, startDirection, vector7, endDirection, true, true, out b, out c);
            Bezier3 bezier3 = new Bezier3(vector6, b, c, vector7);
            Vector3 vector8 = bezier3.Position(0.5f);
            Vector3 vector9 = bezier3.Position(0.25f);

            vector9 = Line2.Offset(VectorUtils.XZ(vector6), VectorUtils.XZ(vector8), VectorUtils.XZ(vector9));
            Vector3 vector10 = bezier3.Position(0.75f);

            vector10 = Line2.Offset(VectorUtils.XZ(vector7), VectorUtils.XZ(vector8), VectorUtils.XZ(vector10));
            Vector3 vector11 = vector6;
            Vector3 a        = vector7;
            float   d;
            float   num10;

            if (Line2.Intersect(VectorUtils.XZ(startPosition), VectorUtils.XZ(vector6), VectorUtils.XZ(vector11 - vector9), VectorUtils.XZ(vector8 - vector9), out d, out num10))
            {
                vector6 = startPosition + (vector6 - startPosition) * d;
            }
            if (Line2.Intersect(VectorUtils.XZ(endPosition), VectorUtils.XZ(vector7), VectorUtils.XZ(a - vector10), VectorUtils.XZ(vector8 - vector10), out d, out num10))
            {
                vector7 = endPosition + (vector7 - endPosition) * d;
            }
            if (Line2.Intersect(VectorUtils.XZ(vector11 - vector9), VectorUtils.XZ(vector8 - vector9), VectorUtils.XZ(a - vector10), VectorUtils.XZ(vector8 - vector10), out d, out num10))
            {
                vector8 = vector11 - vector9 + (vector8 - vector11) * d;
            }
            float   num11;
            Vector3 vector12 = VectorUtils.NormalizeXZ(vector8 - vector6, out num11);
            int     num12    = Mathf.FloorToInt(num11 / 8f + 0.01f);
            float   num13    = num11 * 0.5f + (float)(num12 - 8) * ((!flag2) ? 4f : -4f);

            if (num12 != 0)
            {
                float   angle3    = (!flag2) ? Mathf.Atan2(-vector12.x, vector12.z) : Mathf.Atan2(vector12.x, -vector12.z);
                Vector3 position5 = vector6 + new Vector3(vector12.x * num13 + vector12.z * num3, 0f, vector12.z * num13 - vector12.x * num3);
                if (flag2)
                {
                    Singleton <ZoneManager> .instance.CreateBlock(
                        out segment.m_blockStartLeft,
                        ref randomizer,
                        position5,
                        angle3,
                        num12,
                        segment.m_buildIndex);
                }
                else
                {
                    Singleton <ZoneManager> .instance.CreateBlock(
                        out segment.m_blockStartRight,
                        ref randomizer,
                        position5,
                        angle3,
                        num12,
                        segment.m_buildIndex);
                }
            }
            vector12 = VectorUtils.NormalizeXZ(vector7 - vector8, out num11);
            num12    = Mathf.FloorToInt(num11 / 8f + 0.01f);
            num13    = num11 * 0.5f + (float)(num12 - 8) * ((!flag2) ? 4f : -4f);
            if (num12 != 0)
            {
                float   angle4    = (!flag2) ? Mathf.Atan2(-vector12.x, vector12.z) : Mathf.Atan2(vector12.x, -vector12.z);
                Vector3 position6 = vector8 + new Vector3(vector12.x * num13 + vector12.z * num3, 0f, vector12.z * num13 - vector12.x * num3);
                if (flag2)
                {
                    Singleton <ZoneManager> .instance.CreateBlock(
                        out segment.m_blockEndLeft,
                        ref randomizer,
                        position6,
                        angle4,
                        num12,
                        segment.m_buildIndex + 1u);
                }
                else
                {
                    Singleton <ZoneManager> .instance.CreateBlock(
                        out segment.m_blockEndRight,
                        ref randomizer,
                        position6,
                        angle4,
                        num12,
                        segment.m_buildIndex + 1u);
                }
            }
        }
예제 #18
0
        /// <summary>
        /// Generic n-gon slicer. If the nodes in V do not represent a valid, convex NGon
        /// then the result will not be reliable.
        /// </summary>
        /// <param name="V">Corners of NGon</param>
        /// <param name="line">The line to slice with</param>
        /// <param name="side">Side of NGon to keep (with respect to line)</param>
        /// <returns>Result. List may share Node instances with V</returns>
        public static List <Node2> SliceConvexNGon(
            List <Node2> V,
            Line2 line,
            Side2 side,
            ref bool changed)
        {
            changed = false;
            List <Node2> node2List1;

            if (V.Count < 2)
            {
                node2List1 = V;
            }
            else
            {
                List <Node2> node2List2 = new List <Node2>(V.Count + 2);
                int          num1       = 0;
                Side2        side2      = Side2.Coincident;
                int          num2       = V.Count - 1;
                for (int index1 = 0; index1 <= num2; ++index1)
                {
                    if (side2 == Side2.Coincident)
                    {
                        side2 = Line2.Side(line, V[index1]);
                        if (side2 != side)
                        {
                            changed = true;
                        }
                    }
                    int index2 = index1 + 1;
                    if (index2 == V.Count)
                    {
                        index2 = 0;
                    }
                    Line2  A = new Line2(V[index1], V[index2]);
                    double t = 0.0;
                    switch (Line2.Intersect(A, line, ref t))
                    {
                    case LineX.None:
                        if (side2 == side)
                        {
                            node2List2.Add(V[index1]);
                            break;
                        }
                        break;

                    case LineX.Parallel:
                        if (side2 == side)
                        {
                            node2List2.Add(V[index1]);
                            break;
                        }
                        break;

                    case LineX.Coincident:
                        changed    = false;
                        node2List1 = V;
                        goto label_28;

                    case LineX.Point:
                        Node2 node2 = A.PointAt(t);
                        if (node2.IsCoincident(V[index1]))
                        {
                            node2List2.Add(V[index1]);
                            side2 = Side2.Coincident;
                            ++num1;
                            changed = true;
                            break;
                        }
                        if (node2.IsCoincident(V[index2]))
                        {
                            if (side2 == side)
                            {
                                node2List2.Add(V[index1]);
                                break;
                            }
                            break;
                        }
                        if (t < 0.0 || t > 1.0)
                        {
                            if (side2 == side)
                            {
                                node2List2.Add(V[index1]);
                                break;
                            }
                            break;
                        }
                        if (side2 == side)
                        {
                            node2List2.Add(V[index1]);
                        }
                        node2List2.Add(node2);
                        side2 = Side2.Coincident;
                        ++num1;
                        changed = true;
                        break;
                    }
                }
                node2List1 = node2List2;
            }
label_28:
            return(node2List1);
        }
예제 #19
0
        private Vector3 SnapSegmentDirections(ushort segment, Vector3 newPosition, Vector3 moveDelta)
        {
            NetManager netManager = NetManager.instance;

            NetSegment[] segmentBuffer = netManager.m_segments.m_buffer;
            NetNode[]    nodeBuffer    = netManager.m_nodes.m_buffer;

            float minSqDistance = segmentBuffer[segment].Info.GetMinNodeDistance() / 2f;

            minSqDistance *= minSqDistance;

            ushort startNode = segmentBuffer[segment].m_startNode;
            ushort endNode   = segmentBuffer[segment].m_endNode;

            Vector3 startPos = nodeBuffer[segmentBuffer[segment].m_startNode].m_position;
            Vector3 endPos   = nodeBuffer[segmentBuffer[segment].m_endNode].m_position;

            Vector3 newMoveDelta = moveDelta;
            float   distanceSq   = minSqDistance;
            bool    snap         = false;

            // Snap to tangent intersection
            for (int i = 0; i < 8; i++)
            {
                ushort segmentA = nodeBuffer[startNode].GetSegment(i);
                if (segmentA != 0 && segmentA != segment)
                {
                    for (int j = 0; j < 8; j++)
                    {
                        ushort segmentB = nodeBuffer[endNode].GetSegment(j);

                        if (segmentB != 0 && segmentB != segment)
                        {
                            Vector3 startDir = segmentBuffer[segmentA].m_startNode == startNode ? segmentBuffer[segmentA].m_startDirection : segmentBuffer[segmentA].m_endDirection;
                            Vector3 endDir   = segmentBuffer[segmentB].m_startNode == endNode ? segmentBuffer[segmentB].m_startDirection : segmentBuffer[segmentB].m_endDirection;

                            if (!NetSegment.IsStraight(startPos, startDir, endPos, endDir, out float num))
                            {
                                float dot = startDir.x * endDir.x + startDir.z * endDir.z;
                                if (dot >= -0.999f && Line2.Intersect(VectorUtils.XZ(startPos), VectorUtils.XZ(startPos + startDir), VectorUtils.XZ(endPos), VectorUtils.XZ(endPos + endDir), out float u, out float v))
                                {
                                    snap = TrySnapping(startPos + startDir * u, newPosition, minSqDistance, ref distanceSq, moveDelta, ref newMoveDelta) || snap;
                                }
                            }
                        }
                    }
                }
            }

            if (!snap)
            {
                // Snap to start tangent
                for (int i = 0; i < 8; i++)
                {
                    ushort segmentA = nodeBuffer[startNode].GetSegment(i);
                    if (segmentA != 0 && segmentA != segment)
                    {
                        Vector3 startDir = segmentBuffer[segmentA].m_startNode == startNode ? segmentBuffer[segmentA].m_startDirection : segmentBuffer[segmentA].m_endDirection;
                        Vector3 offset   = Line2.Offset(startDir, startPos - newPosition);
                        offset = newPosition + offset - startPos;
                        float num = offset.x * startDir.x + offset.z * startDir.z;

                        TrySnapping(startPos + startDir * num, newPosition, minSqDistance, ref distanceSq, moveDelta, ref newMoveDelta);
                    }
                }

                // Snap to end tangent
                for (int i = 0; i < 8; i++)
                {
                    ushort segmentB = nodeBuffer[endNode].GetSegment(i);

                    if (segmentB != 0 && segmentB != segment)
                    {
                        Vector3 endDir = segmentBuffer[segmentB].m_startNode == endNode ? segmentBuffer[segmentB].m_startDirection : segmentBuffer[segmentB].m_endDirection;
                        Vector3 offset = Line2.Offset(endDir, endPos - newPosition);
                        offset = newPosition + offset - endPos;
                        float num = offset.x * endDir.x + offset.z * endDir.z;

                        TrySnapping(endPos + endDir * num, newPosition, minSqDistance, ref distanceSq, moveDelta, ref newMoveDelta);
                    }
                }
            }

            // Snap straight
            TrySnapping((startPos + endPos) / 2f, newPosition, minSqDistance, ref distanceSq, moveDelta, ref newMoveDelta);

            return(newMoveDelta);
        }
예제 #20
0
        /// <summary>
        /// Create curved zone blocks.
        /// </summary>
        /// <param name="info">Network prefab</param>
        /// <param name="randomizer">Randomizer</param>
        /// <param name="segment">Network segment</param>
        private static void CurvedZoneBlocks(NetInfo info, Randomizer randomizer, ref NetSegment segment)
        {
#pragma warning disable IDE0018 // Inline variable declaration

            // TODO: Basically game code with some NExT2 modifications.  Could do with a good refactor, and possible replacement with Transpiler.

            var minHalfWidth = MIN_HALFWIDTH_TINY_CURVE;

            NetManager instance       = Singleton <NetManager> .instance;
            Vector3    startPosition  = instance.m_nodes.m_buffer[(int)segment.m_startNode].m_position;
            Vector3    endPosition    = instance.m_nodes.m_buffer[(int)segment.m_endNode].m_position;
            Vector3    startDirection = segment.m_startDirection;
            Vector3    endDirection   = segment.m_endDirection;


            float num      = startDirection.x * endDirection.x + startDirection.z * endDirection.z;
            float num2     = Mathf.Max(minHalfWidth, info.m_halfWidth); // minHalfWidth here.
            float num3     = 32f;
            int   distance = Mathf.RoundToInt(num2);

            float num4  = VectorUtils.LengthXZ(endPosition - startPosition);
            bool  flag2 = startDirection.x * endDirection.z - startDirection.z * endDirection.x > 0f;
            bool  flag3 = num <-0.8f || num4> 50f;
            if (flag2)
            {
                num2 = -num2;
                num3 = -num3;
            }
            Vector3 vector  = startPosition - new Vector3(startDirection.z, 0f, -startDirection.x) * num2;
            Vector3 vector2 = endPosition + new Vector3(endDirection.z, 0f, -endDirection.x) * num2;
            Vector3 vector3;
            Vector3 vector4;
            NetSegment.CalculateMiddlePoints(vector, startDirection, vector2, endDirection, true, true, out vector3, out vector4);
            if (flag3)
            {
                float num5 = num * 0.025f + 0.04f;
                float num6 = num * 0.025f + 0.06f;
                if (num < -0.9f)
                {
                    num6 = num5;
                }
                Bezier3 bezier = new Bezier3(vector, vector3, vector4, vector2);
                vector  = bezier.Position(num5);
                vector3 = bezier.Position(0.5f - num6);
                vector4 = bezier.Position(0.5f + num6);
                vector2 = bezier.Position(1f - num5);
            }
            else
            {
                Bezier3 bezier2 = new Bezier3(vector, vector3, vector4, vector2);
                vector3 = bezier2.Position(0.86f);
                vector  = bezier2.Position(0.14f);
            }
            float   num7;
            Vector3 vector5 = VectorUtils.NormalizeXZ(vector3 - vector, out num7);
            int     num8    = Mathf.FloorToInt(num7 / 8f + 0.01f);
            float   num9    = num7 * 0.5f + (float)(num8 - 8) * ((!flag2) ? -4f : 4f);
            if (num8 != 0)
            {
                float   angle     = (!flag2) ? Mathf.Atan2(vector5.x, -vector5.z) : Mathf.Atan2(-vector5.x, vector5.z);
                Vector3 position3 = vector + new Vector3(vector5.x * num9 - vector5.z * num3, 0f, vector5.z * num9 + vector5.x * num3);
                if (flag2)
                {
                    Singleton <ZoneManager> .instance.CreateBlock(
                        out segment.m_blockStartRight,
                        ref randomizer,
                        position3,
                        angle,
                        num8,
                        distance,
                        segment.m_buildIndex);
                }
                else
                {
                    Singleton <ZoneManager> .instance.CreateBlock(
                        out segment.m_blockStartLeft,
                        ref randomizer,
                        position3,
                        angle,
                        num8,
                        distance,
                        segment.m_buildIndex);
                }
            }
            if (flag3)
            {
                vector5 = VectorUtils.NormalizeXZ(vector2 - vector4, out num7);
                num8    = Mathf.FloorToInt(num7 / 8f + 0.01f);
                num9    = num7 * 0.5f + (float)(num8 - 8) * ((!flag2) ? -4f : 4f);
                if (num8 != 0)
                {
                    float   angle2    = (!flag2) ? Mathf.Atan2(vector5.x, -vector5.z) : Mathf.Atan2(-vector5.x, vector5.z);
                    Vector3 position4 = vector4 + new Vector3(vector5.x * num9 - vector5.z * num3, 0f, vector5.z * num9 + vector5.x * num3);
                    if (flag2)
                    {
                        Singleton <ZoneManager> .instance.CreateBlock(
                            out segment.m_blockEndRight,
                            ref randomizer,
                            position4,
                            angle2,
                            num8,
                            distance,
                            segment.m_buildIndex + 1u);
                    }
                    else
                    {
                        Singleton <ZoneManager> .instance.CreateBlock(
                            out segment.m_blockEndLeft,
                            ref randomizer,
                            position4,
                            angle2,
                            num8,
                            distance,
                            segment.m_buildIndex + 1u);
                    }
                }
            }
            Vector3 vector6 = startPosition + new Vector3(startDirection.z, 0f, -startDirection.x) * num2;
            Vector3 vector7 = endPosition - new Vector3(endDirection.z, 0f, -endDirection.x) * num2;
            Vector3 b;
            Vector3 c;
            NetSegment.CalculateMiddlePoints(vector6, startDirection, vector7, endDirection, true, true, out b, out c);
            Bezier3 bezier3 = new Bezier3(vector6, b, c, vector7);
            Vector3 vector8 = bezier3.Position(0.5f);
            Vector3 vector9 = bezier3.Position(0.25f);
            vector9 = Line2.Offset(VectorUtils.XZ(vector6), VectorUtils.XZ(vector8), VectorUtils.XZ(vector9));
            Vector3 vector10 = bezier3.Position(0.75f);
            vector10 = Line2.Offset(VectorUtils.XZ(vector7), VectorUtils.XZ(vector8), VectorUtils.XZ(vector10));
            Vector3 vector11 = vector6;
            Vector3 a        = vector7;
            float   d;
#pragma warning disable IDE0059 // Unnecessary assignment of a value
            float num10;
            if (Line2.Intersect(VectorUtils.XZ(startPosition), VectorUtils.XZ(vector6), VectorUtils.XZ(vector11 - vector9), VectorUtils.XZ(vector8 - vector9), out d, out num10))
            {
                vector6 = startPosition + (vector6 - startPosition) * d;
            }
            if (Line2.Intersect(VectorUtils.XZ(endPosition), VectorUtils.XZ(vector7), VectorUtils.XZ(a - vector10), VectorUtils.XZ(vector8 - vector10), out d, out num10))
            {
                vector7 = endPosition + (vector7 - endPosition) * d;
            }
            if (Line2.Intersect(VectorUtils.XZ(vector11 - vector9), VectorUtils.XZ(vector8 - vector9), VectorUtils.XZ(a - vector10), VectorUtils.XZ(vector8 - vector10), out d, out num10))
#pragma warning restore IDE0059 // Unnecessary assignment of a value
            {
                vector8 = vector11 - vector9 + (vector8 - vector11) * d;
            }
            float   num11;
            Vector3 vector12 = VectorUtils.NormalizeXZ(vector8 - vector6, out num11);
            int     num12    = Mathf.FloorToInt(num11 / 8f + 0.01f);
            float   num13    = num11 * 0.5f + (float)(num12 - 8) * ((!flag2) ? 4f : -4f);
            if (num12 != 0)
            {
                float   angle3    = (!flag2) ? Mathf.Atan2(-vector12.x, vector12.z) : Mathf.Atan2(vector12.x, -vector12.z);
                Vector3 position5 = vector6 + new Vector3(vector12.x * num13 + vector12.z * num3, 0f, vector12.z * num13 - vector12.x * num3);
                if (flag2)
                {
                    Singleton <ZoneManager> .instance.CreateBlock(
                        out segment.m_blockStartLeft,
                        ref randomizer,
                        position5,
                        angle3,
                        num12,
                        distance,
                        segment.m_buildIndex);
                }
                else
                {
                    Singleton <ZoneManager> .instance.CreateBlock(
                        out segment.m_blockStartRight,
                        ref randomizer,
                        position5,
                        angle3,
                        num12,
                        distance,
                        segment.m_buildIndex);
                }
            }
            vector12 = VectorUtils.NormalizeXZ(vector7 - vector8, out num11);
            num12    = Mathf.FloorToInt(num11 / 8f + 0.01f);
            num13    = num11 * 0.5f + (float)(num12 - 8) * ((!flag2) ? 4f : -4f);
            if (num12 != 0)
            {
                float   angle4    = (!flag2) ? Mathf.Atan2(-vector12.x, vector12.z) : Mathf.Atan2(vector12.x, -vector12.z);
                Vector3 position6 = vector8 + new Vector3(vector12.x * num13 + vector12.z * num3, 0f, vector12.z * num13 - vector12.x * num3);
                if (flag2)
                {
                    Singleton <ZoneManager> .instance.CreateBlock(
                        out segment.m_blockEndLeft,
                        ref randomizer,
                        position6,
                        angle4,
                        num12,
                        distance,
                        segment.m_buildIndex + 1u);
                }
                else
                {
                    Singleton <ZoneManager> .instance.CreateBlock(
                        out segment.m_blockEndRight,
                        ref randomizer,
                        position6,
                        angle4,
                        num12,
                        distance,
                        segment.m_buildIndex + 1u);
                }
            }
#pragma warning restore IDE0018 // Inline variable declaration
        }
예제 #21
0
        private void CreateZoneBlocks(ushort segment, ref NetSegment data)
        {
            NetManager instance       = Singleton <NetManager> .instance;
            Randomizer randomizer     = new Randomizer((int)segment);
            Vector3    position       = instance.m_nodes.m_buffer[(int)data.m_startNode].m_position;
            Vector3    position2      = instance.m_nodes.m_buffer[(int)data.m_endNode].m_position;
            Vector3    startDirection = data.m_startDirection;
            Vector3    endDirection   = data.m_endDirection;
            float      num            = startDirection.x * endDirection.x + startDirection.z * endDirection.z;
            bool       flag           = !NetSegment.IsStraight(position, startDirection, position2, endDirection);
            float      num2           = Mathf.Max(8f, this.m_info.m_halfWidth);
            float      num3           = 32f;

            if (flag)
            {
                float num4  = VectorUtils.LengthXZ(position2 - position);
                bool  flag2 = startDirection.x * endDirection.z - startDirection.z * endDirection.x > 0f;
                bool  flag3 = num <-0.8f || num4> 50f;
                if (flag2)
                {
                    num2 = -num2;
                    num3 = -num3;
                }
                Vector3 vector  = position - new Vector3(startDirection.z, 0f, -startDirection.x) * num2;
                Vector3 vector2 = position2 + new Vector3(endDirection.z, 0f, -endDirection.x) * num2;
                Vector3 vector3;
                Vector3 vector4;
                NetSegment.CalculateMiddlePoints(vector, startDirection, vector2, endDirection, true, true, out vector3, out vector4);
                if (flag3)
                {
                    float num5 = num * 0.025f + 0.04f;
                    float num6 = num * 0.025f + 0.06f;
                    if (num < -0.9f)
                    {
                        num6 = num5;
                    }
                    Bezier3 bezier = new Bezier3(vector, vector3, vector4, vector2);
                    vector  = bezier.Position(num5);
                    vector3 = bezier.Position(0.5f - num6);
                    vector4 = bezier.Position(0.5f + num6);
                    vector2 = bezier.Position(1f - num5);
                }
                else
                {
                    Bezier3 bezier2 = new Bezier3(vector, vector3, vector4, vector2);
                    vector3 = bezier2.Position(0.86f);
                    vector  = bezier2.Position(0.14f);
                }
                float   num7;
                Vector3 vector5 = VectorUtils.NormalizeXZ(vector3 - vector, out num7);
                int     num8    = Mathf.FloorToInt(num7 / 8f + 0.01f);
                float   num9    = num7 * 0.5f + (float)(num8 - 8) * ((!flag2) ? -4f : 4f);
                if (num8 != 0)
                {
                    float   angle     = (!flag2) ? Mathf.Atan2(vector5.x, -vector5.z) : Mathf.Atan2(-vector5.x, vector5.z);
                    Vector3 position3 = vector + new Vector3(vector5.x * num9 - vector5.z * num3, 0f, vector5.z * num9 + vector5.x * num3);
                    if (flag2)
                    {
                        Singleton <ZoneManager> .instance.CreateBlock(out data.m_blockStartRight, ref randomizer, position3, angle, num8, data.m_buildIndex);
                    }
                    else
                    {
                        Singleton <ZoneManager> .instance.CreateBlock(out data.m_blockStartLeft, ref randomizer, position3, angle, num8, data.m_buildIndex);
                    }
                }
                if (flag3)
                {
                    vector5 = VectorUtils.NormalizeXZ(vector2 - vector4, out num7);
                    num8    = Mathf.FloorToInt(num7 / 8f + 0.01f);
                    num9    = num7 * 0.5f + (float)(num8 - 8) * ((!flag2) ? -4f : 4f);
                    if (num8 != 0)
                    {
                        float   angle2    = (!flag2) ? Mathf.Atan2(vector5.x, -vector5.z) : Mathf.Atan2(-vector5.x, vector5.z);
                        Vector3 position4 = vector4 + new Vector3(vector5.x * num9 - vector5.z * num3, 0f, vector5.z * num9 + vector5.x * num3);
                        if (flag2)
                        {
                            Singleton <ZoneManager> .instance.CreateBlock(out data.m_blockEndRight, ref randomizer, position4, angle2, num8, data.m_buildIndex + 1u);
                        }
                        else
                        {
                            Singleton <ZoneManager> .instance.CreateBlock(out data.m_blockEndLeft, ref randomizer, position4, angle2, num8, data.m_buildIndex + 1u);
                        }
                    }
                }
                Vector3 vector6 = position + new Vector3(startDirection.z, 0f, -startDirection.x) * num2;
                Vector3 vector7 = position2 - new Vector3(endDirection.z, 0f, -endDirection.x) * num2;
                Vector3 b;
                Vector3 c;
                NetSegment.CalculateMiddlePoints(vector6, startDirection, vector7, endDirection, true, true, out b, out c);
                Bezier3 bezier3 = new Bezier3(vector6, b, c, vector7);
                Vector3 vector8 = bezier3.Position(0.5f);
                Vector3 vector9 = bezier3.Position(0.25f);
                vector9 = Line2.Offset(VectorUtils.XZ(vector6), VectorUtils.XZ(vector8), VectorUtils.XZ(vector9));
                Vector3 vector10 = bezier3.Position(0.75f);
                vector10 = Line2.Offset(VectorUtils.XZ(vector7), VectorUtils.XZ(vector8), VectorUtils.XZ(vector10));
                Vector3 vector11 = vector6;
                Vector3 a        = vector7;
                float   d;
                float   num10;
                if (Line2.Intersect(VectorUtils.XZ(position), VectorUtils.XZ(vector6), VectorUtils.XZ(vector11 - vector9), VectorUtils.XZ(vector8 - vector9), out d, out num10))
                {
                    vector6 = position + (vector6 - position) * d;
                }
                if (Line2.Intersect(VectorUtils.XZ(position2), VectorUtils.XZ(vector7), VectorUtils.XZ(a - vector10), VectorUtils.XZ(vector8 - vector10), out d, out num10))
                {
                    vector7 = position2 + (vector7 - position2) * d;
                }
                if (Line2.Intersect(VectorUtils.XZ(vector11 - vector9), VectorUtils.XZ(vector8 - vector9), VectorUtils.XZ(a - vector10), VectorUtils.XZ(vector8 - vector10), out d, out num10))
                {
                    vector8 = vector11 - vector9 + (vector8 - vector11) * d;
                }
                float   num11;
                Vector3 vector12 = VectorUtils.NormalizeXZ(vector8 - vector6, out num11);
                int     num12    = Mathf.FloorToInt(num11 / 8f + 0.01f);
                float   num13    = num11 * 0.5f + (float)(num12 - 8) * ((!flag2) ? 4f : -4f);
                if (num12 != 0)
                {
                    float   angle3    = (!flag2) ? Mathf.Atan2(-vector12.x, vector12.z) : Mathf.Atan2(vector12.x, -vector12.z);
                    Vector3 position5 = vector6 + new Vector3(vector12.x * num13 + vector12.z * num3, 0f, vector12.z * num13 - vector12.x * num3);
                    if (flag2)
                    {
                        Singleton <ZoneManager> .instance.CreateBlock(out data.m_blockStartLeft, ref randomizer, position5, angle3, num12, data.m_buildIndex);
                    }
                    else
                    {
                        Singleton <ZoneManager> .instance.CreateBlock(out data.m_blockStartRight, ref randomizer, position5, angle3, num12, data.m_buildIndex);
                    }
                }
                vector12 = VectorUtils.NormalizeXZ(vector7 - vector8, out num11);
                num12    = Mathf.FloorToInt(num11 / 8f + 0.01f);
                num13    = num11 * 0.5f + (float)(num12 - 8) * ((!flag2) ? 4f : -4f);
                if (num12 != 0)
                {
                    float   angle4    = (!flag2) ? Mathf.Atan2(-vector12.x, vector12.z) : Mathf.Atan2(vector12.x, -vector12.z);
                    Vector3 position6 = vector8 + new Vector3(vector12.x * num13 + vector12.z * num3, 0f, vector12.z * num13 - vector12.x * num3);
                    if (flag2)
                    {
                        Singleton <ZoneManager> .instance.CreateBlock(out data.m_blockEndLeft, ref randomizer, position6, angle4, num12, data.m_buildIndex + 1u);
                    }
                    else
                    {
                        Singleton <ZoneManager> .instance.CreateBlock(out data.m_blockEndRight, ref randomizer, position6, angle4, num12, data.m_buildIndex + 1u);
                    }
                }
            }
            else
            {
                num2 += num3;
                Vector2 vector13  = new Vector2(position2.x - position.x, position2.z - position.z);
                float   magnitude = vector13.magnitude;
                int     num14     = Mathf.FloorToInt(magnitude / 8f + 0.1f);
                int     num15     = (num14 <= 8) ? num14 : (num14 + 1 >> 1);
                int     num16     = (num14 <= 8) ? 0 : (num14 >> 1);
                if (num15 > 0)
                {
                    float   num17     = Mathf.Atan2(startDirection.x, -startDirection.z);
                    Vector3 position7 = position + new Vector3(startDirection.x * 32f - startDirection.z * num2, 0f, startDirection.z * 32f + startDirection.x * num2);
                    Singleton <ZoneManager> .instance.CreateBlock(out data.m_blockStartLeft, ref randomizer, position7, num17, num15, data.m_buildIndex);

                    position7 = position + new Vector3(startDirection.x * (float)(num15 - 4) * 8f + startDirection.z * num2, 0f, startDirection.z * (float)(num15 - 4) * 8f - startDirection.x * num2);
                    Singleton <ZoneManager> .instance.CreateBlock(out data.m_blockStartRight, ref randomizer, position7, num17 + 3.14159274f, num15, data.m_buildIndex);
                }
                if (num16 > 0)
                {
                    float   num18     = magnitude - (float)num14 * 8f;
                    float   num19     = Mathf.Atan2(endDirection.x, -endDirection.z);
                    Vector3 position8 = position2 + new Vector3(endDirection.x * (32f + num18) - endDirection.z * num2, 0f, endDirection.z * (32f + num18) + endDirection.x * num2);
                    Singleton <ZoneManager> .instance.CreateBlock(out data.m_blockEndLeft, ref randomizer, position8, num19, num16, data.m_buildIndex + 1u);

                    position8 = position2 + new Vector3(endDirection.x * ((float)(num16 - 4) * 8f + num18) + endDirection.z * num2, 0f, endDirection.z * ((float)(num16 - 4) * 8f + num18) - endDirection.x * num2);
                    Singleton <ZoneManager> .instance.CreateBlock(out data.m_blockEndRight, ref randomizer, position8, num19 + 3.14159274f, num16, data.m_buildIndex + 1u);
                }
            }
        }
예제 #22
0
        /* Detoured method. We save a list of all the segment ids (and ids of their lanes and nodes as well) to m_pendingSegments
         * We will use it a few moments later when the OnAssetSaved method is called
         * See line 408 */
        public static void SavePaths(BuildingInfo info, ushort buildingID, ref Building data)
        {
            Debug.Log("SavePaths TMPE detour"); //

            List <IdentificationTool.AssetSegment> SavedSegments = new List <IdentificationTool.AssetSegment>();
            // ns end

            FastList <BuildingInfo.PathInfo> fastList = new FastList <BuildingInfo.PathInfo>();
            List <ushort> list  = new List <ushort>();
            List <ushort> list2 = new List <ushort>();

            for (ushort num = 1; num < 49152; num += 1)
            {
                if (Singleton <BuildingManager> .instance.m_buildings.m_buffer[(int)num].m_flags != Building.Flags.None)
                {
                    list.AddRange(BuildingDecoration.GetBuildingSegments(ref Singleton <BuildingManager> .instance.m_buildings.m_buffer[(int)num]));
                    list2.Add(num);
                }
            }
            NetManager instance = Singleton <NetManager> .instance;

            for (int i = 0; i < 36864; i++)
            {
                if ((instance.m_segments.m_buffer[i].m_flags & (NetSegment.Flags.Created | NetSegment.Flags.Deleted)) == NetSegment.Flags.Created)
                {
                    if (!list.Contains((ushort)i))
                    {
                        NetInfo info2          = instance.m_segments.m_buffer[i].Info;
                        ushort  startNode      = instance.m_segments.m_buffer[i].m_startNode;
                        ushort  endNode        = instance.m_segments.m_buffer[i].m_endNode;
                        Vector3 position       = instance.m_nodes.m_buffer[(int)startNode].m_position;
                        Vector3 position2      = instance.m_nodes.m_buffer[(int)endNode].m_position;
                        Vector3 startDirection = instance.m_segments.m_buffer[i].m_startDirection;
                        Vector3 endDirection   = instance.m_segments.m_buffer[i].m_endDirection;
                        Vector3 a;
                        float   num2;
                        float   num3;
                        if (NetSegment.IsStraight(position, startDirection, position2, endDirection))
                        {
                            a = (position + position2) * 0.5f;
                        }
                        else if (Line2.Intersect(VectorUtils.XZ(position), VectorUtils.XZ(position + startDirection), VectorUtils.XZ(position2), VectorUtils.XZ(position2 + endDirection), out num2, out num3))
                        {
                            float minNodeDistance = info2.GetMinNodeDistance();
                            num2 = Mathf.Max(minNodeDistance, num2);
                            num3 = Mathf.Max(minNodeDistance, num3);
                            a    = (position + startDirection * num2 + position2 + endDirection * num3) * 0.5f;
                        }
                        else
                        {
                            a = (position + position2) * 0.5f;
                        }
                        BuildingInfo.PathInfo pathInfo = new BuildingInfo.PathInfo();
                        pathInfo.m_netInfo                 = info2;
                        pathInfo.m_finalNetInfo            = info2;
                        pathInfo.m_nodes                   = new Vector3[2];
                        pathInfo.m_nodes[0]                = position - data.m_position;
                        pathInfo.m_nodes[0].z              = -pathInfo.m_nodes[0].z;
                        pathInfo.m_nodes[1]                = position2 - data.m_position;
                        pathInfo.m_nodes[1].z              = -pathInfo.m_nodes[1].z;
                        pathInfo.m_curveTargets            = new Vector3[1];
                        pathInfo.m_curveTargets[0]         = a - data.m_position;
                        pathInfo.m_curveTargets[0].z       = -pathInfo.m_curveTargets[0].z;
                        pathInfo.m_forbidLaneConnection    = new bool[2];
                        pathInfo.m_forbidLaneConnection[0] = ((instance.m_nodes.m_buffer[(int)startNode].m_flags & NetNode.Flags.ForbidLaneConnection) != NetNode.Flags.None);
                        pathInfo.m_forbidLaneConnection[1] = ((instance.m_nodes.m_buffer[(int)endNode].m_flags & NetNode.Flags.ForbidLaneConnection) != NetNode.Flags.None);
                        pathInfo.m_trafficLights           = new BuildingInfo.TrafficLights[2];
                        pathInfo.m_trafficLights[0]        = /*BuildingDecoration.*/ FlagsToTrafficLights(instance.m_nodes.m_buffer[(int)startNode].m_flags);
                        pathInfo.m_trafficLights[1]        = /*BuildingDecoration.*/ FlagsToTrafficLights(instance.m_nodes.m_buffer[(int)endNode].m_flags);
                        pathInfo.m_yieldSigns              = new bool[2];
                        pathInfo.m_yieldSigns[0]           = ((instance.m_segments.m_buffer[i].m_flags & NetSegment.Flags.YieldStart) != NetSegment.Flags.None);
                        pathInfo.m_yieldSigns[1]           = ((instance.m_segments.m_buffer[i].m_flags & NetSegment.Flags.YieldEnd) != NetSegment.Flags.None);
                        if (info.m_placementMode == BuildingInfo.PlacementMode.Roadside && (position.z > (float)info.m_cellLength * 4f + 8f || position2.z > (float)info.m_cellLength * 4f + 8f))
                        {
                            pathInfo.m_maxSnapDistance = 7.5f;
                        }
                        else
                        {
                            pathInfo.m_maxSnapDistance = 0.1f;
                        }
                        pathInfo.m_invertSegments = ((instance.m_segments.m_buffer[i].m_flags & NetSegment.Flags.Invert) != NetSegment.Flags.None);
                        fastList.Add(pathInfo);
                        SavedSegments.Add(new IdentificationTool.AssetSegment((ushort)i));   // ns
                    }
                }
            }
            for (int j = 0; j < 32768; j++)
            {
                if ((instance.m_nodes.m_buffer[j].m_flags & (NetNode.Flags.Created | NetNode.Flags.Deleted)) == NetNode.Flags.Created && instance.m_nodes.m_buffer[j].CountSegments() == 0)
                {
                    bool flag = false;
                    foreach (ushort num4 in list2)
                    {
                        if (Singleton <BuildingManager> .instance.m_buildings.m_buffer[(int)num4].ContainsNode((ushort)j))
                        {
                            flag = true;
                            break;
                        }
                    }
                    if (!flag)
                    {
                        NetInfo info3     = instance.m_nodes.m_buffer[j].Info;
                        Vector3 position3 = instance.m_nodes.m_buffer[j].m_position;
                        BuildingInfo.PathInfo pathInfo2 = new BuildingInfo.PathInfo();
                        pathInfo2.m_netInfo                 = info3;
                        pathInfo2.m_finalNetInfo            = info3;
                        pathInfo2.m_nodes                   = new Vector3[1];
                        pathInfo2.m_nodes[0]                = position3 - data.m_position;
                        pathInfo2.m_nodes[0].z              = -pathInfo2.m_nodes[0].z;
                        pathInfo2.m_curveTargets            = new Vector3[0];
                        pathInfo2.m_forbidLaneConnection    = new bool[1];
                        pathInfo2.m_forbidLaneConnection[0] = ((instance.m_nodes.m_buffer[j].m_flags & NetNode.Flags.ForbidLaneConnection) != NetNode.Flags.None);
                        pathInfo2.m_trafficLights           = new BuildingInfo.TrafficLights[1];
                        pathInfo2.m_trafficLights[0]        = /*BuildingDecoration.*/ FlagsToTrafficLights(instance.m_nodes.m_buffer[j].m_flags);
                        pathInfo2.m_yieldSigns              = new bool[0];
                        pathInfo2.m_maxSnapDistance         = 0.1f;
                        pathInfo2.m_invertSegments          = false;
                        fastList.Add(pathInfo2);
                    }
                }
            }
            info.m_paths = fastList.ToArray();

            // ns:
            if (SavedSegments.Count > 0)
            {
                m_pendingSegments = SavedSegments;
            }
        }
#pragma warning disable 108,114
        public virtual ToolBase.ToolErrors CheckBuildPosition(bool test, bool visualize, bool overlay, bool autofix,
#pragma warning restore 108,114
                                                              ref NetTool.ControlPoint startPoint, ref NetTool.ControlPoint middlePoint, ref NetTool.ControlPoint endPoint,
                                                              out BuildingInfo ownerBuilding, out Vector3 ownerPosition, out Vector3 ownerDirection,
                                                              out int productionRate)
        {
            ownerBuilding  = null;
            ownerPosition  = Vector3.zero;
            ownerDirection = Vector3.forward;
            productionRate = 0;
            ToolBase.ToolErrors toolErrors = ToolBase.ToolErrors.None;
            if (test)
            {
                ushort num = middlePoint.m_segment;
                if (startPoint.m_segment == num || endPoint.m_segment == num)
                {
                    num = 0;
                }
                if (num != 0 && Singleton <NetManager> .instance.m_segments.m_buffer[(int)num].Info == this.m_info)
                {
                    if (ZoneBlocksOffset.Mode == ZoneBlocksOffsetMode.Default)
                    {
                        toolErrors |= ToolBase.ToolErrors.CannotUpgrade;
                    }
                    else
                    {
                        // Do nothing
                    }
                }
            }
            if (autofix && this.m_info.m_enableBendingSegments)
            {
                Vector3 vector          = middlePoint.m_direction;
                Vector3 vector2         = -endPoint.m_direction;
                Vector3 vector3         = middlePoint.m_position;
                float   minNodeDistance = this.m_info.GetMinNodeDistance();
                for (int i = 0; i < 3; i++)
                {
                    bool flag  = false;
                    bool flag2 = false;
                    if (startPoint.m_node != 0)
                    {
                        if (ForceValidDirection(this.m_info, ref vector, startPoint.m_node,
                                                ref Singleton <NetManager> .instance.m_nodes.m_buffer[(int)startPoint.m_node]))
                        {
                            flag = true;
                        }
                    }
                    else if (startPoint.m_segment != 0 &&
                             ForceValidDirection(this.m_info, startPoint.m_position, ref vector,
                                                 startPoint.m_segment,
                                                 ref Singleton <NetManager> .instance.m_segments.m_buffer[(int)startPoint.m_segment]))
                    {
                        flag = true;
                    }
                    if (flag)
                    {
                        Line2 line  = Line2.XZ(startPoint.m_position, startPoint.m_position + vector);
                        Line2 line2 = Line2.XZ(endPoint.m_position, endPoint.m_position + vector2);
                        bool  flag3 = true;
                        float num2;
                        float num3;
                        if (line.Intersect(line2, out num2, out num3) && num2 >= minNodeDistance &&
                            num3 >= minNodeDistance)
                        {
                            vector3 = startPoint.m_position + vector * num2;
                            flag3   = false;
                        }
                        if (flag3)
                        {
                            Vector3 vector4 = endPoint.m_position - startPoint.m_position;
                            Vector3 vector5 = vector;
                            vector4.y = 0f;
                            vector5.y = 0f;
                            float num4 = Vector3.SqrMagnitude(vector4);
                            vector4 = Vector3.Normalize(vector4);
                            float num5 = Mathf.Min(1.17809725f, Mathf.Acos(Vector3.Dot(vector4, vector5)));
                            float d    = Mathf.Sqrt(0.5f * num4 / Mathf.Max(0.001f, 1f - Mathf.Cos(3.14159274f - 2f * num5)));
                            vector3   = startPoint.m_position + vector5 * d;
                            vector2   = vector3 - endPoint.m_position;
                            vector2.y = 0f;
                            vector2.Normalize();
                        }
                    }
                    if (endPoint.m_node != 0)
                    {
                        if (ForceValidDirection(this.m_info, ref vector2, endPoint.m_node,
                                                ref Singleton <NetManager> .instance.m_nodes.m_buffer[(int)endPoint.m_node]))
                        {
                            flag2 = true;
                        }
                    }
                    else if (endPoint.m_segment != 0 &&
                             ForceValidDirection(this.m_info, endPoint.m_position, ref vector2, endPoint.m_segment,
                                                 ref Singleton <NetManager> .instance.m_segments.m_buffer[(int)endPoint.m_segment]))
                    {
                        flag2 = true;
                    }
                    if (flag2)
                    {
                        Line2 line3 = Line2.XZ(startPoint.m_position, startPoint.m_position + vector);
                        Line2 line4 = Line2.XZ(endPoint.m_position, endPoint.m_position + vector2);
                        bool  flag4 = true;
                        float num6;
                        float num7;
                        if (line3.Intersect(line4, out num6, out num7) && num6 >= minNodeDistance &&
                            num7 >= minNodeDistance)
                        {
                            vector3 = endPoint.m_position + vector2 * num7;
                            flag4   = false;
                        }
                        if (flag4)
                        {
                            Vector3 vector6 = startPoint.m_position - endPoint.m_position;
                            Vector3 vector7 = vector2;
                            vector6.y = 0f;
                            vector7.y = 0f;
                            float num8 = Vector3.SqrMagnitude(vector6);
                            vector6 = Vector3.Normalize(vector6);
                            float num9 = Mathf.Min(1.17809725f, Mathf.Acos(Vector3.Dot(vector6, vector7)));
                            float d2   = Mathf.Sqrt(0.5f * num8 / Mathf.Max(0.001f, 1f - Mathf.Cos(3.14159274f - 2f * num9)));
                            vector3  = endPoint.m_position + vector7 * d2;
                            vector   = vector3 - startPoint.m_position;
                            vector.y = 0f;
                            vector.Normalize();
                        }
                    }
                    if (!flag && !flag2)
                    {
                        middlePoint.m_direction = vector;
                        endPoint.m_direction    = -vector2;
                        middlePoint.m_position  = vector3;
                        break;
                    }
                }
            }
            return(toolErrors);
        }