Merge2

CMakeLists.txt

@@ -101,7 +101,7 @@ set(SRC_FILES
         ${SRC_DIR}/Avatar/Avatar.cpp
         ${SRC_DIR}/Avatar/Hunter.cpp
         ${SRC_DIR}/Avatar/PathUtility.cpp
-        ${SRC_DIR}/Avatar/PathFindingUnit.cpp
+        ${SRC_DIR}/Avatar/Moving.cpp
 
         ${SRC_DIR}/Scene/DefaultScene.cpp
         ${SRC_DIR}/Camera.cpp
@@ -113,7 +113,7 @@ set(SRC_FILES
         ${SRC_DIR}/Map/MapbinReader.cpp
         ${SRC_DIR}/Map/Map.cpp
 
-        ${SRC_DIR}/Mechanics/FindValidPathToDest.cpp
+        ${SRC_DIR}/Mechanics/AvatarNavigator.cpp
         ${SRC_DIR}/Mechanics/GameObjectID.cpp
         ${SRC_DIR}/Mechanics/CursorSelection.cpp
         ${SRC_DIR}/Mechanics/AvatarManager.cpp
@@ -201,7 +201,7 @@ set(INCLUDE_FILES
         ${INCLUDE_DIR}/Structure/WarFactory.hpp
         ${INCLUDE_DIR}/Structure/ADVPowerPlants.hpp
 
-        ${INCLUDE_DIR}/Avatar/PathfindingUnit.hpp
+        ${INCLUDE_DIR}/Avatar/Moving.hpp
         ${INCLUDE_DIR}/Avatar/Avatar.hpp
         ${INCLUDE_DIR}/Avatar/WayPointUnit.hpp
         ${INCLUDE_DIR}/Avatar/Runner.hpp

include/Avatar/Avatar.hpp

@@ -27,7 +27,9 @@ class Avatar : public Moving,
     ~Avatar() override{};
 
     virtual void Start(glm::vec2 spawnlocationcell);
-    void aliveUpdate();
+    void noOrderUpdate();
+    void spawnedUpdate();
+    void moveUpdate();
     void deadUpdate();
     void attackUpdate();
 
@@ -64,6 +66,10 @@ class Avatar : public Moving,
         m_Health = health;
     }
 
+    std::shared_ptr<AttackAndDamage> getAttackAndDamager() {
+        return m_AttackAndDamage;
+    }
+
 protected:
     std::shared_ptr<SpriteSheet> m_AvatarSpriteSheet =
         std::make_shared<SpriteSheet>();

include/Avatar/Moving.hpp

@@ -25,9 +25,7 @@ class Moving {
     MoveDirection m_CurrentDir = MoveDirection::IDLE;
 
     float m_MovementSpeed = 1.F;
-    int m_MoveDistance = 0;
-
-    bool b_NewDestinationIsSetted = false;
+    glm::vec2 m_PrevCell;
 
 public:
     enum class AvatarStandingCorner {
@@ -56,16 +54,13 @@ class Moving {
 
     void setMovePath(std::deque<MoveDirection> movepath) {
         m_MovePath = movepath;
-        setNewDestinationIsSetted(false);
+        m_CurrentDir = m_MovePath.front();
+        m_MovePath.pop_front();
+        m_PrevCell = getCurrentCell();
     }
 
-    bool ifNewDestionationIsSetted() { return b_NewDestinationIsSetted; }
-
     void setMovementSpeed(float speed) { m_MovementSpeed = speed; }
 
-    void setNewDestinationIsSetted(bool value) {
-        b_NewDestinationIsSetted = value;
-    }
     glm::vec2 getDestinationCell() {
         return MapUtil::CellCoordToGlobal(m_DestinationLocation);
     }

include/Map/Tile.hpp

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

include/Mechanics/NemesisManager.hpp

@@ -46,7 +46,7 @@ class NemesisManager {
             if (ifNemesisWithinWeaponRange(hunter)) {
                 hunter->setAvatarOrder(AvatarOrderType::OPEN_FIRE);
                 prey->setAvatarOrder(AvatarOrderType::TAKEN_DAMAGE);
-                hunter->openFireToTarget(prey);
+                hunter->getAttackAndDamager()->openFireToTarget(prey);
             }
 
             if (*pair.second->getHealth()->getLivingStatus() ==

src/Avatar/Avatar.cpp

@@ -16,39 +16,53 @@ void Avatar::Update() {
 
     case (LivingStatus::ALIVE):
         whenSelected();
-        aliveUpdate();
 
         if (m_AvatarOrder == AvatarOrderType::OPEN_FIRE) {
 
         } else if (m_AvatarOrder == AvatarOrderType::MOVE) {
-
+            moveUpdate();
         } else if (m_AvatarOrder == AvatarOrderType::NO_ORDER) {
+            noOrderUpdate();
         } else if (m_AvatarOrder == AvatarOrderType::TAKEN_DAMAGE) {
+        } else if (m_AvatarOrder == AvatarOrderType::SPAWNED) {
+            spawnedUpdate();
         }
 
         break;
     }
 }
 
-void Avatar::aliveUpdate() {
-    moveToNextCell();
+void Avatar::noOrderUpdate() {
+    m_CurrentDir = MoveDirection::IDLE;
+    SetVisible(true);
+    m_Transform.translation = getCurrentLocation();
+
+    Draw();
+}
+
+void Avatar::spawnedUpdate() {
+    SetVisible(true);
+    m_Transform.translation = getCurrentLocation();
+
+    Draw();
+}
+void Avatar::moveUpdate() {
+
     if (ifArrivedAtNextCell()) {
         if (m_MovePath.size() >= 1) {
             m_CurrentDir = m_MovePath.front();
             m_MovePath.pop_front();
         } else {
             m_CurrentDir = MoveDirection::IDLE;
+            m_AvatarOrder = AvatarOrderType::NO_ORDER;
         }
     }
+    moveToNextCell();
 
     SetVisible(true);
     m_Transform.translation = getCurrentLocation();
 
     Draw();
-
-    printf("Avatar cell={%d,%d}\n", getCurrentLocation().x,
-           getCurrentLocation().y);
-    printf("-----------avatar------------------\n");
 }
 
 void Avatar::Start(glm::vec2 spawnlocationcell) { // destination = Barrack's
@@ -58,7 +72,7 @@ void Avatar::Start(glm::vec2 spawnlocationcell) { // destination = Barrack's
     //        setSpriteSheet();
     SetVisible(true);
     setMovementSpeed(4);
-    m_AvatarOrder = AvatarOrderType::MOVE;
+    m_AvatarOrder = AvatarOrderType::SPAWNED;
     m_CurrentLocation = MapUtil::CellCoordToGlobal(spawnlocationcell);
     m_Transform.scale = {1, 1};
     getHealth()->setLivingStatus(

src/Avatar/PathFindingUnit.cpp → src/Avatar/Moving.cpp

@@ -57,14 +57,18 @@ void Moving::moveToNextCell() {
 
         break;
     }
+    case MoveDirection::IDLE: {
+        return;
+    }
     }
 }
 
 bool Moving::ifArrivedAtNextCell() {
-    // change this to check
-    // previous cell
-    // getCurrentCell() != previousCell()
-    return false;
+    if (m_PrevCell != getCurrentCell()) {
+        return true;
+    } else {
+        return false;
+    }
 }
 void Moving::moveToCellCorner(AvatarStandingCorner corner) {
     float quaterHeight = CELL_SIZE.y / 4;

src/Mechanics/AvatarManager.cpp

@@ -17,32 +17,37 @@ void AvatarManager::Update() {
 }
 
 void AvatarManager::giveOrderToAvatar(std::shared_ptr<Avatar> unit) {
+    if (Util::Input::IsKeyDown(Util::Keycode::MOUSE_RB)) {
+        auto dest = Util::Input::GetCursorPosition();
+        auto queue = m_Navigator->findPath(
+            unit->getCurrentCell(), MapUtil::GlobalCoordToCellCoord(
+                                        MapUtil::ScreenToGlobalCoord(dest)));
+        // unit
+        unit->setMovePath(queue);
 
-    auto queue = m_Navigator->findPath(unit->getCurrentCell(),
-                                       unit->getDestinationCell());
-    // unit
-    unit->setMovePath(queue);
-    unit->setNewDestinationIsSetted(false);
-
-    if (m_Map->getTileByCellPosition(unit->getDestinationCell())
-            ->ifEnemyAtTile()) {
-        m_NemesisManager->addNemesis(
-            unit, m_Map->getTileByCellPosition(unit->getDestinationCell())
-                      ->getAvatars()[0]);
-    } else {
-        unit->setAvatarOrder(AvatarOrderType::MOVE);
+        if (m_Map->getTileByCellPosition(unit->getDestinationCell())
+                ->ifEnemyAtTile()) {
+            m_NemesisManager->addNemesis(
+                unit, m_Map->getTileByCellPosition(unit->getDestinationCell())
+                          ->getAvatars()[0]);
+        } else {
+            unit->setAvatarOrder(AvatarOrderType::MOVE);
+        }
     }
 }
 
-void AvatarManager::updateTileWhileAvatarMoving(std::shared_ptr<Avatar> unit) {
-    if (unit->ifArrivedAtNextCell()) {
-        m_Map->removeAvatarsByCellPosition(unit, unitArrayAndLocation[unit]);
-        m_Map->setAvatarByCellPosition(unit, unit->getCurrentCell());
-        unitArrayAndLocation[unit] = unit->getCurrentCell();
+void AvatarManager::updateTileWhileAvatarMoving(
+    std::shared_ptr<Avatar> avatar) {
+    if (avatar->ifArrivedAtNextCell()) {
+        m_Map->removeAvatarsByCellPosition(avatar,
+                                           unitArrayAndLocation[avatar]);
+        m_Map->setAvatarByCellPosition(avatar, avatar->getCurrentCell());
+        unitArrayAndLocation[avatar] = avatar->getCurrentCell();
     }
 }
 
 void AvatarManager::AppendAvatar(std::shared_ptr<Avatar> newAvatar) {
     m_AvatarArray.push_back(newAvatar);
     unitArrayAndLocation[newAvatar] = newAvatar->getCurrentCell();
+    m_Map->setAvatarByCellPosition(newAvatar, newAvatar->getCurrentCell());
 }