Implement terrain and resource system (#9, #10)

.gitmodules

@@ -4,3 +4,5 @@
 [submodule "Libraries/googlebenchmark"]
 	path = Libraries/googlebenchmark
 	url = https://github.com/google/benchmark.git
+[submodule "bar1"]
+	branch = master

Includes/BaseUnit.h

@@ -13,8 +13,9 @@ class BaseUnit {
  public:
     BaseUnit(int x, int y);
     virtual ~BaseUnit() = default;
-
+    
     virtual std::pair<int, int> Move(int x, int y) noexcept;
+    std::pair<int, int> GetPosition();
 };
 }  // namespace Civilizationpp
 

Includes/HexTile.h

@@ -1,9 +1,33 @@
 #ifndef CIVILIZATIONPP_HEX_TILE_H
 #define CIVILIZATIONPP_HEX_TILE_H
 
+#include <Terrain.h>
+
 namespace Civilizationpp
 {
-    class HexTile {};
-}
+class HexTile
+{
+ private:
+    Terrain* m_Terrain;
+
+ public:
+    HexTile()
+    {
+        m_Terrain = new Terrain();
+    }
+    Terrain* GetTerrain()
+    {
+        return m_Terrain;
+    }
+    void ChangeTerrain(Terrain* terrain)
+    {
+        m_Terrain = terrain;
+    }
+    void ChangeResource(Resource* resource)
+    {
+        m_Terrain->ChangeResource(resource);
+    }
+};
+}  // namespace Civilizationpp
 
 #endif  // CIVILIZATIONPP_HEX_TILE_H

Includes/Resource.h

@@ -0,0 +1,18 @@
+#ifndef CIVILIZATIONPP_RESOURCE
+#define CIVILIZATIONPP_RESOURCE
+
+namespace Civilizationpp {
+struct Resource {
+ private:
+    int m_Food;
+    int m_Production;
+    int m_Gold;
+
+ public:
+    Resource();
+    int GetFood() const;
+    int GetProduction() const;
+    int GetGold() const;
+};
+}  // namespace Civilizationpp
+#endif  // Resource

Includes/Terrain.h

@@ -0,0 +1,57 @@
+#ifndef CIVILAZATIONPP_TERRAIN
+#define CIVILAZATIONPP_TERRAIN
+
+#include <Resource.h>
+
+namespace Civilizationpp
+{
+enum class BaseTerrain
+{
+    Open,
+    Rough,
+    Lake,
+    Coast,
+    Ocean,
+    Fresh_Water
+};
+enum class TerrainName
+{
+    Coast,
+    Desert,
+    GrassLand,
+    Hill,
+    Mountain,
+    Ocean,
+    Plains,
+    Snow,
+    Tundra,
+    Forest,
+    Jungle,
+    Marsh,
+    Atoll,
+    FloodPlains,
+    Ice,
+    LAkes,
+    Oasis
+};
+struct Terrain
+{
+ private:
+    BaseTerrain m_Category;
+    TerrainName m_Name;
+    int m_Movement;
+    int m_Combat;  // percent
+    Resource* m_Resource;
+
+ public:
+    Terrain();
+    BaseTerrain GetCategory() const;
+    TerrainName GetName() const;
+    int GetMovement() const;
+    int GetCombat() const;
+    Resource* GetResource() const;
+    void ChangeResource(Resource* resource);
+};
+}  // namespace Civilizationpp
+
+#endif  // CIVILAZATIONPP_TERRAIN

Includes/UnitFactory.h

@@ -14,7 +14,6 @@ class UnitFactory {
  private:
     int m_x;
     int m_y;
-
  public:
     UnitFactory(int x, int y);
     auto CreatUnit(Unit::Codes unitCode) -> BaseUnit* {

Includes/Worker.h

@@ -2,14 +2,13 @@
 #define CIVILIZATIONPP_WORKER
 
 #include <BaseUnit.h>
-#include <Material.h>
 
 namespace Civilizationpp {
 class Worker : public BaseUnit {
  public:
     Worker(int x, int y);
-    void Build(Obtainable* tile);
-    void Build(Obtainable* tile, eventFunction f);
+    void Build(Resource* tile);
+    void Build(HexTile* tile, Resource* resource);
 };
 }  // namespace Civilizationpp
 

Sources/BaseUnit.cpp

@@ -6,8 +6,13 @@ BaseUnit::BaseUnit(int x, int y) {
     m_positionX = x;
     m_positionY = y;
 }
+
 std::pair<int, int> BaseUnit::Move(int x, int y) noexcept {
     m_positionX = x;
     m_positionY = y;
     return {m_positionX, m_positionY};
-}
+}
+
+std::pair<int, int> Civilizationpp::BaseUnit::GetPosition() {
+    return {m_positionX, m_positionY};
+}

Sources/Resource.cpp

@@ -0,0 +1,10 @@
+#include <Resource.h>
+Civilizationpp::Resource::Resource()
+{
+    m_Food = 0;
+    m_Gold = 0;
+    m_Production = 0;
+};
+int Civilizationpp::Resource::GetFood() const { return m_Food; }
+int Civilizationpp::Resource::GetProduction() const { return m_Production; }
+int Civilizationpp::Resource::GetGold() const { return m_Gold; }

Sources/Terrain.cpp

@@ -0,0 +1,34 @@
+#include <Terrain.h>
+
+int Civilizationpp::Terrain::GetCombat() const
+{
+    return m_Combat;
+}
+Civilizationpp::Terrain::Terrain()
+    : m_Category(BaseTerrain::Open),
+      m_Name(TerrainName::Plains)
+{
+    m_Movement = 0;
+    m_Combat = 0;
+}
+int Civilizationpp::Terrain::GetMovement() const
+{
+    return m_Movement;
+}
+
+Civilizationpp::Resource* Civilizationpp::Terrain::GetResource() const
+{
+    return m_Resource;
+}
+void Civilizationpp::Terrain::ChangeResource(Resource* resource)
+{
+    m_Resource = resource;
+}
+Civilizationpp::BaseTerrain Civilizationpp::Terrain::GetCategory() const
+{
+    return m_Category;
+}
+Civilizationpp::TerrainName Civilizationpp::Terrain::GetName() const
+{
+    return m_Name;
+}

Sources/Worker.cpp

@@ -1,8 +1,15 @@
 #include <Worker.h>
 
 using namespace Civilizationpp;
-void Worker::Build(Obtainable* tile) {
-    tile->ChangeFood([]() -> int { return 1; });
+
+Worker::Worker(int x, int y) : BaseUnit(x, y) {}
+
+void Worker::Build(Resource* resource) {
+    auto position = GetPosition();
+	HexMap::GetInstance()->GetTile(position.first, position.second)->ChangeResource(resource);
+}
+
+void Worker::Build(HexTile* tile, Resource* resource)
+{
+    tile->ChangeResource(resource);
 }
-void Worker::Build(Obtainable* tile, eventFunction f) { tile->ChangeFood(f); }
-Worker::Worker(int x, int y) : BaseUnit(x, y) {}

Tests/UnitTests/WorkerTests.cpp

@@ -1,29 +1,31 @@
+#include <Resource.h>
 #include <Worker.h>
 
 #include <gtest/gtest.h>
 
 using namespace Civilizationpp;
 
-class WorkerTest : public ::testing::Test {
+class WorkerTest : public ::testing::Test
+{
  protected:
-    Worker worker{0, 0};
-};
-class ObtainableTileTest : public Obtainable {
- public:
-    int GetFood() { return Food(); }
-    int GetProduction() { return Production(); }
-    int GetGold() { return Gold(); }
+    void SetUp() override
+    {
+        HexMap::GetInstance()->Generate(GameSettings(30, 30));
+    }
+    Worker worker{ 0, 0 };
 };
 
-TEST_F(WorkerTest, WorkerCanMoveAnywhere) {
-    auto position = worker.Move(1, 2);
+TEST_F(WorkerTest, WorkerCanMoveAnywhere)
+{
+    worker.Move(1, 2);
+    auto position = worker.GetPosition();
     ASSERT_EQ(position.first == 1, position.second == 2);
 }
-TEST_F(WorkerTest, WorkerCanChangeTile) {
-    ObtainableTileTest tile;
-    worker.Build(&tile);
-    ASSERT_EQ(tile.GetFood(), 1);
-    int t = 10;
-    worker.Build(&tile, [t]() -> int { return t + 10; });
-    ASSERT_EQ(tile.GetFood(), 20);
+TEST_F(WorkerTest, WorkerCanChangeTile)
+{
+    Resource res;
+    worker.Build(&res);
+    auto position = worker.GetPosition();
+    ASSERT_EQ(HexMap::GetInstance()->GetTile(position.first, position.second)->GetTerrain()->GetResource(),
+              &res);
 }