diff --git a/shm/CMakeLists.txt b/shm/CMakeLists.txt
index 5590fc92a..504367b87 100644
--- a/shm/CMakeLists.txt
+++ b/shm/CMakeLists.txt
@@ -3,16 +3,17 @@ cmake_minimum_required(VERSION 3.10)
 project(SHM_2077)
 
 set(FILES
+    alcohol.cpp
+    cargo.cpp
+    coordinates.cpp
+    fruit.cpp 
     island.cpp
+    item.cpp 
     map.cpp
     player.cpp
     ship.cpp
-    coordinates.cpp
-    cargo.cpp
     store.cpp
-    alcohol.cpp
-    item.cpp 
-    fruit.cpp 
+    time.cpp
     )
 
 set(FLAGS 
diff --git a/shm/alcohol.cpp b/shm/alcohol.cpp
index add2b2f5e..cef680e33 100644
--- a/shm/alcohol.cpp
+++ b/shm/alcohol.cpp
@@ -1,27 +1,36 @@
 #include "alcohol.hpp"
 #include <iostream>
 
-Alcohol::Alcohol(const std::string& name, size_t amount, size_t basePrice, size_t percentage)
-        : Cargo(name, amount, basePrice), percentage_(percentage) {} ;
+Alcohol::Alcohol(const std::string& name,
+    size_t amount,
+    size_t basePrice,
+    size_t percentage,
+    Time* time)
+    : Cargo(name, amount, basePrice, time)
+    , percentage_(percentage) {};
 
-size_t Alcohol::getPrice() const {
-    return static_cast<size_t>(basePrice_ * static_cast<float>(percentage_)/static_cast<float>(MaxPercentage));
+size_t Alcohol::getPrice() const
+{
+    return static_cast<size_t>(basePrice_ * static_cast<float>(percentage_) / static_cast<float>(MaxPercentage));
 }
 
-Cargo& Alcohol::operator+=(size_t amount) {
+Cargo& Alcohol::operator+=(size_t amount)
+{
     amount_ += amount;
     return *this;
 }
 
-Cargo& Alcohol::operator-=(size_t amount) {
- if (amount <= amount_) {
+Cargo& Alcohol::operator-=(size_t amount)
+{
+    if (amount <= amount_) {
         amount_ -= amount;
-    } else if(amount_ < 0){
+    } else if (amount_ < 0) {
         std::cerr << "Amount of cargo can not be under 0!!!\n";
     }
     return *this;
 }
 
-bool Alcohol::operator==(const Cargo& cargo) const {
-        return cargo.getName() == getName();
+bool Alcohol::operator==(const Cargo& cargo) const
+{
+    return cargo.getName() == getName();
 }
\ No newline at end of file
diff --git a/shm/alcohol.hpp b/shm/alcohol.hpp
index 8dd3f7d14..90d9b8390 100644
--- a/shm/alcohol.hpp
+++ b/shm/alcohol.hpp
@@ -1,12 +1,16 @@
 #pragma once
 #include "cargo.hpp"
 
-constexpr size_t MaxPercentage{96};
-//Class responsible for managing Alcohol in the game.
+constexpr size_t MaxPercentage { 96 };
+// Class responsible for managing Alcohol in the game.
 class Alcohol : public Cargo {
 public:
-    Alcohol(const std::string& name, size_t amount, size_t basePrice, size_t percentage);
-    ~Alcohol() override{};
+    Alcohol(const std::string& name,
+        size_t amount,
+        size_t basePrice,
+        size_t percentage,
+        Time* time);
+    ~Alcohol() override {};
 
     Cargo& operator+=(size_t amount) override;
     Cargo& operator-=(size_t amount) override;
@@ -15,12 +19,13 @@ class Alcohol : public Cargo {
     size_t getPercentage() const { return percentage_; };
     void setPercentage(size_t percentage) { percentage_ = percentage; };
 
-    //Methods override from Cargo class.
+    // Methods override from Cargo class.
     size_t getPrice() const override;
     std::string getName() const override { return name_; };
     size_t getAmount() const override { return amount_; };
     size_t getBasePrice() const override { return basePrice_; };
-    void setAmount(const size_t& amount) override { amount_ = amount;};
+    void setAmount(const size_t& amount) override { amount_ = amount; };
+
 private:
     size_t percentage_;
 };
\ No newline at end of file
diff --git a/shm/cargo.cpp b/shm/cargo.cpp
index 586a13c97..b2263e8bf 100644
--- a/shm/cargo.cpp
+++ b/shm/cargo.cpp
@@ -1,21 +1,26 @@
-#include <iostream>
 #include "cargo.hpp"
+#include <iostream>
 
-Cargo::Cargo(const std::string& name, size_t amount, size_t basePrice, Time *time)
+Cargo::Cargo(const std::string& name,
+    size_t amount,
+    size_t basePrice,
+    Time* time)
     : name_(name)
     , amount_(amount)
     , basePrice_(basePrice)
     , time_(time)
-    {
-        time->attachObserver(this);
-    }
+{
+    time->attachObserver(this);
+}
 
-Cargo& Cargo::operator+=(size_t amount) {
+Cargo& Cargo::operator+=(size_t amount)
+{
     amount_ += amount;
     return *this;
 }
 
-Cargo& Cargo::operator-=(size_t amount) {
+Cargo& Cargo::operator-=(size_t amount)
+{
     if (amount <= amount_) {
         amount_ -= amount;
     } else {
@@ -24,11 +29,13 @@ Cargo& Cargo::operator-=(size_t amount) {
     return *this;
 }
 
-bool Cargo::operator==(const Cargo& cargo) const {
+bool Cargo::operator==(const Cargo& cargo) const
+{
     return cargo.getName() == getName();
 }
 
-void Cargo::nextDay() {
+void Cargo::nextDay()
+{
     if (lifespan_ >= 0.01) {
         lifespan_ -= 0.01;
     }
diff --git a/shm/cargo.hpp b/shm/cargo.hpp
index 021194205..589dcc8df 100644
--- a/shm/cargo.hpp
+++ b/shm/cargo.hpp
@@ -1,13 +1,13 @@
 
 #pragma once
-#include <string>
-#include "time.hpp"
 #include "iObserver.hpp"
+#include "time.hpp"
+#include <string>
 
-//Class responsible for managing Cargo in the game.
+// Class responsible for managing Cargo in the game.
 class Cargo : public IObserver {
 public:
-    Cargo(const std::string& name, size_t amount, size_t basePrice, Time *time);
+    Cargo(const std::string& name, size_t amount, size_t basePrice, Time* time);
     Cargo(const std::string& name, size_t amount, size_t basePrice);
     virtual ~Cargo() = default;
 
@@ -22,7 +22,7 @@ class Cargo : public IObserver {
 
     virtual void setAmount(const size_t& amount) = 0; //{ amount_ = amount; };
     void nextDay();
-    
+
 protected:
     std::string name_;
     size_t amount_;
diff --git a/shm/coordinates.cpp b/shm/coordinates.cpp
index 043eca120..c23350e47 100644
--- a/shm/coordinates.cpp
+++ b/shm/coordinates.cpp
@@ -1,23 +1,32 @@
 #include "coordinates.hpp"
 
-void Coordinates::setPositionX(size_t positionX) {
+void Coordinates::setPositionX(size_t positionX)
+{
     positionX = positionX_;
 }
-size_t Coordinates::getPositionX() const {
+size_t Coordinates::getPositionX() const
+{
     return positionX_;
 }
 
-void Coordinates::setPositionY(size_t positionY) {
+void Coordinates::setPositionY(size_t positionY)
+{
     positionY = positionY_;
 }
-size_t Coordinates::getPositionY() const {
+size_t Coordinates::getPositionY() const
+{
     return positionY_;
 }
 
-bool Coordinates::operator== (const Coordinates n_pos) const {
+bool Coordinates::operator==(const Coordinates n_pos) const
+{
     return positionX_ == n_pos.positionX_ && positionY_ == n_pos.positionY_;
 }
 
-size_t Coordinates::distance(const Coordinates& lhs, const Coordinates& rhs) {
-    return std::round(std::sqrt(std::pow((static_cast<int>(lhs.getPositionX()) - static_cast<int>(rhs.getPositionX())),2) + std::pow((static_cast<int>(lhs.getPositionY()) - static_cast<int>(rhs.getPositionY())),2)));
+size_t Coordinates::distance(const Coordinates& lhs, const Coordinates& rhs)
+{
+    return std::round(std::sqrt(std::pow((static_cast<int>(lhs.getPositionX()) - static_cast<int>(rhs.getPositionX())),
+                                    2)
+        + std::pow((static_cast<int>(lhs.getPositionY()) - static_cast<int>(rhs.getPositionY())),
+            2)));
 }
diff --git a/shm/coordinates.hpp b/shm/coordinates.hpp
index b7433a8ff..aafab8f99 100644
--- a/shm/coordinates.hpp
+++ b/shm/coordinates.hpp
@@ -4,24 +4,26 @@
 class Coordinates {
 public:
     Coordinates()
-    : positionX_(0)
-    , positionY_(0)
-    {}
+        : positionX_(0)
+        , positionY_(0)
+    {
+    }
 
-    Coordinates(size_t positionX, size_t positionY) 
-    : positionX_(positionX)
-    , positionY_(positionY)
-    {}
+    Coordinates(size_t positionX, size_t positionY)
+        : positionX_(positionX)
+        , positionY_(positionY)
+    {
+    }
 
-    void setPositionX(size_t );
+    void setPositionX(size_t);
     size_t getPositionX() const;
 
-    void setPositionY(size_t );
+    void setPositionY(size_t);
     size_t getPositionY() const;
 
-    bool operator== (const Coordinates ) const;
+    bool operator==(const Coordinates) const;
 
-    size_t distance(const Coordinates& , const Coordinates& );
+    size_t distance(const Coordinates&, const Coordinates&);
 
 private:
     size_t positionX_;
diff --git a/shm/fruit.cpp b/shm/fruit.cpp
index 0c11e3a4b..d8e7510b7 100644
--- a/shm/fruit.cpp
+++ b/shm/fruit.cpp
@@ -1,19 +1,27 @@
 #include "fruit.hpp"
 #include <iostream>
 
-Fruit::Fruit(const std::string& name, size_t amount, size_t basePrice, size_t expirationDate)
-         : Cargo(name, amount, basePrice), expirationDate_(expirationDate) {};
+Fruit::Fruit(const std::string& name,
+    size_t amount,
+    size_t basePrice,
+    size_t expirationDate,
+    Time* time)
+    : Cargo(name, amount, basePrice, time)
+    , expirationDate_(expirationDate) {};
 
-size_t Fruit::getPrice() const  {
-    return static_cast<size_t>( basePrice_ * static_cast<float>(purchaseDate_)/ expirationDate_);
+size_t Fruit::getPrice() const
+{
+    return static_cast<size_t>(basePrice_ * static_cast<float>(purchaseDate_) / expirationDate_);
 }
 
-Cargo& Fruit::operator+=(size_t amount) {
+Cargo& Fruit::operator+=(size_t amount)
+{
     amount_ += amount;
     return *this;
 }
 
-Cargo& Fruit::operator-=(size_t amount) {
+Cargo& Fruit::operator-=(size_t amount)
+{
     if (amount <= amount_) {
         amount_ -= amount;
     } else {
@@ -22,20 +30,23 @@ Cargo& Fruit::operator-=(size_t amount) {
     return *this;
 }
 
-bool Fruit::operator==(const Cargo& cargo) const {
+bool Fruit::operator==(const Cargo& cargo) const
+{
     return cargo.getName() == getName();
 }
 
-Fruit& Fruit::operator--() {
-    if(purchaseDate_ <= 0) {
+Fruit& Fruit::operator--()
+{
+    if (purchaseDate_ <= 0) {
         purchaseDate_ = 0;
     }
     purchaseDate_--;
     return *this;
 }
 
-Fruit& Fruit::operator--(int) {
-    if(purchaseDate_ <= 0) {
+Fruit& Fruit::operator--(int)
+{
+    if (purchaseDate_ <= 0) {
         purchaseDate_ = 0;
     }
     purchaseDate_--;
diff --git a/shm/fruit.hpp b/shm/fruit.hpp
index 2d8ba12b5..59a69ad9e 100644
--- a/shm/fruit.hpp
+++ b/shm/fruit.hpp
@@ -1,10 +1,14 @@
 #pragma once
 
 #include "cargo.hpp"
-//Class responsible for managing Fruit in the game.
+// Class responsible for managing Fruit in the game.
 class Fruit : public Cargo {
 public:
-    Fruit(const std::string& name, size_t amount, size_t basePrice, size_t expirationDate);
+    Fruit(const std::string& name,
+        size_t amount,
+        size_t basePrice,
+        size_t expirationDate,
+        Time* time);
     ~Fruit() override {};
 
     Cargo& operator+=(size_t amount) override;
@@ -13,7 +17,7 @@ class Fruit : public Cargo {
     virtual Fruit& operator--();
     virtual Fruit& operator--(int);
 
-    //Methods override from Cargo class.
+    // Methods override from Cargo class.
     virtual size_t getPrice() const override;
     virtual std::string getName() const override { return name_; };
     size_t getAmount() const override { return amount_; };
@@ -21,7 +25,7 @@ class Fruit : public Cargo {
 
     size_t getExpirationDate() const { return expirationDate_; };
     size_t getPurchaseData() const { return purchaseDate_; };
-    void setAmount(const size_t& amount) override { amount_ = amount;};
+    void setAmount(const size_t& amount) override { amount_ = amount; };
 
 protected:
     size_t expirationDate_;
diff --git a/shm/game.cpp b/shm/game.cpp
new file mode 100644
index 000000000..7088878fa
--- /dev/null
+++ b/shm/game.cpp
@@ -0,0 +1,240 @@
+#include "game.hpp"
+#include "map.hpp"
+#include <iomanip>
+
+Game::Game(size_t money, size_t days, size_t goal)
+    : money_(money)
+    , gameDayes_(days)
+    , finalGoal_(goal)
+{
+    time_ = std::make_shared<Time>(gameDayes_);
+    map_ = std::make_shared<Map>(time_);
+    ship_ = std::make_shared<Ship>(1000, 40, 10, 20, "Santa Blanca", 1, 40);
+    player_ = std::make_shared<Player>(ship_, money);
+}
+
+//   ship_(std::make_shared<Ship>(1000, 40, 15, 10, "Babilon", 2, {}, 10))
+
+Game::~Game() {};
+
+void Game::startGame()
+{
+    printHeader();
+    // printMenu();
+
+    // size_t option;
+
+    // std::cin >> option;
+
+    while (true) {
+        if (checkWinCondition()) {
+            printWinScreen();
+            exit();
+        } else if (checkLoseCondition()) {
+            break;
+        }
+        printMenu();
+        std::cout << "Write your choice: ";
+        size_t choice;
+
+        std::cin.clear();
+        std::cin >> choice;
+
+        chooseOption(static_cast<MenuOption>(choice));
+    }
+    // printLoseScreen();
+    // exit();
+}
+
+void Game::printMenu()
+{
+    std::cout << "/" << std::setfill('-') << std::setw(100) << "/\n";
+    std::cout << "*" << std::setfill(' ') << std::setw(58)
+              << " CHOOSE ACTION: " << std::setw(42) << "/\n";
+    std::cout << "/" << std::setfill('-') << std::setw(100) << "/\n";
+    std::cout << "/" << std::setfill(' ') << std::setw(100) << "/\n";
+    std::cout << "/" << std::setfill(' ') << std::setw(55)
+              << " 1. TRAVEL: " << std::setw(45) << "/\n";
+    std::cout << "/" << std::setfill(' ') << std::setw(60)
+              << " 2. PRINT CARGO: " << std::setw(40) << "/\n";
+    std::cout << "/" << std::setfill(' ') << std::setw(52)
+              << " 3. BUY: " << std::setw(48) << "/\n";
+    std::cout << "/" << std::setfill(' ') << std::setw(53)
+              << " 4. SELL: " << std::setw(47) << "/\n";
+    std::cout << "/" << std::setfill(' ') << std::setw(53)
+              << " 5. EXIT: " << std::setw(47) << "/\n";
+    std::cout << "/" << std::setfill('-') << std::setw(100) << "/\n";
+}
+
+void Game::printHeader()
+{
+    std::cout << "/" << std::setfill('-') << std::setw(100) << "/\n";
+    std::cout << "/" << std::setfill(' ') << std::setw(100) << "/\n";
+    std::cout << "/" << std::setfill(' ') << std::setw(62)
+              << "Welcom to the game SHM" << std::setw(38) << "/\n";
+    std::cout << "/" << std::setfill(' ') << std::setw(100) << "/\n";
+    std::cout << "/" << std::setfill(' ') << std::setw(55)
+              << "YOUR MONEY: " << std::setw(4) << money_ << std::setw(41)
+              << "/\n";
+    std::cout << "/" << std::setfill(' ') << std::setw(54)
+              << "YOUR GOAL: " << std::setw(5) << finalGoal_ << std::setw(41)
+              << "/\n";
+    std::cout << "/" << std::setfill(' ') << std::setw(54)
+              << "TIME LEFT: " << std::setw(5) << gameDayes_ << std::setw(41)
+              << "/\n";
+    std::cout << "/" << std::setfill(' ') << std::setw(100) << "/\n";
+    std::cout << "/" << std::setfill('-') << std::setw(100) << "/\n";
+}
+
+void Game::printWinScreen()
+{
+    std::cout << "/" << std::setfill('-') << std::setw(100) << "/\n";
+    std::cout << "/" << std::setfill(' ') << std::setw(100) << "/\n";
+    std::cout << "/" << std::setfill(' ') << std::setw(60) << "CONGRATULATION!!!!"
+              << std::setw(40) << "/\n";
+    std::cout << "/" << std::setfill(' ') << std::setw(100) << "/\n";
+    std::cout << "/" << std::setfill(' ') << std::setw(55) << "YOU WIN!!"
+              << std::setw(45) << "/\n";
+    std::cout << "/" << std::setfill(' ') << std::setw(100) << "/\n";
+    std::cout << "/" << std::setfill('-') << std::setw(100) << "/\n";
+}
+
+void Game::printLoseScreen()
+{
+    std::cout << "/" << std::setfill('-') << std::setw(100) << "/\n";
+    std::cout << "/" << std::setfill(' ') << std::setw(100) << "/\n";
+    std::cout << "/" << std::setfill(' ') << std::setw(60) << "YOU HAVE LOST!!!!"
+              << std::setw(40) << "/\n";
+    std::cout << "/" << std::setfill(' ') << std::setw(100) << "/\n";
+    std::cout << "/" << std::setfill(' ') << std::setw(55) << "SORRY!!!"
+              << std::setw(45) << "/\n";
+    std::cout << "/" << std::setfill(' ') << std::setw(100) << "/\n";
+    std::cout << "/" << std::setfill('-') << std::setw(100) << "/\n";
+}
+
+bool Game::checkWinCondition()
+{
+    // if (player_->getMoney() >= finalGoal_) {
+    //     return true;
+    // }
+    return false;
+}
+
+bool Game::checkLoseCondition()
+{
+    return money_ = 0 || (gameDayes_ >= 0 && money_ < finalGoal_);
+}
+
+void Game::chooseOption(MenuOption option)
+{
+    switch (option) {
+    case MenuOption::Travel:
+        travel();
+        break;
+    case MenuOption::PrintCargo:
+        printCargo();
+        break;
+    case MenuOption::Buy:
+        buy();
+        break;
+    case MenuOption::Sell:
+        sell();
+        break;
+    case MenuOption::Exit:
+        exit();
+        break;
+    default:
+        std::cout << "Try again\n";
+        break;
+    }
+}
+
+void Game::exit()
+{
+    std::exit(0);
+}
+
+void Game::sell()
+{
+    // Space for a code
+}
+
+void Game::printMap(std::shared_ptr<Map> map)
+{
+    // Space for a code.
+}
+
+void Game::travel()
+{
+    // std::cout << "Travel\n";
+    // map_->printCurrentPosition();
+    // std::cout << "Choose island [x, y]: ";
+    // size_t x, y;
+    // std::cin >> x >> y;
+    // while (std::cin.fail()) {
+    //     std::cin.clear();
+    //     std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
+    //     std::cout << "Wrong data type. Enter two digits: ";
+    //     std::cin >> x >> y;
+    // }
+
+    // // auto coordinates = Coordinates(x, y);
+
+    // // std::cout << coordinates.getPositionX() << '\n';
+    // // std::cout << coordinates.getPositionY() << '\n';
+    // // auto destination = map_->getIsland(coordinates);
+
+    // // std::cout << "What the fuck is destination coordinates: " <<
+    // destination.get()->getPosition().getPositionX();
+
+    // // if (destination != nullptr) {
+    // //     for (auto i = map_->getDistanceToIsland(destination); i > 0; i--) {
+    // //         (*time_)++;
+    // //         // if (time_->getTimeElapsed() == 0) {
+    // //         //     break;
+    // //         // }
+    // //     }
+    // //     // map_->travel(destination);
+    // // } else {
+    // //     std::cout << "Wrong coordinates!" << '\n';
+    // }
+}
+
+void Game::buy()
+{
+    std::cout << "Buy\n";
+
+    // Spcae for  a code.
+    // auto actualIslandStore = map_->getIsland(1);
+    // std::cout << &actualIslandStore << '\n';
+    // size_t cargoNr, amountNr;
+    // std::cout << "Write cargo number: ";
+    // std::cin >> cargoNr;
+    // std::cout << "Write amount: ";
+    // std::cin >> amountNr;
+
+    // while(std::cin.fail() || cargoNr < 0 || cargoNr >> 5 /* wielkość wektora
+    // ilosći zakupów w Store*/) {
+    //     std::cin.clear();
+    //     std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
+    //     std::cout << " Wrong data. First digit from 0 to " <<  12/* wektor
+    //     size*/ << ": "; std::cin >> cargoNr;
+    // }
+    // cargoNr--;
+
+    // Response
+}
+
+void Game::printCargo()
+{
+    std::cout << "Chuj, dupa i kamienia kupa\n";
+    player_->printCargo();
+}
+
+void Game::setPlayer()
+{
+    std::cout << "Set ship name!";
+    std::string shipName;
+    std::cin >> shipName;
+    ship_->setName(shipName);
+}
\ No newline at end of file
diff --git a/shm/game.hpp b/shm/game.hpp
new file mode 100644
index 000000000..dbf49c9e5
--- /dev/null
+++ b/shm/game.hpp
@@ -0,0 +1,53 @@
+#pragma once
+#include <iostream>
+#include <memory>
+
+#include "coordinates.hpp"
+#include "island.hpp"
+#include "map.hpp"
+#include "player.hpp"
+#include "ship.hpp"
+#include "time.hpp"
+
+class Game {
+    enum class MenuOption { Travel = 1,
+        PrintCargo,
+        Buy,
+        Sell,
+        Exit };
+
+public:
+    // Game();
+    Game(size_t money, size_t days, size_t goal);
+    ~Game();
+    void startGame();
+
+    void printWinScreen();
+    void printLoseScreen();
+    void printHeader();
+    void printMenu();
+
+    bool checkLoseCondition();
+    bool checkWinCondition();
+
+    void setPlayer();
+
+    void chooseOption(MenuOption option);
+    void printMap(std::shared_ptr<Map>);
+    void printCargo();
+    void travel();
+    void sell();
+    void exit();
+    void buy();
+
+private:
+    size_t money_;
+    size_t gameDayes_;
+    size_t finalGoal_;
+
+    std::shared_ptr<Player> player_;
+    ;
+    std::shared_ptr<Ship> ship_;
+    std::shared_ptr<Time> time_;
+    std::shared_ptr<Map> map_;
+};
\ No newline at end of file
diff --git a/shm/iObserver.hpp b/shm/iObserver.hpp
index 6482860b1..9ff293780 100644
--- a/shm/iObserver.hpp
+++ b/shm/iObserver.hpp
@@ -3,4 +3,5 @@
 class IObserver {
 public:
     virtual void nextDay() = 0;
+    virtual ~IObserver() = default;
 };
\ No newline at end of file
diff --git a/shm/island.cpp b/shm/island.cpp
index cd243a41e..d7087d183 100644
--- a/shm/island.cpp
+++ b/shm/island.cpp
@@ -1,9 +1,11 @@
 #include "island.hpp"
 
-Coordinates Island::getPosition() const {
+Coordinates Island::getPosition() const
+{
     return position_;
 }
 
-void Island::setPosition(Coordinates position){
+void Island::setPosition(Coordinates position)
+{
     position_ = position;
 }
diff --git a/shm/island.hpp b/shm/island.hpp
index 6bc60f81d..12da0cc34 100644
--- a/shm/island.hpp
+++ b/shm/island.hpp
@@ -1,17 +1,17 @@
 #pragma once
 #include "coordinates.hpp"
 
-class Island {    
+class Island {
 public:
-    Island() {}
+    Island() { }
 
     Island(Coordinates position)
-    : position_(position)
-    {}
+        : position_(position)
+    {
+    }
 
     Coordinates getPosition() const;
     void setPosition(Coordinates);
-    
 
 private:
     Coordinates position_;
diff --git a/shm/item.cpp b/shm/item.cpp
index 1ebfee8ff..f5320778e 100644
--- a/shm/item.cpp
+++ b/shm/item.cpp
@@ -1,18 +1,25 @@
 #include "item.hpp"
 
-Item::Item(const std::string& name, size_t amount, size_t basePrice, Rarity rarity)
-    : Cargo(name, amount, basePrice), rarity_(rarity){};
+Item::Item(const std::string& name,
+    size_t amount,
+    size_t basePrice,
+    Rarity rarity,
+    Time* time)
+    : Cargo(name, amount, basePrice, time)
+    , rarity_(rarity) {};
 
 // size_t Item::getPrice() const {
 //     return basePrice_ * static_cast<size_t>(rarity_);
 // }
 
-Cargo& Item::operator+=(size_t amount) {
+Cargo& Item::operator+=(size_t amount)
+{
     amount_ += amount;
     return *this;
 }
 
-Cargo& Item::operator-=(size_t amount) {
+Cargo& Item::operator-=(size_t amount)
+{
     if (amount <= amount_) {
         amount_ -= amount;
     } else {
@@ -21,6 +28,7 @@ Cargo& Item::operator-=(size_t amount) {
     return *this;
 }
 
-bool Item::operator==(const Cargo& cargo) const {
+bool Item::operator==(const Cargo& cargo) const
+{
     return cargo.getName() == getName();
 }
\ No newline at end of file
diff --git a/shm/item.hpp b/shm/item.hpp
index 73e1b9197..3a2115f92 100644
--- a/shm/item.hpp
+++ b/shm/item.hpp
@@ -1,33 +1,35 @@
 #pragma once
 
-#include <iostream>
 #include "cargo.hpp"
+#include <iostream>
 
-enum class Rarity {
-    common = 1,
+enum class Rarity { common = 1,
     rare = 5,
     epic = 10,
-    legendary = 20
-};
-//Class responsible for managing Items in the game.
+    legendary = 20 };
+// Class responsible for managing Items in the game.
 class Item : public Cargo {
 public:
-    Item(const std::string& name, size_t amount, size_t basePrice, Rarity rarity);
-    ~Item() override{};
+    Item(const std::string& name, size_t amount, size_t basePrice, Rarity rarity, Time* time);
+    ~Item() override {};
 
     Cargo& operator+=(const size_t amount) override;
     Cargo& operator-=(const size_t amount) override;
     bool operator==(const Cargo&) const override;
 
-    //Methods override from Cargo class.
-    size_t getPrice() const override { return basePrice_ * static_cast<size_t>(rarity_); };
+    // Methods override from Cargo class.
+    size_t getPrice() const override
+    {
+        return basePrice_ * static_cast<size_t>(rarity_);
+    };
     std::string getName() const override { return name_; };
     size_t getAmount() const override { return amount_; };
     size_t getBasePrice() const override { return basePrice_; };
 
-    Rarity getRarity() const {return rarity_;};
+    Rarity getRarity() const { return rarity_; };
+
+    void setAmount(const size_t& amount) override { amount_ = amount; };
 
-    void setAmount(const size_t& amount) override { amount_ = amount;};
 private:
     Rarity rarity_;
 };
\ No newline at end of file
diff --git a/shm/main.cpp b/shm/main.cpp
index ce3f285ff..823c78d91 100644
--- a/shm/main.cpp
+++ b/shm/main.cpp
@@ -12,63 +12,27 @@
 #include "ship.hpp"
 #include "store.hpp"
 
-int main() {
-    auto cargo1 = std::make_shared<Fruit>("cebula", 40, 2, 20);
-    auto cargo2 = std::make_shared<Item>("drewno", 10, 20, Rarity::epic);
-    auto cargo3 = std::make_shared<Alcohol>("wino", 10, 100, 15);
-    // auto cargo4 = std::make_shared<Cargo>("miedz", 10, 1);
-    // auto cargo5 = std::make_shared<Cargo>("rubin", 10, 2);
-    // auto cargo6 = std::make_shared<Cargo>("cebula", 3, 10);
-    // auto cargo7 = std::make_shared<Cargo>("Woda", 200, 500);
+int main()
+{
+    Time* time;
+    // auto cargo1 = std::make_shared<Fruit>("cebula", 40, 2, 20, time);
+    // auto cargo2 = std::make_shared<Item>("drewno", 10, 20, Rarity::epic);
+    // auto cargo3 = std::make_shared<Alcohol>("wino", 10, 100, 15);
 
-    std::vector<std::shared_ptr<Cargo>> LOAD{cargo1, cargo2, cargo3};
+    std::vector<std::shared_ptr<Cargo>> LOAD {}; //{ cargo1/*, cargo2, cargo3*/ };
+    auto s1 = std::make_shared<Ship>(500, 20, 14, 5, "Black Widow", 1, LOAD, time);
+    // Player pla1(s1, 5000, 0);
+    // std::cout << '\n';
 
-    auto s1 = std::make_shared<Ship>(500, 20, 14, 5, "Black Widow", 1, LOAD);
-    Player pla1(s1, 5000, 0);
-    std::cout << '\n';
+    // Store s;
 
-    // pla1.printCargo();
-    // std::cout << s1;
-    Store s;
+    // auto car1 = s.getCargoOfStore()[1];
 
-    auto car1 = s.getCargoOfStore()[1];
-//     std::cout << '\n';
+    // std::cout << car1->getName() << " " << car1->getAmount() << " : "
+    //           << car1->getBasePrice() << '\n';
+    // std::cout << '\n';
+    // std::cout << '\n';
+    // std::cout << s;
 
-    // std::cout << "\nile miejsca na statku :" << pla1.getAvailableSpace() << '\n';
-    std::cout << car1->getName() << " " << car1->getAmount() << " : " << car1->getBasePrice() << '\n';
-    std::cout << '\n';
-    std::cout << '\n';
-    std::cout << s;
-
-    // pla1.getShip()->load(car1, 20);
-    // pla1.getShip()->load(car1, 20);
-    // pla1.getShip()->load(car1, 20);
-    // pla1.getShip()->unload(car1, 0);
-    
-    // std::cout << "Ile miejsca na statku " << pla1.getAvailableSpace() << '\n';
-
-    // pla1.printCargo();    
-
-
-//     std::cout << "Kasa gracza: " << pla1.getMoney() << '\n';
-//     s.sell(car1, 80, &pla1);
-//     std::cout << "Kasa gracza: " << pla1.getMoney() << '\n';
-    
-//     std::cout << '\n';
-//     std::cout << '\n';
-//     pla1.printCargo();
-//     std::cout << '\n';
-//     std::cout << '\n';
-//     std::cout << s;
-//     // s.buy(car1, 20, &pla1);
-// std::cout << '\n';
-//     std::cout << '\n';
-//     pla1.printCargo();
-//     // s.sell(car1, 50, &pla1);
-//     std::cout << s;
-//     std::cout << '\n';
-//     std::cout << "\nile miejsca na statku :" << pla1.getAvailableSpace() << '\n';
-//     // s.buy(car1, 20, &pla1);
-    
     return 0;
 }
diff --git a/shm/map.cpp b/shm/map.cpp
index 444507368..84ad3bd4d 100644
--- a/shm/map.cpp
+++ b/shm/map.cpp
@@ -1,8 +1,8 @@
-#include <random>
 #include "map.hpp"
+#include <random>
 
-
-Map::Map() {
+Map::Map()
+{
     islands_.reserve(10);
     for (int i = 0; i < islandsQuantity_;) {
         Coordinates tempCoordinates = getRandomCoordinates();
@@ -14,7 +14,8 @@ Map::Map() {
     }
 }
 
-Island* const Map::getIsland(const Coordinates& coordinate) {
+Island* const Map::getIsland(const Coordinates& coordinate)
+{
     for (auto& island : islands_) {
         if (island.getPosition() == coordinate) {
             return &island;
@@ -23,11 +24,13 @@ Island* const Map::getIsland(const Coordinates& coordinate) {
     return nullptr;
 }
 
-Coordinates Map::getRandomCoordinates() {
+Coordinates Map::getRandomCoordinates()
+{
     std::random_device randomDevice;
     std::mt19937 randomGenerator(randomDevice());
     std::uniform_int_distribution<> widthDistribution(0, maxWidth_);
     std::uniform_int_distribution<> heightDistribution(0, maxHeight_);
-    Coordinates randomCoordinates(widthDistribution(randomGenerator), heightDistribution(randomGenerator));
+    Coordinates randomCoordinates(widthDistribution(randomGenerator),
+        heightDistribution(randomGenerator));
     return randomCoordinates;
 }
diff --git a/shm/map.hpp b/shm/map.hpp
index a24410923..a64ac8cdf 100644
--- a/shm/map.hpp
+++ b/shm/map.hpp
@@ -1,7 +1,7 @@
 #pragma once
-#include <vector>
 #include "coordinates.hpp"
 #include "island.hpp"
+#include <vector>
 class Map {
 public:
     Map();
diff --git a/shm/player.cpp b/shm/player.cpp
index 3d33f1d1c..238d777a5 100644
--- a/shm/player.cpp
+++ b/shm/player.cpp
@@ -1,50 +1,60 @@
 #include "player.hpp"
+#include "cargo.hpp"
+#include "player.hpp"
+#include "ship.hpp"
 #include <iostream>
 #include <numeric>
 #include <utility>
-#include "player.hpp"
-#include "cargo.hpp"
-#include "ship.hpp"
 
-Player::Player(std::shared_ptr<Ship> ship, const size_t& money, size_t getAvailableSpace)
-    : ship_(std::move(ship)), money_(money) {
+Player::Player(std::shared_ptr<Ship> ship,
+    const size_t& money,
+    size_t getAvailableSpace)
+    : ship_(std::move(ship))
+    , money_(money)
+{
     countAvailableSpace();
 }
 
-size_t Player::getMoney() const{
+size_t Player::getMoney() const
+{
     return money_;
 }
-size_t Player::getAvailableSpace() const {
+size_t Player::getAvailableSpace() const
+{
     return availableSpace_;
 }
-std::shared_ptr<Ship> Player::getShip() const {
+std::shared_ptr<Ship> Player::getShip() const
+{
     return ship_;
 }
 
-size_t Player::getSpeed() const {
+size_t Player::getSpeed() const
+{
     return ship_->getSpeed();
 }
-std::shared_ptr<Cargo> Player::getCargo(size_t index) const {
+std::shared_ptr<Cargo> Player::getCargo(size_t index) const
+{
     return ship_->getCargo(index);
 }
 
-void Player::countAvailableSpace() {
+void Player::countAvailableSpace()
+{
     if (!ship_) {
         return;
     };
     std::cout << " jestem w sumowaniu miejsca\n";
     auto sum = std::accumulate(ship_->getCargosVector().begin(),
-                                  ship_->getCargosVector().end(),
-                                  0,
-                                  [](size_t amount, const auto& cargo)
-                                  { return amount += cargo->getAmount();}
-                                 );
+        ship_->getCargosVector().end(), 0,
+        [](size_t amount, const auto& cargo) {
+            return amount += cargo->getAmount();
+        });
     const auto& cargoVector = ship_->getCapacity();
-    
+
     availableSpace_ = cargoVector - sum;
 }
 
-void Player::printCargo() const {
+void Player::printCargo() const
+{
     if (!ship_) {
         return;
     }
@@ -56,11 +66,14 @@ void Player::printCargo() const {
     int i = 0;
     std::cout << "Current ship's cargo\n";
     for (const auto& el : ship_->getCargosVector()) {
-        std::cout << i++ << " Name: " << el->getName() << ",\t\t Amount: " << el->getAmount() << ",\t\t Base price: " << el->getBasePrice() << '\n';
+        std::cout << i++ << " Name: " << el->getName()
+                  << ",\t\t Amount: " << el->getAmount()
+                  << ",\t\t Base price: " << el->getBasePrice() << '\n';
     }
 }
 
-void Player::sell(std::shared_ptr<Cargo>& cargo, const size_t& amount) {
+void Player::sell(std::shared_ptr<Cargo>& cargo, const size_t& amount)
+{
     if (!cargo) {
         return;
     }
@@ -72,16 +85,18 @@ void Player::sell(std::shared_ptr<Cargo>& cargo, const size_t& amount) {
     std::cout << "Stan pieniążków: " << getMoney() << '\n';
 }
 
-void Player::buy(std::shared_ptr<Cargo>& cargo,const size_t& amount) {
+void Player::buy(std::shared_ptr<Cargo>& cargo, const size_t& amount)
+{
     if (!cargo) {
         return;
     }
     std::cout << "Dupa:\n";
     getShip()->load(cargo, amount);
-    
+
     money_ -= cargo->getPrice() * amount;
 }
 
-void Player::setMoney(size_t money) {
+void Player::setMoney(size_t money)
+{
     money_ = money;
 }
\ No newline at end of file
diff --git a/shm/player.hpp b/shm/player.hpp
index 7b51a9dbb..06b7f7489 100644
--- a/shm/player.hpp
+++ b/shm/player.hpp
@@ -1,15 +1,16 @@
 #pragma once
 #include <memory>
 
-
 class Cargo;
 class Ship;
 // Class responsible for managing Player in the game.
 class Player {
 public:
-    Player(std::shared_ptr<Ship> ship, const size_t& money, size_t getAvailableSpace);
+    Player(std::shared_ptr<Ship> ship,
+        const size_t& money,
+        size_t getAvailableSpace);
 
-    size_t getMoney() const; 
+    size_t getMoney() const;
     size_t getAvailableSpace() const;
     std::shared_ptr<Ship> getShip() const;
     size_t getSpeed() const;
@@ -18,8 +19,8 @@ class Player {
     void printCargo() const;
     void setMoney(size_t money);
 
-    void sell( std::shared_ptr<Cargo>& cargo,const  size_t& amount);
-    void buy ( std::shared_ptr<Cargo>& cargo,const  size_t& amount);
+    void sell(std::shared_ptr<Cargo>& cargo, const size_t& amount);
+    void buy(std::shared_ptr<Cargo>& cargo, const size_t& amount);
 
 private:
     std::shared_ptr<Ship> ship_;
diff --git a/shm/ship.cpp b/shm/ship.cpp
index 56683a091..7530eb25b 100644
--- a/shm/ship.cpp
+++ b/shm/ship.cpp
@@ -9,92 +9,137 @@
 #include "item.hpp"
 #include "ship.hpp"
 
-// Class responsible for managing Ships in the game.
-Ship& Ship::operator-=(size_t num) {
+Ship::Ship(Time* time)
+    : id_(-1)
+{
+    time->attachObserver(this);
+}
+
+Ship::Ship(size_t capacity, size_t maxCrew, size_t crew, size_t speed,
+    const std::string& name, size_t id, std::vector<std::shared_ptr<Cargo>> cargos,
+    Time* time)
+    : capacity_(capacity)
+    , maxCrew_(maxCrew)
+    , crew_(crew)
+    , speed_(speed)
+    , name_(name)
+    , id_(id)
+    , cargos_(cargos)
+    , time_(time)
+{
+    time->attachObserver(this);
+}
+Ship::Ship(size_t maxCrew, size_t speed, size_t id, Time* time)
+    : Ship(0, maxCrew, 0, speed, "", id, {}, time)
+{
+    time->attachObserver(this);
+}
+
+Ship::~Ship()
+{
+    time_->detachObserver(this);
+}
+
+Ship& Ship::operator-=(size_t num)
+{
     if (crew_ - num <= crew_) {
         crew_ -= num;
     } else {
+        crew_ = 0;
         std::cerr << "You need at least one member of the crew !!!\n";
     }
     return *this;
 }
 
-Ship& Ship::operator+=(size_t num) {
+Ship& Ship::operator+=(size_t num)
+{
     if (crew_ + num <= maxCrew_) {
         crew_ += num;
     } else {
-        std::cerr << " The maximum amount of members of the crew is " << maxCrew_ << " !!!! \n";
+        crew_ = maxCrew_;
+        std::cerr << " The maximum amount of members of the crew is " << maxCrew_
+                  << " !!!! \n";
     }
     return *this;
 }
 
-size_t Ship::getCapacity() const {
+size_t Ship::getCapacity() const
+{
     return capacity_;
 }
-size_t Ship::getMaxCrew() const {
+size_t Ship::getMaxCrew() const
+{
     return maxCrew_;
 }
-size_t Ship::getCrew() const {
+size_t Ship::getCrew() const
+{
     return crew_;
 }
-size_t Ship::getSpeed() const {
+size_t Ship::getSpeed() const
+{
     return speed_;
 }
-std::string Ship::getName() const {
+std::string Ship::getName() const
+{
     return name_;
 }
-size_t Ship::getId() const {
+size_t Ship::getId() const
+{
     return id_;
 }
 // Function returns specific cargo
-std::shared_ptr<Cargo> Ship::getCargo(size_t index) const {
+std::shared_ptr<Cargo> Ship::getCargo(size_t index) const
+{
     if (cargos_.size() <= index) {
         return nullptr;
     }
     return cargos_[index];
 }
 
-std::vector<std::shared_ptr<Cargo>> Ship::getCargosVector() const {
+std::vector<std::shared_ptr<Cargo>> Ship::getCargosVector() const
+{
     return cargos_;
 }
 
-void Ship::setName(const std::string& name) {
+void Ship::setName(const std::string& name)
+{
     name_ = name;
 }
 
-std::vector<std::shared_ptr<Cargo>>::iterator Ship::findMatchCargo(std::shared_ptr<Cargo> cargo) {
-    return std::find_if(cargos_.begin(),
-                        cargos_.end(),
-                        [&cargo](const auto& searchCargo)
-                        { return searchCargo->getName() == cargo->getName(); });
+std::vector<std::shared_ptr<Cargo>>::iterator Ship::findMatchCargo(
+    std::shared_ptr<Cargo> cargo)
+{
+    return std::find_if(cargos_.begin(), cargos_.end(),
+        [&cargo](const auto& searchCargo) {
+            return searchCargo->getName() == cargo->getName();
+        });
 }
 
-void Ship::unload(std::shared_ptr<Cargo>& cargo, size_t amount) {
+void Ship::unload(std::shared_ptr<Cargo>& cargo, size_t amount)
+{
     auto findCargo = findMatchCargo(cargo);
-    if(findCargo == cargos_.end()) {
+    if (findCargo == cargos_.end()) {
         return;
     }
     std::cout << "Jestem w unload\n";
 
-    
     if (findCargo != cargos_.end()) {
         findCargo->get()->setAmount(findCargo->get()->getAmount() - amount);
         std::cout << "Jestem w po odjeciu towaru ze statku\n";
     }
-
-
 }
 
-void Ship::load(std::shared_ptr<Cargo>& cargo, size_t amount) {
+void Ship::load(std::shared_ptr<Cargo>& cargo, size_t amount)
+{
     auto findCargo = findMatchCargo(cargo);
-    
+
     if (findCargo != cargos_.end()) {
         std::cout << "Dlaczego w to wchodze\n";
         if (capacity_ > cargo->getAmount()) {
-
-            /// I just want to know, is the line below  corrected wrote? OR should I write it, in another way?
+            /// I just want to know, is the line below  corrected wrote? OR should I
+            /// write it, in another way?
             findCargo->get()->setAmount(findCargo->get()->getAmount() + amount);
-           
+
         } else {
             std::cerr << "Not enuogh space on ship!!!!\n";
         }
@@ -110,39 +155,29 @@ void Ship::load(std::shared_ptr<Cargo>& cargo, size_t amount) {
     std::cout << "wychodze z funkcji Ship::load\n";
 }
 
-// std::ostream& operator<<(std::ostream& os, const std::shared_ptr<Ship> ship) {
-//     int counter = 1;
-//     for (const auto el : ship->getCargosVector()) {
-//         os << "|" << std::setw(20);
-//         os << std::setfill(' ') << std::setw(20) << "ID: " << counter;
-//         os << std::setw(20) << " TYPE OF CARGO: " << el->getName();
-//         os << std::setw(20) << " AMOUNT: " << el->getAmount();
-//         os << std::setw(20) << " PRICE: " << el->getPrice() << '\n';
-//         counter++;
-//     }
-//     os << "|" << std::setfill('*') << std::setw(100) << "|\n";
-
-//     return os;
-// }
-
-void Ship::addCargo(std::shared_ptr<Cargo>& cargo, size_t amount) {
+void Ship::addCargo(std::shared_ptr<Cargo>& cargo, size_t amount)
+{
     if (Alcohol* alcohol = dynamic_cast<Alcohol*>(cargo.get())) {
-        cargos_.push_back(std::make_shared<Alcohol>(alcohol->getName(),
-                                                    amount,
-                                                    alcohol->getBasePrice(),
-                                                    alcohol->getPercentage()));
-    } else if(Fruit* fruit = dynamic_cast<Fruit*>(cargo.get())){
-        cargos_.push_back(std::make_shared<Fruit>(fruit->getName(),
-                                                    amount,
-                                                    fruit->getBasePrice(),
-                                                    fruit->getExpirationDate()));
-    } else if(Item* item =dynamic_cast<Item*>(cargo.get())) {
-        cargos_.push_back(std::make_shared<Item>(item->getName(),
-                                                 amount,
-                                                 item->getPrice(),
-                                                 item->getRarity()));
+        cargos_.push_back(std::make_shared<Alcohol>(alcohol->getName(), amount,
+            alcohol->getBasePrice(),
+            alcohol->getPercentage(),
+            time_));
+    } else if (Fruit* fruit = dynamic_cast<Fruit*>(cargo.get())) {
+        cargos_.push_back(std::make_shared<Fruit>(fruit->getName(), amount,
+            fruit->getBasePrice(),
+            fruit->getExpirationDate(),
+            time_));
+    } else if (Item* item = dynamic_cast<Item*>(cargo.get())) {
+        cargos_.push_back(std::make_shared<Item>(
+            item->getName(), amount, item->getPrice(), item->getRarity(), time_));
     }
 }
-void Ship::nextDay(Player& player) {
-    player.setMoney(player.getMoney() - ((*player.getShip()).getCrew()));
+void Ship::setOwner(Player* newOwner)
+{
+    owner_ = newOwner;
+}
+
+void Ship::nextDay()
+{
+    owner_->setMoney(owner_->getMoney() - ((*owner_->getShip()).getCrew()));
 }
diff --git a/shm/ship.hpp b/shm/ship.hpp
index bb2a46224..99b41dd9c 100644
--- a/shm/ship.hpp
+++ b/shm/ship.hpp
@@ -1,37 +1,29 @@
 #pragma once
-#include <memory>
-#include <string>
-#include <vector>
 #include "cargo.hpp"
 #include "iObserver.hpp"
-#include "time.hpp"
 #include "player.hpp"
+#include "time.hpp"
+#include <memory>
+#include <string>
+#include <vector>
 
 class Cargo;
 // Class responsible for managing Ship in the game.
-class Ship : public IObserver
-{
+class Ship : public IObserver {
 public:
-    Ship(Time * time)
-        : id_(-1) {
-            time ->attachObserver(this);
-        }
-    Ship(size_t capacity, size_t maxCrew, size_t crew, size_t speed, const std::string& name, size_t id, std::vector<std::shared_ptr<Cargo>> cargos, Time * time)
-        :  capacity_(capacity)
-        , maxCrew_(maxCrew)
-        , crew_(crew)
-        , speed_(speed)
-        , name_(name)
-        , id_(id)
-        , cargos_(cargos)
-        , time_(time)
-     {
-         time->attachObserver(this);
-     }
-    Ship(size_t maxCrew, size_t speed, size_t id, Time * time)
-        : Ship(0, maxCrew, 0, speed, "", id, {}, time) {
-            time->attachObserver(this);
-        }
+    Ship(Time* time);
+    Ship(size_t capacity,
+        size_t maxCrew,
+        size_t crew,
+        size_t speed,
+        const std::string& name,
+        size_t id,
+        std::vector<std::shared_ptr<Cargo>> cargos,
+        Time* time);
+
+    Ship(size_t maxCrew, size_t speed, size_t id, Time* time);
+
+    ~Ship();
 
     Ship& operator-=(size_t num);
     Ship& operator+=(size_t num);
@@ -42,28 +34,30 @@ class Ship : public IObserver
     size_t getCrew() const;
     std::string getName() const;
     size_t getId() const;
-    std::shared_ptr<Cargo> getCargo(size_t index) const;    
+    std::shared_ptr<Cargo> getCargo(size_t index) const;
     std::vector<std::shared_ptr<Cargo>> getCargosVector() const;
-
     std::vector<std::shared_ptr<Cargo>>::iterator findMatchCargo(std::shared_ptr<Cargo> cargo);
-    
+
     void setName(const std::string& name);
 
     void addCargo(std::shared_ptr<Cargo>& cargo, size_t amount);
-    
     void unload(std::shared_ptr<Cargo>& cargo, size_t amount);
     void load(std::shared_ptr<Cargo>& cargo, size_t amount);
 
-    friend std::ostream& operator<<(std::ostream& os, const Ship& ship);
-    void nextDay(Player& player);
-   
+    // friend std::ostream& operator<<(std::ostream& os, const Ship& ship);
+
+    void nextDay();
+    void setOwner(Player*);
+
 private:
     size_t capacity_;
     size_t maxCrew_;
     size_t crew_;
     size_t speed_;
-    Time * time_;
     std::string name_;
     const size_t id_;
     std::vector<std::shared_ptr<Cargo>> cargos_;
+
+    Player* owner_ = nullptr;
+    Time* time_;
 };
\ No newline at end of file
diff --git a/shm/store.cpp b/shm/store.cpp
index 6b7c57979..016a9d38d 100644
--- a/shm/store.cpp
+++ b/shm/store.cpp
@@ -10,14 +10,16 @@
 #include <random>
 #include <typeinfo>
 
-Store::Store() {
+Store::Store()
+{
     generateDefaultCargo();
 };
 
 // std::shared_ptr<Cargo> Store::findCargoInStore(const std::string& name) {
 //     auto find = std::find_if(stock_.begin(),
 //                              stock_.end(),
-//                              [&name](const auto& cargo) { return cargo->getName() == name; });
+//                              [&name](const auto& cargo) { return
+//                              cargo->getName() == name; });
 //     if (find != stock_.end()) {
 //         return find->get()
 //     }
@@ -25,7 +27,8 @@ Store::Store() {
 //     return nullptr;
 // }
 
-// std::shared_ptr<Cargo> Store::findCargoInStore(const std::shared_ptr<Cargo> wantedCargo) {
+// std::shared_ptr<Cargo> Store::findCargoInStore(const std::shared_ptr<Cargo>
+// wantedCargo) {
 //     for( const auto el : stock_) {
 //         if(*el == *wantedCargo){
 //             return el;
@@ -33,7 +36,8 @@ Store::Store() {
 //     }
 // }
 
-// Response Store::buy(std::shared_ptr<Cargo>& cargo, size_t amount, Player* player) {
+// Response Store::buy(std::shared_ptr<Cargo>& cargo, size_t amount, Player*
+// player) {
 //     if (!cargo || !amount || !player) {
 //         return Response::lack_of_cargo;
 //     }
@@ -66,52 +70,59 @@ Store::Store() {
 
 // }
 
-Response Store::sell(std::shared_ptr<Cargo>& cargo, size_t amount, Player* player) {
-    //lack of an amount of cargo in store
-
-    std::cout << "nazwa ładunku: " << cargo->getName() << " ilosć ładunku: " << amount << " ile miejsc wolnych u zawodnika: " << player->getAvailableSpace() << '\n';
-    if (!cargo || !amount) {
-        std::cout << " lack of cargo !cargo || !amount\n";
-        Response::lack_of_cargo;
-    }
+// Response Store::sell(std::shared_ptr<Cargo>& cargo,
+//     size_t amount,
+//     Player* player)
+// {
+//     // lack of an amount of cargo in store
+
+//     std::cout << "nazwa ładunku: " << cargo->getName()
+//               << " ilosć ładunku: " << amount
+//               << " ile miejsc wolnych u zawodnika: "
+//               << player->getAvailableSpace() << '\n';
+//     if (!cargo || !amount) {
+//         std::cout << " lack of cargo !cargo || !amount\n";
+//         Response::lack_of_cargo;
+//     }
 
-    //lack of space on player's ship
-    if (!player) {
-        std::cout << " I am here !player'\n";
+//     // lack of space on player's ship
+//     if (!player) {
+//         std::cout << " I am here !player'\n";
 
-        return Response::lack_of_space;
-    }
+//         return Response::lack_of_space;
+//     }
 
-    std::shared_ptr<Ship> playerShip = player->getShip();
-    if (!playerShip) {
-        std::cout << " I am here . NO player ship'\n";
+//     std::shared_ptr<Ship> playerShip = player->getShip();
+//     if (!playerShip) {
+//         std::cout << " I am here . NO player ship'\n";
 
-        return Response::lack_of_space;
-    }
+//         return Response::lack_of_space;
+//     }
 
-    // Check if player can take cargo on ship
-    bool playerHaveTheSameCargo = false;
-    auto playerCargo = playerShip->getCargosVector();
-    for (const auto& el : playerCargo) {
-        if (el->getName() == cargo->getName()) {
-            playerHaveTheSameCargo = true;
-            break;
-        }
-    }
-    if (!playerHaveTheSameCargo && !player->getAvailableSpace()) {
-        std::cout << " I am here brak miejsca'\n";
-        ;
+//     // Check if player can take cargo on ship
+//     bool playerHaveTheSameCargo = false;
+//     auto playerCargo = playerShip->getCargosVector();
+//     for (const auto& el : playerCargo) {
+//         if (el->getName() == cargo->getName()) {
+//             playerHaveTheSameCargo = true;
+//             break;
+//         }
+//     }
+//     if (!playerHaveTheSameCargo && !player->getAvailableSpace()) {
+//         std::cout << " I am here brak miejsca'\n";
+//         ;
 
-        return Response::lack_of_space;
-    }
+//         return Response::lack_of_space;
+    // }
 
     // Finding cargo in the store
     // auto StoredCargo = findCargoInStore(cargo);
-    // std::cout << 
+    // std::cout <<
 
     // std::cout << "nazw stored Cargo: " << StoredCargo->get()->getAmount();
     // if (StoredCargo != stock_.end()) {
-    //     std::cout << " I am here NIE ma cargo w store'\n" << StoredCargo->get()->getName() << '\n';
+    //     std::cout << " I am here NIE ma cargo w store'\n" <<
+    //     StoredCargo->get()->getName() << '\n';
 
     //     return Response::lack_of_cargo;
     // }
@@ -135,16 +146,13 @@ Response Store::sell(std::shared_ptr<Cargo>& cargo, size_t amount, Player* playe
     // Dopisać co sie stanie gdy dojedzie do sprzedaży.
     // Unload ze Statku. Load na statek.
     // Jak sie zmieni konto gracza.
-    player->buy(cargo, amount);
-    loadShip(cargo, amount);
-    return Response::done;
-    
-}
-
-
-
+//     player->buy(cargo, amount);
+//     loadShip(cargo, amount);
+//     return Response::done;
+// }
 
-std::ostream& operator<<(std::ostream& os, const Store& store) {
+std::ostream& operator<<(std::ostream& os, const Store& store)
+{
     int counter = 1;
     for (const auto& el : store.stock_) {
         os << "|" << std::setw(20);
@@ -167,7 +175,8 @@ constexpr size_t DAY_MAX = 17;
 constexpr size_t PRICE_MIN = 5;
 constexpr size_t PRICE_MAX = 145;
 
-void Store::generateDefaultCargo() {
+void Store::generateDefaultCargo()
+{
     std::random_device rm;
     std::mt19937 gr(rm());
 
@@ -177,57 +186,69 @@ void Store::generateDefaultCargo() {
     std::uniform_int_distribution<> priceR(PRICE_MIN, PRICE_MAX);
 
     stock_.reserve(12);
-
-    stock_.push_back(std::make_shared<Alcohol>("BUH", amountR(gr), priceR(gr), powerR(gr)));
-    stock_.push_back(std::make_shared<Alcohol>("Jack Walker", amountR(gr), priceR(gr), powerR(gr)));
-    stock_.push_back(std::make_shared<Alcohol>("Johny Daniels", amountR(gr), priceR(gr), powerR(gr)));
-    stock_.push_back(std::make_shared<Alcohol>("Żubrówkeczka", amountR(gr), priceR(gr), powerR(gr)));
-    stock_.push_back(std::make_shared<Fruit>("Peach", amountR(gr), priceR(gr), dayR(gr)));
-    stock_.push_back(std::make_shared<Fruit>("Strawbarry", amountR(gr), priceR(gr), dayR(gr)));
-    stock_.push_back(std::make_shared<Fruit>("Water melon", amountR(gr), priceR(gr), dayR(gr)));
-    stock_.push_back(std::make_shared<Fruit>("Coconat", amountR(gr), priceR(gr), dayR(gr)));
-    stock_.push_back(std::make_shared<Item>("Fork", amountR(gr), priceR(gr), Rarity::common));
-    stock_.push_back(std::make_shared<Item>("Philosopher's stone", amountR(gr), priceR(gr), Rarity::legendary));
-    stock_.push_back(std::make_shared<Item>("necklace", amountR(gr), priceR(gr), Rarity::rare));
-    stock_.push_back(std::make_shared<Item>("Ivory", amountR(gr), priceR(gr), Rarity::rare));
+    stock_.push_back(
+        std::make_shared<Fruit>("Peach", amountR(gr), priceR(gr), dayR(gr), time_));
+
+    // stock_.push_back(
+    //     std::make_shared<Alcohol>("BUH", amountR(gr), priceR(gr), powerR(gr)));
+    // stock_.push_back(std::make_shared<Alcohol>("Jack Walker", amountR(gr),
+    //     priceR(gr), powerR(gr)));
+    // stock_.push_back(std::make_shared<Alcohol>("Johny Daniels", amountR(gr),
+    //     priceR(gr), powerR(gr)));
+    // stock_.push_back(std::make_shared<Alcohol>("Żubrówkeczka", amountR(gr),
+    //     priceR(gr), powerR(gr)));
+    // stock_.push_back(
+    //     std::make_shared<Fruit>("Strawbarry", amountR(gr), priceR(gr), dayR(gr)));
+    // stock_.push_back(std::make_shared<Fruit>("Water melon", amountR(gr),
+    //     priceR(gr), dayR(gr)));
+    // stock_.push_back(
+    //     std::make_shared<Fruit>("Coconat", amountR(gr), priceR(gr), dayR(gr)));
+    // stock_.push_back(
+    //     std::make_shared<Item>("Fork", amountR(gr), priceR(gr), Rarity::common));
+    // stock_.push_back(std::make_shared<Item>("Philosopher's stone", amountR(gr),
+    //     priceR(gr), Rarity::legendary));
+    // stock_.push_back(std::make_shared<Item>("necklace", amountR(gr), priceR(gr),
+    //     Rarity::rare));
+    // stock_.push_back(
+    //     std::make_shared<Item>("Ivory", amountR(gr), priceR(gr), Rarity::rare));
 }
 
-
-void Store::loadShip(std::shared_ptr<Cargo>& cargo, size_t& amount) {
-    if(!cargo){
+void Store::loadShip(std::shared_ptr<Cargo>& cargo, size_t& amount)
+{
+    if (!cargo) {
         return;
     }
     bool flag = false;
     for (const auto& el : stock_) {
-        if( el->getName() == cargo->getName())
-        {
+        if (el->getName() == cargo->getName()) {
             el->setAmount(el->getAmount() - amount);
             flag = true;
             break;
         }
     }
-    if(!flag) {
+    if (!flag) {
         std::cout << "dupa: \n";
     }
 }
 
-void Store::unloadShip(std::shared_ptr<Cargo>& cargo, size_t& amount) {
-    if(!cargo){
+void Store::unloadShip(std::shared_ptr<Cargo>& cargo, size_t& amount)
+{
+    if (!cargo) {
         return;
     }
     for (const auto& el : stock_) {
-        if( el->getName() == cargo->getName())
-        {
-            el->setAmount(el->getAmount()  + amount);
+        if (el->getName() == cargo->getName()) {
+            el->setAmount(el->getAmount() + amount);
             std::cout << "dodało do store'\n";
             break;
         }
     }
 }
 
-void Store::nextDay() {
+void Store::nextDay()
+{
     for (auto cargo : Store::getCargoOfStore()) {
-        if(cargo == nullptr) {
+        if (cargo == nullptr) {
             break;
         } else {
             std::random_device rm;
@@ -236,9 +257,11 @@ void Store::nextDay() {
             int less_stuff_in_store = 0;
             int adding_taking_max = 10;
             int adding_taking_min = 1;
-            std::uniform_int_distribution<> in_store_action(less_stuff_in_store, more_stuff_in_store);
-            std::uniform_int_distribution<> to_add_or_take(adding_taking_min, adding_taking_max);
-            if(in_store_action(gr)) {
+            std::uniform_int_distribution<> in_store_action(less_stuff_in_store,
+                more_stuff_in_store);
+            std::uniform_int_distribution<> to_add_or_take(adding_taking_min,
+                adding_taking_max);
+            if (in_store_action(gr)) {
                 *cargo -= to_add_or_take(gr);
                 if (cargo->getAmount() < 0) {
                     *cargo -= cargo->getAmount();
diff --git a/shm/store.hpp b/shm/store.hpp
index 7c85e40d7..e5a5d0367 100644
--- a/shm/store.hpp
+++ b/shm/store.hpp
@@ -7,13 +7,12 @@
 
 #include "cargo.hpp"
 #include "player.hpp"
+#include "time.hpp"
 
-enum class Response {
-    done,
+enum class Response { done,
     lack_of_money,
     lack_of_cargo,
-    lack_of_space
-};
+    lack_of_space };
 
 class Store {
 public:
@@ -29,18 +28,21 @@ class Store {
     // void unload(const std::shared_ptr<Cargo>& cargo);
     void addCargosOfStore(std::shared_ptr<Cargo>);
 
-
     void loadShip(std::shared_ptr<Cargo>& cargo, size_t& amount);
     void unloadShip(std::shared_ptr<Cargo>& cargo, size_t& amount);
     // void ereasFromCargosOfStore(std::shared_ptr<Cargo>);
-    // std::shared_ptr<Cargo> findCargoInStore(const std::shared_ptr<Cargo>  wantedCargo);    
+    // std::shared_ptr<Cargo> findCargoInStore(const std::shared_ptr<Cargo>
+    // wantedCargo);
 
     friend std::ostream& operator<<(std::ostream& os, const Store& store);
-    std::vector<std::shared_ptr<Cargo>> getCargoOfStore() const { return stock_; };
+    std::vector<std::shared_ptr<Cargo>> getCargoOfStore() const
+    {
+        return stock_;
+    };
 
 private:
-    std::vector<std::shared_ptr<Cargo>> stock_{};
+    std::vector<std::shared_ptr<Cargo>> stock_ {};
     void generateDefaultCargo();
     void nextDay();
-
+    Time* time_ {nullptr};
 };
diff --git a/shm/time.cpp b/shm/time.cpp
index e0f48388a..173e798d8 100644
--- a/shm/time.cpp
+++ b/shm/time.cpp
@@ -1,25 +1,27 @@
+#include "time.hpp"
+#include "iObserver.hpp"
 #include <iostream>
-#include <memory>
 #include <list>
-#include "iObserver.hpp"
-#include "time.hpp"
-
-
+#include <memory>
 
-void Time::attachObserver(IObserver * observer) {
+void Time::attachObserver(IObserver* observer)
+{
     observerList_.push_back(observer);
 }
 
-void Time::detachObserver(IObserver * observer) {
+void Time::detachObserver(IObserver* observer)
+{
     observerList_.remove(observer);
 }
 
-void Time::onTimeChange() {
+void Time::onTimeChange()
+{
     notifyAll();
 }
 
-void Time::notifyAll() { 
-    for(auto it = observerList_.begin(); it != observerList_.end(); ++it) {
+void Time::notifyAll()
+{
+    for (auto it = observerList_.begin(); it != observerList_.end(); ++it) {
         (*it)->nextDay();
     }
 }
diff --git a/shm/time.hpp b/shm/time.hpp
index 0d6803b79..ab7da580e 100644
--- a/shm/time.hpp
+++ b/shm/time.hpp
@@ -1,7 +1,7 @@
 #pragma once
-#include <memory>
-#include <list>
 #include "iObserver.hpp"
+#include <list>
+#include <memory>
 
 class IObserver;
 
@@ -10,17 +10,14 @@ class Time {
     Time();
     ~Time() = default;
 
+    void attachObserver(IObserver*);
 
-    void attachObserver(IObserver * );
-
-    void detachObserver(IObserver * );
+    void detachObserver(IObserver*);
 
     void onTimeChange();
 
-
 private:
-    std::list<IObserver*> observerList_; 
+    std::list<IObserver*> observerList_;
 
     void notifyAll();
-
 };
\ No newline at end of file