Złączono i wszystko działa, ale trzeba zrobić mocny refactor Planszy bo za dużo niewiadomo skąd biorących się pętli

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

CMakeLists.txt

@@ -40,6 +40,8 @@ add_executable(LotoStatek main.cpp
         sources/Wiazkowiec.cpp
         headers/Beam.h
         sources/Beam.cpp
+        headers/Heart.hpp
+        sources/Heart.cpp
 )
 
 if(WIN32)

headers/Actor.h

@@ -5,17 +5,19 @@
 #include "SFML/Graphics/Texture.hpp"
 #include "Bullet.h"
 #include "Position.h"
+#include "SFML/System/Clock.hpp"
 
 
 class Actor {
 public:
     Actor(int x, int y, const sf::Texture& texture);
 
-    void loadTexture(std::string path);
+
 
     sf::Sprite& getSprite();
-
+    unsigned int getHP();
     Position getPosition();
+    std::vector<Bullet>& getBullets();
 
     virtual void move(float deltaX, float deltaY) = 0;
     virtual void moveLeft() = 0;
@@ -24,23 +26,23 @@ public:
     virtual void moveDown() = 0;
     virtual void shoot() = 0;
 
-    std::vector<Bullet>& getBullets();
-
     void updateBullets();
-
     void setMovingSpeed(float speed);
+    void dealDamage();
+    void healUP();
 
 protected:
+    Position position;
     sf::Sprite actorSprite;
     sf::Texture actorTexture;
-    sf::Texture bulletTextureLeft;
-    sf::Texture bulletTextureRight;
-    Position position;
-    unsigned int hp;
+    sf::Texture bulletTexture;
+    sf::Texture rocketTexture;
+    std::vector<Bullet> bullets;
+    sf::Clock damageDealClock;
+    int hp;
     unsigned int damage;
     unsigned int firerate;
     float moving_speed;
-    std::vector<Bullet> bullets;
 };
 
 #endif //ACTOR_H

headers/Heart.hpp

@@ -0,0 +1,14 @@
+#ifndef LOTOSTATEK_HEART_HPP
+#define LOTOSTATEK_HEART_HPP
+
+#include "SFML/Graphics/Texture.hpp"
+#include "SFML/Graphics/Sprite.hpp"
+#include "ObjectItem.hpp"
+
+class Heart : public ObjectItem {
+public:
+    Heart(float x, float y, sf::Texture &texture);
+    void update();
+};
+
+#endif //LOTOSTATEK_HEART_HPP

headers/Plansza.h

@@ -1,75 +1,85 @@
 #ifndef PLANSZA_H
 #define PLANSZA_H
 
+#include "SFML/System/Clock.hpp"
+#include "SFML/Graphics/RenderWindow.hpp"
+
 #include "Meteor.h"
 #include "Enemy.h"
 #include "AdvancedEnemy.h"
 #include "Bomber.h"
 #include "Kamikadze.h"
 #include "Wiazkowiec.h"
-#include "Beam.h"
-#include "RandomNumberGenerator.h"
-#include "SFML/System/Clock.hpp"
-#include "SFML/Graphics/RenderWindow.hpp"
-#include "Size.h"
-#include <memory>
-
 #include "Player.h"
 #include "Background.h"
 #include "AudioManager.h"
-#include "Meteor.h"
 #include "Plansza.h"
+#include "Heart.hpp"
+#include "Size.h"
 
 class Plansza {
 public:
-    Plansza(unsigned int windowHeight, unsigned int windowWidth, sf::RenderWindow *mainWindow,
-      const sf::Texture& playerTexture, const sf::Texture& playerBulletTexture, const sf::Texture& playerRocketTexture);
+    Plansza(unsigned int windowHeight, unsigned int windowWidth, sf::RenderWindow *mainWindow);
     Size getSize();
     std::vector<Meteor> &getMeteors();
-
-
     void spawn_meteor();
+    void spawn_hearts();
     void update_meteors();
+    void update_hearts();
     void update();
-    void spawn_enemy();
+    void update_score();
     void setOutOfBounds(bool status);
+    void spawn_player();
+    void spawn_enemy();
     void spawn_advanced_enemy();
     void spawn_wiazkowiec();
     void spawn_bomber();
     void spawn_kamikadze();
-
+    ~Plansza() {
+        delete ship; // usuwanie wskaźnika ship
+    }
 private:
-    Size size;
     Background background;
-    Player ship;
     AudioManager audioManager;
-    sf::Texture meteorTexture1;
-    sf::Texture meteorTexture2;
-    sf::Texture enemyBulletTexture;
-    sf::Texture WiazkaTexture;
-    sf::Texture BombaTexture;
-    sf::Texture playerTexture;
-    sf::Texture playerBulletTexture;
-    sf::Texture playerRocketTexture;
-    sf::Texture enemyTexture;
-    sf::Texture advancedEnemyTexture;
-    sf::Texture BomberEnemyTexture;
-    sf::Texture KamikadzeTexture;
-    sf::Texture WiazkowiecTexture;
+    Player *ship;
+    Size size;
+    sf::RenderWindow *window;
+    sf::Font font;
+    sf::Clock meteorSpawnClock;
+    sf::Clock heartSpawnClock;
     sf::Clock spawnClock;
+    sf::Clock scoreClock;
     sf::Clock shooterSpawnClock;
-    std::vector<Enemy> enemies;
-    std::vector<AdvancedEnemy> AEnemies;
-    std::vector<Bomber> BEnemies;
-    std::vector<Kamikadze> KEnemies;
-    std::vector<Wiazkowiec> WEnemies;
     sf::Clock enemySpawnClock;
     sf::Clock AenemySpawnClock;
     sf::Clock BomberSpawnClock;
     sf::Clock KamikadzeSpawnClock;
     sf::Clock WiazkowiecSpawnClock;
+    sf::Texture playerTexture;
+    sf::Texture playerBulletTexture;
+    sf::Texture playerRocketTexture;
+    sf::Texture enemyTexture;
+    sf::Texture enemyBulletTexture;
+    sf::Texture advancedEnemyTexture;
+    sf::Texture BomberEnemyTexture;
+    sf::Texture BombaTexture;
+    sf::Texture KamikadzeTexture;
+    sf::Texture WiazkowiecTexture;
+    sf::Texture WiazkaTexture;
+    sf::Texture meteorTexture1;
+    sf::Texture meteorTexture2;
+    sf::Texture heartTexture;
+    sf::Texture heartTextureGray;
+    std::vector<Enemy> enemies;
+    std::vector<AdvancedEnemy> AEnemies;
+    std::vector<Bomber> BEnemies;
+    std::vector<Kamikadze> KEnemies;
+    std::vector<Wiazkowiec> WEnemies;
     std::vector<Meteor> meteors;
-    sf::RenderWindow *window;
+    std::vector<Heart> hearts;
+    std::vector<sf::Sprite> heartStats;
+    bool gameOver = false;
+    unsigned int score = 0;
 };
 
 #endif //PLANSZA_H

headers/Player.h

@@ -9,9 +9,17 @@
 #include "Rocket.h"
 
 class Player : public Actor {
+    // Zgodnie z refactoring.guru singleton pattern
+    // https://refactoring.guru/design-patterns/singleton/cpp/example
+protected:
+    Player(int x, int y, const sf::Texture &texture);
+    static Player* player_;
 public:
-    Player(int x, int y, const sf::Texture& texture, const sf::Texture& bulletTexture, const sf::Texture& rocketTexture);
-    void setTextures(const sf::Texture& shipTexture, const sf::Texture& bulletTexture, const sf::Texture& rocketTexture);
+    Player(Player &other) = delete;
+    void operator=(const Player &) = delete;
+    static Player* getInstance(int x, int y, const sf::Texture &texture);
+    // Tu się kończy definicja singletona
+
     void shoot() override;
     void alternate_shoot();
     void setFirerate(unsigned int firerate);
@@ -21,18 +29,21 @@ public:
     void moveUp() override;
     void moveDown() override;
     void takeDamage();
-    bool isAlive() const;
+
     void update();
     std::vector<Rocket>& getRockets();
+
+    void loadTexture();
+
 private:
     std::chrono::steady_clock::time_point lastShotTime = std::chrono::steady_clock::now();
     std::vector<Rocket> rockets;
     sf::Texture rocketTexture;
-    int health = 3; // Liczba punktów życia gracza
     sf::Texture bulletTexture;
-    bool isImmortal = false;           // flaga na immortal
+    sf::Color originalColor;
     sf::Clock immortalityClock;       // Zegar kontrolujący czas nieśmiertelności
     float immortalityDuration = 1.5f; // Czas trwania nieśmiertelności w sec
+    bool isImmortal = false;           // flaga na immortal
 };
 
 

main.cpp

@@ -3,16 +3,8 @@
 
 #include "headers/Plansza.h"
 
-int main()
-{
+int main() {
     std::clog << "Game started\n";
-    sf::Texture playerTexture, playerBulletTexture, playerRocketTexture;
-    if (!playerTexture.loadFromFile("../assets/ship/Dreadnought-Base.png") ||
-        !playerBulletTexture.loadFromFile("../assets/img/bullets/bullet_pink.png") ||
-        !playerRocketTexture.loadFromFile("../assets/img/rockets/Rocket_111.png")) {
-        std::cerr << "Failed to load player textures!" << std::endl;
-        return -1;
-        }
     sf::RenderWindow mainWindow(sf::VideoMode(600, 800), "LotoStatek");
     mainWindow.setVerticalSyncEnabled(true);
     mainWindow.setFramerateLimit(60);
@@ -22,8 +14,7 @@ int main()
     mainWindow.setIcon(128, 128, icon.getPixelsPtr());
 
 
-
-    Plansza plansza(mainWindow.getSize().y, mainWindow.getSize().x, &mainWindow,playerTexture, playerBulletTexture, playerRocketTexture);
+    Plansza plansza(mainWindow.getSize().y, mainWindow.getSize().x, &mainWindow);
 
     while (mainWindow.isOpen()) {
         mainWindow.clear();
@@ -31,7 +22,7 @@ int main()
         // Tu są handlowane eventy
         sf::Event event{};
         while (mainWindow.pollEvent(event)) {
-            if(event.type == sf::Event::Closed || sf::Keyboard::isKeyPressed(sf::Keyboard::Escape))
+            if (event.type == sf::Event::Closed || sf::Keyboard::isKeyPressed(sf::Keyboard::Escape))
                 mainWindow.close();
         }
 

sources/Actor.cpp

@@ -10,14 +10,6 @@ Actor::Actor(int x, int y, const sf::Texture& texture) {
     actorSprite.setPosition(float(x), float(y));
 }
 
-void Actor::loadTexture(std::string path) {
-    actorTexture.loadFromFile(path);
-    actorSprite.setTexture(actorTexture);
-
-    bulletTextureLeft.loadFromFile("../assets/img/bullets/bullet_pink.png");
-    bulletTextureRight.loadFromFile("../assets/img/rockets/Rocket_111.png");
-}
-
 sf::Sprite &Actor::getSprite() {
     if (!actorSprite.getTexture()) {
         std::cerr << "actorSprite has no texture set!" << std::endl;
@@ -29,6 +21,25 @@ Position Actor::getPosition() {
     return {position.x, position.y};
 }
 
+unsigned int Actor::getHP() {
+    return hp;
+}
+
+void Actor::dealDamage() {
+    if(damageDealClock.getElapsedTime().asSeconds() > 1.5) {
+        if(hp > 0) {
+            hp--;
+        }
+        damageDealClock.restart();
+    }
+}
+
+void Actor::healUP() {
+    if(hp < 3){
+        hp++;
+    }
+}
+
 std::vector<Bullet> &Actor::getBullets() {
     return bullets;
 }
@@ -47,4 +58,4 @@ void Actor::updateBullets() {
 
 void Actor::setMovingSpeed(float speed) {
     moving_speed = speed;
-}
+}

sources/Heart.cpp

@@ -0,0 +1,23 @@
+#include "../headers/Heart.hpp"
+
+Heart::Heart(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
+    sprite.setPosition(x, y);
+    movingSpeed = 3.0f;
+//    sprite.scale(0.05f, 0.05f);
+    position.x = x;
+    position.y = y;
+    rotationSpeed = 0;
+}
+
+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/Plansza.cpp

@@ -1,22 +1,37 @@
 #include <random>
 #include <iostream>
 #include "../headers/Plansza.h"
-#include "../headers/ObjectItem.hpp"
+#include "../headers/RandomNumberGenerator.h"
 
-Plansza::Plansza(unsigned int windowHeight, unsigned int windowWidth, sf::RenderWindow *mainWindow,
-    const sf::Texture& playerTexture,
-    const sf::Texture& playerBulletTexture,
-    const sf::Texture& playerRocketTexture)
-    : background("../assets/img/background/background.png", 2.0f),
-      ship(static_cast<int>(mainWindow->getSize().x) / 2, static_cast<int>(mainWindow->getSize().y) - 100,
-           playerTexture, playerBulletTexture, playerRocketTexture) {
+Plansza::Plansza(unsigned int windowHeight, unsigned int windowWidth, sf::RenderWindow *mainWindow)
+        : background("../assets/img/background/background.png", 2.0f) {
     window = mainWindow;
     size.height = static_cast<int>(windowHeight);
     size.width = static_cast<int>(windowWidth);
 
+    try {
+        playerTexture.loadFromFile("../assets/ship/Dreadnought-Base.png");
+        meteorTexture1.loadFromFile("../assets/img/meteors/meteor-1.png");
+        meteorTexture2.loadFromFile("../assets/img/meteors/meteor-2.png");
+        // Ładowanie tekstur wrogów
+        enemyTexture.loadFromFile("../assets/img/enemy/enemy.png");
+        advancedEnemyTexture.loadFromFile("../assets/img/enemy/advanced_enemy.png");
+        BomberEnemyTexture.loadFromFile("../assets/img/enemy/bomber.png");
+        KamikadzeTexture.loadFromFile("../assets/img/enemy/kamikadze.png");
+        BombaTexture.loadFromFile("../assets/img/bullets/bomba.png");
+        WiazkowiecTexture.loadFromFile("../assets/img/enemy/wiazkowiec.png");
+    } catch (std::exception &e) {
+        std::cerr << "Failed to load textures: " << e.what() << std::endl;
+        exit(-500);
+    }
 
-    ship.setMovingSpeed(8);
-    ship.setFirerate(200);
+    score = 0;
+
+    // Wczytywanie czcionki dla licznika punktów
+    if (!font.loadFromFile("../assets/fonts/arial.ttf")) {
+        std::cerr << "Error loading font\n";
+        exit(-500);
+    }
 
     audioManager.loadBackgroundMusic("../assets/music/background.ogg");
     audioManager.playBackgroundMusic();
@@ -25,206 +40,218 @@ 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");
 
-    // Ładowanie tekstur wrogów
-    if (!enemyTexture.loadFromFile("../assets/img/enemy/enemy.png")) {
-        std::cerr << "Failed to load enemy texture!" << std::endl;
-        exit(-1);
-    }
-    if (!advancedEnemyTexture.loadFromFile("../assets/img/enemy/advanced_enemy.png")) {
-        std::cerr << "Failed to load advanced enemy texture!" << std::endl;
-        exit(-1);
-    }
-    if (!BomberEnemyTexture.loadFromFile("../assets/img/enemy/bomber.png")) {
-        std::cerr << "Failed to load advanced enemy texture!" << std::endl;
-        exit(-1);
-    }
-    if (!KamikadzeTexture.loadFromFile("../assets/img/enemy/kamikadze.png")) {
-        std::cerr << "Failed to load advanced enemy texture!" << std::endl;
-        exit(-1);
-    }
-    if (!BombaTexture.loadFromFile("../assets/img/bullets/bomba.png")) {
-        std::cerr << "Failed to load BombaTexture!" << std::endl;
-        exit(-1);
-    }
-    if (!WiazkowiecTexture.loadFromFile("../assets/img/enemy/wiazkowiec.png")) {
-        std::cerr << "Failed to load Wiazkowiec texture!" << std::endl;
-        exit(-1);
-    }
+    heartTexture.loadFromFile("../assets/img/hearts/heart.png");
+    heartTextureGray.loadFromFile("../assets/img/hearts/heart_gray.png");
+
+    heartStats.emplace_back(sf::Sprite(heartTexture));
+    heartStats.emplace_back(sf::Sprite(heartTexture));
+    heartStats.emplace_back(sf::Sprite(heartTexture));
+    heartStats[0].setPosition(565, 10);
+    heartStats[1].setPosition(530, 10);
+    heartStats[2].setPosition(495, 10);
+
+    meteorSpawnClock.restart();
+    spawn_player();
+
     spawnClock.restart();
 }
 
-
+// TODO: Refactor tej metody bo rozrosła się za bardzo już
 void Plansza::update() {
 // tło
-        background.update();
-        background.draw(*window);
+    background.update();
+    background.draw(*window);
 
-        // poruszanie się statkiem
-        if(sf::Keyboard::isKeyPressed(sf::Keyboard::A)) {
-            if(ship.getPosition().x > 50) {
-                ship.moveLeft();
-            }
+    // poruszanie się statkiem
+    if (sf::Keyboard::isKeyPressed(sf::Keyboard::A)) {
+        if (ship->getPosition().x > 50) {
+            ship->moveLeft();
         }
-        if (sf::Keyboard::isKeyPressed(sf::Keyboard::W)) {
-            if(ship.getPosition().y > 80) {
-                ship.moveUp();
-            }
+    }
+    if (sf::Keyboard::isKeyPressed(sf::Keyboard::W)) {
+        if (ship->getPosition().y > 80) {
+            ship->moveUp();
         }
-        if (sf::Keyboard::isKeyPressed(sf::Keyboard::S)) {
-            if(ship.getPosition().y < 720) {
-                ship.moveDown();
-            }
+    }
+    if (sf::Keyboard::isKeyPressed(sf::Keyboard::S)) {
+        if (ship->getPosition().y < 720) {
+            ship->moveDown();
         }
-        if (sf::Keyboard::isKeyPressed(sf::Keyboard::D)) {
-            if(ship.getPosition().x < 550) {
-                ship.moveRight();
-            }
+    }
+    if (sf::Keyboard::isKeyPressed(sf::Keyboard::D)) {
+        if (ship->getPosition().x < 550) {
+            ship->moveRight();
         }
-
-        // 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
-        }
-        if (sf::Mouse::isButtonPressed(sf::Mouse::Right)) {
-            ship.alternate_shoot();
-            audioManager.playSoundEffect("shoot_alt", 70.f); // Odtworzenie dźwięku dla alternatywnego strzału
-        }
-
-        // generowanie nowego meteoru
-        ship.update();
-        spawn_meteor();
-        spawn_enemy();
-        spawn_advanced_enemy();
-        spawn_wiazkowiec();
-        spawn_bomber();
-        spawn_kamikadze();
-
-        // utrzymanie meteorów i pocisków w ruchu
-        for (auto& meteor : getMeteors()) {
-            meteor.update();
-            window->draw(meteor.getSprite());
-        }
-
-        for (auto& bullet : ship.getBullets()) {
-            bullet.update();
-            window->draw(bullet.getSprite());
-        }
-
-        for (auto& rocket : ship.getRockets()) {
-            rocket.update();
-            window->draw(rocket.getSprite());
-        }
-
-        // Sprawdzenie czy meteory i pociski są poza granicami ekranu
-        update_meteors();
-        ship.updateBullets();
-
-        window->draw(ship.getSprite());
-
-        // trochę dziwny sposób ale jednak działa
-        for (auto& meteor : getMeteors()) {
-            if(ship.getSprite().getGlobalBounds().intersects(meteor.getSprite().getGlobalBounds())) {
-                std::cout << "You lost the game!\n";
-                sf::RenderWindow errorWindow(sf::VideoMode(350, 200), "The end");
-                sf::Font font;
-                if (!font.loadFromFile("../assets/fonts/arial.ttf")) {
-                    std::cerr << "Error loading font\n";
-                    exit(-500);
-                }
-                sf::Text text("Your ship is destroyed!", font, 24);
-                text.setFillColor(sf::Color::Red);
-                text.setPosition(50, 80);
-
-                // zatrzymanie muzyki i odtworzenie dźwięku przegranej
-                audioManager.playSoundEffect("fail", 70.f);
-                audioManager.stopBackgroundMusic();
-                sf::Event event{};
-                while (errorWindow.isOpen()) {
-                    while (errorWindow.pollEvent(event)) {
-                        if (event.type == sf::Event::Closed || sf::Keyboard::isKeyPressed(sf::Keyboard::Escape)) {
-                            errorWindow.close();
-                            window->close();
-                            exit(-2);
-                        }
-                    }
-                    errorWindow.clear();
-                    errorWindow.draw(text);
-                    errorWindow.display();
-                }
-            }
-        }
-
-
-
-        if (!ship.isAlive()) {
-        std::cout << "Game Over! Player is dead." << std::endl;
-            std::cout << "You lost the game!\n";
-            sf::RenderWindow errorWindow(sf::VideoMode(350, 200), "The end");
-            sf::Font font;
-            if (!font.loadFromFile("../assets/fonts/arial.ttf")) {
-                std::cerr << "Error loading font\n";
-                exit(-500);
-            }
-            sf::Text text("Your ship is destroyed!", font, 24);
-            text.setFillColor(sf::Color::Red);
-            text.setPosition(50, 80);
-
-            // zatrzymanie muzyki i odtworzenie dźwięku przegranej
-            audioManager.playSoundEffect("fail", 70.f);
-            audioManager.stopBackgroundMusic();
-            sf::Event event{};
-            while (errorWindow.isOpen()) {
-                while (errorWindow.pollEvent(event)) {
-                    if (event.type == sf::Event::Closed || sf::Keyboard::isKeyPressed(sf::Keyboard::Escape)) {
-                        errorWindow.close();
-                        window->close();
-                        exit(-2);
-                    }
-                }
-                errorWindow.clear();
-                errorWindow.draw(text);
-                errorWindow.display();
-            }
     }
 
-        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: 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
+    }
+    if (sf::Mouse::isButtonPressed(sf::Mouse::Right)) {
+        ship->alternate_shoot();
+        audioManager.playSoundEffect("shoot_alt", 70.f); // Odtworzenie dźwięku dla alternatywnego strzału
+    }
 
-        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;
+    // generowanie nowego meteoru
+    ship->update(); // migotanie statku
+    update_score(); // naliczanie punktów
+    // Sprawnowanie wszystkich rodzajów wrogów
+    spawn_meteor();
+    spawn_hearts();
+    spawn_enemy();
+    spawn_advanced_enemy();
+    spawn_wiazkowiec();
+    spawn_bomber();
+    spawn_kamikadze();
+
+
+
+
+    // utrzymanie meteorów i pocisków w ruchu
+    for (auto &meteor: meteors) {
+        meteor.update();
+        window->draw(meteor.getSprite());
+    }
+
+    for (auto &heart: hearts) {
+        heart.update();
+        window->draw(heart.getSprite());
+    }for (auto &bullet: ship->getBullets()) {
+        bullet.update();
+        window->draw(bullet.getSprite());
+    }
+
+    for (auto &rocket: ship->getRockets()) {
+        rocket.update();
+        window->draw(rocket.getSprite());
+    }
+
+    // Sprawdzenie czy meteory i pociski są poza granicami ekranu
+    update_meteors();
+    update_hearts();
+    ship->updateBullets();
+
+    ship->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;
+        }
+    }
+
+    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");
+        sf::Font font;
+        if (!font.loadFromFile("../assets/fonts/arial.ttf")) {
+            std::cerr << "Error loading font\n";
+            exit(-500);
+        }
+        sf::Text text("Your ship is destroyed!", font, 24);
+        text.setFillColor(sf::Color::Red);
+        text.setPosition(50, 80);
+
+        // zatrzymanie muzyki i odtworzenie dźwięku przegranej
+        audioManager.playSoundEffect("fail", 70.f);
+        audioManager.stopBackgroundMusic();
+        sf::Event event{};
+        while (errorWindow.isOpen()) {
+            while (errorWindow.pollEvent(event)) {
+                if (event.type == sf::Event::Closed || sf::Keyboard::isKeyPressed(sf::Keyboard::Escape)) {
+                    errorWindow.close();
+                    window->close();
+                    exit(-2);
+                }
+            }
+            errorWindow.clear();
+            errorWindow.draw(text);
+            errorWindow.display();
+        }
+    }
+
+    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
@@ -269,16 +296,16 @@ void Plansza::update() {
 
 
     for (auto it = KEnemies.begin(); it != KEnemies.end();) {
-        sf::Vector2f playerPosition = ship.getSprite().getPosition(); // Aktualna pozycja gracza
+        sf::Vector2f playerPosition = ship->getSprite().getPosition(); // Aktualna pozycja gracza
         bool playerHit = false;
 
         it->update(playerPosition);
 
         // Wybuch, gdy Kamikadze dotknie gracza
-        if (ship.getSprite().getGlobalBounds().intersects(it->getSprite().getGlobalBounds())) {
+        if (ship->getSprite().getGlobalBounds().intersects(it->getSprite().getGlobalBounds())) {
             it->explode(playerPosition, playerHit);
             if (playerHit) {
-                ship.takeDamage(); // Gracz otrzymuje obrażenia
+                ship->takeDamage(); // Gracz otrzymuje obrażenia
                 std::cout << "Gracz został trafiony przez eksplozję Kamikadze!" << std::endl;
             }
         }
@@ -300,10 +327,10 @@ void Plansza::update() {
 
 
     // Obsługa pocisków zaawansowanych przeciwników
-    for (auto& aEnemy : AEnemies) {
+    for (auto &aEnemy: AEnemies) {
         for (auto it = aEnemy.getBullets().begin(); it != aEnemy.getBullets().end();) {
-            if (ship.getSprite().getGlobalBounds().intersects(it->getSprite().getGlobalBounds())) {
-                ship.takeDamage(); // Zadanie obrażeń graczowi
+            if (ship->getSprite().getGlobalBounds().intersects(it->getSprite().getGlobalBounds())) {
+                ship->takeDamage(); // Zadanie obrażeń graczowi
                 it = aEnemy.getBullets().erase(it); // Usuwanie pocisku po trafieniu
             } else {
                 ++it;
@@ -312,10 +339,10 @@ void Plansza::update() {
     }
 
     // Obsługa bomb
-    for (auto& aEnemy : BEnemies) {
+    for (auto &aEnemy: BEnemies) {
         for (auto it = aEnemy.getBullets().begin(); it != aEnemy.getBullets().end();) {
-            if (ship.getSprite().getGlobalBounds().intersects(it->getSprite().getGlobalBounds())) {
-                ship.takeDamage(); // Zadanie obrażeń graczowi
+            if (ship->getSprite().getGlobalBounds().intersects(it->getSprite().getGlobalBounds())) {
+                ship->takeDamage(); // Zadanie obrażeń graczowi
                 it = aEnemy.getBullets().erase(it); // Usuwanie pocisku po trafieniu
             } else {
                 ++it;
@@ -324,39 +351,36 @@ void Plansza::update() {
     }
 
 
-    for (auto& enemy : enemies) {
+    for (auto &enemy: enemies) {
         enemy.shoot();
         enemy.updateBullets();
-        for (auto& bullet : enemy.getBullets()) {
+        for (auto &bullet: enemy.getBullets()) {
             bullet.update();
             window->draw(bullet.getSprite());
         }
     }
 
-    for (auto& advancedEnemy : AEnemies) {
+    for (auto &advancedEnemy: AEnemies) {
         advancedEnemy.updateBullets(); // Obsługuje pociski zaawansowanych przeciwników
-        for (auto& bullet : advancedEnemy.getBullets()) {
+        for (auto &bullet: advancedEnemy.getBullets()) {
             bullet.update();
             window->draw(bullet.getSprite());
         }
     }
 
-    for (auto& bomberEnemy : BEnemies) {
+    for (auto &bomberEnemy: BEnemies) {
         bomberEnemy.updateBullets(); // Obsługuje bomby
-        for (auto& bullet : bomberEnemy.getBullets()) {
+        for (auto &bullet: bomberEnemy.getBullets()) {
             bullet.update();
             window->draw(bullet.getSprite());
         }
     }
 
-    for (auto& enemy : enemies) {
+    for (auto &enemy: enemies) {
         for (auto it = enemy.getBullets().begin(); it != enemy.getBullets().end();) {
-            if (ship.getSprite().getGlobalBounds().intersects(it->getSprite().getGlobalBounds())) {
+            if (ship->getSprite().getGlobalBounds().intersects(it->getSprite().getGlobalBounds())) {
                 // Kolizja wykryta
-                std::cout << "Player hit by enemy bullet!\n";
-
-                ship.takeDamage();
-
+                ship->takeDamage();
                 // Usuwanie pocisku
                 it = enemy.getBullets().erase(it);
             } else {
@@ -365,16 +389,16 @@ void Plansza::update() {
         }
     }
 
-    for (auto& bomberEnemy : BEnemies) {
+    for (auto &bomberEnemy: BEnemies) {
         for (auto it = bomberEnemy.getBullets().begin(); it != bomberEnemy.getBullets().end();) {
             bool bulletDestroyed = false;
 
             // Kolizja pocisku gracza z pociskiem Bombera
-            for (auto playerBulletIt = ship.getBullets().begin(); playerBulletIt != ship.getBullets().end();) {
+            for (auto playerBulletIt = ship->getBullets().begin(); playerBulletIt != ship->getBullets().end();) {
                 if (playerBulletIt->getSprite().getGlobalBounds().intersects(it->getSprite().getGlobalBounds())) {
                     // Usuń pocisk Bombera i pocisk gracza
                     it = bomberEnemy.getBullets().erase(it);
-                    playerBulletIt = ship.getBullets().erase(playerBulletIt);
+                    playerBulletIt = ship->getBullets().erase(playerBulletIt);
                     bulletDestroyed = true;
                     break;
                 } else {
@@ -384,11 +408,11 @@ void Plansza::update() {
 
             // Kolizja rakiety gracza z pociskiem Bombera
             if (!bulletDestroyed) {
-                for (auto rocketIt = ship.getRockets().begin(); rocketIt != ship.getRockets().end();) {
+                for (auto rocketIt = ship->getRockets().begin(); rocketIt != ship->getRockets().end();) {
                     if (rocketIt->getSprite().getGlobalBounds().intersects(it->getSprite().getGlobalBounds())) {
                         // Usuń pocisk Bombera i rakietę gracza
                         it = bomberEnemy.getBullets().erase(it);
-                        rocketIt = ship.getRockets().erase(rocketIt);
+                        rocketIt = ship->getRockets().erase(rocketIt);
                         bulletDestroyed = true;
                         break;
                     } else {
@@ -399,9 +423,9 @@ void Plansza::update() {
 
             // Jeśli pocisk Bombera przetrwał dotychczasowe sprawdzenia, wykonaj inne działania
             if (!bulletDestroyed) {
-                if (ship.getSprite().getGlobalBounds().intersects(it->getSprite().getGlobalBounds())) {
+                if (ship->getSprite().getGlobalBounds().intersects(it->getSprite().getGlobalBounds())) {
                     // Kolizja pocisku Bombera z graczem
-                    ship.takeDamage();
+                    ship->takeDamage();
                     it = bomberEnemy.getBullets().erase(it);
                 } else {
                     ++it;
@@ -410,12 +434,12 @@ void Plansza::update() {
         }
     }
 
-    for (auto& wiazkowiec : WEnemies) {
+    for (auto &wiazkowiec: WEnemies) {
         wiazkowiec.update();
 
         if (wiazkowiec.isShooting() && wiazkowiec.getBeam().isVisible()) {
-            if (ship.getSprite().getGlobalBounds().intersects(wiazkowiec.getBeam().getBounds())) {
-                ship.takeDamage(); // Gracz otrzymuje obrażenia
+            if (ship->getSprite().getGlobalBounds().intersects(wiazkowiec.getBeam().getBounds())) {
+                ship->takeDamage(); // Gracz otrzymuje obrażenia
             }
         }
 
@@ -424,7 +448,7 @@ void Plansza::update() {
     }
 
     // Usuwanie pocisków, które są poza ekranem srednio to dziala
-    for (auto enemyIt = enemies.begin(); enemyIt != enemies.end(); ) {
+    for (auto enemyIt = enemies.begin(); enemyIt != enemies.end();) {
         for (auto bulletIt = enemyIt->getBullets().begin(); bulletIt != enemyIt->getBullets().end();) {
             if (bulletIt->isOutOfBounds()) {
                 bulletIt = enemyIt->getBullets().erase(bulletIt); // Usuwamy pocisk, który wyszedł poza ekran
@@ -439,9 +463,9 @@ void Plansza::update() {
     // Kolizje między pociskami gracza a przeciwnikami
     for (auto enemyIt = enemies.begin(); enemyIt != enemies.end();) {
         bool hit = false;
-        for (auto bulletIt = ship.getBullets().begin(); bulletIt != ship.getBullets().end();) {
+        for (auto bulletIt = ship->getBullets().begin(); bulletIt != ship->getBullets().end();) {
             if (enemyIt->getSprite().getGlobalBounds().intersects(bulletIt->getSprite().getGlobalBounds())) {
-                bulletIt = ship.getBullets().erase(bulletIt);
+                bulletIt = ship->getBullets().erase(bulletIt);
                 enemyIt->takeDamage();
                 hit = true;
                 break;
@@ -458,9 +482,9 @@ void Plansza::update() {
 
     for (auto advancedIt = AEnemies.begin(); advancedIt != AEnemies.end();) {
         bool hit = false;
-        for (auto bulletIt = ship.getBullets().begin(); bulletIt != ship.getBullets().end();) {
+        for (auto bulletIt = ship->getBullets().begin(); bulletIt != ship->getBullets().end();) {
             if (advancedIt->getSprite().getGlobalBounds().intersects(bulletIt->getSprite().getGlobalBounds())) {
-                bulletIt = ship.getBullets().erase(bulletIt);
+                bulletIt = ship->getBullets().erase(bulletIt);
                 advancedIt->takeDamage();
                 hit = true;
                 break;
@@ -477,9 +501,9 @@ void Plansza::update() {
 
     for (auto bomberIt = BEnemies.begin(); bomberIt != BEnemies.end();) {
         bool hit = false;
-        for (auto bulletIt = ship.getBullets().begin(); bulletIt != ship.getBullets().end();) {
+        for (auto bulletIt = ship->getBullets().begin(); bulletIt != ship->getBullets().end();) {
             if (bomberIt->getSprite().getGlobalBounds().intersects(bulletIt->getSprite().getGlobalBounds())) {
-                bulletIt = ship.getBullets().erase(bulletIt);
+                bulletIt = ship->getBullets().erase(bulletIt);
                 bomberIt->takeDamage();
                 hit = true;
                 break;
@@ -496,9 +520,9 @@ void Plansza::update() {
 
     for (auto kamikadzeIt = KEnemies.begin(); kamikadzeIt != KEnemies.end();) {
         bool hit = false;
-        for (auto bulletIt = ship.getBullets().begin(); bulletIt != ship.getBullets().end();) {
+        for (auto bulletIt = ship->getBullets().begin(); bulletIt != ship->getBullets().end();) {
             if (kamikadzeIt->getSprite().getGlobalBounds().intersects(bulletIt->getSprite().getGlobalBounds())) {
-                bulletIt = ship.getBullets().erase(bulletIt);
+                bulletIt = ship->getBullets().erase(bulletIt);
                 kamikadzeIt->takeDamage();
                 hit = true;
                 break;
@@ -515,9 +539,9 @@ void Plansza::update() {
 
     for (auto wiazkowiecIt = WEnemies.begin(); wiazkowiecIt != WEnemies.end();) {
         bool hit = false;
-        for (auto bulletIt = ship.getBullets().begin(); bulletIt != ship.getBullets().end();) {
+        for (auto bulletIt = ship->getBullets().begin(); bulletIt != ship->getBullets().end();) {
             if (wiazkowiecIt->getSprite().getGlobalBounds().intersects(bulletIt->getSprite().getGlobalBounds())) {
-                bulletIt = ship.getBullets().erase(bulletIt);
+                bulletIt = ship->getBullets().erase(bulletIt);
                 wiazkowiecIt->takeDamage();
                 hit = true;
                 break;
@@ -537,9 +561,9 @@ void Plansza::update() {
     //oblsuga dla rakiety
     for (auto enemyIt = enemies.begin(); enemyIt != enemies.end();) {
         bool hit = false;
-        for (auto rocketIt = ship.getRockets().begin(); rocketIt != ship.getRockets().end();) {
+        for (auto rocketIt = ship->getRockets().begin(); rocketIt != ship->getRockets().end();) {
             if (enemyIt->getSprite().getGlobalBounds().intersects(rocketIt->getSprite().getGlobalBounds())) {
-                rocketIt = ship.getRockets().erase(rocketIt);
+                rocketIt = ship->getRockets().erase(rocketIt);
                 enemyIt->takeDamage();
                 hit = true;
                 break;
@@ -556,9 +580,9 @@ void Plansza::update() {
 
     for (auto advancedIt = AEnemies.begin(); advancedIt != AEnemies.end();) {
         bool hit = false;
-        for (auto rocketIt = ship.getRockets().begin(); rocketIt != ship.getRockets().end();) {
+        for (auto rocketIt = ship->getRockets().begin(); rocketIt != ship->getRockets().end();) {
             if (advancedIt->getSprite().getGlobalBounds().intersects(rocketIt->getSprite().getGlobalBounds())) {
-                rocketIt = ship.getRockets().erase(rocketIt);
+                rocketIt = ship->getRockets().erase(rocketIt);
                 advancedIt->takeDamage();
                 hit = true;
                 break;
@@ -575,9 +599,9 @@ void Plansza::update() {
 
     for (auto bomberIt = BEnemies.begin(); bomberIt != BEnemies.end();) {
         bool hit = false;
-        for (auto rocketIt = ship.getRockets().begin(); rocketIt != ship.getRockets().end();) {
+        for (auto rocketIt = ship->getRockets().begin(); rocketIt != ship->getRockets().end();) {
             if (bomberIt->getSprite().getGlobalBounds().intersects(rocketIt->getSprite().getGlobalBounds())) {
-                rocketIt = ship.getRockets().erase(rocketIt);
+                rocketIt = ship->getRockets().erase(rocketIt);
                 bomberIt->takeDamage();
                 hit = true;
                 break;
@@ -594,9 +618,9 @@ void Plansza::update() {
 
     for (auto kamikadzeIt = KEnemies.begin(); kamikadzeIt != KEnemies.end();) {
         bool hit = false;
-        for (auto rocketIt = ship.getRockets().begin(); rocketIt != ship.getRockets().end();) {
+        for (auto rocketIt = ship->getRockets().begin(); rocketIt != ship->getRockets().end();) {
             if (kamikadzeIt->getSprite().getGlobalBounds().intersects(rocketIt->getSprite().getGlobalBounds())) {
-                rocketIt = ship.getRockets().erase(rocketIt);
+                rocketIt = ship->getRockets().erase(rocketIt);
                 kamikadzeIt->takeDamage();
                 hit = true;
                 break;
@@ -613,9 +637,9 @@ void Plansza::update() {
 
     for (auto wiazkowiecIt = WEnemies.begin(); wiazkowiecIt != WEnemies.end();) {
         bool hit = false;
-        for (auto rocketIt = ship.getRockets().begin(); rocketIt != ship.getRockets().end();) {
+        for (auto rocketIt = ship->getRockets().begin(); rocketIt != ship->getRockets().end();) {
             if (wiazkowiecIt->getSprite().getGlobalBounds().intersects(rocketIt->getSprite().getGlobalBounds())) {
-                rocketIt = ship.getRockets().erase(rocketIt);
+                rocketIt = ship->getRockets().erase(rocketIt);
                 wiazkowiecIt->takeDamage();
                 hit = true;
                 break;
@@ -631,34 +655,79 @@ void Plansza::update() {
     }
 
 
-}
+    // Statystyka życia gracza (wyświetlanie)
+    switch (ship->getHP()) {
+        case 0:
+            heartStats[0].setTexture(heartTextureGray);
+            heartStats[1].setTexture(heartTextureGray);
+            heartStats[2].setTexture(heartTextureGray);
+            gameOver = true;
+            break;
+        case 1:
+            heartStats[0].setTexture(heartTexture);
+            heartStats[1].setTexture(heartTextureGray);
+            heartStats[2].setTexture(heartTextureGray);
+            break;
+        case 2:
+            heartStats[0].setTexture(heartTexture);
+            heartStats[1].setTexture(heartTexture);
+            heartStats[2].setTexture(heartTextureGray);
+            break;
+        case 3:
+            heartStats[0].setTexture(heartTexture);
+            heartStats[1].setTexture(heartTexture);
+            heartStats[2].setTexture(heartTexture);
+            break;
+    }
 
-// Meteor-related niżej
 
-void Plansza::spawn_meteor() {
-    if (spawnClock.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(rand() % 2 == 1) {
-                meteors.emplace_back(RandomNumberGenerator::getRandomNumber(50,499), -100, meteorTexture2);
-            } else {
-                meteors.emplace_back(RandomNumberGenerator::getRandomNumber(50,499), -100, meteorTexture1);
-            }
-        }
-        spawnClock.restart();
+    for (const auto& heart: heartStats) {
+        window->draw(heart);
     }
 }
+// Meteor-related niżej
+
 
 void Plansza::update_meteors() {
     // usuwanie meteorów które wyleciały poza ekran
-    for (auto& meteor : meteors) {
-        if(meteor.getStatus()) {
+    for (auto &meteor: meteors) {
+        if (meteor.getStatus()) {
             meteors.erase(meteors.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 (rand() % 2 == 1) {
+                meteors.emplace_back(RandomNumberGenerator::getRandomNumber(50, 499), -100, meteorTexture2);
+            } else {
+                meteors.emplace_back(RandomNumberGenerator::getRandomNumber(50, 499), -100, meteorTexture1);
+            }
+        }
+        meteorSpawnClock.restart();
+    }
+}
+
+void Plansza::spawn_hearts() {
+    if (heartSpawnClock.getElapsedTime().asSeconds() > rand() % 10 + 1) { // randomowy spawn meteorytów od 10 do 1 sekundy
+        if (hearts.size() < 5) { // jeśli jest mniej niż 5 meteorów na planszy
+             hearts.emplace_back(RandomNumberGenerator::getRandomNumber(50, 499), -100, heartTexture);
+        }
+        heartSpawnClock.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();
+    ship->setMovingSpeed(8);
+    ship->setFirerate(200);
+}
+
 void Plansza::spawn_enemy() {
-    if (enemySpawnClock.getElapsedTime().asSeconds() >= 110) { // Spawn co 10 sekund
+    if (enemySpawnClock.getElapsedTime().asSeconds() >= 10) { // Spawn co 10 sekund
         int spawnX = RandomNumberGenerator::getRandomNumber(50, size.width - 50);
         enemies.emplace_back(spawnX, -50, enemyTexture);
         std::cout << "Spawned Basic Enemy at X: " << spawnX << std::endl;
@@ -668,7 +737,7 @@ void Plansza::spawn_enemy() {
 }
 
 void Plansza::spawn_advanced_enemy() {
-    if (AenemySpawnClock.getElapsedTime().asSeconds() >= 80) { // Spawn co 10 sekund
+    if (AenemySpawnClock.getElapsedTime().asSeconds() >= 20) { // 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;
@@ -677,7 +746,7 @@ void Plansza::spawn_advanced_enemy() {
 }
 
 void Plansza::spawn_bomber() {
-    if (BomberSpawnClock.getElapsedTime().asSeconds() >= 10) { // Spawn co 10 sekund
+    if (BomberSpawnClock.getElapsedTime().asSeconds() >= 30) { // 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
@@ -688,7 +757,7 @@ void Plansza::spawn_bomber() {
 }
 
 void Plansza::spawn_kamikadze() {
-    if (KamikadzeSpawnClock.getElapsedTime().asSeconds() >= 220) { // Spawn co 10 sekund
+    if (KamikadzeSpawnClock.getElapsedTime().asSeconds() >= 40) { // Spawn co 10 sekund
         int spawnX = RandomNumberGenerator::getRandomNumber(50, size.width - 50);
         KEnemies.emplace_back(spawnX, -50, KamikadzeTexture);
         std::cout << "Spawned Kamikadze Enemy at X: " << spawnX << std::endl;
@@ -697,7 +766,7 @@ void Plansza::spawn_kamikadze() {
 }
 
 void Plansza::spawn_wiazkowiec() {
-    if (WiazkowiecSpawnClock.getElapsedTime().asSeconds() >= 110) { // Spawn co 10 sekund
+    if (WiazkowiecSpawnClock.getElapsedTime().asSeconds() >= 50) { // Spawn co 10 sekund
         int spawnX = RandomNumberGenerator::getRandomNumber(50, size.width - 50);
         Wiazkowiec wiazkowiec(spawnX, -50, WiazkowiecTexture);
         wiazkowiec.setPlanszaHeight(size.height, size.width); // Przekazanie wysokości i szerokosci okna
@@ -708,7 +777,14 @@ 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;
@@ -718,5 +794,15 @@ 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++;
+        scoreClock.restart();
+    }
 
-
+    sf::Text text(std::to_string(score), font, 24);
+    text.setFillColor(sf::Color::White);
+    text.setPosition(25, 25);
+    window->draw(text);
+}

sources/Player.cpp

@@ -1,3 +1,5 @@
+#include <utility>
+
 #include "../headers/Player.h"
 
 #include <iostream>
@@ -5,16 +7,22 @@
 #include <SFML/Graphics/RenderWindow.hpp>
 #include <SFML/Graphics/Text.hpp>
 
-#include "../headers/Bullet.h"
+Player::Player(int x, int y, const sf::Texture& texture) : Actor(x, y, texture) {
+    hp = 3;
+}
 
-Player::Player(int x, int y, const sf::Texture& texture, const sf::Texture& bulletTexture, const sf::Texture& rocketTexture) : Actor(x, y, texture), bulletTexture(bulletTexture), rocketTexture(rocketTexture) {
+Player* Player::getInstance(int x, int y, const sf::Texture& texture) {
+    if (player_ == nullptr) {
+        player_ = new Player(x, y, texture);
+    }
+    return player_;
+}
 
-};
-
-void Player::setTextures(const sf::Texture& shipTexture, const sf::Texture& bulletTexture, const sf::Texture& rocketTexture) {
-    this->actorSprite.setTexture(shipTexture); // Poprawiona nazwa - actorSprite zamiast shipSprite
-    this->bulletTexture = bulletTexture;
-    this->rocketTexture = rocketTexture;
+void Player::loadTexture() {
+    bulletTexture.loadFromFile("../assets/img/bullets/bullet_pink.png");
+    rocketTexture.loadFromFile("../assets/img/rockets/Rocket_111.png");
+    damageDealClock.restart();
+    originalColor = actorSprite.getColor();
 }
 
 void Player::shoot() {
@@ -55,26 +63,14 @@ void Player::update() {
 
 void Player::takeDamage() {
     if (!isImmortal) {
-        if (health > 0) {
-            health--;
-            std::cout << "Player hit! Remaining health: " << health << "\n";
+        if (hp > 0) {
+            hp--;
             isImmortal = true;           // Aktywuj chwilową nieśmiertelność
             immortalityClock.restart();
-
-
-            if (health <= 0) {
-                std::cout << "Player has been destroyed!\n";
-                std::cout << "You lost the game!\n";
-
-            }
         }
     }
 }
 
-bool Player::isAlive() const {
-    return health > 0;
-}
-
 void Player::setFirerate(unsigned int firerate) {
     this->firerate = firerate;
 }
@@ -106,3 +102,5 @@ void Player::moveDown() {
 std::vector<Rocket> &Player::getRockets() {
     return rockets;
 }
+
+Player* Player::player_ = nullptr;