diff --git a/shm/CMakeLists.txt b/shm/CMakeLists.txt
new file mode 100644
index 000000000..7e8017dee
--- /dev/null
+++ b/shm/CMakeLists.txt
@@ -0,0 +1,48 @@
+cmake_minimum_required(VERSION 3.14)
+
+set (CMAKE_CXX_STANDARD 20)
+set (CMAKE_CXX_STANDARD_REQUIRED ON)
+project(SHM_2077)
+
+
+include(FetchContent)
+FetchContent_Declare(
+  googletest
+  URL https://github.com/google/googletest/archive/609281088cfefc76f9d0ce82e1ff6c30cc3591e5.zip
+)
+# For Windows: Prevent overriding the parent project's compiler/linker settings
+set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
+FetchContent_MakeAvailable(googletest)
+
+set(FILES
+    island.cpp
+    map.cpp
+    player.cpp
+    ship.cpp
+    cargo.cpp
+    store.cpp
+    alcohol.cpp
+    item.cpp 
+    fruit.cpp
+    time.cpp
+    game.cpp
+    )
+
+set(FLAGS 
+    -Wall 
+    #-Wextra 
+    -Wpedantic 
+    -Wconversion 
+    -O0)
+
+
+
+add_executable(${PROJECT_NAME} main.cpp ${FILES})
+
+add_executable(ShipTest_gt test/ship_gt.cpp ${FILES})
+target_link_libraries(ShipTest_gt gtest_main)
+target_link_directories(ShipTest_gt PUBLIC ${CMAKE_SOURCE_DIR})
+add_test(NAME ShipTest COMMAND Ship)
+
+
+target_compile_options(${PROJECT_NAME} PRIVATE ${FLAGS})
\ No newline at end of file
diff --git a/shm/alcohol.cpp b/shm/alcohol.cpp
new file mode 100644
index 000000000..b3133884c
--- /dev/null
+++ b/shm/alcohol.cpp
@@ -0,0 +1,17 @@
+#include "alcohol.hpp"
+#include <iostream>
+#include <limits>
+
+Alcohol::Alcohol(const std::string& name, size_t amount, size_t basePrice, size_t percentage)
+        : Cargo(name, amount, basePrice), percentage_(percentage) {} ;
+
+size_t Alcohol::getPrice() const {
+    return static_cast<size_t>(basePrice_ * static_cast<float>(percentage_) / static_cast<float>(MaxPercentage));
+}
+
+std::shared_ptr<Cargo> Alcohol::clone(const size_t &amount) const {
+    return std::make_shared<Alcohol>(this->getName(),
+                                    amount,
+                                    this->getBasePrice(),
+                                    this->getPercentage());
+}
diff --git a/shm/alcohol.hpp b/shm/alcohol.hpp
new file mode 100644
index 000000000..869fd1f24
--- /dev/null
+++ b/shm/alcohol.hpp
@@ -0,0 +1,25 @@
+#pragma once
+#include "cargo.hpp"
+
+constexpr size_t MaxPercentage{96};
+class Alcohol : public Cargo {
+public:
+    Alcohol(const std::string& name, size_t amount, size_t basePrice, size_t percentage);
+    Alcohol() = default;
+    ~Alcohol() override {};
+
+    size_t getPercentage() const { return percentage_; };
+    void setPercentage(size_t percentage) { percentage_ = percentage; };
+
+    //Methods override from Cargo class.
+    size_t getPrice() const override;
+
+    void nextDay() override {};
+
+    std::shared_ptr<Cargo> clone(const size_t &) const;
+
+    void setTime(const std::shared_ptr<Time>&) override {};
+    void detachingObserver() override {};
+private:
+    size_t percentage_;
+};
diff --git a/shm/cargo.cpp b/shm/cargo.cpp
new file mode 100644
index 000000000..2e774aff4
--- /dev/null
+++ b/shm/cargo.cpp
@@ -0,0 +1,52 @@
+#include "cargo.hpp"
+
+#include <iostream>
+#include <limits>
+
+
+Cargo::Cargo(const std::string& name, size_t amount, size_t basePrice, std::shared_ptr<Time> time)
+    : name_(name)
+    , amount_(amount)
+    , basePrice_(basePrice)
+    , time_(time)
+    {
+        if (time_) {
+            time_->attachObserver(this);
+        }
+    }
+
+Cargo::Cargo(const std::string& name, size_t amount, size_t basePrice)
+    : name_(name)
+    , amount_(amount)
+    , basePrice_(basePrice) 
+    {};
+
+Cargo& Cargo::operator+=(size_t amount) {
+    if (amount_ + amount < std::numeric_limits<size_t>::max()) {
+        amount_ += amount;
+    }
+    return *this;
+}
+
+Cargo& Cargo::operator-=(size_t amount) {
+    if (amount_ >= amount ) {
+        amount_ -= amount;
+    }
+    return *this;
+}
+
+bool Cargo::operator==(const Cargo& cargo) const {
+    return cargo.getName() == getName();
+}
+
+std::string Cargo::getName() const {
+    return name_;
+}
+
+size_t Cargo::getAmount() const {
+    return amount_;
+}
+
+size_t Cargo::getBasePrice() const {
+    return basePrice_;
+}
diff --git a/shm/cargo.hpp b/shm/cargo.hpp
new file mode 100644
index 000000000..2fbb10f75
--- /dev/null
+++ b/shm/cargo.hpp
@@ -0,0 +1,36 @@
+
+#pragma once
+#include <string>
+#include "time.hpp"
+#include "iObserver.hpp"
+
+class Cargo : public IObserver {
+public:
+    Cargo() = default;
+    Cargo(const std::string& name, size_t amount) : name_(name), amount_(amount) {};
+    Cargo(const std::string& name, size_t amount, size_t basePrice, std::shared_ptr<Time> time);
+    Cargo(const std::string& name, size_t amount, size_t basePrice);
+    virtual ~Cargo() = default;
+
+    Cargo& operator+=(size_t amount);
+    Cargo& operator-=(size_t amount);
+    bool operator==(const Cargo&) const;
+
+    std::string getName() const;
+    size_t getAmount() const;
+    size_t getBasePrice() const;
+
+    virtual size_t getPrice() const = 0;
+
+    virtual std::shared_ptr<Cargo> clone(const size_t &) const = 0;
+
+    virtual void setTime(const std::shared_ptr<Time>&) = 0;
+
+    virtual void detachingObserver() = 0;
+    
+protected:
+    std::string name_;
+    size_t amount_;
+    size_t basePrice_;
+    std::shared_ptr<Time> time_ {nullptr};
+};
diff --git a/shm/coordinates.hpp b/shm/coordinates.hpp
new file mode 100644
index 000000000..9857b7f43
--- /dev/null
+++ b/shm/coordinates.hpp
@@ -0,0 +1,29 @@
+#pragma once
+#include <cmath>
+
+class Coordinates {
+public:
+    constexpr Coordinates(size_t positionX, size_t positionY)
+     : positionX_(positionX)
+     , positionY_(positionY)
+    {}
+
+    constexpr void setPositionX(size_t positionX) { positionX_ = positionX; };
+
+    constexpr size_t getPositionX() const { return positionX_; };
+
+    constexpr void setPositionY(size_t positionY) { positionY_ = positionY; };
+    constexpr size_t getPositionY() const { return positionY_; };
+
+    constexpr bool operator== (const Coordinates& n_pos) const {
+        return positionX_ == n_pos.getPositionX() && positionY_ == n_pos.getPositionY();
+    };
+
+    constexpr size_t distance(const Coordinates& rhs) { 
+                return std::round(std::sqrt(std::pow((static_cast<int>(positionX_) - static_cast<int>(rhs.getPositionX())), 2) +
+                                            std::pow((static_cast<int>(positionY_) - static_cast<int>(rhs.getPositionY())), 2))); };
+
+private:
+    size_t positionX_;
+    size_t positionY_;
+};
diff --git a/shm/fruit.cpp b/shm/fruit.cpp
new file mode 100644
index 000000000..ee6a23c12
--- /dev/null
+++ b/shm/fruit.cpp
@@ -0,0 +1,47 @@
+#include "fruit.hpp"
+#include <iostream>
+#include <limits>
+
+Fruit::Fruit(const std::string &name, size_t amount, size_t basePrice, size_t expirationDate, std::shared_ptr<Time> time) : Cargo(name, amount, basePrice, time), expirationDate_(expirationDate){
+};
+
+Fruit::~Fruit() { time_->detachObserver(this); };
+
+size_t Fruit::getPrice() const
+{
+    return static_cast<size_t>(basePrice_ * static_cast<float>(purchaseDate_) / expirationDate_);
+}
+
+Fruit &Fruit::operator--()
+{
+    if (purchaseDate_ <= 0)
+    {
+        purchaseDate_ = 0;
+    }
+    purchaseDate_--;
+    return *this;
+}
+
+void Fruit::nextDay()
+{
+    if (purchaseDate_)
+    {
+        operator--();
+    }
+}
+
+std::shared_ptr<Cargo> Fruit::clone(const size_t &amount) const {
+    return std::make_shared<Fruit>(this->getName(),
+                                    amount,
+                                    this->getBasePrice(),
+                                    this->getExpirationDate(),
+                                    time_);
+}
+
+void Fruit::setTime(const std::shared_ptr<Time>& time) {
+    time_ = time;
+}
+
+void Fruit::detachingObserver() {
+    time_->detachObserver(this);
+}
diff --git a/shm/fruit.hpp b/shm/fruit.hpp
new file mode 100644
index 000000000..56309bbef
--- /dev/null
+++ b/shm/fruit.hpp
@@ -0,0 +1,29 @@
+#pragma once
+
+#include "cargo.hpp"
+//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, std::shared_ptr<Time> time); 
+    ~Fruit() override;
+
+    Fruit& operator--();
+
+    //Methods override from Cargo class.
+    size_t getPrice() const override;
+
+    size_t getExpirationDate() const { return expirationDate_; };
+    size_t getPurchaseData() const { return purchaseDate_; };
+
+    void nextDay() override;
+
+    std::shared_ptr<Cargo> clone(const size_t &) const;
+
+    void setTime(const std::shared_ptr<Time>&) override;
+
+    void detachingObserver() override;
+
+protected:
+    size_t expirationDate_;
+    size_t purchaseDate_ = expirationDate_;
+};
diff --git a/shm/game.cpp b/shm/game.cpp
new file mode 100644
index 000000000..c3b20af77
--- /dev/null
+++ b/shm/game.cpp
@@ -0,0 +1,323 @@
+#include "game.hpp"
+
+#include <algorithm>
+#include <cctype>
+#include <iomanip>
+#include <random>
+
+#include "coordinates.hpp"
+#include "map.hpp"
+
+template <typename inCheck>
+void inStreamCheck(inCheck& val) {
+    while (std::cin.fail() || val <= 0) {
+        std::cin.clear();
+        std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
+        std::cout << "Bad Input! Try once again!\n";
+        std::cin >> val;
+    }
+}
+
+namespace {
+    constexpr size_t CAPACITY = 1000;
+    constexpr size_t MAXCREW = 40;
+    constexpr size_t CREW = 10;
+    constexpr size_t SPEED = 10;
+    constexpr char NAME[] = "Black Widow";
+    constexpr size_t ID = 1;
+}
+
+Game::Game(size_t money, size_t days, size_t goal)
+    : money_(money),
+      gameDayes_(days),
+      finalGoal_(goal),
+      time_(std::make_shared<Time>()),
+      map_(Map(time_)),
+      ship_(std::make_shared<Ship>(CAPACITY, MAXCREW, CREW, SPEED, NAME, ID, time_)),
+      player_(std::make_shared<Player>(ship_, money)){};
+
+Game::~Game(){};
+
+void Game::startGame() {
+    printHeader();
+    ship_->setOwner(player_);
+    size_t option;
+    while (true)
+    {
+        if (checkWinCondition())
+        {
+            printWinScreen();
+            exit();
+        }
+        else if (checkLoseCondition())
+        {
+            break;
+        }
+        std::cout.flush();
+        printMenu();
+        std::cout << "Write your choice: ";
+        size_t choice;
+
+        std::cin.clear();
+        std::cin >> choice;
+        inStreamCheck(choice);
+
+        chooseOption(static_cast<MenuOption>(choice));
+    }
+    printLoseScreen();
+    exit();
+}
+
+void Game::printMenu() {
+    std::cout << "\n";
+    std::cout << "\n";
+    std::cout << "Your money: " << player_->getMoney() << "Days left: " << gameDayes_ - time_->getDays() << "\n";
+    std::cout << " CHOOSE ACTION: \n";
+    std::cout << '\n';
+    std::cout << '\n';
+    std::cout << " 1. TRAVEL: \n";
+    std::cout << " 2. PRINT CARGO: \n";
+    std::cout << " 3. BUY: \n";
+    std::cout << " 4. SELL:\n";
+    std::cout << " 5. WHERE AM I:\n";
+    std::cout << " 6. EXIT:\n";
+    std::cout << '\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) << "Welcome 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 player_->getMoney() == 0 || (time_->getDays() >= gameDayes_ && player_->getMoney() < finalGoal_);
+}
+
+void Game::chooseOption(Game::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::Position:
+        printMap(player_);
+        break;
+    case MenuOption::Exit:
+        exit();
+        break;
+    default:
+        std::cout << "Try again\n";
+        break;
+    }
+}
+
+void Game::exit() {
+    std::exit(0);
+}
+
+void Game::sell() {
+    if(!map_.getIsland(player_->getPlayerPosition())) {
+        std::cout << "Captain, we are on the sea, you can not sell enything!\n";
+        return;
+    }
+    const auto& vectorOfCargos = player_->getShip()->getCargosVector();
+    if (vectorOfCargos.empty()) {
+        std::cout << "You have nothing to sell!\n";
+        return;
+    }
+    std::cout << "Your are selling. Remember that selling will take one day!\n";
+    const auto& actualStore = map_.getIsland(player_->getPlayerPosition())->getStore();
+    std::cout << "Cargo store and prices:\n" << *actualStore << "\nYour cargo to sell:\n";
+    player_->printCargo();
+    int choose = 0;
+    std::cout << "What you want to sell? ";
+    std::cin >> choose;
+    inStreamCheck(choose);
+    while (choose > vectorOfCargos.size()) {
+        std::cout << "Segmentation fault captain! Choose one more time:\n";
+        std::cin >> choose;
+        inStreamCheck(choose);
+    }
+    const auto& cargoToSell = player_->getShip()->getCargo(choose - 1);
+    std::cout << "How much you want to sell? ";
+    int amount = 0;
+    std::cin >> amount;
+    inStreamCheck(amount);
+    if (amount > cargoToSell->getAmount()) {
+        amount = cargoToSell->getAmount();
+        const auto& response = actualStore->buy(cargoToSell, amount, player_.get());
+        if (response == Response::done) {
+            std::cout << "We didn't have " << amount << " of " << cargoToSell->getName() << ". We sold only " << amount << '\n';
+        } else {
+            responsesFromStore(response);
+        }
+    } else {
+        responsesFromStore(actualStore->buy(cargoToSell, amount, player_.get()));
+    }
+}
+
+void Game::printMap(const std::shared_ptr<Player>& player) {
+    int currentIsland = 0;
+    for (const auto& island : map_.getEveryIsland())
+    {
+        currentIsland++;
+        if (island.getPosition() == player_->getPlayerPosition())
+        {
+            std::cout << "We are on Island " << currentIsland << '\n';
+            return;
+        }
+    }
+    std::cout << "We are on the sea!" << '\n';
+}
+
+void Game::travel() {
+    std::cout << "Where you want to travel?\n";
+    int islandCounter = 0;
+    const auto& islands = map_.getEveryIsland();
+    std::vector<int> daysToGo;
+    daysToGo.reserve(islands.size());
+    for (const auto& island : islands) {
+        int amountOfDays = island.getPosition().distance(player_->getPlayerPosition()) / ship_->getSpeed();
+        if (amountOfDays == 0 && !(island.getPosition() == player_->getPlayerPosition()))
+        {
+            daysToGo.push_back(1);
+        }
+        else
+        {
+            daysToGo.push_back(amountOfDays);
+        }
+        islandCounter++;
+        std::cout << "Island " << islandCounter << " Travel time: " << daysToGo[islandCounter - 1] << " days\n";
+    }
+    std::cout << ++islandCounter << ". Exit\n";
+    std::cout << "Where are we going captain?: ";
+    islandCounter = 0;
+    std::cin.clear();
+    std::cin >> islandCounter;
+    inStreamCheck(islandCounter);
+    while (islandCounter > islands.size() + 1)
+    {
+        std::cout << "Captain you have old map! Here is new one, so where we are going?: \n";
+        std::cin.clear();
+        std::cin >> islandCounter;
+        inStreamCheck(islandCounter);
+    }
+    if (islandCounter == islands.size() + 1)
+    {
+        std::cout << "I changed my mind, we stay here!\n";
+        return;
+    }
+    player_->setPlayerPosition(islands[islandCounter - 1].getPosition().getPositionX(), islands[islandCounter - 1].getPosition().getPositionY());
+    travel(daysToGo[islandCounter - 1]);
+}
+
+void Game::buy() {
+    const auto& IslandWeAreOn = map_.getIsland(player_->getPlayerPosition());
+    if (IslandWeAreOn) {
+        std::cout << *IslandWeAreOn->getStore() << '\n';
+        int choose = 0;
+        std::cout << "What you want to buy? ";
+        std::cin >> choose;
+        inStreamCheck(choose);
+        const auto& cargoOfStore = IslandWeAreOn->getStore()->getCargoOfStore();
+        while (cargoOfStore.size() + 1 < choose) {
+            std::cout << "Wrong choice captain! Try once again!\n";
+            std::cin >> choose;
+            inStreamCheck(choose);
+        }
+        if (choose == cargoOfStore.size() + 1) {
+            return;
+        }
+        std::cout << "Amount: ";
+        size_t amount = 0;
+        std::cin >> amount;
+        inStreamCheck(amount);
+        const auto& object = cargoOfStore[choose - 1];
+        if (object->getAmount() < amount) {
+            amount = object->getAmount();
+            const auto& response = IslandWeAreOn->getStore()->sell(object, amount, player_.get());
+            if ( response == Response::done ) {
+                std::cout << "We bought only " << amount << " of " << object->getName() << '\n';
+            } else {
+                responsesFromStore(response);
+            }
+        } else {
+            responsesFromStore(IslandWeAreOn->getStore()->sell(object, amount, player_.get()));
+        }
+    } else {
+        std::cout << "We are on the sea!";
+        return;
+    }
+}
+
+void Game::printCargo() {
+    player_->printCargo();
+    std::cin.get();
+}
+
+void Game::travel(int days) {
+    while (days--) {
+        time_->onTimeChange();
+    }
+}
+
+void responsesFromStore(const Response& res) {
+    switch(res) {
+        case Response::lack_of_cargo :
+            std::cout << "There is problem with cargo captain!\n";
+            break;
+        case Response::lack_of_money :
+            std::cout << "We have no money captain! \n";
+            break;
+        case Response::lack_of_space :
+            std::cout << "We dont have enough space captain!\n";
+            break;
+        case Response::done :
+            std::cout << "Everything went well!\n";
+        break;
+    };
+}
diff --git a/shm/game.hpp b/shm/game.hpp
new file mode 100644
index 000000000..47f82cb64
--- /dev/null
+++ b/shm/game.hpp
@@ -0,0 +1,64 @@
+#pragma once
+#include <iostream>
+#include <memory>
+
+#include "coordinates.hpp"
+#include "iObserver.hpp"
+#include "island.hpp"
+#include "map.hpp"
+#include "player.hpp"
+#include "ship.hpp"
+#include "time.hpp"
+
+//template <typename inCheck>
+
+class Game {
+    enum class MenuOption {
+        Travel = 1,
+        PrintCargo,
+        Buy,
+        Sell,
+        Position,
+        Exit
+    };
+
+
+public:
+    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(const std::shared_ptr<Player>&);
+    void printCargo();
+    void travel();
+    void sell();
+    void exit();
+    void buy();
+    void travel(int);
+
+protected:
+    std::shared_ptr<Time> time_;
+    std::shared_ptr<Ship> ship_;
+    Map map_;
+    std::shared_ptr<Player> player_;
+
+private:
+    size_t money_;
+    size_t gameDayes_;
+    size_t finalGoal_;
+    size_t islandNo_;
+};
+
+void responsesFromStore(const Response& res);
diff --git a/shm/iObserver.hpp b/shm/iObserver.hpp
new file mode 100644
index 000000000..dd0b4a3b7
--- /dev/null
+++ b/shm/iObserver.hpp
@@ -0,0 +1,7 @@
+#pragma once
+
+class IObserver {
+public:
+    virtual void nextDay() = 0;
+    virtual ~IObserver() = default;
+};
diff --git a/shm/island.cpp b/shm/island.cpp
new file mode 100644
index 000000000..8a41bc4f5
--- /dev/null
+++ b/shm/island.cpp
@@ -0,0 +1,18 @@
+#include "island.hpp"
+#include <memory>
+
+Island::Island(Coordinates position, const std::shared_ptr<Store>& store)
+    : position_(position), store_(store)
+    {}
+
+Coordinates Island::getPosition() const {
+    return position_;
+}
+
+void Island::setPosition(Coordinates position) {
+    position_ = position;
+}
+
+std::shared_ptr<Store> Island::getStore() {
+    return store_;
+}
diff --git a/shm/island.hpp b/shm/island.hpp
new file mode 100644
index 000000000..3f35ea39a
--- /dev/null
+++ b/shm/island.hpp
@@ -0,0 +1,20 @@
+#pragma once
+#include "coordinates.hpp"
+#include "store.hpp"
+
+class Island{    
+public:
+    Island() = default;
+
+    Island(Coordinates position, const std::shared_ptr<Store>& store);
+
+    Coordinates getPosition() const;
+    void setPosition(Coordinates);
+    std::shared_ptr<Store> getStore();
+
+protected:
+    std::shared_ptr<Store> store_;
+
+private:
+    Coordinates position_;
+};
diff --git a/shm/item.cpp b/shm/item.cpp
new file mode 100644
index 000000000..3e3ebb0d5
--- /dev/null
+++ b/shm/item.cpp
@@ -0,0 +1,12 @@
+#include "item.hpp"
+#include <limits>
+
+Item::Item(const std::string& name, size_t amount, size_t basePrice, Rarity rarity)
+    : Cargo(name, amount, basePrice), rarity_(rarity){};
+
+std::shared_ptr<Cargo> Item::clone(const size_t &amount) const {
+    return std::make_shared<Item>(this->getName(),
+                                amount,
+                                this->getBasePrice(),
+                                this->getRarity());
+}
diff --git a/shm/item.hpp b/shm/item.hpp
new file mode 100644
index 000000000..bbb5060f8
--- /dev/null
+++ b/shm/item.hpp
@@ -0,0 +1,32 @@
+#pragma once
+
+#include <iostream>
+#include "cargo.hpp"
+
+enum class Rarity {
+    common = 1,
+    rare = 5,
+    epic = 10,
+    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{};
+
+    //Methods override from Cargo class.
+    size_t getPrice() const override { return basePrice_ * static_cast<size_t>(rarity_); };
+
+    Rarity getRarity() const { return rarity_; };
+
+    void nextDay() override {};
+
+    std::shared_ptr<Cargo> clone(const size_t &) const;
+
+    void setTime(const std::shared_ptr<Time>&) override {};
+
+    void detachingObserver() override {};
+private:
+    Rarity rarity_;
+};
diff --git a/shm/main.cpp b/shm/main.cpp
new file mode 100644
index 000000000..48ff0d96a
--- /dev/null
+++ b/shm/main.cpp
@@ -0,0 +1,27 @@
+#include <iomanip>
+#include <iostream>
+#include <memory>
+
+#include "alcohol.hpp"
+#include "cargo.hpp"
+#include "game.hpp"
+#include "fruit.hpp"
+#include "island.hpp"
+#include "item.hpp"
+#include "map.hpp"
+#include "player.hpp"
+#include "ship.hpp"
+#include "store.hpp"
+#include "time.hpp"
+
+constexpr size_t start_money = 1'000'000;
+constexpr size_t game_days = 100;
+constexpr size_t final_goal = 2'000'000;
+
+int main() {
+   
+    Game game(start_money, game_days, final_goal);
+    game.startGame();
+    
+    return 0;
+}
diff --git a/shm/map.cpp b/shm/map.cpp
new file mode 100644
index 000000000..443d62f1c
--- /dev/null
+++ b/shm/map.cpp
@@ -0,0 +1,37 @@
+#include <random>
+#include "map.hpp"
+
+
+Map::Map(const std::shared_ptr<Time>& time) {
+    islands_.reserve(10);
+    for (int i = 0; i < islandsQuantity_;) {
+        Coordinates tempCoordinates = getRandomCoordinates();
+        if (!getIsland(tempCoordinates)) {
+            Island tempIsland(tempCoordinates, std::make_shared<Store>(time));
+            islands_.push_back(tempIsland);
+            ++i;
+        }
+    }
+}
+
+Island* const Map::getIsland(const Coordinates& coordinate) {
+    for (auto& island : islands_) {
+        if (island.getPosition() == coordinate) {
+            return &island;
+        }
+    }
+    return nullptr;
+}
+
+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));
+    return randomCoordinates;
+}
+
+std::vector<Island> Map::getEveryIsland() const {
+    return islands_;
+}
diff --git a/shm/map.hpp b/shm/map.hpp
new file mode 100644
index 000000000..72d4ff613
--- /dev/null
+++ b/shm/map.hpp
@@ -0,0 +1,19 @@
+#pragma once
+#include <vector>
+#include "coordinates.hpp"
+#include "island.hpp"
+class Map {
+public:
+    Map() = default;
+    Map(const std::shared_ptr<Time>& time);
+    Island* const getIsland(const Coordinates& coordinate);
+    std::vector<Island> getEveryIsland() const;
+    std::vector<Island> islands_;
+    
+private:
+    Coordinates getRandomCoordinates();
+    const int maxWidth_ = 99;
+    const int maxHeight_ = 99;
+    const int islandsQuantity_ = 10;
+    Island* currentPostion_;
+};
diff --git a/shm/player.cpp b/shm/player.cpp
new file mode 100644
index 000000000..1928d6726
--- /dev/null
+++ b/shm/player.cpp
@@ -0,0 +1,112 @@
+#include "player.hpp"
+#include <iostream>
+#include <numeric>
+#include <utility>
+
+#include "cargo.hpp"
+#include "ship.hpp"
+
+Player::Player(std::shared_ptr<Ship> ship, const size_t &money)
+    : ship_(std::move(ship)), money_(money), playerCoordinates_(Coordinates(static_cast<size_t>(25), static_cast<size_t>(75)))
+{
+    countAvailableSpace();
+}
+
+size_t Player::getMoney() const
+{
+    return money_;
+}
+size_t Player::getAvailableSpace() const
+{
+    return availableSpace_;
+}
+std::shared_ptr<Ship> Player::getShip() const
+{
+    return ship_;
+}
+
+size_t Player::getSpeed() const
+{
+    return ship_->getSpeed();
+}
+std::shared_ptr<Cargo> Player::getCargo(size_t index) const
+{
+    return ship_->getCargo(index);
+}
+
+void Player::countAvailableSpace()
+{
+    if (!ship_)
+    {
+        return;
+    };
+
+    auto vectorOfCargos = ship_->getCargosVector();
+    auto sum = std::accumulate(vectorOfCargos.begin(),
+                               vectorOfCargos.end(),
+                               0,
+                               [](size_t amount, const auto &cargo)
+                               { return amount += cargo->getAmount(); });
+
+    const auto &cargoVector = ship_->getCapacity();
+
+    availableSpace_ = cargoVector - sum;
+}
+
+void Player::printCargo() const
+{
+    std::cout << "Ship name: " << ship_->getName() << '\n'
+              << "Ship capacity: " << ship_->getCapacity() << '\n'
+              << "Available space: " << availableSpace_ << '\n'
+              << '\n';
+    int i = 0;
+    std::cout << "Current ship's cargo\n";
+    if (ship_->getCargosVector().empty()) {
+        std::cout << "We have nothing captain! NOTHING!\n";
+        return;
+    } else {
+        for (const auto &el : ship_->getCargosVector())
+        {
+            std::cout << ++i << " Name: " << el->getName() << ",\t\t Amount: " << el->getAmount() << ",\t\t Base price: " << el->getBasePrice() << ",\t\t Actual price: " << el->getPrice() << '\n';
+        }
+    }
+}
+
+void Player::sell(const std::shared_ptr<Cargo>& cargo, const size_t &amount)
+{
+    if (!cargo)
+    {
+        return;
+    }
+    ship_->unload(cargo, amount);
+    money_ += cargo->getPrice() * amount;
+    countAvailableSpace();
+}
+
+void Player::buy(const std::shared_ptr<Cargo>& cargo, const size_t &amount)
+{
+    if (!cargo)
+    {
+        return;
+    }
+    getShip()->load(cargo, amount);
+
+    money_ -= cargo->getPrice() * amount;
+    countAvailableSpace();
+}
+
+void Player::setMoney(size_t money)
+{
+    money_ = money;
+}
+
+Coordinates Player::getPlayerPosition() const
+{
+    return playerCoordinates_;
+}
+
+void Player::setPlayerPosition(const size_t &X, const size_t &Y)
+{
+    playerCoordinates_.setPositionX(X);
+    playerCoordinates_.setPositionY(Y);
+}
diff --git a/shm/player.hpp b/shm/player.hpp
new file mode 100644
index 000000000..03ec31b4a
--- /dev/null
+++ b/shm/player.hpp
@@ -0,0 +1,36 @@
+#pragma once
+#include <memory>
+#include "coordinates.hpp"
+
+
+class Cargo;
+class Ship;
+// Class responsible for managing Player in the game.
+class Player {
+public:
+    Player() = default;
+    Player(std::shared_ptr<Ship> ship, const size_t& money);
+    ~Player() = default;
+    size_t getMoney() const; 
+    size_t getAvailableSpace() const;
+    std::shared_ptr<Ship> getShip() const;
+    size_t getSpeed() const;
+    std::shared_ptr<Cargo> getCargo(size_t index) const;
+
+    void printCargo() const;
+    void setMoney(size_t money);
+
+    void sell( const std::shared_ptr<Cargo>& cargo, const size_t& amount);
+    void buy ( const std::shared_ptr<Cargo>& cargo, const size_t& amount);
+
+    void countAvailableSpace();
+
+    Coordinates getPlayerPosition() const;
+
+    void setPlayerPosition(const size_t&, const size_t&);
+private:
+    std::shared_ptr<Ship> ship_;
+    size_t money_;
+    size_t availableSpace_;
+    Coordinates playerCoordinates_;
+};
diff --git a/shm/ship.cpp b/shm/ship.cpp
new file mode 100644
index 000000000..5160ce964
--- /dev/null
+++ b/shm/ship.cpp
@@ -0,0 +1,160 @@
+#include "ship.hpp"
+#include <algorithm>
+#include <iomanip>
+#include <iostream>
+#include <memory>
+
+#include "alcohol.hpp"
+#include "cargo.hpp"
+#include "fruit.hpp"
+#include "item.hpp"
+
+// Class responsible for managing Ships in the game.
+
+Ship::Ship() : id_(-1){};
+
+Ship::Ship(size_t capacity, size_t maxCrew, size_t crew, size_t speed, const std::string& name, size_t id, const std::shared_ptr<Time>& time)
+        : capacity_(capacity)
+        , maxCrew_(maxCrew)
+        , crew_(crew)
+        , speed_(speed)
+        , name_(name)
+        , id_(id)
+        , time_(time)
+     {
+         time_->attachObserver(this);
+     }
+
+Ship::~Ship() { time_->detachObserver(this); }
+
+Ship &Ship::operator-=(size_t num)
+{
+    if (crew_ - num <= crew_)
+    {
+        crew_ -= num;
+    }
+    else
+    {
+        std::cerr << "You need at least one member of the crew !!!\n";
+    }
+    return *this;
+}
+
+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";
+    }
+    return *this;
+}
+
+size_t Ship::getCapacity() const
+{
+    return capacity_;
+}
+size_t Ship::getMaxCrew() const
+{
+    return maxCrew_;
+}
+size_t Ship::getCrew() const
+{
+    return crew_;
+}
+size_t Ship::getSpeed() const
+{
+    return speed_;
+}
+std::string Ship::getName() const
+{
+    return name_;
+}
+size_t Ship::getId() const
+{
+    return id_;
+}
+// Function returns specific cargo
+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
+{
+    return cargos_;
+}
+
+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(); });
+}
+
+void Ship::unload(const std::shared_ptr<Cargo> &cargo, size_t amount)
+{
+    auto findCargo = findMatchCargo(cargo);
+    if (findCargo == cargos_.end())
+    {
+        return;
+    }
+
+    if (findCargo != cargos_.end())
+    {
+        (**findCargo) -= amount;
+        if (!(*findCargo)->getAmount())
+        {
+            (*findCargo)->detachingObserver();
+            cargos_.erase(findCargo);
+        }
+    }
+}
+
+void Ship::load(const std::shared_ptr<Cargo> &cargo, size_t amount)
+{
+    auto findCargo = findMatchCargo(cargo);
+
+    if (findCargo != cargos_.end()) {
+        if (capacity_ >= (*findCargo)->getAmount() + amount) {
+            (**findCargo) += amount;
+        } else {
+            std::cerr << "Not enuogh space on ship!!!!\n";
+        }
+    } else {
+        addCargo(cargo, amount);
+    }
+}
+
+void Ship::addCargo(const std::shared_ptr<Cargo>& cargo, size_t amount)
+{
+    cargo->setTime(time_);
+    cargos_.push_back(cargo->clone(amount));
+}
+void Ship::nextDay()
+{
+    owner_->setMoney(owner_->getMoney() - crew_);
+}
+
+void Ship::setOwner(const std::shared_ptr<Player>& owner)
+{
+    owner_ = owner;
+}
+
+std::shared_ptr<Time> Ship::getTime() const
+{
+    return time_;
+}
diff --git a/shm/ship.hpp b/shm/ship.hpp
new file mode 100644
index 000000000..130b705b1
--- /dev/null
+++ b/shm/ship.hpp
@@ -0,0 +1,59 @@
+#pragma once
+#include <memory>
+#include <string>
+#include <vector>
+#include "cargo.hpp"
+#include "iObserver.hpp"
+#include "time.hpp"
+#include "player.hpp"
+
+class Cargo;
+// Class responsible for managing Ship in the game.
+class Ship : public IObserver
+{
+public:
+    Ship();
+    Ship(size_t capacity, size_t maxCrew, size_t crew, size_t speed, const std::string& name, size_t id, const std::shared_ptr<Time>& time);
+    ~Ship();
+
+    Ship& operator-=(size_t num);
+    Ship& operator+=(size_t num);
+
+    size_t getCapacity() const;
+    size_t getMaxCrew() const;
+    size_t getSpeed() const;
+    size_t getCrew() const;
+    std::string getName() const;
+    size_t getId() 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(const std::shared_ptr<Cargo>& cargo, size_t amount);
+    
+    void unload(const std::shared_ptr<Cargo>& cargo, size_t amount);
+    void load(const std::shared_ptr<Cargo>& cargo, size_t amount);
+
+    friend std::ostream& operator<<(std::ostream& os, const Ship& ship);
+    void nextDay() override;
+
+    void setOwner(const std::shared_ptr<Player>& owner);
+
+    std::shared_ptr<Time> getTime() const;
+
+protected:
+    std::vector<std::shared_ptr<Cargo>> cargos_{};
+   
+private:
+    size_t capacity_;
+    size_t maxCrew_;
+    size_t crew_;
+    size_t speed_;
+    std::shared_ptr<Time> time_{ nullptr };
+    std::string name_;
+    const size_t id_;
+    std::shared_ptr<Player> owner_{ nullptr };
+};
diff --git a/shm/store.cpp b/shm/store.cpp
new file mode 100644
index 000000000..5d909386d
--- /dev/null
+++ b/shm/store.cpp
@@ -0,0 +1,202 @@
+#include "store.hpp"
+#include "alcohol.hpp"
+#include "fruit.hpp"
+#include "item.hpp"
+#include "player.hpp"
+#include "ship.hpp"
+
+#include <algorithm>
+#include <iomanip>
+#include <random>
+#include <typeinfo>
+
+namespace {
+    constexpr size_t AMOUNT_MIN = 5;
+    constexpr size_t AMOUNT_MAX = 150;
+    constexpr size_t POWER_MIN = 10;
+    constexpr size_t POWER_MAX = 90;
+    constexpr size_t DAY_MIN = 5;
+    constexpr size_t DAY_MAX = 17;
+    constexpr size_t PRICE_MIN = 5;
+    constexpr size_t PRICE_MAX = 145;
+}
+
+Store::Store(std::shared_ptr<Time> time)
+    : time_(time) {
+    generateDefaultCargo();
+    time_->attachObserver(this);
+}
+
+Store::~Store() {
+    time_->detachObserver(this);
+}
+
+
+std::vector<std::shared_ptr<Cargo>>::iterator Store::findMatchCargo(const std::shared_ptr<Cargo>& wantedCargo) {
+    return std::find_if(stock_.begin(),
+                        stock_.end(),
+                        [&wantedCargo](const auto& cargo) { return cargo->getName() == wantedCargo->getName(); });
+}
+
+Response Store::buy(const std::shared_ptr<Cargo>& cargo, const size_t& amount, Player* player) {
+    if (!cargo || !amount || !player) {
+        return Response::lack_of_cargo;
+    }
+
+    std::shared_ptr<Ship> playerShip = player->getShip();
+    if (!playerShip) {
+        return Response::lack_of_cargo;
+    }
+
+    auto shipCargo = playerShip->findMatchCargo(cargo);
+    auto shipStock = playerShip->getCargosVector();
+    if (shipCargo == shipStock.end()) {
+        return Response::lack_of_cargo;
+    }
+
+    if (shipCargo->get()->getAmount() < amount) {
+        return Response::lack_of_cargo;
+    }
+
+    player->sell(cargo, amount);
+    unloadShip(cargo, amount);
+
+    return Response::done;
+}
+
+Response Store::sell(const std::shared_ptr<Cargo>& cargo, const size_t& amount, Player* player) {
+    if (!cargo || !amount) {
+        Response::lack_of_cargo;
+    }
+
+    if (!player) {
+        return Response::lack_of_space;
+    }
+
+    std::shared_ptr<Ship> playerShip = player->getShip();
+    if (!playerShip) {
+        return Response::lack_of_space;
+    }
+    auto wantedCargo = findMatchCargo(cargo);
+    if (wantedCargo != stock_.end()) {
+        if (wantedCargo->get()->getAmount() < amount) {
+            return Response::lack_of_cargo;
+        }
+    }
+
+    if (player->getAvailableSpace() < amount) {
+        return Response::lack_of_space;
+    }
+
+    if (player->getMoney() <= 0 || player->getMoney() < cargo->getPrice() * amount) {
+        return Response::lack_of_money;
+    }
+
+    player->buy(cargo, amount);
+    std::cout << '\n';
+    loadShip(cargo, amount);
+    return Response::done;
+}
+
+std::ostream& operator<<(std::ostream& os, const Store& store) {
+    int counter = 1;
+    os << '\n';
+    os << std::setfill(' ') << "ID" << std::setw(30) << " TYPE OF CARGO" << std::setw(18) << "AMOUNT" << std::setw(20) << "BASE PRICE" << std::setw(10) << "PRICE\n";
+    for (const auto& el : store.stock_) {
+        os << std::left << std::setfill(' ') << std::setw(19) << counter << std::setw(25) << el->getName() << std::setw(20) << el->getAmount() << std::setw(5) << el->getBasePrice() << std::setw(40) << el->getPrice() << '\n';
+        counter++;
+    }
+    std::cout << counter << " Exit\n";
+    os << std::setfill('*') << std::setw(100) << "\n";
+
+    return os;
+}
+
+void Store::generateDefaultCargo() {
+    std::random_device rm;
+    std::mt19937 gr(rm());
+
+    std::uniform_int_distribution<> amountR(AMOUNT_MIN, AMOUNT_MAX);
+    std::uniform_int_distribution<> powerR(POWER_MIN, POWER_MAX);
+    std::uniform_int_distribution<> dayR(DAY_MIN, DAY_MAX);
+    std::uniform_int_distribution<> priceR(PRICE_MIN, PRICE_MAX);
+
+    stock_.reserve(50);
+    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), nullptr));
+    stock_.push_back(std::make_shared<Fruit>("Strawbarry", amountR(gr), priceR(gr), dayR(gr), nullptr));
+    stock_.push_back(std::make_shared<Fruit>("Water melon", amountR(gr), priceR(gr), dayR(gr), nullptr));
+    stock_.push_back(std::make_shared<Fruit>("Coconat", amountR(gr), priceR(gr), dayR(gr), nullptr));
+    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_.shrink_to_fit();
+}
+
+void Store::loadShip(const std::shared_ptr<Cargo>& cargo, const size_t& amount) {
+    if (!cargo) {
+        return;
+    }
+    auto loadedCargo = findMatchCargo(cargo);
+    if (loadedCargo != stock_.end()) {
+        (**loadedCargo) -= amount;
+        if (loadedCargo->get()->getAmount() == 0) {
+            stock_.erase(loadedCargo);
+        }
+    }
+    if (loadedCargo == stock_.end()) {
+        std::cout << "There is no cargo!!!\n";
+        return;
+    }
+}
+
+void Store::unloadShip(const std::shared_ptr<Cargo>& cargo, const size_t& amount) {
+    if (!cargo) {
+        return;
+    }
+    auto unloadCargo = findMatchCargo(cargo);
+    if (unloadCargo != stock_.end()) {
+        (**unloadCargo) += amount;
+    } else {
+        addCargo(cargo, amount);
+    }
+}
+
+void Store::addCargo(const std::shared_ptr<Cargo>& cargo, size_t amount) {
+    cargo->setTime(nullptr);
+    stock_.push_back(cargo->clone(amount));
+}
+
+void Store::nextDay() {
+    for (auto cargo : stock_) {
+        if(cargo) {
+            std::random_device rm;
+            std::mt19937 gr(rm());
+            int more_stuff_in_store = 1;
+            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);
+            int storeCapacity = 500;
+            if(in_store_action(gr)) {
+                *cargo += to_add_or_take(gr);
+                if (cargo->getAmount() > storeCapacity) {
+                    *cargo -= cargo->getAmount() - storeCapacity;
+                }
+            } else {
+                *cargo -= to_add_or_take(gr);
+                if (cargo->getAmount() < 0) {
+                    *cargo -= cargo->getAmount();
+                }
+                if (cargo->getAmount() > storeCapacity) {
+                    *cargo -= cargo->getAmount() - storeCapacity;
+                }
+            }
+        }
+    }
+}
diff --git a/shm/store.hpp b/shm/store.hpp
new file mode 100644
index 000000000..0237e75d6
--- /dev/null
+++ b/shm/store.hpp
@@ -0,0 +1,46 @@
+#pragma once
+
+#include <iomanip>
+#include <iostream>
+#include <memory>
+#include <vector>
+
+#include "cargo.hpp"
+#include "player.hpp"
+
+enum class Response {
+    done,
+    lack_of_money,
+    lack_of_cargo,
+    lack_of_space
+};
+// Class responsible for managing a store
+class Store : public IObserver {
+public:
+    Store() = default;
+    Store(std::shared_ptr<Time> time);
+    ~Store();
+
+    Response buy(const std::shared_ptr<Cargo>& cargo, const size_t& amount, Player* player);
+    Response sell(const std::shared_ptr<Cargo>& cargo, const size_t& amount, Player* player);
+    std::vector<std::shared_ptr<Cargo>> getCargoOfStore() const { return stock_; };
+
+    // Function responsible for adding a new cargo to a Store
+    void addCargo(const std::shared_ptr<Cargo>& cargo, size_t amount);
+    // Fucntion responsible for subtracting cargo from a Store.
+    void loadShip(const std::shared_ptr<Cargo>&  cargo, const size_t& amount);
+    // Funcition responsibel for adding amount of cargo to a Store.
+    void unloadShip(const std::shared_ptr<Cargo>&  cargo, const size_t& amount);
+    // Function responsible for finding proper cargo.
+    std::vector<std::shared_ptr<Cargo>>::iterator findMatchCargo(const std::shared_ptr<Cargo>& wantedCargo);
+
+    friend std::ostream& operator<<(std::ostream& os, const Store& store);
+
+    void nextDay() override; 
+
+private:
+    std::vector<std::shared_ptr<Cargo>> stock_{};
+    void generateDefaultCargo();
+    std::shared_ptr<Time> time_{ nullptr };
+
+};
diff --git a/shm/test/ship_gt.cpp b/shm/test/ship_gt.cpp
new file mode 100644
index 000000000..47e578f21
--- /dev/null
+++ b/shm/test/ship_gt.cpp
@@ -0,0 +1,63 @@
+#include "../alcohol.hpp"
+#include "../cargo.hpp"
+#include "../ship.hpp"
+#include "../time.hpp"
+
+#include "gtest/gtest.h"
+
+#include <memory>
+#include <vector>
+
+struct ShipTest : public ::testing::Test
+{
+    size_t capacity{1000};
+    size_t maxCrew{50};
+    size_t crew{20};
+    size_t speed{15};
+    std::string name{"LoveShip"};
+    size_t id{1};
+    Time time;
+
+    Ship ship = Ship(capacity, maxCrew, crew, speed, name, id, std::make_shared<Time>(time));
+};
+
+TEST_F(ShipTest, ShoulReturnCapacity)
+{
+    EXPECT_EQ(ship.getCapacity(), capacity);
+}
+
+TEST_F(ShipTest, ShouldChangeName)
+{
+    std::string newName = "Labamba";
+    ship.setName(newName);
+    EXPECT_EQ(ship.getName(), newName);
+}
+
+TEST_F(ShipTest, ShouldLoad)
+{
+
+    const size_t alcoholAmount = 50;
+    std::shared_ptr<Alcohol> alcohol = std::make_shared<Alcohol>();
+    auto cargos = ship.getCargosVector();
+
+    EXPECT_FALSE(cargos.size() != 0);
+
+    std::shared_ptr<Cargo> cargo = alcohol;
+    ship.load(alcohol, alcoholAmount);
+
+    EXPECT_EQ(ship.getCargo(0)->getAmount(), alcoholAmount);
+}
+
+TEST_F(ShipTest, ShouldUnload)
+{
+    const size_t alcoholAmount = 50;
+    std::shared_ptr<Alcohol> alcohol = std::make_shared<Alcohol>();
+    auto cargos = ship.getCargosVector();
+    std::shared_ptr<Cargo> cargo = alcohol;
+    ship.load(alcohol, alcoholAmount);
+    
+    EXPECT_FALSE(ship.getCargo(0)->getAmount() != alcoholAmount);
+
+    ship.unload(alcohol, alcoholAmount);
+    EXPECT_FALSE(cargos.size() != 0);
+}
diff --git a/shm/time.cpp b/shm/time.cpp
new file mode 100644
index 000000000..9c4c880be
--- /dev/null
+++ b/shm/time.cpp
@@ -0,0 +1,39 @@
+ #include "time.hpp"
+#include <iostream>
+#include <list>
+#include <memory>
+#include "iObserver.hpp"
+
+void Time::attachObserver(IObserver *observer)
+{
+    observerList_.push_back(observer);
+}
+
+void Time::detachObserver(IObserver *observer)
+{
+    observerList_.remove(observer);
+}
+
+void Time::onTimeChange()
+{
+    notifyAll();
+    daysNum_++;
+}
+
+void Time::notifyAll()
+{   
+    for (auto it = observerList_.begin(); it != observerList_.end(); it++)
+    {
+        if (*it) {
+            (*it)->nextDay();
+        }
+    }
+}
+
+size_t Time::getDays() const {
+    return daysNum_;
+}
+
+std::list<IObserver*> Time::getList() const {
+    return observerList_;
+}
diff --git a/shm/time.hpp b/shm/time.hpp
new file mode 100644
index 000000000..2de6d6dc2
--- /dev/null
+++ b/shm/time.hpp
@@ -0,0 +1,27 @@
+#pragma once
+#include <memory>
+#include <list>
+#include "iObserver.hpp"
+
+class IObserver;
+
+class Time {
+public:
+    Time() = default;
+    ~Time() = default;
+
+    void attachObserver(IObserver * );
+
+    void detachObserver(IObserver * );
+
+    void onTimeChange();
+
+    size_t getDays() const;
+
+    std::list<IObserver*> getList() const;
+private:
+    std::list<IObserver*> observerList_{};
+    void notifyAll();
+    size_t daysNum_ = 0;
+
+};