Modified the namespacing

Added namespace UnityEngine to improve code organization

Custom 2D Colliders/Scripts/ArcCollider2D.cs

@@ -26,54 +26,57 @@
 
 
 #if UNITY_EDITOR
-using UnityEngine;
 using System.Collections;
 using System.Collections.Generic;
 
-[AddComponentMenu("Physics 2D/Arc Collider 2D")]
+namespace UnityEngine
+{
+    [AddComponentMenu("Physics 2D/Arc Collider 2D")]
 
-[RequireComponent(typeof(EdgeCollider2D))]
-public class ArcCollider2D : MonoBehaviour {
+    [RequireComponent(typeof(EdgeCollider2D))]
+    public sealed class ArcCollider2D : Collider2D
+    {
 
-    [Range(1, 25)]
-    public float radius = 3;
-    [Range(10,90)]
-    public int smoothness = 24;
+        public float radius = 3;
 
-    [Range(10, 360)]
-    public int totalAngle = 360;
+        [Range(10, 90)]
+        public int smoothness = 24;
 
-    [Range(0, 360)]
-    public int offsetRotation = 0;
+        [Range(0, 360)]
+        public int totalAngle = 360;
 
-    [Header("Let there be Pizza")]
-    public bool pizzaSlice;
-
-    Vector2 origin, center;
-
-    public Vector2[] getPoints(Vector2 off)
-    {
-        List<Vector2> points = new List<Vector2>();
+        [Range(0, 360)]
+        public int offsetRotation = 0;
 
-        origin = transform.localPosition;
-        center = origin + off;
-
-        float ang = offsetRotation;
+        [Header("Let there be Pizza")]
+        public bool pizzaSlice;
 
-        if (pizzaSlice && totalAngle % 360 != 0) points.Add(center);
+        Vector2 origin, center;
 
-        for (int i = 0; i <= smoothness; i++)
+        public Vector2[] getPoints(Vector2 off)
         {
-            float x = center.x + radius * Mathf.Cos(ang * Mathf.Deg2Rad);
-            float y = center.y + radius * Mathf.Sin(ang * Mathf.Deg2Rad);
+            List<Vector2> points = new List<Vector2>();
 
-            points.Add(new Vector2(x, y));
-            ang += (float)totalAngle/smoothness;
-        }
+            origin = transform.localPosition;
+            center = origin + off;
+
+            float ang = offsetRotation;
 
-        if (pizzaSlice && totalAngle % 360 != 0) points.Add(center);
+            if (pizzaSlice && totalAngle % 360 != 0) points.Add(center);
 
-        return points.ToArray();
+            for (int i = 0; i <= smoothness; i++)
+            {
+                float x = center.x + radius * Mathf.Cos(ang * Mathf.Deg2Rad);
+                float y = center.y + radius * Mathf.Sin(ang * Mathf.Deg2Rad);
+
+                points.Add(new Vector2(x, y));
+                ang += (float)totalAngle / smoothness;
+            }
+
+            if (pizzaSlice && totalAngle % 360 != 0) points.Add(center);
+
+            return points.ToArray();
+        }
     }
 }
 #endif

Custom 2D Colliders/Scripts/BezierCurveCollider2D.cs

@@ -26,136 +26,140 @@
 
 
 #if UNITY_EDITOR
-using UnityEngine;
 using System.Collections;
 using System.Collections.Generic;
 
+namespace UnityEngine
+{
 
-[AddComponentMenu("Physics 2D/Bezier Curve Collider 2D")]
+    [AddComponentMenu("Physics 2D/Bezier Curve Collider 2D")]
 
-[RequireComponent(typeof(EdgeCollider2D))]
-public class BezierCurveCollider2D : MonoBehaviour {
+    [RequireComponent(typeof(EdgeCollider2D))]
+    public sealed class BezierCurveCollider2D : MonoBehaviour
+    {
 
-    public List<Vector2> controlPoints, handlerPoints;
+        public List<Vector2> controlPoints, handlerPoints;
 
-    [Range(3,36)]
-    public int smoothness = 15;
-
-    Vector2 origin, center;
+        [Range(3, 36)]
+        public int smoothness = 15;
 
-    [HideInInspector]
-    public bool initialized;
+        Vector2 origin, center;
 
-    public bool continous = true;
+        [HideInInspector]
+        public bool initialized;
 
-    [HideInInspector]
-    public EdgeCollider2D edge;
-    List<Vector2> pts;
-
+        public bool continous = true;
 
-    public void Init()
-    {
-        if (initialized) return;
-        initialized = true;
-        continous = true;
-        smoothness = 15;
+        [HideInInspector]
+        public EdgeCollider2D edge;
+        List<Vector2> pts;
 
-        controlPoints = new List<Vector2>();
-        handlerPoints = new List<Vector2>();
 
-        controlPoints.Clear();
-        handlerPoints.Clear();
+        public void Init()
+        {
+            if (initialized) return;
+            initialized = true;
+            continous = true;
+            smoothness = 15;
 
-        Vector2 pos = transform.localPosition;        
-        controlPoints.Add(pos);
+            controlPoints = new List<Vector2>();
+            handlerPoints = new List<Vector2>();
 
-        pos.x += 4;
-        controlPoints.Add(pos);
+            controlPoints.Clear();
+            handlerPoints.Clear();
 
-        pos.x -= 4;
-        pos.y += 4;
-        handlerPoints.Add(pos);
+            Vector2 pos = transform.localPosition;
+            controlPoints.Add(pos);
 
-        pos.x += 4;
-        handlerPoints.Add(pos);
+            pos.x += 4;
+            controlPoints.Add(pos);
 
-        drawCurve();
-    }
-
-    public void drawCurve()
-    {
-        pts = new List<Vector2>();
-        pts.Clear();
+            pos.x -= 4;
+            pos.y += 4;
+            handlerPoints.Add(pos);
 
-        edge = GetComponent<EdgeCollider2D>();
-        if (edge == null)
-        {
-            gameObject.AddComponent<EdgeCollider2D>();
+            pos.x += 4;
+            handlerPoints.Add(pos);
+
+            drawCurve();
         }
 
-        if (controlPoints.Count == 2)
+        public void drawCurve()
         {
-            drawSegment(controlPoints[0], controlPoints[1], handlerPoints[0], handlerPoints[1]);
-        } else if (controlPoints.Count > 2)
-        {
-            int h = 0;
-            for(int i = 0; i < controlPoints.Count - 1; i++)
+            pts = new List<Vector2>();
+            pts.Clear();
+
+            edge = GetComponent<EdgeCollider2D>();
+            if (edge == null)
             {
-                drawSegment(controlPoints[i], controlPoints[i+1], handlerPoints[h], handlerPoints[h+1]);
-                h += 2;
+                gameObject.AddComponent<EdgeCollider2D>();
             }
-        }
 
+            if (controlPoints.Count == 2)
+            {
+                drawSegment(controlPoints[0], controlPoints[1], handlerPoints[0], handlerPoints[1]);
+            }
+            else if (controlPoints.Count > 2)
+            {
+                int h = 0;
+                for (int i = 0; i < controlPoints.Count - 1; i++)
+                {
+                    drawSegment(controlPoints[i], controlPoints[i + 1], handlerPoints[h], handlerPoints[h + 1]);
+                    h += 2;
+                }
+            }
 
-        edge.points = pts.ToArray();
 
-    }
+            edge.points = pts.ToArray();
 
-    void drawSegment(Vector3 cPt1, Vector3 cPt2, Vector3 hPt1, Vector3 hPt2)
-    {
+        }
 
-        pts.Add(cPt1);
-        for (int i = 1; i < smoothness; i++)
+        void drawSegment(Vector3 cPt1, Vector3 cPt2, Vector3 hPt1, Vector3 hPt2)
         {
-            pts.Add(CalculateBezierPoint((1f / smoothness) * i, cPt1, hPt1, hPt2, cPt2));
+
+            pts.Add(cPt1);
+            for (int i = 1; i < smoothness; i++)
+            {
+                pts.Add(CalculateBezierPoint((1f / smoothness) * i, cPt1, hPt1, hPt2, cPt2));
+            }
+            pts.Add(cPt2);
         }
-        pts.Add(cPt2);
-    }
 
-    Vector3 CalculateBezierPoint(float t, Vector3 controlP0, Vector3 handlerP0, Vector3 handlerP1, Vector3 controlP1)
-    {
-        //http://devmag.org.za/2011/04/05/bzier-curves-a-tutorial/
-        Vector3 p = (Mathf.Pow((1.0f - t), 3) * controlP0) + (3 * Mathf.Pow((1 - t), 2) * t * handlerP0) + (3 * (1.0f - t) * Mathf.Pow(t, 2) * handlerP1) + (Mathf.Pow(t, 3) * controlP1);
-        return p;
-    }
+        Vector3 CalculateBezierPoint(float t, Vector3 controlP0, Vector3 handlerP0, Vector3 handlerP1, Vector3 controlP1)
+        {
+            //http://devmag.org.za/2011/04/05/bzier-curves-a-tutorial/
+            Vector3 p = (Mathf.Pow((1.0f - t), 3) * controlP0) + (3 * Mathf.Pow((1 - t), 2) * t * handlerP0) + (3 * (1.0f - t) * Mathf.Pow(t, 2) * handlerP1) + (Mathf.Pow(t, 3) * controlP1);
+            return p;
+        }
 
 
-    public void addControlPoint()
-    {
-        Vector2 pos = controlPoints[controlPoints.Count - 1];
-        float hPosY = handlerPoints[handlerPoints.Count - 1].y;
+        public void addControlPoint()
+        {
+            Vector2 pos = controlPoints[controlPoints.Count - 1];
+            float hPosY = handlerPoints[handlerPoints.Count - 1].y;
 
-        float mul = (hPosY > pos.y) ? -1 : 1; // check if the handler point was below or top of the control point and use that info to make sure that the next handler point is in the opposite direction
-
-        handlerPoints.Add(new Vector2(pos.x, pos.y + (4 * mul)));
-
-        pos.x += 4;
-        controlPoints.Add(pos);
+            float mul = (hPosY > pos.y) ? -1 : 1; // check if the handler point was below or top of the control point and use that info to make sure that the next handler point is in the opposite direction
 
-        pos.y += 4 * mul;
-        handlerPoints.Add(pos);
+            handlerPoints.Add(new Vector2(pos.x, pos.y + (4 * mul)));
 
-        drawCurve();
-    }
+            pos.x += 4;
+            controlPoints.Add(pos);
 
+            pos.y += 4 * mul;
+            handlerPoints.Add(pos);
 
-    public void removeControlPoint()
-    {
-        if(controlPoints.Count > 2)
+            drawCurve();
+        }
+
+
+        public void removeControlPoint()
         {
-            controlPoints.RemoveAt(controlPoints.Count - 1);
-            handlerPoints.RemoveAt(handlerPoints.Count - 1);
-            handlerPoints.RemoveAt(handlerPoints.Count - 1);
+            if (controlPoints.Count > 2)
+            {
+                controlPoints.RemoveAt(controlPoints.Count - 1);
+                handlerPoints.RemoveAt(handlerPoints.Count - 1);
+                handlerPoints.RemoveAt(handlerPoints.Count - 1);
+            }
         }
     }
 }