Adding game class

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 

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

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

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

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

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

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

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

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,15 +17,15 @@ 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_; };
     size_t getBasePrice() const override { return basePrice_; };
 
     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_;