Shm

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})

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());
+}

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_;
+};

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_;
+}

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};
+};

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_;
+};

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);
+}

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_;
+};