Merge pull request #72 from jonylu7/combat

interupt open fire command

include/Avatar/AttackAndDamage.hpp

@@ -4,7 +4,7 @@
 
 #ifndef PRACTICALTOOLSFORSIMPLEDESIGN_ATTACKANDDAMAGE_HPP
 #define PRACTICALTOOLSFORSIMPLEDESIGN_ATTACKANDDAMAGE_HPP
-#include "Unit/IHealthable.hpp"
+#include "Unit/Huntable.hpp"
 #include "Util/Time.hpp"
 #include "Weapon.hpp"
 
@@ -13,7 +13,7 @@ class AttackAndDamage {
     AttackAndDamage() {}
     virtual ~AttackAndDamage() {}
 
-    void damageTargetWithWeapon(std::shared_ptr<IHealthable> target,
+    void damageTargetWithWeapon(std::shared_ptr<Huntable> target,
                                 std::shared_ptr<Weapon> weapon) {
         auto targethealth = target->getHealth();
         auto damage =
@@ -22,7 +22,7 @@ class AttackAndDamage {
         targethealth->addHP(-1 * damage);
     }
 
-    void openFireToTarget(std::shared_ptr<IHealthable> target) {
+    void openFireToTarget(std::shared_ptr<Huntable> target) {
         // cd time
         m_DeltaTime += m_Time.GetDeltaTime();
         if (m_Weapon->getIntervalInS() <= m_DeltaTime) {

include/Avatar/Avatar.hpp

@@ -13,9 +13,10 @@
 #include "Map/MapUtility.hpp"
 #include "Mechanics/GameObjectID.hpp"
 #include "Selectable.hpp"
+#include "Unit/Huntable.hpp"
 #include "Util/Image.hpp"
 
-class Avatar : public Util::GameObject, public Selectable, public IHealthable {
+class Avatar : public Util::GameObject, public Selectable, public Huntable {
 
 public:
     Avatar(){};
@@ -68,11 +69,20 @@ class Avatar : public Util::GameObject, public Selectable, public IHealthable {
     std::shared_ptr<Moving> getMoving() { return m_Moving; }
     std::shared_ptr<AvatarOrder> getAvatarOrder() { return m_Order; }
 
-    std::shared_ptr<Health> getHealth() override { return m_Health; }
+    void setHealth(std::shared_ptr<Health> health) { m_Health = health; }
 
-    void setHealth(std::shared_ptr<Health> health) override {
-        m_Health = health;
-    }
+public:
+    // huntable
+    std::shared_ptr<Health> getHealth() override { return m_Health; }
+    void setOrderNoOrder() override {
+        m_Order->setAvatarOrder(AvatarOrderType::NO_ORDER);
+    };
+    void setOrderTakenDamage() override {
+        m_Order->setAvatarOrder(AvatarOrderType::TAKEN_DAMAGE);
+    };
+    glm::vec2 getCurrentLocationInCell() override {
+        return getMoving()->getCurrentCell();
+    };
 
 protected:
     std::shared_ptr<SpriteSheet> m_AvatarSpriteSheet =

include/Avatar/Moving.hpp

@@ -71,8 +71,13 @@ class Moving {
     bool ifArrivedAtNextCell();
 
     void setMovePath(std::deque<MoveDirection> movepath) {
-        m_MovePath = movepath;
-        m_CurrentDir = m_MovePath.front();
+        if (movepath.empty()) {
+            m_MovePath = {MoveDirection::IDLE};
+            m_CurrentDir = MoveDirection::IDLE;
+        } else {
+            m_MovePath = movepath;
+            m_CurrentDir = m_MovePath.front();
+        }
         m_PrevCell = getCurrentCell();
     }
 

include/Map/Tile.hpp

@@ -58,7 +58,7 @@ class TileClass {
 
     std::vector<std::shared_ptr<Avatar>> getAvatars() { return m_Avatars; }
     std::shared_ptr<Structure> getStructure() { return m_Structure; }
-    bool ifStrucutreExists() {
+    bool ifStructureExists() {
         if (*m_Structure->getHealth()->getLivingStatus() ==
             LivingStatus::NOT_BORN_YET) {
             return false;

include/Mechanics/BuiltStructure.hpp

@@ -25,14 +25,14 @@ class BuiltStructure {
                 if (ifCanBuildStructureAtTile(newstruct) == true) {
                     m_BuiltStructure.push_back(newstruct);
                     m_Map->builtStructureByCellPosition(newstruct, coords);
-                    newstruct->getStructureOrder()->setStructOrder(
+                    newstruct->getStructureOrder()->setStructureOrder(
                         StructureOrderType::BUILT);
                 }
             }
         } else {
             m_BuiltStructure.push_back(newstruct);
             m_Map->builtStructureByCellPosition(newstruct, coords);
-            newstruct->getStructureOrder()->setStructOrder(
+            newstruct->getStructureOrder()->setStructureOrder(
                 StructureOrderType::BUILT);
         }
     }

include/Mechanics/NemesisManager.hpp

@@ -12,7 +12,7 @@ class NemesisManager {
     NemesisManager() {}
     ~NemesisManager() {}
     void addNemesis(std::shared_ptr<Avatar> avatar,
-                    std::shared_ptr<Avatar> nemesis) {
+                    std::shared_ptr<Huntable> nemesis) {
         m_Nemesis[avatar] = nemesis;
     }
 
@@ -34,7 +34,7 @@ class NemesisManager {
             return false;
         }
         if (hunter->getDistance(
-                m_Nemesis[hunter]->getMoving()->getCurrentCell()) <=
+                m_Nemesis[hunter]->getCurrentLocationInCell()) <=
             hunter->getAttackAndDamage()->getWeapon()->getFireRange() *
                 CELL_SIZE.x) // check with in range
         {
@@ -52,18 +52,16 @@ class NemesisManager {
             if (ifNemesisWithinWeaponRange(hunter)) {
                 hunter->getAvatarOrder()->setAvatarOrder(
                     AvatarOrderType::OPEN_FIRE);
-                prey->getAvatarOrder()->setAvatarOrder(
-                    AvatarOrderType::TAKEN_DAMAGE);
+                prey->setOrderTakenDamage();
                 hunter->getAttackAndDamage()->openFireToTarget(prey);
             }
 
-            if (*pair.second->getHealth()->getLivingStatus() ==
-                LivingStatus::DEAD) {
+            if (pair.second->getHealth()->ifDead()) {
                 removeNemesis(hunter);
                 hunter->getAvatarOrder()->setAvatarOrder(
                     AvatarOrderType::NO_ORDER);
-                prey->getAvatarOrder()->setAvatarOrder(
-                    AvatarOrderType::NO_ORDER);
+                prey->setOrderNoOrder();
+
                 break;
             }
 
@@ -72,15 +70,14 @@ class NemesisManager {
                 removeNemesis(hunter);
                 hunter->getAvatarOrder()->setAvatarOrder(
                     AvatarOrderType::NO_ORDER);
-                prey->getAvatarOrder()->setAvatarOrder(
-                    AvatarOrderType::NO_ORDER);
+                prey->setOrderNoOrder();
                 break;
             }
         }
     }
 
 private:
-    std::unordered_map<std::shared_ptr<Avatar>, std::shared_ptr<Avatar>>
+    std::unordered_map<std::shared_ptr<Avatar>, std::shared_ptr<Huntable>>
         m_Nemesis;
 };
 #endif // PRACTICALTOOLSFORSIMPLEDESIGN_NEMESISMANAGER_HPP

include/Mechanics/StructureManager.hpp

@@ -27,7 +27,7 @@ class StructureManager {
         newstruct->Start();
         m_StructSelectingConstructionSite = newstruct;
 
-        newstruct->getStructureOrder()->setStructOrder(
+        newstruct->getStructureOrder()->setStructureOrder(
             StructureOrderType::SELECTING_SITE);
     }
 

include/Mechanics/UnitManager.hpp

@@ -110,35 +110,40 @@ class UnitManager : public Player {
         switch (unit) {
         case UnitType::BARRACKS: {
             auto structure = std::make_shared<Barracks>(house);
-            structure->Start(cellPos);
+            auto globalPos = MapUtil::CellCoordToGlobal(cellPos);
+            structure->Start(globalPos);
             m_StructureManager->getStructureArray()->buildNewStructure(
                 structure, true);
             break;
         }
         case UnitType::ORE_REF: {
             auto structure = std::make_shared<OreRefinery>(house);
-            structure->Start(cellPos);
+            auto globalPos = MapUtil::CellCoordToGlobal(cellPos);
+            structure->Start(globalPos);
             m_StructureManager->getStructureArray()->buildNewStructure(
                 structure, true);
             break;
         }
         case UnitType::POWER_PLANT: {
             auto structure = std::make_shared<PowerPlants>(house);
-            structure->Start(cellPos);
+            auto globalPos = MapUtil::CellCoordToGlobal(cellPos);
+            structure->Start(globalPos);
             m_StructureManager->getStructureArray()->buildNewStructure(
                 structure, true);
             break;
         }
         case UnitType::WAR_FACT: {
             auto structure = std::make_shared<WarFactory>(house);
-            structure->Start(cellPos);
+            auto globalPos = MapUtil::CellCoordToGlobal(cellPos);
+            structure->Start(globalPos);
             m_StructureManager->getStructureArray()->buildNewStructure(
                 structure, true);
             break;
         }
         case UnitType::ADV_POWER_PLANT: {
             auto structure = std::make_shared<ADVPowerPlants>(house);
-            structure->Start(cellPos);
+            auto globalPos = MapUtil::CellCoordToGlobal(cellPos);
+            structure->Start(globalPos);
             m_StructureManager->getStructureArray()->buildNewStructure(
                 structure, true);
             break;

include/Structure/Structure.hpp

@@ -13,20 +13,17 @@
 #include "Selectable.hpp"
 #include "Structure/StructureOrder.hpp"
 #include "Unit/Health.hpp"
-#include "Unit/IHealthable.hpp"
-#include "Util/Image.hpp"
-
+#include "Unit/Huntable.hpp"
 #include "Util/GameObject.hpp"
+#include "Util/Image.hpp"
 #include "Util/Input.hpp"
 #include "Util/TransformUtils.hpp"
 #include "glm/glm.hpp"
 #define DEFAULT_ZINDEX 15
 #define CHEAT 0.01
 #define INTERVAL 50
 
-class Structure : public Util::GameObject,
-                  public Selectable,
-                  public IHealthable {
+class Structure : public Util::GameObject, public Selectable, public Huntable {
 
 public:
     Structure()
@@ -97,16 +94,25 @@ class Structure : public Util::GameObject,
 
 public:
     GameObjectID getID() { return m_ID; }
-    std::shared_ptr<Health> getHealth() override { return m_Health; }
-    void setHealth(std::shared_ptr<Health> health) override {
-        m_Health = health;
-    }
+    void setHealth(std::shared_ptr<Health> health) { m_Health = health; }
     std::shared_ptr<StructureOrder> getStructureOrder() { return m_Order; }
-
     std::shared_ptr<AttackAndDamage> getAttackAndDamage() {
         return m_AttackAndDamage;
     }
 
+public:
+    // huntable
+    std::shared_ptr<Health> getHealth() override { return m_Health; }
+    void setOrderNoOrder() override {
+        m_Order->setStructureOrder(StructureOrderType::NO_ORDER);
+    };
+    void setOrderTakenDamage() override {
+        m_Order->setStructureOrder(StructureOrderType::TAKEN_DAMAGE);
+    };
+    glm::vec2 getCurrentLocationInCell() override {
+        return getAbsoluteOccupiedArea()[0];
+    };
+
 protected:
     float m_ElectricPower;
     float m_BuildingTime;

include/Structure/StructureOrder.hpp

@@ -9,7 +9,8 @@ enum class StructureOrderType {
     CONSTRUCTED,
     SELECTING_SITE,
     BUILT,
-    NO_ORDER
+    NO_ORDER,
+    TAKEN_DAMAGE
 };
 class StructureOrder {
 public:
@@ -18,7 +19,7 @@ class StructureOrder {
 
     StructureOrderType getStructureOrderType() { return m_StructOrder; }
 
-    void setStructOrder(StructureOrderType structorder) {
+    void setStructureOrder(StructureOrderType structorder) {
         m_StructOrder = structorder;
     }
 

include/Unit/Huntable.hpp

@@ -0,0 +1,20 @@
+//
+// Created by 盧威任 on 5/20/24.
+//
+
+#ifndef PRACTICALTOOLSFORSIMPLEDESIGN_UNIT_HPP
+#define PRACTICALTOOLSFORSIMPLEDESIGN_UNIT_HPP
+#include "Unit/Health.hpp"
+#include "pch.hpp"
+class Huntable {
+public:
+    Huntable() {}
+    virtual ~Huntable() {}
+
+public:
+    virtual void setOrderNoOrder() = 0;
+    virtual void setOrderTakenDamage() = 0;
+    virtual glm::vec2 getCurrentLocationInCell() = 0;
+    virtual std::shared_ptr<Health> getHealth() = 0;
+};
+#endif // PRACTICALTOOLSFORSIMPLEDESIGN_UNIT_HPP

src/Mechanics/AvatarManager.cpp

@@ -49,13 +49,27 @@ void AvatarManager::giveOrderToMyAvatar(std::shared_ptr<Avatar> unit) {
                         MapUtil::ScreenToGlobalCoord(dest)))
                     ->ifEnemyAtTile()) {
                 unit->getAvatarOrder()->setAvatarOrder(AvatarOrderType::MOVE);
-                m_NemesisManager->addNemesis(
-                    unit,
-                    m_Map
+                if (m_Map
                         ->getTileByCellPosition(MapUtil::GlobalCoordToCellCoord(
                             MapUtil::ScreenToGlobalCoord(dest)))
-                        ->getAvatars()[0]);
+                        ->ifStructureExists()) {
+                    m_NemesisManager->addNemesis(
+                        unit, m_Map
+                                  ->getTileByCellPosition(
+                                      MapUtil::GlobalCoordToCellCoord(
+                                          MapUtil::ScreenToGlobalCoord(dest)))
+                                  ->getStructure());
+                } else {
+                    m_NemesisManager->addNemesis(
+                        unit, m_Map
+                                  ->getTileByCellPosition(
+                                      MapUtil::GlobalCoordToCellCoord(
+                                          MapUtil::ScreenToGlobalCoord(dest)))
+                                  ->getAvatars()[0]);
+                }
+
             } else {
+                m_NemesisManager->removeNemesis(unit);
                 unit->getAvatarOrder()->setAvatarOrder(AvatarOrderType::MOVE);
             }
         }

src/Mechanics/CursorSelection.cpp

@@ -28,7 +28,7 @@ void CursorSelection::cursorSelect() {
         for (int i = min_y_cell; i <= max_y_cell; i++) {
             for (int j = min_x_cell; j <= max_x_cell; j++) {
                 auto tile = m_Map->getTileByCellPosition(glm::vec2(j, i));
-                if (tile->ifStrucutreExists()) {
+                if (tile->ifStructureExists()) {
                     auto structure = tile->getStructure();
                     Append(structure);
 

src/Scene/TutorialScene.cpp

@@ -29,6 +29,8 @@ void TutorialScene::Start() {
     // combat test
     m_EnemyObjectManager->spawn(m_Map, UnitType::INFANTRY, HouseType::ENEMY,
                                 {6, 6});
+    m_EnemyObjectManager->spawn(m_Map, UnitType::BARRACKS, HouseType::ENEMY,
+                                {10, 10});
 
     stageStart();
 }

src/Structure/Barracks.cpp

@@ -20,7 +20,7 @@ void Barracks::Start() {
     m_HighLight.SetHLScale(this->GetTransform().scale);
     whenSelected();
     // State
-    getStructureOrder()->setStructOrder(StructureOrderType::CONSTRUCTED);
+    getStructureOrder()->setStructureOrder(StructureOrderType::CONSTRUCTED);
     // health
     Structure::getHealth()->setLivingStatus(
         std::make_shared<LivingStatus>(LivingStatus::ALIVE));
@@ -47,7 +47,7 @@ void Barracks::Start(glm::vec2 location) {
     SetVisible(true);
     m_SpriteSheetAnimation->initSpriteSheetAnimation(m_StructureSpriteSheet,
                                                      false, INTERVAL, false);
-    getStructureOrder()->setStructOrder(StructureOrderType::BUILT);
+    getStructureOrder()->setStructureOrder(StructureOrderType::BUILT);
     Structure::getHealth()->setLivingStatus(
         std::make_shared<LivingStatus>(LivingStatus::ALIVE));
 }