usunięcie zduplikowanego wpisu

CMakeLists.txt

@@ -44,6 +44,8 @@ add_executable(LotoStatek main.cpp
         sources/Heart.cpp
         headers/PowerUp.h
         sources/PowerUp.cpp
+        sources/Boss.cpp
+        headers/Boss.h
 )
 
 if(WIN32)

headers/Boss.h

@@ -0,0 +1,72 @@
+#ifndef BOSS_H
+#define BOSS_H
+
+#include "Actor.h"
+#include "Bullet.h"
+#include "Beam.h"
+#include <vector>
+#include <SFML/Graphics.hpp>
+
+enum class BossDirection {
+    Up,
+    Down,
+    Left,
+    Right
+};
+
+class Boss : public Actor {
+public:
+    Boss(int x, int y, const sf::Texture &bossTexture, const sf::Texture &bulletTexture, sf::Texture BombaTexture,
+     sf::RenderWindow *window);
+
+    void setPlanszaHeight(int height, int width);
+
+    void moveLeft() override;
+    void moveRight() override;
+    void moveUp() override;
+    void moveDown() override;
+
+
+
+    void shoot() override;
+    void dropBomb();
+    void shootLaser();
+    void move(float deltaX, float deltaY) override;
+    void update();
+    void takeDamage();
+    bool isAlive() const;
+    std::vector<Bullet>& getBullets() { return bullets; }
+    std::vector<Bullet>& getBombs() { return bombs; }
+    bool isShooting() const { return laserBeam != nullptr; }
+    Beam* getBeam() const { return laserBeam; }
+
+private:
+    float movementSpeed = 5.5f;
+    BossDirection direction = BossDirection::Down;
+
+    sf::Clock shootClock;
+    sf::Clock bombClock;
+    sf::Clock laserClock;
+    sf::Clock directionClock;
+    sf::Clock beamDurationClock;
+    float beamDuration = 1.0f;
+
+    sf::Texture bulletTexture;
+    sf::Texture BombaTexture;
+    sf::Texture beamTexture;
+    sf::RenderWindow* window;
+    Beam* laserBeam = nullptr;
+
+    std::vector<Bullet> bullets;
+    std::vector<Bullet> bombs;
+
+    int planszaHeight = 800;
+    int planszaWidth = 600;
+
+    bool isStationary = false;
+
+    void setRandomDirection();
+    void handleBounds();
+};
+
+#endif // BOSS_H

headers/Plansza.h

@@ -17,6 +17,7 @@
 #include "Heart.hpp"
 #include "PowerUp.h"
 #include "Size.h"
+#include "Boss.h"
 
 enum ships{
     nova,
@@ -36,27 +37,38 @@ public:
     void update_meteors();
     void update_hearts();
     void update_power_ups();
+
+
     void update();
     void update_score();
+
+    void check_PowerUp_collisions();
+    void check_Heart_collisions();
+    void check_Meteor_collisions();
+
     void spawn_player();
     void spawn_enemy();
     void spawn_advanced_enemy();
     void spawn_wiazkowiec();
+
+    void spawn_boss();
+
     void spawn_bomber();
     void spawn_kamikadze();
     ~Plansza() {
-        delete ship; // usuwanie wskaźnika ship
+        delete ship;
+        delete boss;
     }
 
     static ships selectedShip;
     static unsigned int score;
+    sf::Font font;
 private:
     Background background;
     AudioManager audioManager;
     Player *ship;
     Size size;
     sf::RenderWindow *window;
-    sf::Font font;
     sf::Clock meteorSpawnClock;
     sf::Clock heartSpawnClock;
     sf::Clock powerUpSpawnClock;
@@ -79,6 +91,7 @@ private:
     sf::Texture advancedEnemyTexture;
     sf::Texture BomberEnemyTexture;
     sf::Texture BombaTexture;
+    sf::Texture BossTexture;
     sf::Texture KamikadzeTexture;
     sf::Texture WiazkowiecTexture;
     sf::Texture WiazkaTexture;
@@ -98,7 +111,11 @@ private:
     std::vector<Heart> hearts;
     std::vector<sf::Sprite> heartStats;
     std::vector<PowerUp> powerUps;
+    Boss* boss = nullptr;          // Wskaźnik na bossa
+    sf::Clock bossSpawnClock;      // Zegar do spawnowania bossa
+    bool bossSpawned = false;      // Flaga informująca, czy boss został już zespawnowany
     bool gameOver = false;
+    unsigned int nextBossScoreThreshold = 1; // Próg punktowy dla spawnu bossa
 };
 
 #endif //PLANSZA_H

main.cpp

@@ -19,6 +19,7 @@ int main() {
     icon.loadFromFile("../assets/img/icon/ikonka.png");
     mainWindow.setIcon(128, 128, icon.getPixelsPtr());
 
+    bool isPaused = false;
 
     Plansza plansza(mainWindow.getSize().y, mainWindow.getSize().x, &mainWindow, selectedShip);
 
@@ -32,9 +33,27 @@ int main() {
                 mainWindow.close();
         }
 
-        plansza.update();
 
-        mainWindow.display();
+        // Obsługa pauzy
+        if (event.key.code == sf::Keyboard::P) {
+            isPaused = !isPaused;
+
+            sf::RectangleShape bg(sf::Vector2f(mainWindow.getSize().x, mainWindow.getSize().y));
+            bg.setFillColor(sf::Color(0,0,0,100));
+            sf::Text text("PAUZA", plansza.font, 50);
+            text.setOrigin(text.getLocalBounds().getSize().x/2, text.getLocalBounds().getSize().y/2);
+            text.setFillColor(sf::Color::White);
+            text.setPosition(mainWindow.getSize().x/2, mainWindow.getSize().y/2);
+            plansza.update();
+            mainWindow.draw(bg);
+            mainWindow.draw(text);
+            mainWindow.display();
+        }
+
+        if (!isPaused) { // jesli nie spauzowane to graj
+            plansza.update();
+            mainWindow.display();
+        }
     }
 
     return 0;
@@ -121,6 +140,9 @@ void menu() {
                 menuWindow.close();
                 exit(-2);
             }
+            if (sf::Keyboard::isKeyPressed(sf::Keyboard::Enter)) {
+                menuWindow.close();
+            }
 
             if (event.type == sf::Event::MouseButtonPressed) {
                 if (event.mouseButton.button == sf::Mouse::Left) {

sources/Boss.cpp

@@ -0,0 +1,188 @@
+#include "../headers/Boss.h"
+#include <random>
+#include <iostream>
+#include "../headers/RandomNumberGenerator.h"
+
+Boss::Boss(int x, int y, const sf::Texture& bossTexture, const sf::Texture& bulletTexture, const sf::Texture BombaTexture, sf::RenderWindow* window)
+    : Actor(x, y, bossTexture), bulletTexture(bulletTexture), BombaTexture(BombaTexture), window(window) {
+    try {
+        beamTexture.loadFromFile("../assets/img/wiazka/laser.png");
+    } catch (std::exception& e) {
+        std::cerr << "Failed to load textures: " << e.what() << std::endl;
+        exit(-500);
+    }
+    hp = 100;
+    firerate = 2000;
+    movementSpeed = 2.0f;
+
+}
+
+void Boss::setPlanszaHeight(int height, int width) {
+    planszaHeight = height;
+    planszaWidth = width;
+}
+
+// TODO: Po mergowaniu dodać obsługę pocisku, przy pomocy nowego konstruktora Bullet
+void Boss::shoot() {
+    if (shootClock.getElapsedTime().asMilliseconds() >= firerate) {
+        Bullet leftBullet(position.x - 20, position.y, bulletTexture);
+        leftBullet.setSpeed(5.0f);
+        Bullet centerBullet(position.x, position.y, bulletTexture);
+        centerBullet.setSpeed(5.0f);
+        Bullet rightBullet(position.x + 20, position.y, bulletTexture);
+        rightBullet.setSpeed(5.0f);
+        bullets.push_back(std::move(leftBullet));
+        bullets.push_back(std::move(centerBullet));
+        bullets.push_back(std::move(rightBullet));
+        std::cout << "Strzal lezy" << std::endl;
+        shootClock.restart();
+    }
+}
+
+void Boss::dropBomb() {
+    if (bombClock.getElapsedTime().asMilliseconds() >= 5000) {
+        Bullet Bomb(position.x, position.y, BombaTexture);
+        Bomb.setSpeed(0.5f);
+        bombs.emplace_back(std::move(Bomb)); // Można zmienić na bombę
+        std::cout << "Bombka lezy" << std::endl;
+        bombClock.restart();
+    }
+}
+
+void Boss::shootLaser() {
+    if (!laserBeam && laserClock.getElapsedTime().asSeconds() >= 5.0f) {
+        laserBeam = new Beam(position.x, position.y, beamTexture);
+        beamDurationClock.restart();
+        laserClock.restart();
+        isStationary = true;
+    }
+
+    if (laserBeam) {
+        window->draw(laserBeam->getSprite());
+        std::cout << "Laser beam shooted" << std::endl;
+
+        if (beamDurationClock.getElapsedTime().asSeconds() >= beamDuration) {
+            delete laserBeam;
+            laserBeam = nullptr;
+            isStationary = false;
+        }
+    }
+}
+
+
+void Boss::move(float deltaX, float deltaY) {
+    if (deltaX == 0 && deltaY == 0) {
+        std::cerr << "Boss stopped: deltaX and deltaY are both 0" << std::endl;
+    }
+    actorSprite.move(deltaX, deltaY);
+    position.x += static_cast<int>(deltaX);
+    position.y += static_cast<int>(deltaY);
+    handleBounds();
+}
+
+void Boss::update() {
+    std::cout << "Current movementSpeed: " << movementSpeed << std::endl;
+    std::cout << "Boss position: (" << position.x << ", " << position.y << "), Direction: " << static_cast<int>(direction) << std::endl;
+
+    if (!isStationary) {
+        if (directionClock.getElapsedTime().asSeconds() >= 3.0f) {
+            setRandomDirection();
+            directionClock.restart();
+        }
+
+        switch (direction) {
+            case BossDirection::Up: moveUp(); break;
+            case BossDirection::Down: moveDown(); break;
+            case BossDirection::Left: moveLeft(); break;
+            case BossDirection::Right: moveRight(); break;
+        }
+    }
+
+    shoot();
+    dropBomb();
+    shootLaser();
+
+    // Aktualizacja pocisków
+    for (auto it = bullets.begin(); it != bullets.end();) {
+        it->update();
+        window->draw(it->getSprite());
+        if (it->isOutOfBounds()) {
+            it = bullets.erase(it);
+        } else {
+            ++it;
+        }
+    }
+
+    // Aktualizacja bomb
+    for (auto it = bombs.begin(); it != bombs.end();) {
+        it->update();
+        window->draw(it->getSprite());
+        if (it->isOutOfBounds()) {
+            it = bombs.erase(it);
+        } else {
+            ++it;
+        }
+    }
+}
+
+void Boss::moveLeft() {
+    move(-movementSpeed, 0.0f);
+}
+
+void Boss::moveRight() {
+    move(movementSpeed, 0.0f);
+}
+
+void Boss::moveUp() {
+    move(0.0f, -movementSpeed);
+}
+
+void Boss::moveDown() {
+    move(0.0f, movementSpeed);
+}
+
+
+
+void Boss::takeDamage() {
+    if (--hp <= 0) {
+        hp = 0;
+        std::cout << "HP bossa" << hp << std::endl;
+    }
+}
+
+bool Boss::isAlive() const {
+    return hp > 0;
+}
+
+void Boss::setRandomDirection() {
+    BossDirection previousDirection = direction;
+    do {
+        int randomValue = RandomNumberGenerator::getRandomNumber(0, 3);
+        direction = static_cast<BossDirection>(randomValue);
+    } while (
+        (direction == BossDirection::Left && position.x <= 0) ||
+        (direction == BossDirection::Right && position.x >= 600) ||
+        (direction == BossDirection::Up && position.y <= 0) ||
+        (direction == BossDirection::Down && position.y >= 800)
+    );
+    if (previousDirection == direction) {
+        std::cerr << "Boss kept the same direction: " << static_cast<int>(direction) << std::endl;
+    }
+}
+
+
+
+void Boss::handleBounds() {
+    if (position.x < 0) {
+        direction = BossDirection::Right;
+    } else if (position.x > 600 - actorSprite.getGlobalBounds().width) {
+        direction = BossDirection::Left;
+    }
+
+    if (position.y < 0) {
+        direction = BossDirection::Down;
+    } else if (position.y > 800 - actorSprite.getGlobalBounds().height) {
+        direction = BossDirection::Up;
+    }
+}
+

sources/Plansza.cpp

@@ -36,6 +36,8 @@ Plansza::Plansza(unsigned int windowHeight, unsigned int windowWidth, sf::Render
         KamikadzeTexture.loadFromFile("../assets/img/enemy/kamikadze.png");
         BombaTexture.loadFromFile("../assets/img/bullets/bomba.png");
         WiazkowiecTexture.loadFromFile("../assets/img/enemy/wiazkowiec.png");
+        enemyBulletTexture.loadFromFile("../assets/img/bullets/enemy_bullet.png");
+        BossTexture.loadFromFile("../assets/img/boss/boss.png");
     } catch (std::exception &e) {
         std::cerr << "Failed to load textures: " << e.what() << std::endl;
         exit(-500);
@@ -72,7 +74,7 @@ Plansza::Plansza(unsigned int windowHeight, unsigned int windowWidth, sf::Render
 
 // TODO: Refactor tej metody bo rozrosła się za bardzo już
 void Plansza::update() {
-    srand(time(0));
+    srand(time(0)); // generacja innego ziarna na podstawie zegara systemowego
     // tło
     background.update();
     background.draw(*window);
@@ -109,18 +111,18 @@ void Plansza::update() {
         // audioManager.playSoundEffect("shoot_alt", 70.f); // Odtworzenie dźwięku dla alternatywnego strzału
     }
 
-    // generowanie nowego meteoru
     ship->update(); // migotanie statku
     update_score(); // naliczanie punktów
     // Sprawnowanie wszystkich rodzajów wrogów
-    // spawn_meteor();
-    // spawn_hearts();
+    spawn_meteor();
+    spawn_hearts();
     spawn_power_up();
-    // spawn_enemy();
-    // spawn_advanced_enemy();
-    // spawn_wiazkowiec();
-    // spawn_bomber();
-    // spawn_kamikadze();
+  //  spawn_enemy();
+ //   spawn_advanced_enemy();
+  //  spawn_wiazkowiec();
+  //  spawn_bomber();
+  //  spawn_kamikadze();
+    spawn_boss();
 
     // utrzymanie meteorów i pocisków w ruchu
     for (auto &meteor: meteors) {
@@ -156,44 +158,9 @@ void Plansza::update() {
 
     window->draw(ship->getSprite());
 
-    for (auto &meteor: meteors) {
-        if (ship->getSprite().getGlobalBounds().intersects(meteor.getSprite().getGlobalBounds())) {
-            ship->takeDamage();
-        }
-    }
-
-    for (auto heartIt = hearts.begin(); heartIt != hearts.end();) {
-        if (ship->getSprite().getGlobalBounds().intersects(heartIt->getSprite().getGlobalBounds())) {
-            ship->healUP();
-            heartIt = hearts.erase(heartIt);
-        } else {
-            ++heartIt;
-        }
-    }
-
-    // TODO: Dodać obsługę kilku różnych power-upów
-
-    ////////////////////////////////////////////////////////////////////////////////////////////////
-    // Sprawdzenie kolizji z power-upem na prędkość poruszania się i zwiększenie prędkości statku
-    for (auto powerUpIt = powerUps.begin(); powerUpIt != powerUps.end();) {
-        if (ship->getSprite().getGlobalBounds().intersects(powerUpIt->getSprite().getGlobalBounds())) {
-            if (powerUpIt->getType() == PowerUp::movingSpeedUp) {
-                ship->setMovingSpeed(15.0f);
-                movingSpeedPUTimer.restart();
-            }
-            if (powerUpIt->getType() == PowerUp::firerateUp) {
-                ship->setFirerate(100);
-                fireratePUTimer.restart();
-            }
-            if (powerUpIt->getType() == PowerUp::tripleShotUp) {
-                ship->setTripleShot(true);
-                tripleShotPUTimer.restart();
-            }
-            powerUpIt = powerUps.erase(powerUpIt);
-        } else {
-            ++powerUpIt;
-        }
-    }
+    check_Meteor_collisions();
+    check_Heart_collisions();
+    check_PowerUp_collisions();
 
     if (movingSpeedPUTimer.getElapsedTime().asSeconds() >= 5.0f) {
         ship->setMovingSpeed(8.0f);
@@ -204,43 +171,6 @@ void Plansza::update() {
     if (tripleShotPUTimer.getElapsedTime().asSeconds() >= 5.0f) {
         ship->setTripleShot(false);
     }
-    ///////////////////////////////Koniec obsługi kolizji z power-upami//////////////////////////////
-    ////////////////////////////////////////////////////////////////////////////////////////////////
-
-    for (auto meteorIt = getMeteors().begin(); meteorIt != getMeteors().end();) {
-        bool meteorHit = false;
-        for (auto rocketIt = ship->getBullets().begin(); rocketIt != ship->getBullets().end();) {
-            if (meteorIt->getSprite().getGlobalBounds().intersects(rocketIt->getSprite().getGlobalBounds())) {
-                ship->getBullets().erase(rocketIt);
-                meteorIt = getMeteors().erase(meteorIt);
-                meteorHit = true;
-                break;
-            } else {
-                ++rocketIt;
-            }
-        }
-        if (!meteorHit) {
-            ++meteorIt;
-        }
-    }
-
-    for (auto meteorIt = getMeteors().begin(); meteorIt != getMeteors().end();) {
-        bool meteorHit = false;
-        for (auto rocketIt = ship->getRockets().begin(); rocketIt != ship->getRockets().end();) {
-            if (meteorIt->getSprite().getGlobalBounds().intersects(rocketIt->getSprite().getGlobalBounds())) {
-                ship->getRockets().erase(rocketIt);
-                meteorIt = getMeteors().erase(meteorIt);
-                meteorHit = true;
-                break;
-            } else {
-                ++rocketIt;
-            }
-        }
-        if (!meteorHit) {
-            ++meteorIt;
-        }
-    }
-
 
     if (gameOver) {
         sf::RenderWindow errorWindow(sf::VideoMode(350, 200), "The end");
@@ -305,6 +235,40 @@ void Plansza::update() {
         }
     }
 
+    for (auto meteorIt = getMeteors().begin(); meteorIt != getMeteors().end();) {
+        bool meteorHit = false;
+        for (auto bulletIt = ship->getBullets().begin(); bulletIt != ship->getBullets().end();) {
+            if (meteorIt->getSprite().getGlobalBounds().intersects(bulletIt->getSprite().getGlobalBounds())) {
+                ship->getBullets().erase(bulletIt);
+                meteorIt = getMeteors().erase(meteorIt);
+                meteorHit = true;
+                break;
+            } else {
+                ++bulletIt;
+            }
+        }
+        if (!meteorHit) {
+            ++meteorIt;
+        }
+    }
+
+    for (auto meteorIt = getMeteors().begin(); meteorIt != getMeteors().end();) {
+        bool meteorHit = false;
+        for (auto rocketIt = ship->getRockets().begin(); rocketIt != ship->getRockets().end();) {
+            if (meteorIt->getSprite().getGlobalBounds().intersects(rocketIt->getSprite().getGlobalBounds())) {
+                ship->getRockets().erase(rocketIt);
+                meteorIt = getMeteors().erase(meteorIt);
+                meteorHit = true;
+                break;
+            } else {
+                ++rocketIt;
+            }
+        }
+        if (!meteorHit) {
+            ++meteorIt;
+        }
+    }
+
     // Ruch i render przeciwnika
     for (auto it = enemies.begin(); it != enemies.end();) {
         it->update();  // Aktualizacja kierunku i ruchu
@@ -403,6 +367,107 @@ void Plansza::update() {
         }
     }
 
+    // Aktualizacja bossa
+    if (boss && boss->isAlive()) {
+        boss->update();
+        window->draw(boss->getSprite());
+
+        // Kolizje bossa z pociskami
+        for (auto bulletIt = ship->getBullets().begin(); bulletIt != ship->getBullets().end();) {
+            if (boss->getSprite().getGlobalBounds().intersects(bulletIt->getSprite().getGlobalBounds())) {
+                boss->takeDamage();
+                bulletIt = ship->getBullets().erase(bulletIt);
+            } else {
+                ++bulletIt;
+            }
+        }
+
+        for (auto rocketIt = ship->getRockets().begin(); rocketIt != ship->getRockets().end();) {
+            if (boss->getSprite().getGlobalBounds().intersects(rocketIt->getSprite().getGlobalBounds())) {
+                boss->takeDamage();
+                rocketIt = ship->getRockets().erase(rocketIt);
+                std::cout << "Rocket hit boss! Boss HP: " << boss->getHP() << std::endl;
+            } else {
+                ++rocketIt;
+            }
+        }
+
+        // Kolizja bossa z graczem
+        // if (ship->getSprite().getGlobalBounds().intersects(boss->getSprite().getGlobalBounds())) {
+        //     ship->takeDamage();
+        // }
+    } else if (bossSpawned && (!boss || !boss->isAlive())) {
+        std::cout << "Boss defeated!" << std::endl;
+        delete boss;
+        boss = nullptr;
+        bossSpawned = false; // Resetowanie flagi, jeśli boss został pokonany
+    }
+
+    // Obsługa pocisków bossa
+    if (boss && boss->isAlive()) {
+        for (auto it = boss->getBullets().begin(); it != boss->getBullets().end();) {
+            if (ship->getSprite().getGlobalBounds().intersects(it->getSprite().getGlobalBounds())) {
+                ship->takeDamage();
+                it = boss->getBullets().erase(it); // Usuwanie pocisku po trafieniu
+            } else {
+                ++it;
+            }
+        }
+
+        // Obsługa bomb bossa
+        for (auto it = boss->getBombs().begin(); it != boss->getBombs().end();) {
+            if (ship->getSprite().getGlobalBounds().intersects(it->getSprite().getGlobalBounds())) {
+                ship->takeDamage();
+                it = boss->getBombs().erase(it); // Usuwanie bomby po trafieniu
+            } else {
+                ++it;
+            }
+        }
+
+
+        if (boss->isShooting() && boss->getBeam() != nullptr) {
+            if (ship->getSprite().getGlobalBounds().intersects(boss->getBeam()->getSprite().getGlobalBounds())) {
+                ship->takeDamage(); // Gracz otrzymuje obrażenia
+            }
+        }
+
+        // Sprawdzenie kolizji pocisków gracza z bombami Bossa
+        for (auto bombIt = boss->getBombs().begin(); bombIt != boss->getBombs().end();) {
+            bool bombHit = false;
+            for (auto bulletIt = ship->getBullets().begin(); bulletIt != ship->getBullets().end();) {
+                if (bombIt->getSprite().getGlobalBounds().intersects(bulletIt->getSprite().getGlobalBounds())) {
+                    ship->getBullets().erase(bulletIt);
+                    bombIt = boss->getBombs().erase(bombIt);
+                    bombHit = true;
+                    break;
+                } else {
+                    ++bulletIt;
+                }
+            }
+            if (!bombHit) {
+                ++bombIt;
+            }
+        }
+
+        // Sprawdzenie kolizji rakiet gracza z bombami Bossa
+        for (auto bombIt = boss->getBombs().begin(); bombIt != boss->getBombs().end();) {
+            bool bombHit = false;
+            for (auto rocketIt = ship->getRockets().begin(); rocketIt != ship->getRockets().end();) {
+                if (bombIt->getSprite().getGlobalBounds().intersects(rocketIt->getSprite().getGlobalBounds())) {
+                    ship->getRockets().erase(rocketIt);
+                    bombIt = boss->getBombs().erase(bombIt);
+                    bombHit = true;
+                    break;
+                } else {
+                    ++rocketIt;
+                }
+            }
+            if (!bombHit) {
+                ++bombIt;
+            }
+        }
+    }
+
 
     for (auto &enemy: enemies) {
         enemy.shoot();
@@ -442,6 +507,7 @@ void Plansza::update() {
         }
     }
 
+
     for (auto &bomberEnemy: BEnemies) {
         for (auto it = bomberEnemy.getBullets().begin(); it != bomberEnemy.getBullets().end();) {
             bool bulletDestroyed = false;
@@ -769,8 +835,8 @@ void Plansza::update_power_ups() {
 }
 
 void Plansza::spawn_meteor() {
-    if (meteorSpawnClock.getElapsedTime().asSeconds() > rand() % 10 + 1) { // randomowy spawn meteorytów od 10 do 1 sekundy
-        if (meteors.size() < 5) { // jeśli jest mniej niż 5 meteorów na planszy
+    if (meteorSpawnClock.getElapsedTime().asSeconds() > rand() % 30 + 5) { // randomowy spawn meteorytów od 10 do 1 sekundy
+        if (meteors.size() < 3) { // jeśli jest mniej niż 5 meteorów na planszy
             if (rand() % 2 == 1) {
                 meteors.emplace_back(RandomNumberGenerator::getRandomNumber(50, 499), -100, meteorTexture2);
             } else {
@@ -829,7 +895,7 @@ void Plansza::spawn_enemy() {
 }
 
 void Plansza::spawn_advanced_enemy() {
-    if (AenemySpawnClock.getElapsedTime().asSeconds() >= 20) { // Spawn co 10 sekund
+    if (AenemySpawnClock.getElapsedTime().asSeconds() >= 8) { // Spawn co 10 sekund
         int spawnX = RandomNumberGenerator::getRandomNumber(50, size.width - 50);
         AEnemies.emplace_back(spawnX, -50, advancedEnemyTexture, enemyBulletTexture);
         std::cout << "Spawned Advanced Enemy at X: " << spawnX << std::endl;
@@ -838,7 +904,7 @@ void Plansza::spawn_advanced_enemy() {
 }
 
 void Plansza::spawn_bomber() {
-    if (BomberSpawnClock.getElapsedTime().asSeconds() >= 30) { // Spawn co 10 sekund
+    if (BomberSpawnClock.getElapsedTime().asSeconds() >= 5) { // Spawn co 10 sekund
         int spawnX = RandomNumberGenerator::getRandomNumber(50, size.width - 50);
         Bomber bomber(spawnX, -50, BomberEnemyTexture, BombaTexture);
         bomber.setPlanszaHeight(size.height, size.width); // Przekazanie wysokości i szerokości okna
@@ -858,7 +924,7 @@ void Plansza::spawn_kamikadze() {
 }
 
 void Plansza::spawn_wiazkowiec() {
-    if (WiazkowiecSpawnClock.getElapsedTime().asSeconds() >= 50) { // Spawn co 10 sekund
+    if (WiazkowiecSpawnClock.getElapsedTime().asSeconds() >= 3) { // Spawn co 10 sekund
         if (WEnemies.size() < 1) {
             int spawnX = RandomNumberGenerator::getRandomNumber(50, size.width - 50);
             Wiazkowiec wiazkowiec(spawnX, -50, WiazkowiecTexture, window);
@@ -870,6 +936,17 @@ void Plansza::spawn_wiazkowiec() {
     }
 }
 
+void Plansza::spawn_boss() {
+    if (!bossSpawned && score >= nextBossScoreThreshold) { // Spawn po 60 sekundach
+        boss = new Boss(size.width / 2, -100, BossTexture, enemyBulletTexture, BombaTexture, window);
+        boss->setPlanszaHeight(size.width, size.height);
+        bossSpawned = true;
+        nextBossScoreThreshold += 1000;
+        std::cout << "Boss spawned at score: " << score << std::endl;
+    }
+}
+
+
 Size Plansza::getSize() {
     return size;
 }
@@ -890,5 +967,47 @@ void Plansza::update_score() {
     window->draw(text);
 }
 
+void Plansza::check_PowerUp_collisions() {
+    for (auto powerUpIt = powerUps.begin(); powerUpIt != powerUps.end();) {
+        if (ship->getSprite().getGlobalBounds().intersects(powerUpIt->getSprite().getGlobalBounds())) {
+            if (powerUpIt->getType() == PowerUp::movingSpeedUp) {
+                ship->setMovingSpeed(15.0f);
+                movingSpeedPUTimer.restart();
+            }
+            if (powerUpIt->getType() == PowerUp::firerateUp) {
+                ship->setFirerate(100);
+                fireratePUTimer.restart();
+            }
+            if (powerUpIt->getType() == PowerUp::tripleShotUp) {
+                ship->setTripleShot(true);
+                tripleShotPUTimer.restart();
+            }
+            powerUpIt = powerUps.erase(powerUpIt);
+        } else {
+            ++powerUpIt;
+        }
+    }
+}
+
+void Plansza::check_Heart_collisions() {
+    for (auto heartIt = hearts.begin(); heartIt != hearts.end();) {
+        if (ship->getSprite().getGlobalBounds().intersects(heartIt->getSprite().getGlobalBounds())) {
+            ship->healUP();
+            heartIt = hearts.erase(heartIt);
+        } else {
+            ++heartIt;
+        }
+    }
+}
+
+void Plansza::check_Meteor_collisions() {
+    for (auto &meteor: meteors) {
+        if (ship->getSprite().getGlobalBounds().intersects(meteor.getSprite().getGlobalBounds())) {
+            ship->takeDamage();
+        }
+    }
+}
+
 ships Plansza::selectedShip = none;
-unsigned int Plansza::score = 0;
+unsigned int Plansza::score = 0;
+