Laser naprawiono

# 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,11 +5,18 @@
 #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);
+    virtual ~Actor() = default;
+
+    sf::Sprite& getSprite();
+    unsigned int getHP();
+    Position getPosition();
+    std::vector<Bullet>& getBullets();
 
     virtual void move(float deltaX, float deltaY) = 0;
     virtual void moveLeft() = 0;
@@ -18,13 +25,10 @@ public:
     virtual void moveDown() = 0;
     virtual void shoot() = 0;
 
-    std::vector<Bullet>& getBullets();
-    sf::Sprite& getSprite();
-    Position getPosition();
-
-    void setMovingSpeed(float speed);
-
     void updateBullets();
+    void setMovingSpeed(float speed);
+    void dealDamage();
+    void healUP();
 
 protected:
     Position position;
@@ -33,7 +37,8 @@ protected:
     sf::Texture bulletTexture;
     sf::Texture rocketTexture;
     std::vector<Bullet> bullets;
-    unsigned int hp;
+    sf::Clock damageDealClock;
+    int hp;
     unsigned int damage;
     unsigned int firerate;
     float moving_speed;

headers/AdvancedEnemy.h

@@ -3,8 +3,6 @@
 
 #include "Enemy.h"
 
-#include <cmath>
-
 enum class DirectionA {
     Up,
     Down,

headers/Beam.h

@@ -2,27 +2,16 @@
 #define LOTOSTATEK_BEAM_H
 
 #include <SFML/Graphics.hpp>
-#include "Position.h"
 
 class Beam {
 public:
-    Beam(float x, float y, float width, float height, const sf::Color& color);
+    Beam() = default;
-
+    Beam(int x, int y, const sf::Texture &texture);
-    void draw(sf::RenderWindow &window);
-
-    void update();
-    void render(sf::RenderWindow& window);
-
-    sf::FloatRect getBounds() const;
-
-    bool isVisible() const;
-    void setVisible(bool visible);
 
+    sf::Sprite getSprite();
 
+    void setRotation(float angle);
 private:
-    sf::RectangleShape beamShape;
-    bool visible;
-    sf::Texture beamTexture;
     sf::Sprite beamSprite;
 };
 

headers/Bullet.h

@@ -2,14 +2,11 @@
 #define LOTOSTATEK_BULLET_H
 
 #include "Projectile.h"
-#include "SFML/Graphics/Texture.hpp"
 
 class Bullet : public Projectile {
 public:
     Bullet(float x, float y, sf::Texture &texture) : Projectile(x,y, texture) {};
     void update() override;
-private:
-    float directionY;
 };
 
 

headers/Heart.hpp

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

headers/Meteor.h

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

headers/ObjectItem.hpp

@@ -12,7 +12,7 @@ public:
     bool getStatus();
     virtual void update() = 0;
 protected:
-    sf::Texture texture;
+    sf::Texture texture_;
     sf::Sprite sprite;
     Position position;
     float rotationSpeed;

headers/Plansza.h

@@ -14,18 +14,27 @@
 #include "Background.h"
 #include "AudioManager.h"
 #include "Plansza.h"
+#include "Heart.hpp"
 #include "Size.h"
 
+enum ships{
+    nova,
+    pulsar,
+    zenith,
+    none
+};
+
 class Plansza {
 public:
-    Plansza(unsigned int windowHeight, unsigned int windowWidth, sf::RenderWindow *mainWindow);
+    Plansza(unsigned int windowHeight, unsigned int windowWidth, sf::RenderWindow *mainWindow, ships selectedShip);
     Size getSize();
     std::vector<Meteor> &getMeteors();
     void spawn_meteor();
+    void spawn_hearts();
     void update_meteors();
+    void update_hearts();
     void update();
     void update_score();
-    void setOutOfBounds(bool status);
     void spawn_player();
     void spawn_enemy();
     void spawn_advanced_enemy();
@@ -35,26 +44,18 @@ public:
     ~Plansza() {
         delete ship; // usuwanie wskaźnika ship
     }
+
+    static ships selectedShip;
+    static unsigned int score;
 private:
-    Size size;
     Background background;
     AudioManager audioManager;
     Player *ship;
+    Size size;
     sf::RenderWindow *window;
     sf::Font font;
-    sf::Texture meteorTexture1;
+    sf::Clock meteorSpawnClock;
-    sf::Texture meteorTexture2;
+    sf::Clock heartSpawnClock;
-    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;
     sf::Clock spawnClock;
     sf::Clock scoreClock;
     sf::Clock shooterSpawnClock;
@@ -63,14 +64,30 @@ private:
     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;
-    unsigned int score = 0;
+    std::vector<Heart> hearts;
-    bool isPlayerSpawned = false;
+    std::vector<sf::Sprite> heartStats;
+    bool gameOver = false;
 };
 
 #endif //PLANSZA_H

headers/Player.h

@@ -1,6 +1,7 @@
 #ifndef LOTOSTATEK_PLAYER_H
 #define LOTOSTATEK_PLAYER_H
 
+
 #include <chrono>
 #include <SFML/System/Clock.hpp>
 
@@ -28,7 +29,7 @@ public:
     void moveUp() override;
     void moveDown() override;
     void takeDamage();
-    bool isAlive() const;
+
     void update();
     std::vector<Rocket>& getRockets();
 
@@ -39,8 +40,8 @@ private:
     std::vector<Rocket> rockets;
     sf::Texture rocketTexture;
     sf::Texture bulletTexture;
+    sf::Color originalColor;
     sf::Clock immortalityClock;       // Zegar kontrolujący czas nieśmiertelności
-    int health = 3; // Liczba punktów życia gracza
     float immortalityDuration = 1.5f; // Czas trwania nieśmiertelności w sec
     bool isImmortal = false;           // flaga na immortal
 };

headers/Position.h

@@ -6,4 +6,14 @@ struct Position {
     int y;
 };
 
+struct PositionU {
+    unsigned int x;
+    unsigned int y;
+};
+
+struct PositionF {
+    float x;
+    float y;
+};
+
 #endif //LOTOSTATEK_POSITION_H

headers/Wiazkowiec.h

@@ -13,42 +13,47 @@ enum class DirectionW {
 
 class Wiazkowiec : public Actor {
 public:
-    Wiazkowiec(int x, int y, const sf::Texture& texture);
+    Wiazkowiec(int x, int y, const sf::Texture& texture, sf::RenderWindow *window);
 
-    void shoot() override;
     void move(float deltaX, float deltaY) override;
     void moveLeft() override;
     void moveRight() override;
     void moveUp() override;
     void moveDown() override;
+
+    void takeDamage();
+
     void setRandomDirection();
+    void checkIfBeamShootOutOfBounds();
 
     void update();
-
+    void shoot() override;
     void render(sf::RenderWindow &window);
 
     bool isAlive() const;
-    void takeDamage();
-    void updateDirection();
     bool isShooting() const;
-    const Beam& getBeam() const;
-    void setPlanszaHeight(float height, float width);
-    void setMapBounds(float width, float height);
 
+    void setPlanszaHeight(int height, int width);
+    Beam* getBeam() const;
 
 private:
-    float planszaHeight = 800.f;
-    float planszaWidth = 600.f;
-    sf::Clock shootClock;
     sf::Texture WiazkaTexture;
-    float movementSpeed = 2.0f;
+    sf::Texture beamTexture;
-    bool alive = true;
+    sf::Clock shootClock;
-    DirectionW direction = DirectionW::Down;
-    Beam beam; // Wiązka
-    bool shooting = false;
     sf::Clock shootingClock;
-    float beamDuration = 1.0f;
+    DirectionW direction = DirectionW::Down;
+
+    Beam *beam; // wskaźnik na wiązkę
+    sf::RenderWindow *window_ptr;
+
     void spawnBeam(); // Tworzy wiązkę
+
+    int planszaHeight = 800;
+    int planszaWidth = 600;
+    float beamDuration = 1.0f;
+    float movementSpeed = 2.0f;
+    bool shooting = false;
+    bool alive = true;
 };
 
 #endif //WIAZKOWIEC_H

main.cpp

@@ -3,7 +3,13 @@
 
 #include "headers/Plansza.h"
 
+ships selectedShip = none;
+
+void menu();
+
 int main() {
+    menu();
+
     std::clog << "Game started\n";
     sf::RenderWindow mainWindow(sf::VideoMode(600, 800), "LotoStatek");
     mainWindow.setVerticalSyncEnabled(true);
@@ -14,7 +20,7 @@ int main() {
     mainWindow.setIcon(128, 128, icon.getPixelsPtr());
 
 
-    Plansza plansza(mainWindow.getSize().y, mainWindow.getSize().x, &mainWindow);
+    Plansza plansza(mainWindow.getSize().y, mainWindow.getSize().x, &mainWindow, selectedShip);
 
     while (mainWindow.isOpen()) {
         mainWindow.clear();
@@ -32,4 +38,148 @@ int main() {
     }
 
     return 0;
-}
+}
+
+
+void menu() {
+    sf::RenderWindow menuWindow(sf::VideoMode(800, 400), "LotoStatek->Menu");
+    // Ustawienia ikonki okna
+    sf::Image icon;
+    icon.loadFromFile("../assets/img/icon/ikonka.png");
+    menuWindow.setIcon(128, 128, icon.getPixelsPtr());
+
+    // start button
+    sf::RectangleShape startButton(sf::Vector2f(140, 50));
+    startButton.setPosition(50, 20);
+    startButton.setFillColor(sf::Color::White);
+
+
+    sf::Font font;
+    if (!font.loadFromFile("../assets/fonts/arial.ttf")) {
+        std::cerr << "Nie można załadować czcionki\n";
+        exit(-1);
+    }
+    // tekst dla start button
+    sf::Text startText("Start", font, 24);
+    startText.setFillColor(sf::Color::Black);
+    startText.setPosition(startButton.getSize().x / 2 + 20, startButton.getSize().y / 2 + 5);
+
+
+    // exit button
+    sf::RectangleShape exitButton(sf::Vector2f(140, 50));
+    exitButton.setPosition(600, 20);
+    exitButton.setFillColor(sf::Color::White);
+
+    sf::Text exitText("Exit", font, 24);
+    exitText.setFillColor(sf::Color::Black);
+    exitText.setPosition(exitButton.getPosition().x + 45, exitButton.getPosition().y + 10);
+
+
+    sf::Texture pulsarTexture;
+    pulsarTexture.loadFromFile("../assets/ship/pulsar.png");
+    sf::Sprite pulsarSprite(pulsarTexture);
+    pulsarSprite.setPosition(50, 200);
+    pulsarSprite.setScale(0.25f, 0.25f);
+
+    sf::Texture novaTexture;
+    novaTexture.loadFromFile("../assets/ship/nova.png");
+    sf::Sprite novaSprite(novaTexture);
+    novaSprite.setPosition(330, 200);
+    novaSprite.setScale(0.25f, 0.25f);
+
+    sf::Texture zenithTexture;
+    zenithTexture.loadFromFile("../assets/ship/zenith.png");
+    sf::Sprite zenithSprite(zenithTexture);
+    zenithSprite.setPosition(600, 200);
+    zenithSprite.setScale(0.25f, 0.25f);
+
+    sf::RectangleShape pulsarBorder(sf::Vector2f(pulsarSprite.getGlobalBounds().width + 4,
+                                                 pulsarSprite.getGlobalBounds().height + 4));
+    pulsarBorder.setPosition(pulsarSprite.getPosition().x - 2, pulsarSprite.getPosition().y - 2);
+    pulsarBorder.setFillColor(sf::Color::Transparent);
+    pulsarBorder.setOutlineThickness(2);
+    pulsarBorder.setOutlineColor(sf::Color::Transparent);
+
+    sf::RectangleShape novaBorder(sf::Vector2f(novaSprite.getGlobalBounds().width + 4,
+                                               novaSprite.getGlobalBounds().height + 4));
+    novaBorder.setPosition(novaSprite.getPosition().x - 2, novaSprite.getPosition().y - 2);
+    novaBorder.setFillColor(sf::Color::Transparent);
+    novaBorder.setOutlineThickness(2);
+    novaBorder.setOutlineColor(sf::Color::Transparent);
+
+    sf::RectangleShape zenithBorder(sf::Vector2f(zenithSprite.getGlobalBounds().width + 4,
+                                                 zenithSprite.getGlobalBounds().height + 4));
+    zenithBorder.setPosition(zenithSprite.getPosition().x - 2, zenithSprite.getPosition().y - 2);
+    zenithBorder.setFillColor(sf::Color::Transparent);
+    zenithBorder.setOutlineThickness(2);
+    zenithBorder.setOutlineColor(sf::Color::Transparent);
+
+    while (menuWindow.isOpen()) {
+        sf::Event event{};
+        while (menuWindow.pollEvent(event)) {
+            if (event.type == sf::Event::Closed || sf::Keyboard::isKeyPressed(sf::Keyboard::Escape)) {
+                menuWindow.close();
+                exit(-2);
+            }
+
+            if (event.type == sf::Event::MouseButtonPressed) {
+                if (event.mouseButton.button == sf::Mouse::Left) {
+                    sf::Vector2i mousePos = sf::Mouse::getPosition(menuWindow);
+                    if (startButton.getGlobalBounds().contains(static_cast<sf::Vector2f>(mousePos))) {
+                        std::cout << "Przycisk Start zostal kliknięty\n";
+                        menuWindow.close();
+                    }
+                    if (exitButton.getGlobalBounds().contains(static_cast<sf::Vector2f>(mousePos))) {
+                        std::cout << "Przycisk Exit zostal kliknięty\n";
+                        menuWindow.close();
+                        exit(-2);
+                    }
+
+                    if (pulsarSprite.getGlobalBounds().contains(static_cast<sf::Vector2f>(mousePos))) {
+                        pulsarBorder.setOutlineColor(sf::Color::White);
+                        selectedShip = pulsar;
+                    } else {
+                        pulsarBorder.setOutlineColor(sf::Color::Transparent);
+                    }
+                    if (novaSprite.getGlobalBounds().contains(static_cast<sf::Vector2f>(mousePos))) {
+                        novaBorder.setOutlineColor(sf::Color::White);
+                        selectedShip = nova;
+                    } else {
+                        novaBorder.setOutlineColor(sf::Color::Transparent);
+                    }
+                    if (zenithSprite.getGlobalBounds().contains(static_cast<sf::Vector2f>(mousePos))) {
+                        zenithBorder.setOutlineColor(sf::Color::White);
+                        selectedShip = zenith;
+                    } else {
+                        zenithBorder.setOutlineColor(sf::Color::Transparent);
+                    }
+                    if (!pulsarSprite.getGlobalBounds().contains(static_cast<sf::Vector2f>(mousePos)) &&
+                        !novaSprite.getGlobalBounds().contains(static_cast<sf::Vector2f>(mousePos)) &&
+                        !zenithSprite.getGlobalBounds().contains(static_cast<sf::Vector2f>(mousePos)) &&
+                        !startButton.getGlobalBounds().contains(static_cast<sf::Vector2f>(mousePos)) &&
+                        !exitButton.getGlobalBounds().contains(static_cast<sf::Vector2f>(mousePos))) {
+                        selectedShip = none;
+                    }
+                }
+            }
+        }
+
+        menuWindow.clear();
+
+        menuWindow.draw(startButton);
+        menuWindow.draw(startText);
+
+        menuWindow.draw(exitButton);
+        menuWindow.draw(exitText);
+
+        menuWindow.draw(pulsarSprite);
+        menuWindow.draw(novaSprite);
+        menuWindow.draw(zenithSprite);
+
+        menuWindow.draw(pulsarBorder);
+        menuWindow.draw(novaBorder);
+        menuWindow.draw(zenithBorder);
+
+        menuWindow.display();
+    }
+}

sources/Actor.cpp

@@ -21,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;
 }
@@ -39,4 +58,4 @@ void Actor::updateBullets() {
 
 void Actor::setMovingSpeed(float speed) {
     moving_speed = speed;
-}
+}

sources/AdvancedEnemy.cpp

@@ -1,8 +1,8 @@
 #include "../headers/AdvancedEnemy.h"
 #include "../headers/Bullet.h"
+#include "../headers/Plansza.h"
 
 AdvancedEnemy::AdvancedEnemy(int x, int y, const sf::Texture& texture, const sf::Texture& bulletTexture) : Actor(x, y, texture) {
-    actorSprite.setTexture(texture);
     enemyBulletTexture = bulletTexture;
     hp = 2; //  2 punkty życia
     firerate = 2000; // Strzela co 2
@@ -85,5 +85,6 @@ bool AdvancedEnemy::isAlive() const {
 void AdvancedEnemy::takeDamage() {
     if (--hp <= 0) {
         alive = false;
+        Plansza::score += 10;
     }
 }

sources/Beam.cpp

@@ -2,50 +2,21 @@
 
 #include <iostream>
 
-Beam::Beam(float x, float y, float width, float height, const sf::Color& color)
+Beam::Beam(int x, int y, const sf::Texture& texture) {
-    : visible(false) {
+    beamSprite.setOrigin(beamSprite.getLocalBounds().width/2, beamSprite.getLocalBounds().height/2);
-    beamShape.setPosition(x, y);
+    if (texture.getSize().x > 0 && texture.getSize().y > 0) {
-    beamShape.setSize({width, height});
-    beamShape.setFillColor(color);
-
-    if (!beamTexture.loadFromFile("../assets/img/wiazka/wiazka.png")) {
-        std::cerr << "Błąd! Nie można załadować tekstury wiazka.png" << std::endl;
-    }
-    beamSprite.setTexture(beamTexture);
-
-    if (beamTexture.getSize().x > 0 && beamTexture.getSize().y > 0) {
-        float scaleX = width / beamTexture.getSize().x;
-        float scaleY = height / beamTexture.getSize().y;
-        beamSprite.setScale(scaleX, scaleY);
         beamSprite.setPosition(x, y);
     } else {
         std::cerr << "Błąd: Tekstura wiązki nie została poprawnie załadowana." << std::endl;
     }
-
+    beamSprite.setTexture(texture);
 }
 
-void Beam::draw(sf::RenderWindow& window) {
+sf::Sprite Beam::getSprite() {
-
+    return beamSprite;
-    window.draw(beamSprite);
-
 }
 
-void Beam::update() {
+void Beam::setRotation(float angle) {
-}
+    beamSprite.setRotation(angle);
-
-void Beam::render(sf::RenderWindow& window) {
-    window.draw(beamSprite);
-}
-
-sf::FloatRect Beam::getBounds() const {
-    return beamShape.getGlobalBounds();
-}
-
-bool Beam::isVisible() const {
-    return visible;
-}
-
-void Beam::setVisible(bool visible) {
-    this->visible = visible;
 }
 

sources/Bomber.cpp

@@ -1,9 +1,9 @@
 #include "../headers/Bomber.h"
 #include "../headers/Bullet.h"
+#include "../headers/Plansza.h"
 #include <random>
 
 Bomber::Bomber(int x, int y, const sf::Texture& texture, const sf::Texture& bulletTexture) : Actor(x, y, texture) {
-    actorSprite.setTexture(texture);
     BombaTexture = bulletTexture;
     hp = 2; //  2 punkty życia
     firerate = 10000; // Strzela co 10
@@ -121,5 +121,6 @@ bool Bomber::isAlive() const {
 void Bomber::takeDamage() {
     if (--hp <= 0) {
         alive = false;
+        Plansza::score += 15;
     }
 }

sources/Bullet.cpp

@@ -1,8 +1,5 @@
 #include "../headers/Bullet.h"
 
-#include <iostream>
-#include <ostream>
-
 void Bullet::update() {
     //std::cout << "Start update: speed = " << speed << ", position.y = " << position.y << std::endl;
     sprite.move(0.0f, speed);

sources/Enemy.cpp

@@ -1,8 +1,8 @@
 #include "../headers/Enemy.h"
 #include "../headers/Bullet.h"
+#include "../headers/Plansza.h"
 
 Enemy::Enemy(int x, int y, const sf::Texture& texture) : Actor(x, y, texture) {
-    actorSprite.setTexture(texture);
     hp = 1; // Przeciwnik ma 1 punkt życia
     firerate = 2000; // Strzela co 2
     moving_speed = 2.0f; // Prędkość
@@ -75,5 +75,6 @@ bool Enemy::isAlive() const {
 void Enemy::takeDamage() {
     if (--hp <= 0) {
         alive = false;
+        Plansza::score += 5;
     }
 }

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

@@ -1,12 +1,12 @@
-#include "../headers/Kamikadze.h"
-
 #include <iostream>
 #include <random>
-
+#include "../headers/Kamikadze.h"
 #include "../headers/RandomNumberGenerator.h"
+#include "../headers/Plansza.h"
+
+
 
 Kamikadze::Kamikadze(int x, int y, const sf::Texture& texture) : Actor(x, y, texture) {
-    actorSprite.setTexture(texture);
     hp = 3; //  3 punkty życia
     moving_speed = 2.0f; // Prędkość
 }
@@ -130,5 +130,6 @@ bool Kamikadze::isAlive() const {
 void Kamikadze::takeDamage() {
     if (--hp <= 0) {
         alive = false;
+        Plansza::score += 20;
     }
 }

sources/Meteor.cpp

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

sources/ObjectItem.cpp

@@ -1,11 +1,11 @@
 #include "../headers/ObjectItem.hpp"
 
 ObjectItem::ObjectItem(float x, float y, sf::Texture &texture) {
-    Position position_;
+    Position position_ = {0,0};
-    position_.x = x;
+    position_.x = static_cast<int>(x);
-    position_.y = y;
+    position_.y = static_cast<int>(y);
     position = position_;
-    this->texture = texture;
+    this->texture_ = texture;
 }
 
 bool ObjectItem::getStatus() {

sources/Plansza.cpp

@@ -3,14 +3,24 @@
 #include "../headers/Plansza.h"
 #include "../headers/RandomNumberGenerator.h"
 
-Plansza::Plansza(unsigned int windowHeight, unsigned int windowWidth, sf::RenderWindow *mainWindow)
+Plansza::Plansza(unsigned int windowHeight, unsigned int windowWidth, sf::RenderWindow *mainWindow, ships selectedShip)
         : background("../assets/img/background/background.png", 2.0f) {
     window = mainWindow;
     size.height = static_cast<int>(windowHeight);
     size.width = static_cast<int>(windowWidth);
 
+    Plansza::selectedShip = selectedShip;
+
     try {
-        playerTexture.loadFromFile("../assets/ship/Dreadnought-Base.png");
+        if(selectedShip == nova) {
+            playerTexture.loadFromFile("../assets/ship/nova.png");
+        } else if(selectedShip == pulsar) {
+            playerTexture.loadFromFile("../assets/ship/pulsar.png");
+        } else if(selectedShip == zenith) {
+            playerTexture.loadFromFile("../assets/ship/zenith.png");
+        } else {
+            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
@@ -40,12 +50,26 @@ 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);
+    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();
@@ -87,19 +111,25 @@ void Plansza::update() {
     ship->update(); // migotanie statku
     update_score(); // naliczanie punktów
     // Sprawnowanie wszystkich rodzajów wrogów
-    spawn_meteor();
+    // spawn_meteor();
-    spawn_enemy();
+    // spawn_hearts();
-    spawn_advanced_enemy();
+    // spawn_enemy();
+    // spawn_advanced_enemy();
     spawn_wiazkowiec();
-    spawn_bomber();
+    // spawn_bomber();
-    spawn_kamikadze();
+    // spawn_kamikadze();
 
     // utrzymanie meteorów i pocisków w ruchu
-    for (auto &meteor: getMeteors()) {
+    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());
@@ -110,19 +140,64 @@ void Plansza::update() {
         window->draw(rocket.getSprite());
     }
 
-    // Sprawdzenie czy meteory i pociski są poza granicami ekranu
+    // Sprawdzenie, czy meteory i pociski są poza granicami ekranu
     update_meteors();
+    update_hearts();
     ship->updateBullets();
 
     window->draw(ship->getSprite());
 
-    for (auto &meteor: getMeteors()) {
+    for (auto &meteor: meteors) {
         if (ship->getSprite().getGlobalBounds().intersects(meteor.getSprite().getGlobalBounds())) {
             ship->takeDamage();
         }
     }
 
-    if (!ship->isAlive()) {
+    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")) {
@@ -331,7 +406,7 @@ void Plansza::update() {
                 if (playerBulletIt->getSprite().getGlobalBounds().intersects(it->getSprite().getGlobalBounds())) {
                     // Usuń pocisk Bombera i pocisk gracza
                     it = bomberEnemy.getBullets().erase(it);
-                    playerBulletIt = ship->getBullets().erase(playerBulletIt);
+                    ship->getBullets().erase(playerBulletIt);
                     bulletDestroyed = true;
                     break;
                 } else {
@@ -345,7 +420,7 @@ void Plansza::update() {
                     if (rocketIt->getSprite().getGlobalBounds().intersects(it->getSprite().getGlobalBounds())) {
                         // Usuń pocisk Bombera i rakietę gracza
                         it = bomberEnemy.getBullets().erase(it);
-                        rocketIt = ship->getRockets().erase(rocketIt);
+                        ship->getRockets().erase(rocketIt);
                         bulletDestroyed = true;
                         break;
                     } else {
@@ -370,16 +445,16 @@ void Plansza::update() {
     for (auto &wiazkowiec: WEnemies) {
         wiazkowiec.update();
 
-        if (wiazkowiec.isShooting() && wiazkowiec.getBeam().isVisible()) {
+        if (wiazkowiec.isShooting()) {
-            if (ship->getSprite().getGlobalBounds().intersects(wiazkowiec.getBeam().getBounds())) {
+            if (ship->getSprite().getGlobalBounds().intersects(wiazkowiec.getBeam()->getSprite().getGlobalBounds())) {
                 ship->takeDamage(); // Gracz otrzymuje obrażenia
             }
         }
 
         window->draw(wiazkowiec.getSprite());
-        wiazkowiec.render(*window);
     }
 
+    // TODO: naprawić to co średnio działa
     // Usuwanie pocisków, które są poza ekranem srednio to dziala
     for (auto enemyIt = enemies.begin(); enemyIt != enemies.end();) {
         for (auto bulletIt = enemyIt->getBullets().begin(); bulletIt != enemyIt->getBullets().end();) {
@@ -398,7 +473,7 @@ void Plansza::update() {
         bool hit = false;
         for (auto bulletIt = ship->getBullets().begin(); bulletIt != ship->getBullets().end();) {
             if (enemyIt->getSprite().getGlobalBounds().intersects(bulletIt->getSprite().getGlobalBounds())) {
-                bulletIt = ship->getBullets().erase(bulletIt);
+                ship->getBullets().erase(bulletIt);
                 enemyIt->takeDamage();
                 hit = true;
                 break;
@@ -417,7 +492,7 @@ void Plansza::update() {
         bool hit = false;
         for (auto bulletIt = ship->getBullets().begin(); bulletIt != ship->getBullets().end();) {
             if (advancedIt->getSprite().getGlobalBounds().intersects(bulletIt->getSprite().getGlobalBounds())) {
-                bulletIt = ship->getBullets().erase(bulletIt);
+                ship->getBullets().erase(bulletIt);
                 advancedIt->takeDamage();
                 hit = true;
                 break;
@@ -436,7 +511,7 @@ void Plansza::update() {
         bool hit = false;
         for (auto bulletIt = ship->getBullets().begin(); bulletIt != ship->getBullets().end();) {
             if (bomberIt->getSprite().getGlobalBounds().intersects(bulletIt->getSprite().getGlobalBounds())) {
-                bulletIt = ship->getBullets().erase(bulletIt);
+                ship->getBullets().erase(bulletIt);
                 bomberIt->takeDamage();
                 hit = true;
                 break;
@@ -455,7 +530,7 @@ void Plansza::update() {
         bool hit = false;
         for (auto bulletIt = ship->getBullets().begin(); bulletIt != ship->getBullets().end();) {
             if (kamikadzeIt->getSprite().getGlobalBounds().intersects(bulletIt->getSprite().getGlobalBounds())) {
-                bulletIt = ship->getBullets().erase(bulletIt);
+                ship->getBullets().erase(bulletIt);
                 kamikadzeIt->takeDamage();
                 hit = true;
                 break;
@@ -474,7 +549,7 @@ void Plansza::update() {
         bool hit = false;
         for (auto bulletIt = ship->getBullets().begin(); bulletIt != ship->getBullets().end();) {
             if (wiazkowiecIt->getSprite().getGlobalBounds().intersects(bulletIt->getSprite().getGlobalBounds())) {
-                bulletIt = ship->getBullets().erase(bulletIt);
+                ship->getBullets().erase(bulletIt);
                 wiazkowiecIt->takeDamage();
                 hit = true;
                 break;
@@ -496,7 +571,7 @@ void Plansza::update() {
         bool hit = false;
         for (auto rocketIt = ship->getRockets().begin(); rocketIt != ship->getRockets().end();) {
             if (enemyIt->getSprite().getGlobalBounds().intersects(rocketIt->getSprite().getGlobalBounds())) {
-                rocketIt = ship->getRockets().erase(rocketIt);
+                ship->getRockets().erase(rocketIt);
                 enemyIt->takeDamage();
                 hit = true;
                 break;
@@ -515,7 +590,7 @@ void Plansza::update() {
         bool hit = false;
         for (auto rocketIt = ship->getRockets().begin(); rocketIt != ship->getRockets().end();) {
             if (advancedIt->getSprite().getGlobalBounds().intersects(rocketIt->getSprite().getGlobalBounds())) {
-                rocketIt = ship->getRockets().erase(rocketIt);
+                ship->getRockets().erase(rocketIt);
                 advancedIt->takeDamage();
                 hit = true;
                 break;
@@ -534,7 +609,7 @@ void Plansza::update() {
         bool hit = false;
         for (auto rocketIt = ship->getRockets().begin(); rocketIt != ship->getRockets().end();) {
             if (bomberIt->getSprite().getGlobalBounds().intersects(rocketIt->getSprite().getGlobalBounds())) {
-                rocketIt = ship->getRockets().erase(rocketIt);
+                ship->getRockets().erase(rocketIt);
                 bomberIt->takeDamage();
                 hit = true;
                 break;
@@ -553,7 +628,7 @@ void Plansza::update() {
         bool hit = false;
         for (auto rocketIt = ship->getRockets().begin(); rocketIt != ship->getRockets().end();) {
             if (kamikadzeIt->getSprite().getGlobalBounds().intersects(rocketIt->getSprite().getGlobalBounds())) {
-                rocketIt = ship->getRockets().erase(rocketIt);
+                ship->getRockets().erase(rocketIt);
                 kamikadzeIt->takeDamage();
                 hit = true;
                 break;
@@ -572,7 +647,7 @@ void Plansza::update() {
         bool hit = false;
         for (auto rocketIt = ship->getRockets().begin(); rocketIt != ship->getRockets().end();) {
             if (wiazkowiecIt->getSprite().getGlobalBounds().intersects(rocketIt->getSprite().getGlobalBounds())) {
-                rocketIt = ship->getRockets().erase(rocketIt);
+                ship->getRockets().erase(rocketIt);
                 wiazkowiecIt->takeDamage();
                 hit = true;
                 break;
@@ -588,13 +663,43 @@ 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;
+        default:
+            break;
+    }
 
+
+    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
+    // usuwanie meteorów, które wyleciały poza ekran
     for (auto &meteor: meteors) {
         if (meteor.getStatus()) {
             meteors.erase(meteors.begin());
@@ -603,7 +708,7 @@ void Plansza::update_meteors() {
 }
 
 void Plansza::spawn_meteor() {
-    if (spawnClock.getElapsedTime().asSeconds() > rand() % 10 + 1) { // randomowy spawn meteorytów od 10 do 1 sekundy
+    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);
@@ -611,7 +716,16 @@ void Plansza::spawn_meteor() {
                 meteors.emplace_back(RandomNumberGenerator::getRandomNumber(50, 499), -100, meteorTexture1);
             }
         }
-        spawnClock.restart();
+        meteorSpawnClock.restart();
+    }
+}
+
+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
+             hearts.emplace_back(RandomNumberGenerator::getRandomNumber(50, 499), -100, heartTexture);
+        }
+        heartSpawnClock.restart();
     }
 }
 
@@ -662,17 +776,28 @@ void Plansza::spawn_kamikadze() {
 }
 
 void Plansza::spawn_wiazkowiec() {
-    if (WiazkowiecSpawnClock.getElapsedTime().asSeconds() >= 50) { // Spawn co 10 sekund
+    if (WiazkowiecSpawnClock.getElapsedTime().asSeconds() >= 5) { // Spawn co 10 sekund
-        int spawnX = RandomNumberGenerator::getRandomNumber(50, size.width - 50);
+        if (WEnemies.size() < 1) {
-        Wiazkowiec wiazkowiec(spawnX, -50, WiazkowiecTexture);
+            int spawnX = RandomNumberGenerator::getRandomNumber(50, size.width - 50);
-        wiazkowiec.setPlanszaHeight(size.height, size.width); // Przekazanie wysokości i szerokosci okna
+            Wiazkowiec wiazkowiec(spawnX, -50, WiazkowiecTexture, window);
-        WEnemies.push_back(wiazkowiec);
+            wiazkowiec.setPlanszaHeight(size.height, size.width); // Przekazanie wysokości i szerokosci okna
-        std::cout << "Spawned Wiazkowiec Enemy at X: " << spawnX << std::endl;
+            WEnemies.push_back(wiazkowiec);
-        WiazkowiecSpawnClock.restart();
+            std::cout << "Spawned Wiazkowiec Enemy at X: " << spawnX << std::endl;
+            WiazkowiecSpawnClock.restart();
+        }
     }
 }
 
 
+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;
 }
@@ -692,4 +817,7 @@ void Plansza::update_score() {
     text.setFillColor(sf::Color::White);
     text.setPosition(25, 25);
     window->draw(text);
-}
+}
+
+ships Plansza::selectedShip = none;
+unsigned int Plansza::score = 0;

sources/Player.cpp

@@ -2,11 +2,15 @@
 
 #include <iostream>
 #include <SFML/Graphics/Font.hpp>
-#include <SFML/Graphics/RenderWindow.hpp>
 #include <SFML/Graphics/Text.hpp>
 
-Player::Player(int x, int y, const sf::Texture& texture) : Actor(x, y, texture) {
+#include "../headers/Plansza.h"
 
+Player::Player(int x, int y, const sf::Texture& texture) : Actor(x, y, texture) {
+    hp = 3;
+    if(Plansza::selectedShip != none) {
+        actorSprite.setScale(0.20f, 0.20f);
+    }
 }
 
 Player* Player::getInstance(int x, int y, const sf::Texture& texture) {
@@ -17,8 +21,16 @@ Player* Player::getInstance(int x, int y, const sf::Texture& texture) {
 }
 
 void Player::loadTexture() {
-    bulletTexture.loadFromFile("../assets/img/bullets/bullet_pink.png");
+    try {
-    rocketTexture.loadFromFile("../assets/img/rockets/Rocket_111.png");
+        bulletTexture.loadFromFile("../assets/img/bullets/bullet_pink.png");
+        rocketTexture.loadFromFile("../assets/img/rockets/Rocket_111.png");
+    } catch (std::exception &e) {
+        std::cerr << "Failed to load textures: " << e.what() << std::endl;
+        exit(-500);
+    }
+
+    damageDealClock.restart();
+    originalColor = actorSprite.getColor();
 }
 
 void Player::shoot() {
@@ -59,26 +71,14 @@ void Player::update() {
 
 void Player::takeDamage() {
     if (!isImmortal) {
-        if (health > 0) {
+        if (hp > 0) {
-            health--;
+            hp--;
-            std::cout << "Player hit! Remaining health: " << health << "\n";
             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;
 }

sources/Rocket.cpp

@@ -2,7 +2,7 @@
 
 void Rocket::update() {
     sprite.move(0.0f, speed);
-    position.y += int(speed);
+    position.y += static_cast<int>(speed);
     if(position.y < -100) {
         outOfBounds = true;
     }

sources/Wiazkowiec.cpp

@@ -1,56 +1,60 @@
 #include "../headers/Wiazkowiec.h"
+#include "../headers/Plansza.h"
+#include "../headers/RandomNumberGenerator.h"
 
 #include <iostream>
 
-#include "../headers/Bullet.h"
-#include <random>
 
-Wiazkowiec::Wiazkowiec(int x, int y, const sf::Texture& texture) : Actor(x, y, texture), beam(0, 0, 50.f, 50.f, sf::Color::Red) {
+Wiazkowiec::Wiazkowiec(int x, int y, const sf::Texture &texture, sf::RenderWindow *window) : Actor(x, y, texture),
-    actorSprite.setTexture(texture);
+    beam(nullptr)
+{
+    window_ptr = window;
+
+    try {
+        beamTexture.loadFromFile("../assets/img/wiazka/laser.png");
+    } catch (std::exception &e) {
+        std::cerr << "Failed to load textures: " << e.what() << std::endl;
+        exit(-500);
+    }
+
     hp = 2; //  2 punkty życia
     firerate = 5000; // Strzela co 10
     moving_speed = 5.0f; // Prędkość
 }
 
-void Wiazkowiec::setPlanszaHeight(float height, float width) {
+void Wiazkowiec::setPlanszaHeight(int height, int width) {
     planszaHeight = height;
     planszaWidth = width;
 }
 
 void Wiazkowiec::spawnBeam() {
-    float beamX = position.x;
+    int beamX = actorSprite.getPosition().x;
-    float beamY = position.y;
+    int beamY = actorSprite.getPosition().y;
-    float beamWidth = 50.f;
-    float beamHeight = 0.f;
 
     switch (direction) {
-        case DirectionW::Up:
+        case DirectionW::Up: {
-            beamHeight = position.y;
+            beam = new Beam(beamX, beamY, beamTexture);
-        beamY -= beamHeight;
+            beam->setRotation(180);
-        beam = Beam(beamX, beamY, beamWidth, beamHeight, sf::Color::Red);
+            break;
-        break;
+        }
-        case DirectionW::Down:
+        case DirectionW::Down: {
-            beamHeight = planszaHeight - position.y;
+            beam = new Beam(beamX, beamY, beamTexture);
-            beam = Beam(beamX, beamY, beamWidth, beamHeight, sf::Color::Red);
+            break;
-        break;
+        }
-        case DirectionW::Left:
+        case DirectionW::Left: {
-            beamHeight = 50.f;
+            beam = new Beam(beamX, beamY, beamTexture);
-        beamWidth = position.x;
+            beam->setRotation(90);
-        beamX -= beamWidth;
+            break;
-        beamY = position.y + (actorSprite.getGlobalBounds().height / 2) - 25.f;
+        }
-        beam = Beam(beamX, beamY, beamWidth, beamHeight, sf::Color::Red);
+        case DirectionW::Right: {
-        break;
+            beam = new Beam(beamX, beamY, beamTexture);
-        case DirectionW::Right:
+            beam->setRotation(270);
-            beamHeight = 50.f;
+            break;
-        beamWidth = 800 - position.x;
+        }
-        beamY = position.y + (actorSprite.getGlobalBounds().height / 2) - 25.f;
+        default:
-        beam = Beam(beamX, beamY, beamWidth, beamHeight, sf::Color::Red);
+            break;
-        break;
     }
 
-    beam = Beam(beamX, beamY, beamWidth, beamHeight, sf::Color::Red);
-    beam.setVisible(true);
-
     shooting = true;
     shootingClock.restart();
 }
@@ -59,31 +63,53 @@ void Wiazkowiec::spawnBeam() {
 void Wiazkowiec::shoot() {
     if (!shooting) {
         spawnBeam();
-        std::cout << "Wiazkowiec shot a beam!" << std::endl;
+    }
+    switch (direction) {
+        case DirectionW::Up: {
+            std::cout << "Direction is up" << std::endl;
+            break;
+        }
+        case DirectionW::Down: {
+            std::cout << "Direction is down" << std::endl;
+            break;
+        }
+        case DirectionW::Left: {
+            std::cout << "Direction is left" << std::endl;
+            break;
+        }
+        case DirectionW::Right: {
+            std::cout << "Direction is right" << std::endl;
+            break;
+        }
+        default:
+            break;
     }
 }
 
 void Wiazkowiec::setRandomDirection() {
     // Losowanie kierunku: 0 = Up, 1 = Down, 2 = Left, 3 = Right
-    int directionIndex = std::rand() % 4;
 
-    switch (directionIndex) {
+    int whatNumber = rand() % 4;
+
+    switch (whatNumber) {
         case 0:
             direction = DirectionW::Up;
-        break;
+            break;
         case 1:
             direction = DirectionW::Down;
-        break;
+            break;
         case 2:
             direction = DirectionW::Left;
-        break;
+            break;
         case 3:
             direction = DirectionW::Right;
-        break;
+            break;
+        default:
+            break;
     }
 }
 
-void Wiazkowiec::updateDirection() {
+void Wiazkowiec::checkIfBeamShootOutOfBounds() {
     auto spriteBounds = actorSprite.getGlobalBounds(); // Pobierz rozmiar i pozycję sprite'a
 
     // Kontrola górnej i dolnej krawędzi
@@ -106,17 +132,17 @@ void Wiazkowiec::move(float deltaX, float deltaY) {
     auto spriteBounds = actorSprite.getGlobalBounds(); // Rozmiar i pozycja sprite'a
 
     // Zapobiegaj wyjściu poza poziome granice
-    if (position.x + deltaX < 0) {
+    if (static_cast<float>(position.x) + deltaX < 0) {
-        deltaX = -position.x;
+        deltaX = static_cast<float>(-position.x);
-    } else if (position.x + spriteBounds.width + deltaX > planszaWidth) {
+    } else if (static_cast<float>(position.x) + spriteBounds.width + deltaX > static_cast<float>(planszaWidth)) {
-        deltaX = planszaWidth - (position.x + spriteBounds.width);
+        deltaX = static_cast<float>(planszaWidth) - (static_cast<float>(position.x) + spriteBounds.width);
     }
 
     // Zapobiegaj wyjściu poza pionowe granice
-    if (position.y + deltaY < 0) {
+    if (static_cast<float>(position.y) + deltaY < 0) {
-        deltaY = -position.y;
+        deltaY = static_cast<float>(-position.y);
-    } else if (position.y + spriteBounds.height + deltaY > planszaHeight) {
+    } else if (static_cast<float>(position.y) + spriteBounds.height + deltaY > static_cast<float>(planszaHeight)) {
-        deltaY = planszaHeight - (position.y + spriteBounds.height);
+        deltaY = static_cast<float>(planszaHeight) - (static_cast<float>(position.y) + spriteBounds.height);
     }
 
     actorSprite.move(deltaX, deltaY);
@@ -133,42 +159,39 @@ void Wiazkowiec::update() {
     if (shooting) {
         // Kontrola zakończenia strzału
         if (shootingClock.getElapsedTime().asSeconds() >= beamDuration) {
-            beam.setVisible(false);
             shooting = false;
+            delete beam;
+            beam = nullptr;
             setRandomDirection(); // Zmień kierunek po strzale
+        } else {
+            window_ptr->draw(beam->getSprite());
         }
     } else {
-        updateDirection();
+        checkIfBeamShootOutOfBounds();
 
         switch (direction) {
             case DirectionW::Up:
                 moveUp();
-            break;
+                break;
             case DirectionW::Down:
                 moveDown();
-            break;
+                break;
             case DirectionW::Left:
                 moveLeft();
-            break;
+                break;
             case DirectionW::Right:
                 moveRight();
-            break;
+                break;
         }
 
-        if (shootClock.getElapsedTime().asSeconds() >= 3.0f) {  // Co 3 sekundy
+        if (shootClock.getElapsedTime().asSeconds() >= 3.0f) {
+            // Co 3 sekundy
             shoot();
             shootClock.restart();
         }
     }
 }
 
-// Ustawianie widoczności wiązki podczas renderowania
-void Wiazkowiec::render(sf::RenderWindow& window) {
-    if (beam.isVisible()) {
-        beam.render(window);
-    }
-}
-
 bool Wiazkowiec::isAlive() const {
     return alive;
 }
@@ -176,6 +199,7 @@ bool Wiazkowiec::isAlive() const {
 void Wiazkowiec::takeDamage() {
     if (--hp <= 0) {
         alive = false;
+        Plansza::score += 10;
     }
 }
 
@@ -183,6 +207,6 @@ bool Wiazkowiec::isShooting() const {
     return shooting;
 }
 
-const Beam& Wiazkowiec::getBeam() const {
+Beam* Wiazkowiec::getBeam() const {
     return beam;
-}
+}