SHM part 2

shm/CMakeLists.txt

@@ -0,0 +1,41 @@
+cmake_minimum_required(VERSION 3.16)
+project(shm)
+set(testFile ../test/test.cpp ../test/catch_amalgamated.cpp)
+
+set(SRC 
+    alcohol.cpp 
+    cargo.cpp 
+    coordinates.cpp 
+    fruit.cpp
+    Game.cpp 
+    island.cpp 
+    item.cpp 
+    Map.cpp 
+    Menu.cpp
+    player.cpp 
+    ship.cpp 
+    Storable.cpp 
+    Store.cpp 
+    Time.cpp)
+
+set(FLAGS -Wall -Wextra -Werror -Wconversion -O3)
+
+add_library(${PROJECT_NAME}-lib STATIC ${SRC})
+add_executable(${PROJECT_NAME} main.cpp ${SRC})
+add_executable(${PROJECT_NAME}-ut ${testFile} ${SRC})
+
+target_link_libraries(${PROJECT_NAME} ${PROJECT_NAME}-lib)
+target_link_libraries(${PROJECT_NAME}-ut ${PROJECT_NAME}-lib)
+
+set_target_properties(${PROJECT_NAME} PROPERTIES
+                      CXX_STANDARD 17
+                      CXX_STANDARD_REQUIRED ON)                  
+set_target_properties(${PROJECT_NAME}-lib PROPERTIES
+                      CXX_STANDARD 17
+                      CXX_STANDARD_REQUIRED ON)
+set_target_properties(${PROJECT_NAME}-ut PROPERTIES
+                      CXX_STANDARD 17
+                      CXX_STANDARD_REQUIRED ON)
+
+
+

shm/Game.cpp

@@ -0,0 +1,190 @@
+#include "Game.hpp"
+#include <limits>
+
+class Map;
+
+Game::Game(size_t money, size_t gameDays, size_t finalGoal)
+    : time_(new Time()),
+      money_(money),
+      gameDays_(gameDays),
+      finalGoal_(finalGoal),
+      menu_(std::make_unique<Menu>(this)),
+      map_(new Map(time_)),
+      playerOne_(new Player(std::make_unique<Ship>(20, 30, 10, "Dar Pomorza", 3, time_), 1000, 1000))
+{}
+
+Game::Game(){}
+
+Game::~Game()
+{
+    //std::for_each(currentStore_.storeCargo.begin(), currentStore_.storeCargo.end(),[](Cargo* n){delete n;});
+    delete time_;
+}
+
+void Game::startGame()
+{
+    printTitle();
+    setPlayer();
+
+    while (true)
+    {
+        if (playerOne_->getMoney() >= 2000)
+        {
+            endGameWin();
+            quitRequested();
+        }
+        else if (playerOne_->getMoney() < 0 || time_->getCurrentTime() >= gameDays_)
+        {
+            endGameLose();
+            quitRequested();
+        }
+        if (quitRequest)
+        {
+            delete map_;
+            delete playerOne_;
+            break;
+        }
+        menu_->printMenu();
+        menu_->playerChoice();
+    }
+}
+
+void Game::printTitle()
+{
+    std::cout << "Project SHM" << '\n';
+}
+
+void Game::setPlayer()
+{
+    std::cout << "Set your name captain!:" << '\n';
+    std::string playerName;
+    std::cin >> playerName;
+    playerOne_->setName(playerName);
+    setStartingCargo();
+    std::cout << "Welcome on board captain " << playerOne_->getName() << '\n';
+    map_->changeCurrentPosition(&map_->islands_.at(0));
+    currentStore_ = map_->islands_.at(0).returnIslandStore();
+    std::cout << "Your's ship " << playerOne_->getShip()->getName() << " is waiting! Good Luck!" << '\n';
+    std::cout << "You are in start point. ";
+    map_->PrintCurrentPosition();
+    std::cout << "You have " << playerOne_->getMoney() << " gold in Your treasure chest!" << '\n';
+    std::cout << "Choose Your next move!" << '\n';
+}
+
+void Game::printMap(Map &map)
+
+{
+    map.PrintCurrentPosition();
+    map.DebugPrintIsland();
+}
+
+void Game::travel()
+
+{
+    auto i = 0;
+    printMap(*map_);
+    std::cout << "Choose Your destination captain!" << '\n';
+    std::cin >> i;
+    if (i < (int)map_->islands_.size() && i >= 0)
+    {
+        auto travelTime = map_->calculateDistance(map_->islands_.at(i)) / playerOne_->getSpeed();
+        std::cout << "Your travel will take " << travelTime << " days." << '\n';
+        map_->changeCurrentPosition(&map_->islands_.at(i));
+        map_->PrintCurrentPosition();
+        time_->changeTime(travelTime);
+        currentStore_ = map_->islands_.at(i).returnIslandStore();
+    }
+    else
+    {
+        std::cout << "There is no such island on the map! Choose another destination!" << '\n';
+        std::cin.clear();
+        std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
+        Game::travel();
+    }
+}
+
+void Game::printPlayerCargo()
+{
+    playerOne_->getShip()->printShipCargo();
+}
+
+void Game::setStartingCargo()
+{
+    playerOne_->getShip()->shipCargo.push_back(new Fruit("Banany", 1, 40, time_, 5, 0));
+    playerOne_->getShip()->shipCargo.push_back(new Fruit("Apple", 1, 14, time_, 20, 0));
+    playerOne_->getShip()->shipCargo.push_back(new Alcohol("Rum", 1, 60, time_, 70));
+    playerOne_->getShip()->shipCargo.push_back(new Item("Hook", 1, 100, time_, Rarity::common));
+}
+
+void Game::quitRequested()
+{
+    quitRequest = true;
+}
+
+void Game::displayPlayerStats()
+{
+    std::cout << "(Little reminder)" << '\n';
+    std::cout << "Available gold: " << playerOne_->getMoney() << '\n';
+    std::cout << "Your position on the map: \n";
+    map_->PrintCurrentPosition();
+    std::cout << "Day " << time_->getCurrentTime() << "/" << gameDays_ << '\n';
+    std::cout << "==========================\n";
+}
+
+void Game::printStoreCargo()
+{
+    std::cout << "This store contains: " << '\n';
+    currentStore_->printStoreCargo();
+}
+
+void Game::buyCargo()
+{
+    int cargoElement = 0;
+    size_t amount = 0;
+    std::cout << "Choose cargo: ";
+    std::cin >> cargoElement;
+    if (cargoElement >= 0 && cargoElement < (int)currentStore_->storeCargo.size())
+    {
+        std::cout << "Choose amount: ";
+        std::cin >> amount;
+        currentStore_->buy(currentStore_->storeCargo.at(cargoElement), amount, playerOne_);
+    }
+    else
+    {
+        std::cout << "There is no such cargo in this store." << '\n';
+        std::cin.clear();
+        std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
+        buyCargo();
+    }
+}
+
+void Game::sellCargo()
+{
+    int cargoElement = 0;
+    size_t amount = 0;
+    std::cout << "Choose cargo: ";
+    std::cin >> cargoElement;
+    if (cargoElement >= 0 && cargoElement < (int)playerOne_->getShip()->shipCargo.size())
+    {
+        std::cout << "Choose amount: ";
+        std::cin >> amount;
+        currentStore_->sell(playerOne_->getCargo(cargoElement), amount, playerOne_);
+    }
+    else
+    {
+        std::cout << "There is no such cargo in this ship." << '\n';
+        std::cin.clear();
+        std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
+        sellCargo();
+    }
+}
+
+void Game::endGameLose()
+{
+    std::cout << "You're time has come Captain! This is sad end!" << '\n';
+}
+void Game::endGameWin()
+
+{
+    std::cout << "Arrr you won" << '\n';
+}

shm/Game.hpp

@@ -0,0 +1,41 @@
+#pragma once
+#include <iostream>
+#include <memory>
+#include "Map.hpp"
+#include "Menu.hpp"
+#include "player.hpp"
+#include "Time.hpp"
+#include "coordinates.hpp"
+class Game
+{
+public:
+    Game(size_t money, size_t gameDays, size_t finalGoal);
+    Game();
+    ~Game();
+
+    void displayPlayerStats();
+    void setPlayer();
+    void startGame();
+    void printTitle();
+    void printMap(Map &);
+    void travel();
+    void buyCargo();
+    void sellCargo();
+    void setStartingCargo();
+    void printPlayerCargo();
+    void quitRequested();
+    void printStoreCargo();
+    void endGameWin();
+    void endGameLose();
+
+private:
+    Time* time_;
+    size_t money_;
+    size_t gameDays_;
+    size_t finalGoal_;
+    bool quitRequest = false;
+    std::unique_ptr<Menu> menu_;
+    Map* map_;
+    Store* currentStore_;
+    Player* playerOne_;
+};

shm/Map.cpp

@@ -0,0 +1,86 @@
+#include <algorithm>
+#include <iostream>
+#include <random>
+#include <utility>
+#include <iterator>
+#include <math.h>
+#include "coordinates.hpp"
+#include "island.hpp"
+#include "Map.hpp"
+
+namespace constVariables
+{
+
+    constexpr size_t COORDINATE_MIN = 0;
+    constexpr size_t COORDINATE_MAX = 99;
+    constexpr size_t ISLANDS_COUNT = 10;
+
+} // namespace constVariables
+
+Map::Map(Time *time)
+{
+    SetUpRandomIsland(time);
+}
+
+void Map::SetUpRandomIsland(Time *time)
+{
+    islands_.reserve(constVariables::ISLANDS_COUNT);
+    std::random_device rd;
+    std::mt19937 gen(rd());
+    std::uniform_real_distribution<> distrib(constVariables::COORDINATE_MIN, constVariables::COORDINATE_MAX);
+    std::vector<Coordinates> cords;
+    cords.reserve(constVariables::ISLANDS_COUNT);
+    for (int i = 0; i < (int)constVariables::ISLANDS_COUNT; i++)
+    {
+        int x = (int)distrib(gen);
+        int y = (int)distrib(gen);
+        Coordinates c(x, y);
+        while (contains(cords, c))
+        {
+            x = (int)distrib(gen);
+            y = (int)distrib(gen);
+            c.SetPositionX(x);
+            c.SetPositionY(y);
+        }
+
+        islands_.emplace_back(Island(c, time));
+        cords.push_back(c);
+    }
+}
+
+void Map::DebugPrintIsland()
+{
+    int j = 0;
+    for (auto &el : islands_)
+    {
+        std::cout << j << " | " << std::to_string(el.getPosition().GetPositionX()) << " | " << std::to_string(el.getPosition().GetPositionY()) << '\n';
+
+        j++;
+    }
+}
+
+void Map::PrintCurrentPosition()
+{
+    std::cout << "Current coordinates: " << std::to_string(current_pos_->getPosition().GetPositionX()) << " | " << std::to_string(current_pos_->getPosition().GetPositionY()) << '\n';
+}
+
+bool Map::contains(const std::vector<Coordinates> &vec, const Coordinates &c)
+{
+    return std::find(vec.begin(), vec.end(), c) != vec.end();
+}
+
+size_t Map::calculateDistance(Island island_pos_)
+{
+    const auto distanceX = current_pos_->getPosition().GetPositionX();
+    const auto distanceY = current_pos_->getPosition().GetPositionY();
+    const auto disX = island_pos_.getPosition().GetPositionX();
+    const auto disY = island_pos_.getPosition().GetPositionY();
+    const auto distance = sqrt(pow((disX - distanceX), 2) + pow((disY - distanceY), 2));
+    std::cout << "Distance: " << distance << '\n';
+    return (size_t)distance;
+}
+
+void Map::addIsland(Coordinates &coordinate, Time *time)
+{
+    islands_.push_back(Island(coordinate, time));
+}

shm/Map.hpp

@@ -0,0 +1,27 @@
+#pragma once
+#include "island.hpp"
+#include <vector>
+#include "Time.hpp"
+
+//class Island;
+class Coordinates;
+
+//Class responsible for representing map in game
+class Map {
+public:
+    Map(Time * time);
+    void DebugPrintIsland();
+    void PrintCurrentPosition();
+    friend class Game;
+    Island* getCurrentPos() {return current_pos_;}
+    void changeCurrentPosition(Island* position) {current_pos_ = position;}
+    size_t calculateDistance(Island);
+    Island *getIsland(const Coordinates &);
+    void addIsland(Coordinates &, Time *);
+
+private:
+    Island *current_pos_;
+    std::vector<Island> islands_;
+    bool contains(const std::vector<Coordinates>&, const Coordinates&);
+    void SetUpRandomIsland(Time *);
+};