protected override void Initialize()
 {
     camera = new Camera(GraphicsDevice.Viewport);
     base.Initialize();
 }
        //Metoda odpowiedzialna za kolizję, obroty i sam wyścig
        public void Update(GameTime gameTime, Camera camera)
        {
            if (Keyboard.GetState().IsKeyDown(Keys.Escape))
            {
                this.Exit();
            }
            //Odliczanie rozpoczęte
            if (clock.isRunning == false)
            {
                clock.start(3);
                //Gdy zegar odlicza porusznie zablokowane

                //Odpowiednie położenie mapy
                Matrix mapTransform = Matrix.CreateTranslation(new Vector3(backgroundPosition, 0.0f));

                //Odpowiednie ustawienie pierwsego AI
                Matrix firstAiTransform = Matrix.CreateTranslation(new Vector3(-firstAiOrigin, 0.0f)) *
                                          Matrix.CreateRotationZ(firstAi.rotation) *
                                          Matrix.CreateTranslation(new Vector3(firstAi.position, 0.0f));
                //Odpowiednie ustawienie drugiego AI
                Matrix secondAiTransform = Matrix.CreateTranslation(new Vector3(-secondAiOrigin, 0.0f)) *
                                           Matrix.CreateRotationZ(secondAi.rotation) *
                                           Matrix.CreateTranslation(new Vector3(secondAi.position, 0.0f));
                //Odpowiednie ustawienie gracza
                Matrix playerTransform = Matrix.CreateTranslation(new Vector3(-playerOrigin, 0.0f)) *
                                         Matrix.CreateRotationZ(playerRotation) *
                                         Matrix.CreateTranslation(new Vector3(playerPosition, 0.0f));
                //Wyliczenie odpowiednie położenie prostokąta w którym jest umieszczona tekstura
                playerRectangle = Collisions.CalculateBoundingRectangle(new Rectangle(0, 0, playerTexture.Width, playerTexture.Height), playerTransform);

                //Centralna część tekstury gracza
                playerOrigin = new Vector2(playerRectangle.Width / 2, playerRectangle.Height / 2);

                //Wyliczenie odpowiednie położenie prostokąta w którym jest umieszczona tekstura dla pierszego AI
                firstAiRectangle = Collisions.CalculateBoundingRectangle(new Rectangle(0, 0, firstAiTexture.Width, firstAiTexture.Height), firstAiTransform);

                //Centralna część tekstury pierwszego AI
                firstAiOrigin = new Vector2(firstAiRectangle.Width / 2, firstAiRectangle.Height / 2);

                //Wyliczenie odpowiednie położenie prostokąta w którym jest umieszczona tekstura dla drugiego AI
                secondAiRectangle = Collisions.CalculateBoundingRectangle(new Rectangle(0, 0, secondAiTexture.Width, secondAiTexture.Height), secondAiTransform);

                //Centralna część tekstury pierwszego AI
                secondAiOrigin = new Vector2(secondAiRectangle.Width / 2, secondAiRectangle.Height / 2);

                //Prostokąt dla mapy
                mapRectangle = new Rectangle((int)backgroundPosition.X, (int)backgroundPosition.Y, backgroundTexture.Width, backgroundTexture.Height);

                firstAi.CalculatePosition(backgroundTexture);
                secondAi.CalculatePosition(backgroundTexture);
                camera.Update(gameTime, playerPosition, playerRectangle);

            }
            else if (lap > maxlap || firstAi.lap > maxlap || secondAi.lap > maxlap)
            {
                ; // Nie robimy nic, gdy wyścig został wygrany
            }
            else if (clock.isFinished == true)
            {
                //Gdy zegar skończy odliczać start wyścigu
                //Cześć zmiennych jest taka sama jak powyżej ponieważ odpowiada tylko za przedstawienie mapy, gracza, AI podczas odliczania do rozpoczęcia
                // wyścigu
                Matrix mapTransform = Matrix.CreateTranslation(new Vector3(backgroundPosition, 0.0f));

                Matrix firstAiTransform = Matrix.CreateTranslation(new Vector3(-firstAiOrigin, 0.0f)) *
                                          Matrix.CreateRotationZ(firstAi.rotation) *
                                          Matrix.CreateTranslation(new Vector3(firstAi.position, 0.0f));

                Matrix secondAiTransform = Matrix.CreateTranslation(new Vector3(-secondAiOrigin, 0.0f)) *
                                           Matrix.CreateRotationZ(secondAi.rotation) *
                                           Matrix.CreateTranslation(new Vector3(secondAi.position, 0.0f));

                Matrix playerTransform = Matrix.CreateTranslation(new Vector3(-playerOrigin, 0.0f)) *
                                         Matrix.CreateRotationZ(playerRotation) *
                                         Matrix.CreateTranslation(new Vector3(playerPosition, 0.0f));

                playerRectangle = Collisions.CalculateBoundingRectangle(new Rectangle(0, 0, playerTexture.Width, playerTexture.Height), playerTransform);
                playerOrigin = new Vector2(playerRectangle.Width / 2, playerRectangle.Height / 2);

                firstAiRectangle = Collisions.CalculateBoundingRectangle(new Rectangle(0, 0, firstAiTexture.Width, firstAiTexture.Height), firstAiTransform);
                firstAiOrigin = new Vector2(firstAiRectangle.Width / 2, firstAiRectangle.Height / 2);

                secondAiRectangle = Collisions.CalculateBoundingRectangle(new Rectangle(0, 0, secondAiTexture.Width, secondAiTexture.Height), secondAiTransform);
                secondAiOrigin = new Vector2(secondAiRectangle.Width / 2, secondAiRectangle.Height / 2);

                mapRectangle = new Rectangle((int)backgroundPosition.X, (int)backgroundPosition.Y, backgroundTexture.Width, backgroundTexture.Height);

                //Dalsza część
                //Poruszanie do przodu uwzględniając rotację
                if (this.playerCollision)
                {
                    if (playerVelocity.X > -0.5 && playerVelocity.X < 0.5 && playerVelocity.Y > -0.5 && playerVelocity.Y < 0.5)
                    {
                        this.playerCollision = false;
                    }
                    else
                    {
                        playerVelocity *= 1 - friction;
                    }
                }
                else if (Keyboard.GetState().IsKeyDown(Keys.Up))
                {
                    //Obroty samochodu
                    if (Keyboard.GetState().IsKeyDown(Keys.Right)) playerRotation += 0.05f;
                    if (Keyboard.GetState().IsKeyDown(Keys.Left)) playerRotation -= 0.05f;
                    playerVelocity.X = (float)Math.Cos(playerRotation) * playerTangentialVelocity;
                    playerVelocity.Y = (float)Math.Sin(playerRotation) * playerTangentialVelocity;
                }
                else if (playerVelocity != Vector2.Zero)
                {
                    playerVelocity *= 1 - friction;
                }

                // Kolizja z przeciwnikiem za pomocą metody Per Piksel Collision
                if (firstAiRectangle.Intersects(playerRectangle))
                {
                    //Jeśli zaszła kolizja
                    if (Collisions.IntersectPixels(firstAiTransform, firstAiTexture.Width, firstAiTexture.Height, firstAiTextureData, playerTransform, playerTexture.Width, playerTexture.Height, playerTextureData))
                    {
                        //Odbicie od przeciwnika po współrzędnej X i Y pod odpowiednim kątem
                        playerVelocity.X = -playerVelocity.X;
                        playerVelocity.Y = -playerVelocity.Y;
                        this.playerCollision = true;
                    }
                }
                if (secondAiRectangle.Intersects(playerRectangle))
                {
                    //Jeśli zaszła kolizja
                    if (Collisions.IntersectPixels(secondAiTransform, secondAiTexture.Width, secondAiTexture.Height, secondAiTextureData, playerTransform, playerTexture.Width, playerTexture.Height, playerTextureData))
                    {
                        //Odbicie od przeciwnika po współrzędnej X i Y pod odpowiednim kątem
                        playerVelocity.X = -playerVelocity.X;
                        playerVelocity.Y = -playerVelocity.Y;
                        this.playerCollision = true;
                    }
                }
                //Kolizja przeciwnika pierwszego z autem gracza
                if (playerRectangle.Intersects(firstAiRectangle))
                {
                    //Jeśli zaszła kolizja
                    if (Collisions.IntersectPixels(playerTransform, playerTexture.Width, playerTexture.Height, playerTextureData, firstAiTransform, firstAiTexture.Width, firstAiTexture.Height, firstAiTextureData))
                    {
                        //Wykrywanie kierunku w jakim porusza się gracz i wzależności od tego odbicie od drugiego pojazdu po odpowiedniej współrzędnej
                        if (playerDestination == Dest.East)
                        {
                            //Jak jedziemy w kierunku wchodnim zmiana następuje po współrzędnej X
                            float tmp = (playerVelocity.X + (float)1);
                            playerVelocity.X = (playerVelocity.X + tmp);
                            this.playerCollision = true;
                        }
                        if (playerDestination == Dest.South)
                        {
                            //Jak jedziemy w kierunku południowym zmiana nastepuje po współrzędnej Y
                            float tmp = (playerVelocity.Y - (float)1);
                            playerVelocity.Y = (playerVelocity.Y + tmp);
                            this.playerCollision = true;
                        }
                        if (playerDestination == Dest.West)
                        {
                            //Jak jedziemy w kierunku zachodnim zmiana nastepuje po współrzędnej X
                            float tmp = (playerVelocity.X - (float)1);
                            playerVelocity.X = (playerVelocity.X + tmp);
                            this.playerCollision = true;
                        }
                        if (playerDestination == Dest.North)
                        {
                            //Jak jedziemy w kierunku północnym zmiana nastepuje w po współrzędnej Y
                            float tmp = (playerVelocity.Y + (float)1);
                            playerVelocity.Y = (playerVelocity.Y + tmp);
                            this.playerCollision = true;
                        }
                    }
                }

                //Kolizja przeciwnika drugiego z autem gracza
                if (playerRectangle.Intersects(secondAiRectangle))
                {
                    //Jeśli kolizja jest wykryta
                    if (Collisions.IntersectPixels(playerTransform, playerTexture.Width, playerTexture.Height, playerTextureData, secondAiTransform, secondAiTexture.Width, secondAiTexture.Height, secondAiTextureData))
                    {
                        //Wykrywanie kierunku w jakim porusza się gracz i wzależności od tego odbicie od drugiego pojazdu po odpowiedniej współrzędnej
                        if (playerDestination == Dest.East)
                        {
                            //Jak jedziemy w kierunku wchodnim zmiana następuje po współrzędnej X
                            float tmp = (playerVelocity.X + (float)1);
                            playerVelocity.X = (playerVelocity.X + tmp);
                            this.playerCollision = true;
                        }
                        if (playerDestination == Dest.South)
                        {
                            //Jak jedziemy w kierunku południowym zmiana nastepuje po współrzędnej Y
                            float tmp = (playerVelocity.Y - (float)1);
                            playerVelocity.Y = (playerVelocity.Y + tmp);
                            this.playerCollision = true;
                        }
                        if (playerDestination == Dest.West)
                        {
                            //Jak jedziemy w kierunku zachodnim zmiana nastepuje po współrzędnej X
                            float tmp = (playerVelocity.X - (float)1);
                            playerVelocity.X = (playerVelocity.X + tmp);
                            this.playerCollision = true;
                        }
                        if (playerDestination == Dest.North)
                        {
                            //Jak jedziemy w kierunku północnym zmiana nastepuje w po współrzędnej Y
                            float tmp = (playerVelocity.Y + (float)1);
                            playerVelocity.Y = (playerVelocity.Y + tmp);
                            this.playerCollision = true;
                        }
                    }
                }

                //Kolizja auta gracza z bandami
                if (Collisions.Intersect(playerTransform, playerTexture.Width, playerTexture.Height, playerTextureData, mapTransform, backgroundTexture.Width, backgroundTexture.Height, mapTextureData))
                {
                    //Odbicie pod odpowiednim kątem po współrzędnych X i Y
                    playerVelocity.X = -playerVelocity.X;
                    playerVelocity.Y = -playerVelocity.Y;
                    this.playerCollision = true;
                }
                //Wykrywanie kierunku poruszania sięsamochodu
                float round = (float)Math.Round(playerRotation, 4);
                float sround = (float)(Math.Round(Math.Sin(round), 4));
                float cround = (float)(Math.Round(Math.Cos(round), 4));
                if ((sround >= 0.5 && sround <= 1) && (cround >= -0.5 && cround <= 0.5))
                {
                    playerDestination = Dest.South;
                }
                else if ((sround <= -0.5 && sround >= -1) && (cround >= -0.5 && cround <= 0.5))
                {
                    playerDestination = Dest.North;
                }
                else if ((sround >= -0.5 && sround <= 0.5) && (cround >= 0.5 && cround <= 1))
                {
                    playerDestination = Dest.East;
                }
                else if ((sround >= -0.5 && sround <= 0.5) && (cround <= -0.5 && cround >= -1))
                {
                    playerDestination = Dest.West;
                }

                playerPosition = (playerVelocity + playerPosition);

                Color[] c = new Color[1];
                backgroundTexture.GetData(0, new Rectangle((int)playerPosition.X + 400, (int)playerPosition.Y, 1, 1), c, 0, c.Length);
                Color black = new Color(43, 42, 41);
                Color white = new Color(254, 254, 254);
                if (c[0] == black || c[0] == white)
                {
                    lapChange = true;
                }
                else
                {
                    if (lapChange && (DateTime.Now.Subtract(lastLapChange) > TimeSpan.FromSeconds(1)))
                    {
                        lastLapChange = DateTime.Now;
                        lap++;
                    }
                    lapChange = false;
                }

                firstAi.CalculatePosition(backgroundTexture);
                secondAi.CalculatePosition(backgroundTexture);
                camera.Update(gameTime, playerPosition, playerRectangle);
            }
            else
            {
                clock.checkTime(gameTime);
            }
            base.Update(gameTime);
        }