Overwrite

Complete Overwrite of the Folder with the free shard. ServUO 57.3 has been added.

Scripts/Misc/Geometry.cs

@@ -0,0 +1,240 @@
+using System;
+
+namespace Server.Misc
+{
+    public delegate void DoEffect_Callback(Point3D p, Map map);
+
+    public static class Geometry
+    {
+        public static void Swap<T>(ref T a, ref T b)
+        {
+            T temp = a;
+            a = b;
+            b = temp;
+        }
+
+        public static double RadiansToDegrees(double angle) 
+        {
+            return angle * (180.0 / Math.PI);
+        }
+
+        public static double DegreesToRadians(double angle) 
+        {
+            return angle * (Math.PI / 180.0);
+        }
+
+        public static Point2D ArcPoint(Point3D loc, int radius, int angle)
+        {
+            int sideA, sideB;
+			
+            if (angle < 0)
+                angle = 0;
+			
+            if (angle > 90)
+                angle = 90;
+			
+            sideA = (int)Math.Round(radius * Math.Sin(DegreesToRadians(angle)));
+            sideB = (int)Math.Round(radius * Math.Cos(DegreesToRadians(angle)));
+			
+            return new Point2D(loc.X - sideB, loc.Y - sideA);
+        }
+
+        public static void Circle2D(Point3D loc, Map map, int radius, DoEffect_Callback effect)
+        {
+            Circle2D(loc, map, radius, effect, 0, 360);
+        }
+
+        public static void Circle2D(Point3D loc, Map map, int radius, DoEffect_Callback effect, int angleStart, int angleEnd)
+        {
+            if (angleStart < 0 || angleStart > 360)
+                angleStart = 0;
+			
+            if (angleEnd > 360 || angleEnd < 0)
+                angleEnd = 360;
+			
+            if (angleStart == angleEnd)
+                return;
+
+            bool opposite = angleStart > angleEnd;
+			
+            int startQuadrant = angleStart / 90;
+            int endQuadrant = angleEnd / 90;
+			
+            Point2D start = ArcPoint(loc, radius, angleStart % 90);
+            Point2D end = ArcPoint(loc, radius, angleEnd % 90);
+			
+            if (opposite)
+            {
+                Swap(ref start, ref end);
+                Swap(ref startQuadrant, ref endQuadrant);
+            }
+			
+            CirclePoint startPoint = new CirclePoint(start, angleStart, startQuadrant);
+            CirclePoint endPoint = new CirclePoint(end, angleEnd, endQuadrant);
+			
+            int error = -radius;
+            int x = radius;
+            int y = 0;
+			
+            while (x > y)
+            {
+                plot4points(loc, map, x, y, startPoint, endPoint, effect, opposite);
+                plot4points(loc, map, y, x, startPoint, endPoint, effect, opposite);
+ 
+                error += (y * 2) + 1;
+                ++y;
+				
+                if (error >= 0)
+                {
+                    --x;
+                    error -= x * 2;
+                }
+            }
+			
+            plot4points(loc, map, x, y, startPoint, endPoint, effect, opposite);
+        }
+
+        public static void plot4points(Point3D loc, Map map, int x, int y, CirclePoint start, CirclePoint end, DoEffect_Callback effect, bool opposite)
+        {
+            Point2D pointA = new Point2D(loc.X - x, loc.Y - y);
+            Point2D pointB = new Point2D(loc.X - y, loc.Y - x);
+			
+            int quadrant = 2;
+			
+            if (x == 0 && start.Quadrant == 3)
+                quadrant = 3;
+			
+            if (WithinCircleBounds(quadrant == 3 ? pointB : pointA, quadrant, loc, start, end, opposite))
+                effect(new Point3D(loc.X + x, loc.Y + y, loc.Z), map);
+			
+            quadrant = 3;
+			
+            if (y == 0 && start.Quadrant == 0)
+                quadrant = 0;
+			
+            if (x != 0 && WithinCircleBounds(quadrant == 0 ? pointA : pointB, quadrant, loc, start, end, opposite))
+                effect(new Point3D(loc.X - x, loc.Y + y, loc.Z), map);
+            if (y != 0 && WithinCircleBounds(pointB, 1, loc, start, end, opposite))
+                effect(new Point3D(loc.X + x, loc.Y - y, loc.Z), map);
+            if (x != 0 && y != 0 && WithinCircleBounds(pointA, 0, loc, start, end, opposite))
+                effect(new Point3D(loc.X - x, loc.Y - y, loc.Z), map);
+        }
+
+        public static bool WithinCircleBounds(Point2D pointLoc, int pointQuadrant, Point3D center, CirclePoint start, CirclePoint end, bool opposite)
+        {
+            if (start.Angle == 0 && end.Angle == 360)
+                return true;
+
+            int startX = start.Point.X;	
+            int startY = start.Point.Y;
+            int endX = end.Point.X;
+            int endY = end.Point.Y;
+			
+            int x = pointLoc.X;
+            int y = pointLoc.Y;
+
+            if (pointQuadrant < start.Quadrant || pointQuadrant > end.Quadrant)
+                return opposite;
+			
+            if (pointQuadrant > start.Quadrant && pointQuadrant < end.Quadrant)
+                return !opposite;
+
+            bool withinBounds = true;
+			
+            if (start.Quadrant == end.Quadrant)
+            {
+                if (startX == endX && (x > startX || y > startY || y < endY))
+                    withinBounds = false;
+                else if (startY == endY && (y < startY || x < startX || x > endX))
+                    withinBounds = false;
+                else if (x < startX || x > endX || y > startY || y < endY)
+                    withinBounds = false;
+            }
+            else if (pointQuadrant == start.Quadrant && (x < startX || y > startY))
+                withinBounds = false;
+            else if (pointQuadrant == end.Quadrant && (x > endX || y < endY))
+                withinBounds = false;
+			
+            return opposite ? !withinBounds : withinBounds;
+        }
+
+        public static void Line2D(Point3D start, Point3D end, Map map, DoEffect_Callback effect)
+        {
+            bool steep = Math.Abs(end.Y - start.Y) > Math.Abs(end.X - start.X);
+			
+            int x0 = start.X;
+            int x1 = end.X;
+            int y0 = start.Y;
+            int y1 = end.Y;
+			
+            if (steep)
+            {
+                Swap(ref x0, ref y0);
+                Swap(ref x1, ref y1);
+            }
+			
+            if (x0 > x1)
+            {
+                Swap(ref x0, ref x1);
+                Swap(ref y0, ref y1);
+            }
+			
+            int deltax = x1 - x0;
+            int deltay = Math.Abs(y1 - y0);
+            int error = deltax / 2;
+            int ystep = y0 < y1 ? 1 : -1;
+            int y = y0;
+			
+            for (int x = x0; x <= x1; x++)
+            {
+                if (steep)
+                    effect(new Point3D(y, x, start.Z), map);
+                else
+                    effect(new Point3D(x, y, start.Z), map);
+				
+                error -= deltay;
+				
+                if (error < 0)
+                {
+                    y += ystep;
+                    error += deltax;
+                }
+            }
+        }
+
+        public class CirclePoint
+        {
+            private readonly Point2D point;
+            private readonly int angle;
+            private readonly int quadrant;
+            public CirclePoint(Point2D point, int angle, int quadrant)
+            {
+                this.point = point;
+                this.angle = angle;
+                this.quadrant = quadrant;
+            }
+
+            public Point2D Point
+            {
+                get
+                {
+                    return this.point;
+                }
+            }
+            public int Angle
+            {
+                get
+                {
+                    return this.angle;
+                }
+            }
+            public int Quadrant
+            {
+                get
+                {
+                    return this.quadrant;
+                }
+            }
+        }
+    }
+}