public BlueBall(Vector2D position, double radius, PlayerPaddle paddle)
        {
            lock (lockCounter)
            {
                ballID = IDCounter++;
            }

            this.playerPaddle = paddle;
            this.Velocity = new Vector2D(0, 0);
            ObjectTextures = new List<GameBitmap>();
            this.Position = position;
            this.Radius = radius;
            ObjectTextures.Add(new GameBitmap("\\Resources\\Images\\ballBlue.png", this.Position - new Vector2D(0, Radius)
                - new Vector2D(Radius, 0),
                this.Position - new Vector2D(0, Radius) + new Vector2D(Radius, 0), this.Position + new Vector2D(0, Radius)
                + new Vector2D(-Radius, 0)));
            ObjectTextures[0].IsBall = true;
            ObjectWidth = ObjectHeight = 2 * radius;
            ObjectTextures[0].IsSquare = true;
            ObjectTextures[0].ColorLowSpec = Color.Aqua;

            //квадратот ќе ги има истите темиња како и сликата
            textureRotator = new GameRectangle(ObjectTextures[0].PositionUL,
                ObjectTextures[0].PositionUR, ObjectTextures[0].PositionDL);

            Health = 1000;
        }
 /* public AbstractBrick(Vector2D positionUL, Vector2D positionUR, Vector2D positionDL,string p)
 {
     this.PositionUL = positionUL;
     this.PositionUR = positionUR;
     this.PositionDL = positionDL;
     this.picture = p;
 }*/
 public AbstractBrick(Vector2D positionUL, Vector2D positionUR, Vector2D positionDL, GameBitmap bmp)
 {
     this.PositionUL = positionUL;
     this.PositionUR = positionUR;
     this.PositionDL = positionDL;
     this.bmp = bmp;
     this.ObjectTextures = null;
 }
        /// <summary>
        /// Креира нов правоаголник со позиција на темето
        /// во горниот лев агол специфицирана со радиус векторот positionUL,
        /// темето во горниот десен агол со радиус вектор positionUR
        /// и темето во долниот лев агол со радиус вектор positionDL
        /// Притоа радиус векторот се однесува на темето кое се наоѓа во горниот лев агол.
        /// </summary>
        /// <param name="positionUL"></param>
        /// <param name="width"></param>
        /// <param name="height"></param>
        public GameRectangle(Vector2D positionUL, Vector2D positionUR, Vector2D positionDL)
        {
            this.PositionUL = new Vector2D(positionUL);
            this.PositionUR = new Vector2D(positionUR);
            this.PositionDL = new Vector2D(positionDL);

            this.Width = Math.Abs(PositionUL.X - positionUR.X);
            this.Height = Math.Abs(PositionUL.Y - positionDL.Y);
        }
        public void DrawCircle(Vector2D center, float radius, Graphics g, Color color, int frameWidth, int frameHeight)
        {
            float x = (float)center.X;
            float y = (float)center.Y;

            this.FrameWidth = frameWidth;
            this.FrameHeight = frameHeight;

            this.ToScreenCoordinates(ref x, ref y);
            radius = (float)ToScreenLength(x, y, x + radius, y);
            g.DrawEllipse(new Pen(new SolidBrush(color), 2), x - radius, y - radius, 2 * radius, 2 * radius);
        }
        public PlayerPaddle(Vector2D positionVector, int virtualGameWidth, int virutalGameHeight)
        {
            this.GameWidth = virtualGameWidth;
            this.GameHeight = virutalGameHeight;
            this.Position = new Vector2D(positionVector);
            ObjectWidth = 400;
            ObjectHeight = 85;
            Velocity = new Vector2D(0, 0);
            maxVelocity = new Vector2D(75, 0);
            maxAcceleration = new Vector2D(2, 0);

            this.InitTextures();
        }
 public GameBitmap(string relativePath, Vector2D positionUL, Vector2D positionUR, Vector2D positionDL)
 {
     long uniqueKey = 0;
     lock (lockObject)
     {
         uniqueKey = IDCounter++;
     }
     RendererCache.LoadBitmapIntoMainMemory(relativePath, uniqueKey);
     this.PositionUL = positionUL;
     this.PositionUR = positionUR;
     this.PositionDL = positionDL;
     this.UniqueKey = uniqueKey;
     this.SetDimensions();
     this.DrawLowSpec = false;
 }
        public BigBrick(Vector2D positionVector, int virtualGameWidth, int virtualGameHeight, GameBitmap bmp)
            : base(new Vector2D(positionVector), new Vector2D(positionVector.X + 220, positionVector.Y), //+ висината
            new Vector2D(positionVector.X, positionVector.Y + 100) /* + висината */ ,bmp/*slikata*/)
        {
            this.GameWidth = virtualGameWidth;
            this.GameHeight = virtualGameHeight;
            this.Position = new Vector2D(positionVector);

            ObjectWidth = 220;
            ObjectHeight = 100;
            Velocity = new Vector2D(0, 0);

            this.Health = 200;
            this.DamageEffect = 200;
            this.InitTextures();
        }
        //дечки, тоа што сте го пратиле на конструкторот
        //: base(new Vector2D(positionVector), positionVector + new Vector2D(200, 0), //+ висината
        //positionVector + new Vector2D(0, 80) /* + висината */, p)
        //тука треба да биде како што го поправив, овој + new Vector2D(100, 0) поместува
        //од горното лево теме до горното десно при што поместувањето треба
        //да биде за вектор (должина, 0), затоа тука е 100, не 200.
        public SmallBrick(Vector2D positionVector, int virtualGameWidth, int virtualGameHeight,GameBitmap bmp)
            : base(new Vector2D(positionVector), new Vector2D(positionVector.X + 100, positionVector.Y), //+ ШИРИНА (width)
            new Vector2D(positionVector.X, positionVector.Y + 100) /* + висината (height) */,bmp)
        {
            this.GameWidth = virtualGameWidth;
            this.GameHeight = virtualGameHeight;
            this.Position = new Vector2D(positionVector);

            ObjectWidth = 100;
            ObjectHeight = 100;
            Velocity = new Vector2D(0, 0);

            this.Health = 100;
            this.DamageEffect = 200;
            this.InitTextures();
        }
 public GameBitmap(Bitmap bitmap, Vector2D positionUL, Vector2D positionUR, Vector2D positionDL)
 {
     long uniqueKey = 0;
     lock (lockObject)
     {
         uniqueKey = IDCounter++;
     }
     RendererCache.SaveBitmap(uniqueKey, bitmap);
     this.UniqueKey = uniqueKey;
     this.PositionUL = positionUL;
     this.PositionUR = positionUR;
     this.PositionDL = positionDL;
     this.SetDimensions();
     this.UniqueKey = uniqueKey;
     this.DrawLowSpec = false;
 }
 /// <summary>
 /// Го ротира темето и враќа радиус вектор кон новата локација
 /// </summary>
 /// <param name="point"></param>
 /// <param name="vertexRadiusVector"></param>
 /// <returns></returns>
 private Vector2D RotateVertex(Vector2D point, Vector2D vertexRadiusVector, double angleInRadians)
 {
     Vector2D vec = vertexRadiusVector - point;
     vec.Rotate(angleInRadians);
     return point + vec;
 }
 /// <summary>
 /// Го ротира правоаголникот околу некоја точка за одреден агол
 /// </summary>
 public void RotateAroundPointDeg(Vector2D pointRadiusVector, double angleInDegrees)
 {
     this.RotateAroundPoint(pointRadiusVector, angleInDegrees * Math.PI / 180.0);
 }
        /// <summary>
        /// Враќа листа на точки на пресек или допир на права и кружница. Ако не постојат такви, тогаш
        /// оваа функција враќа празна листа.
        /// </summary>
        /// <param name="lineP1"></param>
        /// <param name="lineP2"></param>
        /// <param name="circleCenter"></param>
        /// <param name="circleRadius"></param>
        /// <returns></returns>
        public static List<Vector2D> IntersectLineCircle(Vector2D lineP1, Vector2D lineP2,
            Vector2D circleCenter, double circleRadius)
        {
            /* http://mathworld.wolfram.com/Circle-LineIntersection.html */

            lineP1 = new Vector2D(lineP1 - circleCenter);
            lineP2 = new Vector2D(lineP2 - circleCenter);

            List<Vector2D> pointsOfInteresction = new List<Vector2D>();

            double dx = lineP2.X - lineP1.X;
            double dy = lineP2.Y - lineP1.Y;
            double dr = Math.Sqrt(dx * dx + dy * dy);
            double D = lineP1.X * lineP2.Y - lineP2.X * lineP1.Y;
            double r = circleRadius;

            //точки на пресек
            if (r * r * dr * dr - D * D < 0)
                return new List<Vector2D>(); //во овој случај нема пресечни точки

            double sq = Math.Sqrt(r * r * dr * dr - D * D);
            double x = (D * dy + sgn(dy) * dx * sq) / (dr * dr);
            double y = (-D * dx + Math.Abs(dy) * sq) / (dr * dr);

            Vector2D point = new Vector2D(x, y);

            //Ако точката се наоѓа помеѓу двете точки од отсечката, тогаш е пресечна точка
            if ((point - lineP1).Magnitude() + (point - lineP2).Magnitude() <= (lineP2 - lineP1).Magnitude())
            {
                pointsOfInteresction.Add(point + circleCenter);
            }

            x = (D * dy + sgn(dy) * dx * sq) / (dr * dr);
            y = (-D * dx - Math.Abs(dy) * sq) / (dr * dr);

            point = new Vector2D(x, y);

            //Ако точката се наоѓа помеѓу двете точки од отсечката, тогаш е пресечна точка
            if ((point - lineP1).Magnitude() + (point - lineP2).Magnitude() <= (lineP2 - lineP1).Magnitude())
            {
                pointsOfInteresction.Add(point + circleCenter);
            }

            x = (D * dy - sgn(dy) * dx * sq) / (dr * dr);
            y = (-D * dx + Math.Abs(dy) * sq) / (dr * dr);

            point = new Vector2D(x, y);

            //Ако точката се наоѓа помеѓу двете точки од отсечката, тогаш е пресечна точка
            if ((point - lineP1).Magnitude() + (point - lineP2).Magnitude() <= (lineP2 - lineP1).Magnitude())
            {
                pointsOfInteresction.Add(point + circleCenter);
            }

            x = (D * dy + sgn(dy) * dx * sq) / (dr * dr);
            y = (-D * dx + Math.Abs(dy) * sq) / (dr * dr);

            point = new Vector2D(x, y);

            //Ако точката се наоѓа помеѓу двете точки од отсечката, тогаш е пресечна точка
            if ((point - lineP1).Magnitude() + (point - lineP2).Magnitude() <= (lineP2 - lineP1).Magnitude())
            {
                pointsOfInteresction.Add(point + circleCenter);
            }

            return pointsOfInteresction;
        }
 private static double Distance(Vector2D point1, Vector2D point2)
 {
     return (point2 - point1).Magnitude();
 }
 /// <summary>
 /// Претворање на должина од должина во игра на должина на екран
 /// </summary>
 public double ToScreenLength(Vector2D vec)
 {
     Vector2D vec1 = new Vector2D(0, 0);
     Vector2D vec2 = ToScreenCoordinates(vec);
     return (vec2 - vec1).Magnitude();
 }
 /// <summary>
 /// Претворање на должина од должина во игра на должина на екран
 /// </summary>
 public double ToScreenLength(double x1, double y1, double x2, double y2)
 {
     Vector2D vec1 = new Vector2D(x1, y1);
     vec1 = ToScreenCoordinates(vec1);
     Vector2D vec2 = new Vector2D(x2, y2);
     vec2 = ToScreenCoordinates(vec2);
     return (vec2 - vec1).Magnitude();
 }
 /// <summary>
 /// Ги претвора координатите од играта во координати од прозорецот
 /// </summary>
 /// <param name="vectorInGameCoordinates"></param>
 /// <returns></returns>
 public Vector2D ToScreenCoordinates(Vector2D vectorInGameCoordinates)
 {
     double x, y;
     GameUnitConversion.ConvertGameUnits(vectorInGameCoordinates.X, vectorInGameCoordinates.Y,
         out x, out y, VirtualGameWidth, VirtualGameHeight, FrameWidth, FrameHeight);
     return new Vector2D(x, y);
 }
        private void ReadKeyboardInput(IKeyState leftArrowState, IKeyState rightArrowState)
        {
            if (leftArrowState.IsPressed && rightArrowState.IsPressed)
            {
                if (Velocity.Magnitude() < maxAcceleration.Magnitude() * 1.5)
                    Velocity = new Vector2D(0, 0);
                else if (Velocity.X > 0)
                    Velocity -= 5 * maxAcceleration;
                else if (Velocity.X < 0)
                    Velocity += 5 * maxAcceleration;
            }
            else if (leftArrowState.IsPressed)
            {
                if (Velocity.X > 0)
                {
                    this.Velocity -= 5 * maxAcceleration;
                    if (this.Velocity.X < 0)
                        this.Velocity.X = 0;
                }
                else
                {
                    this.Velocity -= maxAcceleration;
                }

                if (Velocity.Magnitude() > maxVelocity.Magnitude())
                {
                    Velocity = -maxVelocity;
                }
            }
            else if (rightArrowState.IsPressed)
            {

                if (Velocity.X < 0)
                {
                    this.Velocity += 5 * maxAcceleration;
                    if (this.Velocity.X > 0)
                        this.Velocity.X = 0;
                }
                else
                {
                    this.Velocity += maxAcceleration;
                }

                if (Velocity.Magnitude() > maxVelocity.Magnitude())
                {
                    Velocity = maxVelocity;
                }
            }
            else if (!rightArrowState.IsPressed && !leftArrowState.IsPressed)
            {
                if (Velocity.Magnitude() < maxAcceleration.Magnitude())
                    Velocity = new Vector2D(0, 0);
                else if (Velocity.X > 0)
                    Velocity -= maxAcceleration;
                else if (Velocity.X < 0)
                    Velocity += maxAcceleration;
            }
        }
 private static void RotateSingleBrick(Vector2D center, IGameObject obj)
 {
     GameRectangle rotator = new GameRectangle(obj.PositionUL, obj.PositionUR, obj.PositionDL);
     rotator.RotateAroundPointDeg(center, 1);
     obj.PositionUL.X = rotator.PositionUL.X;
     obj.PositionUL.Y = rotator.PositionUL.Y;
     obj.PositionUR.X = rotator.PositionUR.X;
     obj.PositionUR.Y = rotator.PositionUR.Y;
     obj.PositionDL.X = rotator.PositionDL.X;
     obj.PositionDL.Y = rotator.PositionDL.Y;
 }
 private void ReadMouseInput(Point cursor)
 {
     Velocity = new Vector2D(cursor.X - (Position.X + Position.X + ObjectWidth) / 2.0, 0) / 11.0;
 }
        private void RotateBricks()
        {
            QuadTree<IGameObject> quadTree = this.quadtree;
            List<IGameObject> area = quadtree.Query(new RectangleF(Game.VirtualGameWidth / 2 - 300, 600, 600, 600));
            Vector2D center = new Vector2D(Game.VirtualGameWidth / 2, 900);

            if (!Game.IsMultithreadingEnabled)
            {
                foreach (IGameObject obj in area)
                {
                    if (obj.ObjectType != GameObjectType.Brick)
                        continue;

                    RotateSingleBrick(center, obj);
                }
            }
            else
            {
                //паралелен дел
                using (CountdownEvent e = new CountdownEvent(1))
                {
                    // fork work:
                    foreach (IGameObject obj in area)
                    {
                        // Dynamically increment signal count.
                        e.AddCount();
                        ThreadPool.QueueUserWorkItem(delegate(object gameObject)
                        {
                            try
                            {
                                RotateSingleBrick(center, obj);
                            }
                            finally
                            {
                                e.Signal();
                            }
                        },
                         obj);
                    }
                    e.Signal();

                    // The first element could be run on this thread.

                    // Join with work.
                    e.Wait();
                }
            }
        }
        /// <summary>
        /// Проверува дали се сечат или преклопуваат две отсечки 
        /// претставени со радиус векторите на нивните темиња.
        /// Притоа line1P1 и line1P2 се радиус вектори на двете темиња на првата отсечка,
        /// а line2P1 и line2P2 се радиус вектори на двете темиња на втората отсечка.
        /// Ако двете отсечки имаат заеднички точки ги враќа истите (не сите ако се преклопуваат),
        /// во спротивно враќа празна листа.
        /// </summary>
        public static List<Vector2D> IntersectLineSegments(Vector2D line1P1, Vector2D line1P2,
            Vector2D line2P1, Vector2D line2P2)
        {
            List<Vector2D> returnList = new List<Vector2D>();

            Vector2D p = line1P1;
            Vector2D q = line2P1;
            Vector2D r = line1P2 - line1P1;
            Vector2D s = line2P2 - line2P1;

            Vector3D crossRS = ((Vector3D)r).CrossProduct(s); //r x s
            Vector3D crossQ_PR = ((Vector3D)(q - p)).CrossProduct(r); //(q - p) x r
            Vector3D crossQ_PS = ((Vector3D)(q - p)).CrossProduct(s); //(q - p) x s

            /* Овде во коментарите * значи множење на скалар или скаларен производ, додека
             * x е векторски производ.
             */

            if (crossRS.Z != 0)
            {
                double t = crossQ_PS.Z / crossRS.Z;
                double u = crossQ_PR.Z / crossRS.Z;

                if (0 <= t && t <= 1 && 0 <= u && u <= 1)
                {
                    //заедничка точка за двете отсечки е p + t * r
                    returnList.Add(p + t * r);
                }
                else
                {
                    //инаку не се сечат
                    return returnList;
                }
            }

            if (crossRS.Z == 0)
            {
                if (crossQ_PR.Z == 0)
                {
                    //колинеарни
                    if (!(0 <= (q - p) * r && (q - p) * r <= r * r)
                        && !(0 <= (p - q) * s && (p - q) * s <= s * s))
                    {
                        //не се сечат
                        return returnList;
                    }

                    //провери дали се преклопувачки
                    double distancePQ = (q - p).Magnitude();
                    double distanceQ_PR = ((p + r) - q).Magnitude();
                    if (distancePQ + distanceQ_PR <= r.Magnitude())
                    {
                        returnList.Add(new Vector2D(q)); //Q е пресечна точка
                    }

                    double distanceP_QS = ((q + s) - p).Magnitude();
                    double distanceQS_PR = ((q + s) - (p + r)).Magnitude();
                    if (distanceP_QS + distanceQS_PR <= r.Magnitude())
                    {
                        returnList.Add(new Vector2D(q + s)); //Q + S е пресечна точка
                    }

                    //Ако не е ниту Q, ниту Q + S, тогаш имаме ваква ситуација
                    // Q______P_________P+R_________Q+S

                    returnList.Add(p);
                    returnList.Add(p + r);
                }
                else
                {
                    //не се сечат
                    return returnList;
                }
            }

            return returnList;
        }
 public GameCircle(Vector2D position, double radius)
 {
     this.Position = new Vector2D(position);
     this.Radius = radius;
 }
 private static bool IsPointOnLine(Vector2D point, Vector2D linePoint1, Vector2D linePoint2)
 {
     return point.Y == (linePoint2.Y - linePoint1.Y) / (linePoint2.X - linePoint1.X)
         * (point.X - linePoint1.X) + linePoint1.Y;
 }
 public Vector2D(Vector2D vec)
 {
     this.X = vec.X;
     this.Y = vec.Y;
 }
 /// <summary>
 /// Го ротира правоаголникот околу некоја точка за одреден агол
 /// </summary>
 /// <param name="pointRadiusVector"></param>
 public void RotateAroundPoint(Vector2D pointRadiusVector, double angleInRadians)
 {
     this.PositionUL = RotateVertex(pointRadiusVector, PositionUL, angleInRadians);
     this.PositionUR = RotateVertex(pointRadiusVector, PositionUR, angleInRadians);
     this.PositionDL = RotateVertex(pointRadiusVector, PositionDL, angleInRadians);
 }
 public static Vector2D operator -(Vector2D vec)
 {
     Vector2D temp = new Vector2D(-vec.X, -vec.Y);
     return temp;
 }
        public void OnCollisionDetected(IDictionary<IGameObject, IList<Geometry.Vector2D>> collisionArguments)
        {
            foreach (KeyValuePair<IGameObject, IList<Vector2D>> args in collisionArguments)
            {
                IGameObject collidingObject = args.Key;

                bool collisionWithSingleObject = collisionArguments.Count == 1;

                if (collisionDetectorSkipFrames > 0)
                    return;

                if (this.Velocity.Magnitude() > 0 && (args.Key.ObjectType == GameObjectType.Brick || GameObjectType.PlayerPaddle
                    == args.Key.ObjectType))
                {
                    collidingObject = args.Key;

                    //темињата се специјален случај

                    /*Vector2D argPositionDR = args.Key.PositionDL + (args.Key.PositionUR - args.Key.PositionUL);

                    //одбиј се во спротивна насока од дијагоналата
                    if (args.Value.Count == 1 && args.Value[0] == args.Key.PositionUL && collisionWithSingleObject)
                    {
                        Vector2D newVelocity = argPositionDR - args.Key.PositionUL;

                        //ми треба единечен вектор само за правецот и насоката, должината е брзината на топчето
                        newVelocity /= newVelocity.Magnitude();
                        this.Velocity = -newVelocity * this.Velocity.Magnitude();
                        break;
                    }

                    if (args.Value.Count == 1 && args.Value[0] == args.Key.PositionDL && collisionWithSingleObject)
                    {
                        Vector2D newVelocity = args.Key.PositionUR - args.Key.PositionDL;
                        newVelocity /= newVelocity.Magnitude();
                        this.Velocity = -newVelocity * this.Velocity.Magnitude();
                        break;
                    }

                    if (args.Value.Count == 1 && args.Value[0] == args.Key.PositionUR && collisionWithSingleObject)
                    {
                        Vector2D newVelocity = args.Key.PositionUR - args.Key.PositionDL;
                        newVelocity /= newVelocity.Magnitude();
                        this.Velocity = newVelocity * this.Velocity.Magnitude();
                        break;
                    }

                    if (args.Value.Count == 1 && args.Value[0] == argPositionDR && collisionWithSingleObject)
                    {
                        Vector2D newVelocity = argPositionDR - args.Key.PositionUL;
                        newVelocity /= newVelocity.Magnitude();
                        this.Velocity = newVelocity * this.Velocity.Magnitude();
                        break;
                    }*/

                    /* http://www.3dkingdoms.com/weekly/weekly.php?a=2 */

                    //најди вектор што ги поврзува првата и последната точка од судирот
                    Vector2D temp = new Vector2D(0, 0);
                    Vector2D lastPoint = null;

                    foreach (KeyValuePair<IGameObject, IList<Vector2D>> pair in collisionArguments)
                    {
                        foreach (Vector2D vec in pair.Value)
                        {
                            if (lastPoint != null)
                            {
                                temp += (vec - lastPoint);
                            }

                            lastPoint = vec;
                        }
                    }

                    //најди го нормалниот вектор на temp
                    //нормалите се (-dy, dx) и (dy, -dx)
                    Vector2D normal = new Vector2D(-temp.Y, temp.X);

                    //единечен вектор на normal
                    if (normal.Magnitude() != 0)
                        normal /= normal.Magnitude();
                    else
                    {
                        temp = args.Value[0] - args.Key.PositionUL;
                        if (temp.Magnitude() == 0)
                        {
                            temp = args.Key.PositionDL - args.Key.PositionUR;
                        }

                        normal = new Vector2D(-temp.Y, temp.X);
                        normal /= normal.Magnitude();
                    }

                    //новата брзина е
                    this.Velocity = -2 * (Velocity * normal) * normal + Velocity;

                    //овозможи играчот да ја менува насоката на топчето со тоа што ќе го удри
                    //во моментот кога paddle се движи
                    if (args.Key.ObjectType == GameObjectType.PlayerPaddle)
                    {
                        double velocityMagnitude = this.Velocity.Magnitude();
                        double x = this.Velocity.X;
                        double y = this.Velocity.Y;

                        //Единечен вектор на брзината
                        this.Velocity /= this.Velocity.Magnitude();

                        double factorSpeedX = Math.Max(0.35, Math.Abs(collidingObject.Velocity.X) / velocityMagnitude);
                        factorSpeedX *= Math.Sign(collidingObject.Velocity.X); //знакот заради насоката на брзината
                        x += velocityMagnitude * factorSpeedX;

                        //Максимална брзина по x оската да не биде поголема од 90% од вкупната брзина
                        if (Math.Abs(x) > velocityMagnitude * 0.9)
                            x = Math.Sign(x) * velocityMagnitude * 0.9;

                        y = Math.Sign(Velocity.Y) * Math.Sqrt(velocityMagnitude * velocityMagnitude - x * x);
                        Velocity.X = x;
                        Velocity.Y = y;

                        this.collisionDetectorSkipFrames = 5;
                    }
                }
            }

            //throw new NotImplementedException();
        }
        public void OnUpdate(long gameElapsedTime)
        {
            Vector2D oldPosition = this.Position;

            //ако брзината е 0, тогаш топчето се наоѓа врз paddle и
            //мора да се помести за да остане врз него
            if (this.Velocity.Magnitude() == 0)
            {
                this.Position += playerPaddle.PositionChange;
            }

            this.Position += Velocity;

            IKeyState leftMouseKey = KeyStateInfo.GetAsyncKeyState(Keys.LButton);
            if (this.Velocity.Magnitude() < 0.001 && leftMouseKey.IsPressed
                && GameArkanoid.GetInstance().CursorIngameCoordinates.X >= 5
                && GameArkanoid.GetInstance().CursorIngameCoordinates.Y >= 5
                && GameArkanoid.GetInstance().CursorIngameCoordinates.X < GameArkanoid.GetInstance().VirtualGameWidth - 5
                && GameArkanoid.GetInstance().CursorIngameCoordinates.Y < GameArkanoid.GetInstance().VirtualGameHeight - 5)
            {
                //најди ја средната точка на paddle
                Vector2D middlePoint = playerPaddle.Position + new Vector2D(playerPaddle.ObjectWidth / 2, 0)
                    + new Vector2D(0, playerPaddle.ObjectHeight / 2);

                //стартувај под агол кој ќе зависи од средната точка на paddle
                Vector2D velocityAngle = this.Position - middlePoint;
                velocityAngle /= velocityAngle.Magnitude();

                this.Velocity = velocityAngle * 18;

                collisionDetectorSkipFrames = 3;
            }

            if (this.Position.Y < this.Radius + 5 || this.Position.Y > GameArkanoid.GetInstance().VirtualGameHeight - Radius - 5)
            {
                this.Velocity.Y = -this.Velocity.Y;

                if (this.Position.Y > playerPaddle.PositionDL.Y)
                {
                    this.Health = 0;
                }

                //ако е надвор од прозорецот врати го назад
                if (this.Position.Y < this.Radius + 5)
                    this.Position.Y = Radius + 5;
                else if (this.Position.Y > GameArkanoid.GetInstance().VirtualGameHeight - Radius - 5)
                    this.Position.Y = GameArkanoid.GetInstance().VirtualGameHeight - Radius - 5;
            }
            else if (this.Position.X < this.Radius + 5 || this.Position.X > GameArkanoid.GetInstance().VirtualGameWidth - Radius - 5)
            {
                this.Velocity.X = -this.Velocity.X;

                if (this.Position.X < Radius + 5)
                    this.Position.X = Radius + 5;
                else if (this.Position.X > GameArkanoid.GetInstance().VirtualGameWidth - Radius - 5)
                    this.Position.X = GameArkanoid.GetInstance().VirtualGameWidth - Radius - 5;
            }

            //Најди го векторот на поместување
            PositionChange = this.Position - oldPosition;

            //Направи транслација на темињата на сликата
            ObjectTextures[0].PositionUL += PositionChange;
            ObjectTextures[0].PositionDL += PositionChange;
            ObjectTextures[0].PositionUR += PositionChange;

            textureRotator.PositionUL = ObjectTextures[0].PositionUL;
            textureRotator.PositionDL = ObjectTextures[0].PositionDL;
            textureRotator.PositionUR = ObjectTextures[0].PositionUR;

            //ротација на текстурата (анимација дека се движи топчето и околу себе)
            //ротација за +5 степени
            textureRotator.RotateAroundPointDeg(this.Position, 5);

            ObjectTextures[0].PositionUL = textureRotator.PositionUL;
            ObjectTextures[0].PositionDL = textureRotator.PositionDL;
            ObjectTextures[0].PositionUR = textureRotator.PositionUR;

            collisionDetectorSkipFrames = Math.Max(collisionDetectorSkipFrames - 1, 0);
        }
 public Vector3D(Vector2D vec)
 {
     this.X = vec.X;
     this.Y = vec.Y;
     this.Z = 0;
 }
        public GameBitmapKey(long uniqueName, Vector2D positionUL, Vector2D positionUR, Vector2D positionDL)
        {
            this.positionUL = positionUL;
            this.positionUR = positionUR;
            this.positionDL = positionDL;

            this.uniqueKey = uniqueName;
        }