public override void OnCreate(GameObject obj)
        {
            if (Missile == null)
            {
                Position = CastArgs.End;
            }
            else
            {
                Position = Missile.EndPosition;
                StartMissilePos = Missile.Position;
            }

            PrimaryCircle = new Circle
            {
                Radius = SpellData.Radius,
                BorderWidth = 3,
                Color = Color.White
            };

            SecondaryCircle = new Circle
            {
                Radius = 10,
                Color = Color.LawnGreen
            };
        }

    static void Main()
    {
        var shapes = new Shape[numberOfShapes];

        for (int i = 0; i < shapes.Length; i++)
        {
            switch (vladoRandoma.Next() % 3)
            {
                case 0:
                    shapes[i] = new Triangle(widths[vladoRandoma.Next(0, widths.Length)],
                                                 heights[vladoRandoma.Next(0, heights.Length)]);
                    break;
                case 1: shapes[i] = new Rectangle(widths[vladoRandoma.Next(0, widths.Length)],
                                                 heights[vladoRandoma.Next(0, heights.Length)]);
                    break;
                case 2: shapes[i] = new Circle(heights[vladoRandoma.Next(0, heights.Length)]);
                    break;

                default:
                    break;
            }
        }

        foreach (var item in shapes)
        {
            Console.WriteLine(item.ToString().Replace(',', '.'));
        }
    }

        public bool CanStructureBePlaced(Point location, int size, Unit builder, bool cutCorners)
        {
            List<PathNode> placingStructurePathNodes = new List<PathNode>();
            Circle collisionCircle = new Circle(new Vector2(location.X * Map.TileSize + (size / 2) * Map.TileSize, location.Y * Map.TileSize + (size / 2) * Map.TileSize), size * Map.TileSize);
            //placingStructureCenterPoint = collisionCircle.CenterPoint;

            for (int x = location.X; x < location.X + size; x++)
            {
                for (int y = location.Y; y < location.Y + size; y++)
                {
                    PathNode node = Rts.pathFinder.PathNodes[(int)MathHelper.Clamp(y, 0, Map.Height - 1), (int)MathHelper.Clamp(x, 0, Map.Width - 1)];
                    if (collisionCircle.Intersects(node.Tile))
                    {
                        placingStructurePathNodes.Add(node);
                    }
                }
            }
            // remove corners
            if (cutCorners)
            {
                placingStructurePathNodes.Remove(Rts.pathFinder.PathNodes[location.Y, location.X]);
                if (location.X + size <= Map.Width - 1)
                    placingStructurePathNodes.Remove(Rts.pathFinder.PathNodes[location.Y, location.X + size - 1]);
                else
                    return false;
                if (location.Y + size <= Map.Height - 1)
                    placingStructurePathNodes.Remove(Rts.pathFinder.PathNodes[location.Y + size - 1, location.X]);
                else
                    return false;
                placingStructurePathNodes.Remove(Rts.pathFinder.PathNodes[location.Y + size - 1, location.X + size - 1]);
            }

            foreach (PathNode node in placingStructurePathNodes)
            {
                if (!node.Tile.Walkable || node.Blocked)
                    return false;
                if (node.UnitsContained.Count > 0)
                {
                    if (node.UnitsContained.Count == 1 && node.UnitsContained.ElementAt<Unit>(0) == builder)
                        continue;
                    else
                    {
                        bool allow = true;

                        foreach (Unit unit in node.UnitsContained)
                        {
                            if (unit.Team != builder.Team)
                            {
                                allow = false;
                                break;
                            }
                        }
                        if (!allow)
                            return false;
                    }
                }
            }

            return true;
        }

        /// <summary>
        /// Determines if a circle intersects a circle.
        /// </summary>
        /// <returns>True if the circle and circle overlap. False otherwise.</returns>
        public bool Intersects(Circle circle)
        {
            float dist = Vector2.Distance(Center, circle.Center);
            float minDist = Radius + circle.Radius;

            return dist <= minDist;
        }

 /// <summary>
 /// Create a new intersection between a segment and a circle.
 /// </summary>
 /// <param name="i">The point of intersection.</param>
 /// <param name="c">The circle.</param>
 /// <param name="s">The segment.</param>
 public CircleSegmentIntersection(Point i, Circle c, Segment s)
     : base()
 {
     intersect = i;
     circle = c;
     segment = s;
 }

 public void DoClick(Circle circle)
 {
     if (Physics.CircleCicleCollision(circle, GaucheCercle) && Valeur > Min)
         Valeur = Math.Max(Min, Valeur - Increment);
     else if (Physics.CircleCicleCollision(circle, DroiteCercle) && Valeur < Max)
         Valeur = Math.Min(Max, Valeur + Increment);
 }

 public static Point2d PP(Object object_i, Object object_j, Circle circle)
 {
     if (object_i is Circle)
     {
         Circle circle_i = object_i as Circle;
         if (object_j is Circle)
         {
             Circle circle_j = object_j as Circle;
             return PlacingPoint.Calc(new Circle() { X = circle_i.X, Y = circle_i.Y, R = circle_i.R + circle.R }, new Circle() { X = circle_j.X, Y = circle_j.Y, R = circle_j.R + circle.R });
         }
         else
         {
             StripLine strip_line_j = object_j as StripLine;
             return PlacingPoint.Calc(new Circle() { X = circle_i.X, Y = circle_i.Y, R = circle_i.R + circle.R }, new StripLine() { PX = strip_line_j.PX + strip_line_j.VY * circle.R, PY = strip_line_j.PY - strip_line_j.VX * circle.R, VX = strip_line_j.VX, VY = strip_line_j.VY });
         }
     }
     else
     {
         StripLine strip_line_i = object_i as StripLine;
         if (object_j is Circle)
         {
             Circle circle_j = object_j as Circle;
             return PlacingPoint.Calc(new StripLine() { PX = strip_line_i.PX + strip_line_i.VY * circle.R, PY = strip_line_i.PY - strip_line_i.VX * circle.R, VX = strip_line_i.VX, VY = strip_line_i.VY }, new Circle() { X = circle_j.X, Y = circle_j.Y, R = circle_j.R + circle.R });
         }
         else
         {
             StripLine strip_line_j = object_j as StripLine;
             return PlacingPoint.Calc(new StripLine() { PX = strip_line_i.PX + strip_line_i.VY * circle.R, PY = strip_line_i.PY - strip_line_i.VX * circle.R, VX = strip_line_i.VX, VY = strip_line_i.VY }, new StripLine() { PX = strip_line_j.PX + strip_line_j.VY * circle.R, PY = strip_line_j.PY - strip_line_j.VX * circle.R, VX = strip_line_j.VX, VY = strip_line_j.VY });
         }
     }
 }

        public Player()
            : base()
        {
            ID = "player";
            PlayerEventCallback = null;
            _lastEvent = PlayerEvent.None;

            RenderLayer = Render_Layer;
            RenderDepth = Render_Depth;

            _mapBounds = Rectangle.Empty;
            CollisionBoundingCircle = new Circle(Vector2.Zero, Body_Collision_Radius);
            Collidable = true;
            Visible = true;

            _motionEngine = new PlayerMotionEngine();
            MotionEngine = _motionEngine;

            _isSmashingSmashBlocks = false;
            _hasTouchedGoalFlag = false;
            IsExitingLevel = false;

            LastRaceRestartPointTouched = null;

            TutorialStepTrigger = null;

            ResetCollisionFlags();
        }

 public void Initialize()
 {
     int size = 75;
     innercircle = new Circle(new Vector2(100 , screen.Height / options.ScaleFactor - 25), content.Load<Texture2D>("Img/Game/LSIC"), size, size);
     System.Threading.Thread.Sleep(10);
     outercircle = new Circle(new Vector2(100, screen.Height / options.ScaleFactor - 25), content.Load<Texture2D>("Img/Game/LSOC"), size, size);
 }

 private static void Main()
 {
     var circle = new Circle(5);
     Console.WriteLine(circle);
     var rect = new Rectangle(2, 3);
     Console.WriteLine(rect);
 }

 public CelestialBodyExplosion()
 {
     Handler = new IntegerHandler(CheckEnemiesHit);
     Output = new Dictionary<int, Enemy>();
     CelestialBodyRectangle = new PhysicalRectangle();
     CelestiablBodyRange = new Circle(Vector3.Zero, 0);
 }

 public PowerUpSpawner(GameObject[] powerUpPrefabs, Circle gameArea, float spawnDelay = 30.0f)
     : base(spawnDelay)
 {
     this.powerUpPrefabs = powerUpPrefabs;
     this.gameArea = gameArea;
     this.spawnTimer = spawnDelay;
 }

        public static bool CircleCollision(Circle circleA, Circle circleB)
        {
            float distance = Vector2.Distance(circleA.Position, circleB.Position);
            float radiusTotal = circleA.Radius + circleB.Radius;

            return (distance < radiusTotal);
        }

 public Vector2 CollisionPoint(Circle circle)
 {
     return new Vector2 {
         X = ((Center.X * circle.Radius) + (circle.Center.X * Radius)) / (Radius + circle.Radius),
         Y = ((Center.Y * circle.Radius) + (circle.Center.Y * Radius)) / (Radius + circle.Radius),
     };
 }

    public override void ExecuteFigureCreationCommand(string[] splitFigString)
    {
        switch (splitFigString[0])
        {
            case "circle":
                {
                    Vector3D center = Vector3D.Parse(splitFigString[1]);
                    double radius = double.Parse(splitFigString[2]);

                    currentFigure = new Circle(center, radius);
                    break;
                }

            case "cylinder":
                {
                    Vector3D bottom = Vector3D.Parse(splitFigString[1]);
                    Vector3D top = Vector3D.Parse(splitFigString[2]);
                    double radius = double.Parse(splitFigString[3]);

                    currentFigure = new Cylinder(bottom, top, radius);
                    break;
                }
        }

        base.ExecuteFigureCreationCommand(splitFigString);
    }

        public static ICollection<Vector2> CollidedSurfaceNormals(Circle circle, ICollection<AABB> aabbs)
        {
            var surfaceNormals = new List<Vector2>();

            restartLoop:
            foreach (var aabb in aabbs)
            {
                Vector2 nearestVector = NearestVectorBetweenCircleAndAABB(aabb, circle);

                if (NearestVectorIntersects(nearestVector, circle))
                {
                    //if (surfaceNormals == EMPTY) surfaceNormals = new List<Vector2>();

                    var surfaceNormal = Vector2.Normalize(nearestVector);

                    if (!surfaceNormals.Contains(surfaceNormal))
                    {
                        surfaceNormals.Add(surfaceNormal);
                        PushCircleApartFromAABB(circle, nearestVector, 1.0f);

                        goto restartLoop;
                    }
                }
            }

            return surfaceNormals;
        }

 public void ConstructorsEqualityTest()
 {
     Circle circle1 = new Circle(84, 64, 32);
     Circle circle2 = new Circle(52, 32, 64, false);
     Assert.True(circle1.Equals(circle2), "the circles should be equal");
     Assert.Equal(circle1.GetHashCode(), circle2.GetHashCode()); //the circles should generate the same hash code
 }

        public ChoicesHorizontalSlider(string label, List<string> choices, int startingIndex)
        {
            Choices = choices;
            ChoiceIndex = startingIndex;

            DecrementRep = new Image("WidgetNext") { Origin = Vector2.Zero, Effect = SpriteEffects.FlipHorizontally, SizeX = 4 };
            IncrementRep = new Image("WidgetNext") { Origin = Vector2.Zero, SizeX = 4 };

            ValueText = new Text(Choices[ChoiceIndex], @"Pixelite") { SizeX = 2 };
            Label = new Text(label, @"Pixelite") { SizeX = 2 };

            LongestChoice = new Text(@"Pixelite") { SizeX = 2 };

            foreach (var choice in Choices)
            {
                if (choice.Length > LongestChoice.Data.Length)
                    LongestChoice.Data = choice;
            }

            DecrementCircle = new Circle(Vector3.Zero, DecrementRep.AbsoluteSize.X / 2);
            IncrementCircle = new Circle(Vector3.Zero, IncrementRep.AbsoluteSize.X / 2);

            SpaceForLabel = 200;
            SpaceForValue = 200;
        }

        /// <summary>
        /// Constructor for the Missle Enemy.
        /// </summary>
        /// <param name="position"></param>
        public MineEnemy(Vector2 position, Player playerOne, Texture2D mineSpawnerTexture, Texture2D mineTexture)
        {
            m_mineEnemyTexture = mineSpawnerTexture;
            m_mineTexture = mineTexture;
            m_pPlayer = playerOne;
            m_position = position;
            m_spriteScale = 0.35f;
            m_dimensions = new Vector2(128, 128) * m_spriteScale;
            m_origin = (m_dimensions / 2.0f) / m_spriteScale;

            m_maxVelocity = 0.0f;
            m_turningSpeed = 150.0f;
            m_wanderPosition = new Vector2();

            m_detectionRadius = new Circle(m_position, 100);
            m_collisionRadius = new Circle(m_position, m_dimensions.X / 2 * m_spriteScale);
            
            m_directionChange = 2.0f;
            m_addMineCountdown = 2.0f;

            m_lerpColour = 0.0f;

            m_mineList = new List<Mine>();

            m_slowMotion = false;
        }

    public static void ThreeCircleIntersectPoints(Circle c1, Circle c2, Circle c3, List<Vector3> insectPoints)
    {
        Vector3[] ps1 = Circle.TwoCircleIntersectPoints(c1, c2);

        if (ps1 != null)
        {
            foreach (Vector3 v in ps1)
            {
                float length = (v - c3.mCenter).magnitude;
                if (length <= c3.mRadius)
                {
                    bool haveSame = false;
                    foreach (Vector3 vv in insectPoints)
                    {
                        if (Mathf.Abs(vv.x - v.x) < 0.0001
                            && Mathf.Abs(vv.y - v.y) < 0.0001
                            && Mathf.Abs(vv.z - v.z) < 0.0001)
                        {
                            haveSame = true;
                        }
                    }
                    if (haveSame == false)
                    {
                        insectPoints.Add(v);
                    }
                }
            }
        }
    }