adjust timings

Do dokończenia resetowanie debuff

CMakeLists.txt

@@ -42,6 +42,10 @@ add_executable(LotoStatek main.cpp
         sources/Beam.cpp
         headers/Heart.hpp
         sources/Heart.cpp
+        headers/PowerUp.h
+        sources/PowerUp.cpp
+        headers/Debuff.h
+        sources/Debuff.cpp
 )
 
 if(WIN32)

README.md

@@ -1 +1,11 @@
-Tu będzie lotoł statek
+The space-invaders type game created for university project.
+The main character is a "Ship", with which you are fighting enemies that have different abilities, for example laser beams or "Kamikaze" that will try to explode at you. 
+Your character has only 3 HP that are showed in right upper corner.
+
+
+There are 5 different types of enemies: 
+1. The simpliest one - just shoots you with one bullet
+2. The advanced enemy - shoots you with the same bullet, but shooted 3 at the one piece of time
+3. The "Kamikaze" will explode at you once reaches you, dealing 2 hp damage.
+4. The Laser enemy will shoot you with laser beam both sideways and up and down direction, dealing 1 hp damage.
+5. The bomber - will leave bombs all around map which will deal 1 hp damage once exploded.

headers/Bullet.h

@@ -5,7 +5,10 @@
 
 class Bullet : public Projectile {
 public:
-    Bullet(float x, float y, sf::Texture &texture) : Projectile(x,y, texture) {};
+    Bullet(float x, float y, sf::Texture &texture);
+
+    Bullet(float x, float y, sf::Texture &texture, float speed);
+
     void update() override;
 };
 

headers/Debuff.h

@@ -0,0 +1,24 @@
+#ifndef DEBUFF_H
+#define DEBUFF_H
+#include "ObjectItem.hpp"
+
+class Debuff : public ObjectItem {
+public:
+    enum Type {
+        movingSpeedDbf,
+        firerateDbf,
+        bulletSpeedDbf
+    };
+    Debuff(float x, float y, sf::Texture &texture, Type type);
+
+    void update() override;
+
+    Type getType() const {
+        return type_;
+    }
+
+private:
+    Type type_;
+};
+
+#endif //DEBUFF_H

headers/Heart.hpp

@@ -6,7 +6,7 @@
 
 class Heart : public ObjectItem {
 public:
-    Heart(float x, float y, sf::Texture &texture);
+    Heart(float x, float y, sf::Texture &texture_);
     void update() override;
 };
 

headers/ObjectItem.hpp

@@ -7,6 +7,7 @@
 
 class ObjectItem {
 public:
+    virtual ~ObjectItem() = default;
     ObjectItem(float x, float y, sf::Texture &texture);
     sf::Sprite &getSprite();
     bool getStatus();

headers/Plansza.h

@@ -15,6 +15,8 @@
 #include "AudioManager.h"
 #include "Plansza.h"
 #include "Heart.hpp"
+#include "PowerUp.h"
+#include "Debuff.h"
 #include "Size.h"
 
 enum ships{
@@ -31,10 +33,22 @@ public:
     std::vector<Meteor> &getMeteors();
     void spawn_meteor();
     void spawn_hearts();
+    void spawn_power_up();
+    void spawn_debuff();
     void update_meteors();
     void update_hearts();
+    void update_power_ups();
+    void update_debuffs();
+
+
     void update();
     void update_score();
+
+    void check_PowerUp_collisions();
+    void check_Heart_collisions();
+    void check_Meteor_collisions();
+    void check_Debuff_collisions();
+
     void spawn_player();
     void spawn_enemy();
     void spawn_advanced_enemy();
@@ -47,16 +61,28 @@ public:
 
     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;
+    // Timers
+    sf::Clock movingSpeedPUTimer;
+    sf::Clock fireratePUTimer;
+    sf::Clock tripleShotPUTimer;
+    sf::Clock movingSpeedDebuffTimer;
+    sf::Clock firerateDebuffTimer;
+    sf::Clock bulletSpeedDebuffTimer;
+
+    // Zegary
     sf::Clock meteorSpawnClock;
     sf::Clock heartSpawnClock;
-    sf::Clock spawnClock;
+    sf::Clock powerUpSpawnClock;
+    sf::Clock debuffSpawnClock;
+    // sf::Clock spawnClock;
     sf::Clock scoreClock;
     sf::Clock shooterSpawnClock;
     sf::Clock enemySpawnClock;
@@ -64,6 +90,8 @@ private:
     sf::Clock BomberSpawnClock;
     sf::Clock KamikadzeSpawnClock;
     sf::Clock WiazkowiecSpawnClock;
+
+    //Textury
     sf::Texture playerTexture;
     sf::Texture playerBulletTexture;
     sf::Texture playerRocketTexture;
@@ -79,6 +107,14 @@ private:
     sf::Texture meteorTexture2;
     sf::Texture heartTexture;
     sf::Texture heartTextureGray;
+    sf::Texture movingSpeedPowerUpTexture;
+    sf::Texture fireratePowerUpTexture;
+    sf::Texture tripleShotPowerUpTexture;
+    sf::Texture movingSpeedDebuffTexture;
+    sf::Texture firerateDebuffTexture;
+    sf::Texture bulletSpeedDebuffTexture;
+
+    // Tablice
     std::vector<Enemy> enemies;
     std::vector<AdvancedEnemy> AEnemies;
     std::vector<Bomber> BEnemies;
@@ -87,7 +123,21 @@ private:
     std::vector<Meteor> meteors;
     std::vector<Heart> hearts;
     std::vector<sf::Sprite> heartStats;
+    std::vector<PowerUp> powerUps;
+    std::vector<Debuff> debuffs;
+
+    // Zmienne prymitywne
     bool gameOver = false;
+    struct {
+        bool movingSpeed = false;
+        bool firerate = false;
+        bool tripleShot = false;
+    } powerUpCollected;
+    struct {
+        bool movingSpeed = false;
+        bool firerate = false;
+        bool bulletSpeed = false;
+    } debuffCollected;
 };
 
 #endif //PLANSZA_H

headers/Player.h

@@ -29,6 +29,8 @@ public:
     void moveUp() override;
     void moveDown() override;
     void takeDamage();
+    void setTripleShot(bool toogle);
+    void setBulletSpeed(float speed);
 
     void update();
     std::vector<Rocket>& getRockets();
@@ -43,7 +45,9 @@ private:
     sf::Color originalColor;
     sf::Clock immortalityClock;       // Zegar kontrolujący czas nieśmiertelności
     float immortalityDuration = 1.5f; // Czas trwania nieśmiertelności w sec
+    float bulletSpeed = 10.0f;         // prędkość pocisku
     bool isImmortal = false;           // flaga na immortal
+    bool tripleShot = false;           // flaga na potrójny strzał
 };
 
 

headers/PowerUp.h

@@ -0,0 +1,25 @@
+#ifndef POWERUP_H
+#define POWERUP_H
+#include "ObjectItem.hpp"
+
+class PowerUp : public ObjectItem {
+public:
+    enum Type {
+        movingSpeedUp,
+        firerateUp,
+        tripleShotUp
+    };
+
+    PowerUp(float x, float y, sf::Texture &texture, Type type);
+
+    void update() override;
+
+    Type getType() const {
+        return type_;
+    }
+
+private:
+    Type type_;
+};
+
+#endif //POWERUP_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/Bullet.cpp

@@ -1,5 +1,11 @@
 #include "../headers/Bullet.h"
 
+Bullet::Bullet(float x, float y, sf::Texture &texture): Projectile(x,y, texture) {}
+
+Bullet::Bullet(float x, float y, sf::Texture &texture, float speed): Projectile(x,y, texture) {
+    this->speed = -speed;
+}
+
 void Bullet::update() {
     //std::cout << "Start update: speed = " << speed << ", position.y = " << position.y << std::endl;
     sprite.move(0.0f, speed);

sources/Debuff.cpp

@@ -0,0 +1,21 @@
+#include "../headers/Debuff.h"
+
+Debuff::Debuff(float x, float y, sf::Texture &texture, Type type) : ObjectItem(x, y, texture) {
+    position.x = x;
+    position.y = y;
+    texture_ = texture;
+    sprite.setTexture(texture);
+    sprite.setOrigin(sprite.getLocalBounds().width / 2, sprite.getLocalBounds().height / 2); // wycentrowanie sprite
+    sprite.setScale(0.5f, 0.5f);
+    sprite.setPosition(x, y);
+    movingSpeed = 3.0f;
+    this->type_ = type;
+}
+
+void Debuff::update() {
+    sprite.move(0.0f, movingSpeed); // przesunięcie sprajta
+    position.y += int(movingSpeed); // przesunięcie pozycji
+    if(position.y > 900) {
+        outOfBounds = true; // jeżeli wyszedł poza granice ekranu ustaw tą zmienną
+    }
+}

sources/Heart.cpp

@@ -1,13 +1,11 @@
 #include "../headers/Heart.hpp"
 
 Heart::Heart(float x, float y, sf::Texture &texture) : ObjectItem(x,y,texture) {
-    outOfBounds = false;
-    texture = texture;
-    sprite.setTexture(texture);
+    texture_ = texture;
+    sprite.setTexture(texture_);
     sprite.setOrigin(sprite.getLocalBounds().width / 2, sprite.getLocalBounds().height / 2); // wycentrowanie sprite
     sprite.setPosition(x, y);
     movingSpeed = 3.0f;
-//    sprite.scale(0.05f, 0.05f);
     position.x = x;
     position.y = y;
     rotationSpeed = 0;
@@ -16,7 +14,6 @@ Heart::Heart(float x, float y, sf::Texture &texture) : ObjectItem(x,y,texture) {
 void Heart::update() {
     sprite.move(0.0f, movingSpeed); // przesunięcie sprajta
     position.y += int(movingSpeed); // przesunięcie pozycji
-//    sprite.rotate(rotationSpeed); // obracanie tym meteorkiem pięknym
     if(position.y > 900) {
         outOfBounds = true; // jeżeli wyszedł poza granice ekranu ustaw tą zmienną
     }

sources/Meteor.cpp

@@ -1,7 +1,6 @@
 #include "../headers/Meteor.h"
 
 Meteor::Meteor(float x, float y, sf::Texture &texture) : ObjectItem(x, y, texture) {
-    outOfBounds = false;
     texture_ = texture;
     sprite.setTexture(texture);
     sprite.setOrigin(sprite.getLocalBounds().width / 2, sprite.getLocalBounds().height / 2); // wycentrowanie sprite

sources/ObjectItem.cpp

@@ -1,6 +1,7 @@
 #include "../headers/ObjectItem.hpp"
 
 ObjectItem::ObjectItem(float x, float y, sf::Texture &texture) {
+    outOfBounds = false;
     Position position_ = {0,0};
     position_.x = static_cast<int>(x);
     position_.y = static_cast<int>(y);

sources/Plansza.cpp

@@ -21,8 +21,17 @@ Plansza::Plansza(unsigned int windowHeight, unsigned int windowWidth, sf::Render
         } else {
             playerTexture.loadFromFile("../assets/ship/Dreadnought-Base.png");
         }
+        // Ładowanie tekstur itemów
         meteorTexture1.loadFromFile("../assets/img/meteors/meteor-1.png");
         meteorTexture2.loadFromFile("../assets/img/meteors/meteor-2.png");
+        heartTexture.loadFromFile("../assets/img/hearts/heart.png");
+        heartTextureGray.loadFromFile("../assets/img/hearts/heart_gray.png");
+        movingSpeedPowerUpTexture.loadFromFile("../assets/img/powerups/movingSpeedPU.png");
+        fireratePowerUpTexture.loadFromFile("../assets/img/powerups/fireratePU.png");
+        tripleShotPowerUpTexture.loadFromFile("../assets/img/powerups/TripleShotPU.png");
+        movingSpeedDebuffTexture.loadFromFile("../assets/img/debuffs/movingSpeedDBF.png");
+        firerateDebuffTexture.loadFromFile("../assets/img/debuffs/firerateDBF.png");
+        bulletSpeedDebuffTexture.loadFromFile("../assets/img/debuffs/BulletSpeedDBF.png");
         // Ładowanie tekstur wrogów
         enemyTexture.loadFromFile("../assets/img/enemy/enemy.png");
         advancedEnemyTexture.loadFromFile("../assets/img/enemy/advanced_enemy.png");
@@ -50,12 +59,6 @@ Plansza::Plansza(unsigned int windowHeight, unsigned int windowWidth, sf::Render
     audioManager.loadSoundEffect("shoot_alt", "../assets/sounds/shoot_alt.ogg");
     audioManager.loadSoundEffect("fail", "../assets/sounds/fail.mp3");
 
-    meteorTexture1.loadFromFile("../assets/img/meteors/meteor-1.png");
-    meteorTexture2.loadFromFile("../assets/img/meteors/meteor-2.png");
-
-    heartTexture.loadFromFile("../assets/img/hearts/heart.png");
-    heartTextureGray.loadFromFile("../assets/img/hearts/heart_gray.png");
-
     heartStats.emplace_back(heartTexture);
     heartStats.emplace_back(heartTexture);
     heartStats.emplace_back(heartTexture);
@@ -64,14 +67,17 @@ Plansza::Plansza(unsigned int windowHeight, unsigned int windowWidth, sf::Render
     heartStats[2].setPosition(495, 10);
 
     meteorSpawnClock.restart();
+    powerUpSpawnClock.restart();
+    debuffSpawnClock.restart();
     spawn_player();
 
-    spawnClock.restart();
+    // spawnClock.restart();
 }
 
 // TODO: Refactor tej metody bo rozrosła się za bardzo już
 void Plansza::update() {
-// tło
+    srand(time(0)); // generacja innego ziarna na podstawie zegara systemowego
+    // tło
     background.update();
     background.draw(*window);
 
@@ -100,22 +106,23 @@ void Plansza::update() {
     // TODO: Przenieść obiekt dźwięku wewnątrz klasy Bullet
     if (sf::Mouse::isButtonPressed(sf::Mouse::Left)) {
         ship->shoot();
-        audioManager.playSoundEffect("shoot", 70.f); // Odtworzenie dźwięku wystrzału
+        // audioManager.playSoundEffect("shoot", 70.f); // Odtworzenie dźwięku wystrzału
     }
     if (sf::Mouse::isButtonPressed(sf::Mouse::Right)) {
         ship->alternate_shoot();
-        audioManager.playSoundEffect("shoot_alt", 70.f); // Odtworzenie dźwięku dla alternatywnego strzału
+        // 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_power_up();
+    spawn_debuff();
     // spawn_enemy();
     // spawn_advanced_enemy();
-    spawn_wiazkowiec();
+    // spawn_wiazkowiec();
     // spawn_bomber();
     // spawn_kamikadze();
 
@@ -130,6 +137,16 @@ void Plansza::update() {
         window->draw(heart.getSprite());
     }
 
+    for (auto &powerUp: powerUps) {
+        powerUp.update();
+        window->draw(powerUp.getSprite());
+    }
+
+    for (auto &debuff: debuffs) {
+        debuff.update();
+        window->draw(debuff.getSprite());
+    }
+
     for (auto &bullet: ship->getBullets()) {
         bullet.update();
         window->draw(bullet.getSprite());
@@ -143,59 +160,43 @@ void Plansza::update() {
     // Sprawdzenie, czy meteory i pociski są poza granicami ekranu
     update_meteors();
     update_hearts();
+    update_power_ups();
+    update_debuffs();
     ship->updateBullets();
 
     window->draw(ship->getSprite());
 
-    for (auto &meteor: meteors) {
-        if (ship->getSprite().getGlobalBounds().intersects(meteor.getSprite().getGlobalBounds())) {
-            ship->takeDamage();
-        }
-    }
+    check_Meteor_collisions();
+    check_Heart_collisions();
+    check_PowerUp_collisions();
+    check_Debuff_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;
-        }
-    }
 
-    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;
-        }
+    // TODO: Dodać flagę aby warunek był sprawdzany nie tylko pod kątem Timeru ale również pod kątem ustawionej flagi
+    if (movingSpeedPUTimer.getElapsedTime().asSeconds() >= 5.0f && powerUpCollected.movingSpeed) {
+        powerUpCollected.movingSpeed = false;
+        ship->setMovingSpeed(8.0f);
     }
-
-    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 (fireratePUTimer.getElapsedTime().asSeconds() >= 10.0f && powerUpCollected.firerate) {
+        powerUpCollected.firerate = false;
+        ship->setFirerate(200);
+    }
+    if (tripleShotPUTimer.getElapsedTime().asSeconds() >= 5.0f && powerUpCollected.tripleShot) {
+        powerUpCollected.tripleShot = false;
+        ship->setTripleShot(false);
+    }
+    if (movingSpeedDebuffTimer.getElapsedTime().asSeconds() >= 5.0f && debuffCollected.movingSpeed) {
+        debuffCollected.movingSpeed = false;
+        ship->setMovingSpeed(8.0f);
+    }
+    if (firerateDebuffTimer.getElapsedTime().asSeconds() >= 5.0f && debuffCollected.firerate) {
+        debuffCollected.firerate = false;
+        ship->setFirerate(200);
+    }
+    if (bulletSpeedDebuffTimer.getElapsedTime().asSeconds() >= 5.0f && debuffCollected.bulletSpeed) {
+        debuffCollected.bulletSpeed = false;
+        ship->setBulletSpeed(10.0f);
     }
-
 
     if (gameOver) {
         sf::RenderWindow errorWindow(sf::VideoMode(350, 200), "The end");
@@ -260,6 +261,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
@@ -697,7 +732,6 @@ void Plansza::update() {
 }
 // Meteor-related niżej
 
-
 void Plansza::update_meteors() {
     // usuwanie meteorów, które wyleciały poza ekran
     for (auto &meteor: meteors) {
@@ -707,9 +741,34 @@ void Plansza::update_meteors() {
     }
 }
 
+void Plansza::update_hearts() {
+    // usuwanie serduszek, które wyleciały poza ekran
+    for (auto& heart : hearts) {
+        if(heart.getStatus()) {
+            hearts.erase(hearts.begin());
+        }
+    }
+}
+
+void Plansza::update_power_ups() {
+    for (auto& power : powerUps) {
+        if(power.getStatus()) {
+            powerUps.erase(powerUps.begin());
+        }
+    }
+}
+
+void Plansza::update_debuffs() {
+    for (auto& debuff : debuffs) {
+        if(debuff.getStatus()) {
+            debuffs.erase(debuffs.begin());
+        }
+    }
+}
+
 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 {
@@ -721,14 +780,55 @@ void Plansza::spawn_meteor() {
 }
 
 void Plansza::spawn_hearts() {
-    if (heartSpawnClock.getElapsedTime().asSeconds() > rand() % 26 + 5) { // randomowy spawn meteorytów od 5 do 30 sekundy
-        if (hearts.size() < 5) { // jeśli jest mniej niż 5 meteorów na planszy
+    if (heartSpawnClock.getElapsedTime().asSeconds() > rand() % 26 + 5) { // randomowy spawn serduszek od 5 do 30 sekundy
+        if (hearts.size() < 5) { // jeśli jest mniej niż 5 serduszek na planszy
              hearts.emplace_back(RandomNumberGenerator::getRandomNumber(50, 499), -100, heartTexture);
         }
         heartSpawnClock.restart();
     }
 }
 
+void Plansza::spawn_power_up() {
+    if (powerUpSpawnClock.getElapsedTime().asSeconds() > 15) {
+        if (powerUps.size() < 2) {
+            auto powerUpRand = rand() % 3;
+            switch (powerUpRand) {
+                case 0:
+                    powerUps.emplace_back(RandomNumberGenerator::getRandomNumber(50, 499), -100, movingSpeedPowerUpTexture, PowerUp::movingSpeedUp);
+                    break;
+                case 1:
+                    powerUps.emplace_back(RandomNumberGenerator::getRandomNumber(50, 499), -100, fireratePowerUpTexture, PowerUp::firerateUp);
+                    break;
+                case 2:
+                    powerUps.emplace_back(RandomNumberGenerator::getRandomNumber(50,499), -100, tripleShotPowerUpTexture, PowerUp::tripleShotUp);
+                    break;
+            }
+
+
+        }
+        powerUpSpawnClock.restart();
+    }
+}
+
+void Plansza::spawn_debuff() {
+    if (debuffSpawnClock.getElapsedTime().asSeconds() > 30) {
+        if (debuffs.size() < 1) {
+            switch (rand() % 3) {
+                case 0:
+                    debuffs.emplace_back(RandomNumberGenerator::getRandomNumber(50, 499), -100, movingSpeedDebuffTexture, Debuff::movingSpeedDbf);
+                    break;
+                case 1:
+                    debuffs.emplace_back(RandomNumberGenerator::getRandomNumber(50, 499), -100, firerateDebuffTexture, Debuff::firerateDbf);
+                    break;
+                case 2:
+                    debuffs.emplace_back(RandomNumberGenerator::getRandomNumber(50,499), -100, bulletSpeedDebuffTexture, Debuff::bulletSpeedDbf);
+                    break;
+            }
+        }
+        debuffSpawnClock.restart();
+    }
+}
+
 void Plansza::spawn_player() {
     ship = Player::getInstance(static_cast<int>(window->getSize().x) / 2, static_cast<int>(window->getSize().y) - 100, this->playerTexture);
     ship->loadTexture();
@@ -776,7 +876,7 @@ void Plansza::spawn_kamikadze() {
 }
 
 void Plansza::spawn_wiazkowiec() {
-    if (WiazkowiecSpawnClock.getElapsedTime().asSeconds() >= 5) { // Spawn co 10 sekund
+    if (WiazkowiecSpawnClock.getElapsedTime().asSeconds() >= 50) { // Spawn co 10 sekund
         if (WEnemies.size() < 1) {
             int spawnX = RandomNumberGenerator::getRandomNumber(50, size.width - 50);
             Wiazkowiec wiazkowiec(spawnX, -50, WiazkowiecTexture, window);
@@ -788,16 +888,6 @@ void Plansza::spawn_wiazkowiec() {
     }
 }
 
-
-void Plansza::update_hearts() {
-    // usuwanie serduszek, które wyleciały poza ekran
-    for (auto& heart : hearts) {
-        if(heart.getStatus()) {
-            hearts.erase(hearts.begin());
-        }
-    }
-}
-
 Size Plansza::getSize() {
     return size;
 }
@@ -806,7 +896,6 @@ std::vector<Meteor> &Plansza::getMeteors() {
     return meteors;
 }
 
-// TODO: naliczanie punktów za zabicie wrogów
 void Plansza::update_score() {
     if (scoreClock.getElapsedTime().asMilliseconds() > 500) {
         score++;
@@ -819,5 +908,75 @@ 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);
+                powerUpCollected.movingSpeed = true;
+                movingSpeedPUTimer.restart();
+            }
+            if (powerUpIt->getType() == PowerUp::firerateUp) {
+                ship->setFirerate(100);
+                powerUpCollected.firerate = true;
+                fireratePUTimer.restart();
+            }
+            if (powerUpIt->getType() == PowerUp::tripleShotUp) {
+                ship->setTripleShot(true);
+                powerUpCollected.tripleShot = true;
+                tripleShotPUTimer.restart();
+            }
+            powerUpIt = powerUps.erase(powerUpIt);
+        } else {
+            ++powerUpIt;
+        }
+    }
+}
+
+void Plansza::check_Debuff_collisions() {
+    for (auto debuffIt = debuffs.begin(); debuffIt != debuffs.end();) {
+        if (ship->getSprite().getGlobalBounds().intersects(debuffIt->getSprite().getGlobalBounds())) {
+            if (debuffIt->getType() == Debuff::movingSpeedDbf) {
+                ship->setMovingSpeed(4.0f);
+                debuffCollected.movingSpeed = true;
+                movingSpeedDebuffTimer.restart();
+            }
+            if (debuffIt->getType() == Debuff::firerateDbf) {
+                ship->setFirerate(500);
+                debuffCollected.firerate = true;
+                firerateDebuffTimer.restart();
+            }
+            if (debuffIt->getType() == Debuff::bulletSpeedDbf) {
+                ship->setBulletSpeed(5.0f);
+                debuffCollected.bulletSpeed = true;
+                bulletSpeedDebuffTimer.restart();
+            }
+            debuffIt = debuffs.erase(debuffIt);
+        } else {
+            ++debuffIt;
+        }
+    }
+}
+
+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;

sources/Player.cpp

@@ -1,11 +1,11 @@
-#include "../headers/Player.h"
-
 #include <iostream>
 #include <SFML/Graphics/Font.hpp>
-#include <SFML/Graphics/Text.hpp>
 
+#include "../headers/Player.h"
 #include "../headers/Plansza.h"
 
+
+
 Player::Player(int x, int y, const sf::Texture& texture) : Actor(x, y, texture) {
     hp = 3;
     if(Plansza::selectedShip != none) {
@@ -36,8 +36,16 @@ void Player::loadTexture() {
 void Player::shoot() {
     auto now = std::chrono::steady_clock::now();
     if (std::chrono::duration_cast<std::chrono::milliseconds>(now - lastShotTime).count() >= firerate) {
-        bullets.emplace_back(position.x, position.y, bulletTexture);
-        lastShotTime = now;
+        if (tripleShot == true) {
+            bullets.emplace_back(position.x - 40, position.y, bulletTexture, bulletSpeed);
+            bullets.emplace_back(position.x, position.y, bulletTexture, bulletSpeed);
+            bullets.emplace_back(position.x + 40, position.y, bulletTexture, bulletSpeed);
+            lastShotTime = now;
+        }
+        if (tripleShot == false) {
+            bullets.emplace_back(position.x, position.y, bulletTexture, bulletSpeed);
+            lastShotTime = now;
+        }
     }
 }
 
@@ -79,6 +87,10 @@ void Player::takeDamage() {
     }
 }
 
+void Player::setTripleShot(bool toogle) {
+    tripleShot = toogle;
+}
+
 void Player::setFirerate(unsigned int firerate) {
     this->firerate = firerate;
 }
@@ -111,4 +123,9 @@ std::vector<Rocket> &Player::getRockets() {
     return rockets;
 }
 
+void Player::setBulletSpeed(float speed) {
+    this->bulletSpeed = speed;
+}
+
+
 Player* Player::player_ = nullptr;

sources/PowerUp.cpp

@@ -0,0 +1,21 @@
+#include "../headers/PowerUp.h"
+
+PowerUp::PowerUp(float x, float y, sf::Texture &texture, PowerUp::Type type): ObjectItem(x, y, texture) {
+    position.x = x;
+    position.y = y;
+    texture_ = texture;
+    sprite.setTexture(texture);
+    sprite.setOrigin(sprite.getLocalBounds().width / 2, sprite.getLocalBounds().height / 2); // wycentrowanie sprite
+    sprite.setScale(0.5f, 0.5f);
+    sprite.setPosition(x, y);
+    movingSpeed = 3.0f;
+    this->type_ = type;
+}
+
+void PowerUp::update() {
+    sprite.move(0.0f, movingSpeed); // przesunięcie sprajta
+    position.y += int(movingSpeed); // przesunięcie pozycji
+    if(position.y > 900) {
+        outOfBounds = true; // jeżeli wyszedł poza granice ekranu ustaw tą zmienną
+    }
+}