Merge remote-tracking branch 'origin/debuff'

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
 )
 
 if(WIN32)

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"
 
 enum ships{
@@ -33,9 +34,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();
@@ -44,6 +47,7 @@ public:
     void check_PowerUp_collisions();
     void check_Heart_collisions();
     void check_Meteor_collisions();
+    void check_Debuff_collisions();
 
     void spawn_player();
     void spawn_enemy();
@@ -58,19 +62,27 @@ public:
     static ships selectedShip;
     static unsigned int score;
     sf::Font font;
+
 private:
     Background background;
     AudioManager audioManager;
     Player *ship;
     Size size;
     sf::RenderWindow *window;
-    sf::Clock meteorSpawnClock;
+    // Timers
-    sf::Clock heartSpawnClock;
-    sf::Clock powerUpSpawnClock;
     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 spawnClock;
     sf::Clock scoreClock;
     sf::Clock shooterSpawnClock;
     sf::Clock enemySpawnClock;
@@ -78,6 +90,8 @@ private:
     sf::Clock BomberSpawnClock;
     sf::Clock KamikadzeSpawnClock;
     sf::Clock WiazkowiecSpawnClock;
+
+    //Textury
     sf::Texture playerTexture;
     sf::Texture playerBulletTexture;
     sf::Texture playerRocketTexture;
@@ -96,6 +110,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;
@@ -105,7 +124,20 @@ private:
     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

@@ -30,6 +30,7 @@ public:
     void moveDown() override;
     void takeDamage();
     void setTripleShot(bool toogle);
+    void setBulletSpeed(float speed);
 
     void update();
     std::vector<Rocket>& getRockets();
@@ -44,6 +45,7 @@ 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ł
 };

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

@@ -29,6 +29,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");
@@ -65,9 +68,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ż
@@ -112,14 +116,15 @@ void Plansza::update() {
     ship->update(); // migotanie statku
     update_score(); // naliczanie punktów
     // Sprawnowanie wszystkich rodzajów wrogów
-    spawn_meteor();
+    // spawn_meteor();
-    spawn_hearts();
+    // spawn_hearts();
     spawn_power_up();
-    spawn_enemy();
+    spawn_debuff();
-    spawn_advanced_enemy();
+    // spawn_enemy();
-    spawn_wiazkowiec();
+    // spawn_advanced_enemy();
-    spawn_bomber();
+    // spawn_wiazkowiec();
-    spawn_kamikadze();
+    // spawn_bomber();
+    // spawn_kamikadze();
 
     // utrzymanie meteorów i pocisków w ruchu
     for (auto &meteor: meteors) {
@@ -137,6 +142,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());
@@ -151,6 +161,7 @@ void Plansza::update() {
     update_meteors();
     update_hearts();
     update_power_ups();
+    update_debuffs();
     ship->updateBullets();
 
     window->draw(ship->getSprite());
@@ -158,16 +169,34 @@ 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);
+    }
 
     if (gameOver) {
         sf::RenderWindow errorWindow(sf::VideoMode(350, 200), "The end");
@@ -729,6 +758,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
@@ -764,6 +801,7 @@ void Plansza::spawn_power_up() {
                     break;
                 case 2:
                     powerUps.emplace_back(RandomNumberGenerator::getRandomNumber(50,499), -100, tripleShotPowerUpTexture, PowerUp::tripleShotUp);
+                    break;
             }
 
 
@@ -772,6 +810,25 @@ void Plansza::spawn_power_up() {
     }
 }
 
+void Plansza::spawn_debuff() {
+    if (debuffSpawnClock.getElapsedTime().asSeconds() > 5) {
+        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();
@@ -856,14 +913,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);
@@ -873,6 +933,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())) {
@@ -892,5 +977,6 @@ void Plansza::check_Meteor_collisions() {
     }
 }
 
+
 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) {
@@ -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 - 40, position.y, bulletTexture, bulletSpeed);
-            bullets.emplace_back(position.x, position.y, bulletTexture);
+            bullets.emplace_back(position.x, position.y, bulletTexture, bulletSpeed);
-            bullets.emplace_back(position.x + 40, position.y, bulletTexture);
+            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;
         }
     }
@@ -123,4 +123,9 @@ std::vector<Rocket> &Player::getRockets() {
     return rockets;
 }
 
+void Player::setBulletSpeed(float speed) {
+    this->bulletSpeed = speed;
+}
+
+
 Player* Player::player_ = nullptr;