counter fixed at 200

# Conflicts:
#	CMakeLists.txt
#	headers/Plansza.h
#	sources/Plansza.cpp

CMakeLists.txt

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

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/Plansza.h

@@ -16,6 +16,7 @@
 #include "Plansza.h"
 #include "Heart.hpp"
 #include "PowerUp.h"
+#include "Debuff.h"
 #include "Size.h"
 #include "Boss.h"
 
@@ -34,9 +35,11 @@ public:
     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();
@@ -45,14 +48,15 @@ public:
     void check_PowerUp_collisions();
     void check_Heart_collisions();
     void check_Meteor_collisions();
+    void check_Debuff_collisions();
+
+    void handleUltimate();
 
     void spawn_player();
     void spawn_enemy();
     void spawn_advanced_enemy();
     void spawn_wiazkowiec();
-
     void spawn_boss();
-
     void spawn_bomber();
     void spawn_kamikadze();
     ~Plansza() {
@@ -62,20 +66,29 @@ public:
 
     static ships selectedShip;
     static unsigned int score;
+    static unsigned int ultimateCounter;
     sf::Font font;
+
 private:
     Background background;
     AudioManager audioManager;
     Player *ship;
     Size size;
     sf::RenderWindow *window;
-    sf::Clock meteorSpawnClock;
-    sf::Clock heartSpawnClock;
-    sf::Clock powerUpSpawnClock;
+    // Timers
     sf::Clock movingSpeedPUTimer;
     sf::Clock fireratePUTimer;
     sf::Clock tripleShotPUTimer;
-    sf::Clock spawnClock;
+    sf::Clock movingSpeedDebuffTimer;
+    sf::Clock firerateDebuffTimer;
+    sf::Clock bulletSpeedDebuffTimer;
+
+    // Zegary
+    sf::Clock meteorSpawnClock;
+    sf::Clock heartSpawnClock;
+    sf::Clock powerUpSpawnClock;
+    sf::Clock debuffSpawnClock;
+    sf::Clock ultimateClock;
     sf::Clock scoreClock;
     sf::Clock shooterSpawnClock;
     sf::Clock enemySpawnClock;
@@ -83,6 +96,8 @@ private:
     sf::Clock BomberSpawnClock;
     sf::Clock KamikadzeSpawnClock;
     sf::Clock WiazkowiecSpawnClock;
+
+    //Textury
     sf::Texture playerTexture;
     sf::Texture playerBulletTexture;
     sf::Texture playerRocketTexture;
@@ -102,6 +117,11 @@ private:
     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;
@@ -111,11 +131,26 @@ private:
     std::vector<Heart> hearts;
     std::vector<sf::Sprite> heartStats;
     std::vector<PowerUp> powerUps;
+    std::vector<Debuff> debuffs;
+
+    // Zmienne prymitywne
     Boss* boss = nullptr;          // Wskaźnik na bossa
     sf::Clock bossSpawnClock;      // Zegar do spawnowania bossa
+    unsigned int nextBossScoreThreshold = 1000; // Próg punktowy dla spawnu 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
+
+    // Używane do powerup i debuff flagi
+    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

@@ -22,6 +22,7 @@ public:
 
     void shoot() override;
     void alternate_shoot();
+    void ultimate_shoot();
     void setFirerate(unsigned int firerate);
     void move(float deltaX, float deltaY) override;
     void moveLeft() override;
@@ -31,11 +32,16 @@ public:
     void takeDamage();
     void setTripleShot(bool toogle);
 
+    void setBulletSpeed(float speed);
+    bool getUltimateStatus();
     void update();
+
     std::vector<Rocket>& getRockets();
 
     void loadTexture();
 
+    void setUltimateStatus(bool status);
+
 private:
     std::chrono::steady_clock::time_point lastShotTime = std::chrono::steady_clock::now();
     std::vector<Rocket> rockets;
@@ -44,8 +50,10 @@ 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ł
+    bool ultimateShootActive = false;
 };
 
 

sources/AdvancedEnemy.cpp

@@ -86,5 +86,6 @@ void AdvancedEnemy::takeDamage() {
     if (--hp <= 0) {
         alive = false;
         Plansza::score += 10;
+        Plansza::ultimateCounter += 10;
     }
 }

sources/Bomber.cpp

@@ -122,5 +122,6 @@ void Bomber::takeDamage() {
     if (--hp <= 0) {
         alive = false;
         Plansza::score += 15;
+        Plansza::ultimateCounter += 15;
     }
 }

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/Enemy.cpp

@@ -76,5 +76,6 @@ void Enemy::takeDamage() {
     if (--hp <= 0) {
         alive = false;
         Plansza::score += 5;
+        Plansza::ultimateCounter += 5;
     }
 }

sources/Kamikadze.cpp

@@ -131,5 +131,6 @@ void Kamikadze::takeDamage() {
     if (--hp <= 0) {
         alive = false;
         Plansza::score += 20;
+        Plansza::ultimateCounter += 20;
     }
 }

sources/Plansza.cpp

@@ -2,6 +2,7 @@
 #include <iostream>
 #include "../headers/Plansza.h"
 #include "../headers/RandomNumberGenerator.h"
+#include <SFML/Graphics.hpp>
 
 Plansza::Plansza(unsigned int windowHeight, unsigned int windowWidth, sf::RenderWindow *mainWindow, ships selectedShip)
         : background("../assets/img/background/background.png", 2.0f) {
@@ -29,6 +30,9 @@ Plansza::Plansza(unsigned int windowHeight, unsigned int windowWidth, sf::Render
         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");
@@ -67,9 +71,10 @@ Plansza::Plansza(unsigned int windowHeight, unsigned int windowWidth, sf::Render
 
     meteorSpawnClock.restart();
     powerUpSpawnClock.restart();
+    debuffSpawnClock.restart();
     spawn_player();
 
-    spawnClock.restart();
+    // spawnClock.restart();
 }
 
 // TODO: Refactor tej metody bo rozrosła się za bardzo już
@@ -101,6 +106,11 @@ void Plansza::update() {
         }
     }
 
+    if (sf::Keyboard::isKeyPressed(sf::Keyboard::Space) && !ship->getUltimateStatus() && ultimateCounter >= 200) {
+        ultimateClock.restart();
+        ship->ultimate_shoot();
+    }
+
     // TODO: Przenieść obiekt dźwięku wewnątrz klasy Bullet
     if (sf::Mouse::isButtonPressed(sf::Mouse::Left)) {
         ship->shoot();
@@ -117,12 +127,13 @@ void Plansza::update() {
     spawn_meteor();
     spawn_hearts();
     spawn_power_up();
-  //  spawn_enemy();
- //   spawn_advanced_enemy();
-  //  spawn_wiazkowiec();
-  //  spawn_bomber();
-  //  spawn_kamikadze();
-    spawn_boss();
+    spawn_debuff();
+    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) {
@@ -140,6 +151,11 @@ void Plansza::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());
@@ -154,6 +170,7 @@ void Plansza::update() {
     update_meteors();
     update_hearts();
     update_power_ups();
+    update_debuffs();
     ship->updateBullets();
 
     window->draw(ship->getSprite());
@@ -161,16 +178,36 @@ void Plansza::update() {
     check_Meteor_collisions();
     check_Heart_collisions();
     check_PowerUp_collisions();
+    check_Debuff_collisions();
 
-    if (movingSpeedPUTimer.getElapsedTime().asSeconds() >= 5.0f) {
+
+    // 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);
     }
-    if (fireratePUTimer.getElapsedTime().asSeconds() >= 10.0f) {
+    if (fireratePUTimer.getElapsedTime().asSeconds() >= 10.0f && powerUpCollected.firerate) {
+        powerUpCollected.firerate = false;
         ship->setFirerate(200);
     }
-    if (tripleShotPUTimer.getElapsedTime().asSeconds() >= 5.0f) {
+    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);
+    }
+
+    handleUltimate();
 
     if (gameOver) {
         sf::RenderWindow errorWindow(sf::VideoMode(350, 200), "The end");
@@ -507,7 +544,6 @@ void Plansza::update() {
         }
     }
 
-
     for (auto &bomberEnemy: BEnemies) {
         for (auto it = bomberEnemy.getBullets().begin(); it != bomberEnemy.getBullets().end();) {
             bool bulletDestroyed = false;
@@ -834,6 +870,14 @@ void Plansza::update_power_ups() {
     }
 }
 
+void Plansza::update_debuffs() {
+    for (auto& debuff : debuffs) {
+        if(debuff.getStatus()) {
+            debuffs.erase(debuffs.begin());
+        }
+    }
+}
+
 void Plansza::spawn_meteor() {
     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
@@ -857,7 +901,7 @@ void Plansza::spawn_hearts() {
 }
 
 void Plansza::spawn_power_up() {
-    if (powerUpSpawnClock.getElapsedTime().asSeconds() > 5) {
+    if (powerUpSpawnClock.getElapsedTime().asSeconds() > 15) {
         if (powerUps.size() < 2) {
             auto powerUpRand = rand() % 3;
             switch (powerUpRand) {
@@ -869,6 +913,7 @@ void Plansza::spawn_power_up() {
                     break;
                 case 2:
                     powerUps.emplace_back(RandomNumberGenerator::getRandomNumber(50,499), -100, tripleShotPowerUpTexture, PowerUp::tripleShotUp);
+                    break;
             }
 
 
@@ -877,6 +922,25 @@ void Plansza::spawn_power_up() {
     }
 }
 
+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();
@@ -958,6 +1022,10 @@ std::vector<Meteor> &Plansza::getMeteors() {
 void Plansza::update_score() {
     if (scoreClock.getElapsedTime().asMilliseconds() > 500) {
         score++;
+        ultimateCounter++;
+        if (ultimateCounter >= 200) {
+            ultimateCounter = 200;
+        }
         scoreClock.restart();
     }
 
@@ -972,14 +1040,17 @@ void Plansza::check_PowerUp_collisions() {
         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);
@@ -989,6 +1060,31 @@ void Plansza::check_PowerUp_collisions() {
     }
 }
 
+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())) {
@@ -1010,4 +1106,30 @@ void Plansza::check_Meteor_collisions() {
 
 ships Plansza::selectedShip = none;
 unsigned int Plansza::score = 0;
+unsigned int Plansza::ultimateCounter = 0;
 
+void Plansza::handleUltimate() {
+    if (ship->getUltimateStatus() && ultimateCounter >= 200) {
+        float elapsedTime = ultimateClock.getElapsedTime().asSeconds();
+        if (ship->getUltimateStatus() && ultimateClock.getElapsedTime().asSeconds() >= 1) {
+            ultimateCounter = 0;
+        }
+        if (elapsedTime < 1) {
+            sf::RectangleShape ultimateShape(sf::Vector2f(600, 800));
+            int alpha = static_cast<int>(255 * (1 - elapsedTime));
+            ultimateShape.setFillColor(sf::Color(255, 255, 255, alpha));
+
+            meteors.clear();
+            debuffs.clear();
+            enemies.clear();
+            AEnemies.clear();
+            BEnemies.clear();
+            KEnemies.clear();
+            WEnemies.clear();
+
+            window->draw(ultimateShape);
+        } else {
+            ship->setUltimateStatus(false);
+        }
+    }
+}

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) {
@@ -37,13 +37,13 @@ void Player::shoot() {
     auto now = std::chrono::steady_clock::now();
     if (std::chrono::duration_cast<std::chrono::milliseconds>(now - lastShotTime).count() >= firerate) {
         if (tripleShot == true) {
-            bullets.emplace_back(position.x - 40, position.y, bulletTexture);
-            bullets.emplace_back(position.x, position.y, bulletTexture);
-            bullets.emplace_back(position.x + 40, position.y, bulletTexture);
+            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);
+            bullets.emplace_back(position.x, position.y, bulletTexture, bulletSpeed);
             lastShotTime = now;
         }
     }
@@ -58,6 +58,10 @@ void Player::alternate_shoot() {
     }
 }
 
+void Player::ultimate_shoot() {
+    ultimateShootActive = true;
+}
+
 void Player::update() {
     // Wyłącz nieśmiertelność po określonym czasie
     if (isImmortal && immortalityClock.getElapsedTime().asSeconds() >= immortalityDuration) {
@@ -123,4 +127,17 @@ std::vector<Rocket> &Player::getRockets() {
     return rockets;
 }
 
+void Player::setBulletSpeed(float speed) {
+    this->bulletSpeed = speed;
+}
+
+
 Player* Player::player_ = nullptr;
+
+bool Player::getUltimateStatus() {
+    return ultimateShootActive;
+}
+
+void Player::setUltimateStatus(bool status) {
+    ultimateShootActive = status;
+}

sources/Wiazkowiec.cpp

@@ -200,6 +200,7 @@ void Wiazkowiec::takeDamage() {
     if (--hp <= 0) {
         alive = false;
         Plansza::score += 10;
+        Plansza::ultimateCounter += 10;
     }
 }