Entity progress

src/dawnrose/CMakeLists.txt

@@ -21,4 +21,5 @@ add_subdirectory(scene)
 set(ROSE_ASSETS_DIR ${DAWN_ASSETS_DIR}/games/rose)
 tool_prefab(${ROSE_ASSETS_DIR}/prefabs/Player.xml)
 tool_prefab(${ROSE_ASSETS_DIR}/prefabs/Urchin.xml)
-tool_prefab(${ROSE_ASSETS_DIR}/prefabs/Crab.xml)
+tool_prefab(${ROSE_ASSETS_DIR}/prefabs/Crab.xml)
+tool_prefab(${ROSE_ASSETS_DIR}/prefabs/SwordHitbox.xml)

src/dawnrose/scene/components/HurtHazard.hpp

@@ -5,11 +5,13 @@
 
 #pragma once
 #include "scene/SceneItemComponent.hpp"
+#include "scene/components/entity/EntityFaction.hpp"
 
 namespace Dawn {
   class HurtHazard : public SceneItemComponent {
     public:
       int32_t damage = 1;
+      enum Faction faction = FACTION_NONE;
       
       HurtHazard(SceneItem* item);
   };

src/dawnrose/scene/components/PlayerController.cpp

@@ -14,16 +14,13 @@ PlayerController::PlayerController(SceneItem *item) : SceneItemComponent(item) {
 
 std::vector<SceneItemComponent*> PlayerController::getDependencies() {
   return {
-    (this->characterController = item->getComponent<CharacterController2D>()),
+    (this->entityMove = item->getComponent<EntityMove>()),
-    (this->entityHealth = item->getComponent<EntityHealth>()),
+    (this->entitySwordAttack = item->getComponent<EntitySwordAttack>())
-    (this->entityMove = item->getComponent<EntityMove>())
   };
 }
 
 void PlayerController::onStart() {
-  assertNotNull(this->characterController);
   assertNotNull(this->entityMove);
-  assertNotNull(this->entityHealth);
 
   useEvent([&](float_t delta){
     // Movement
@@ -31,27 +28,9 @@ void PlayerController::onStart() {
       INPUT_BIND_NEGATIVE_X, INPUT_BIND_POSITIVE_X,
       INPUT_BIND_NEGATIVE_Y, INPUT_BIND_POSITIVE_Y
     );
+
+    if(this->entitySwordAttack != nullptr && getGame()->inputManager.isPressed(INPUT_BIND_ACCEPT)) {
+      this->entitySwordAttack->attack();
+    }
   }, getScene()->eventSceneUpdate);
-
-  // Hurt Hazard Processing
-  useEvent([&](struct CharacterController2DCollisionEventInfo info) {
-    if(entityHealth->isInvincible()) return;
-
-    auto hurtHazard = info.collider->item->getComponent<HurtHazard>();
-    if(hurtHazard == nullptr) return;
-
-    glm::vec2 back = glm::vec2(
-      info.collider->transform->getLocalPosition().x,
-      info.collider->transform->getLocalPosition().z
-    ) - glm::vec2(
-      this->transform->getLocalPosition().x,
-      this->transform->getLocalPosition().z
-    );
-
-    this->characterController->velocity = back * -hitKnockback;
-    this->entityHealth->damage({
-      .amount = hurtHazard->damage
-    });
-  }, this->characterController->eventCollision);
-
 }

src/dawnrose/scene/components/PlayerController.hpp

@@ -4,22 +4,16 @@
 // https://opensource.org/licenses/MIT
 
 #pragma once
-#include "scene/components/physics/2d/CharacterController2D.hpp"
-#include "scene/components/HurtHazard.hpp" 
-#include "scene/components/entity/EntityHealth.hpp"
 #include "scene/components/entity/EntityMove.hpp"
+#include "scene/components/entity/EntitySwordAttack.hpp"
 
 namespace Dawn {
   class PlayerController : public SceneItemComponent {
     protected:
-      CharacterController2D *characterController;
+      EntityMove *entityMove = nullptr;
-      EntityHealth *entityHealth;
+      EntitySwordAttack *entitySwordAttack = nullptr;
-      EntityMove *entityMove;
 
     public:
-      // @optional
-      float_t hitKnockback = 20.0f;
-
       PlayerController(SceneItem *item);
       std::vector<SceneItemComponent*> getDependencies() override;
       void onStart() override;

src/dawnrose/scene/components/entity/CMakeLists.txt

@@ -10,4 +10,6 @@ target_sources(${DAWN_TARGET_NAME}
     EntityHealth.cpp
     EntityRandomWalk.cpp
     EntityMove.cpp
+    EntitySwordAttack.cpp
+    EntityFaction.cpp
 )

src/dawnrose/scene/components/entity/EntityChargePlayer.cpp

@@ -13,12 +13,14 @@ EntityChargePlayer::EntityChargePlayer(SceneItem* item) : SceneItemComponent(ite
 
 std::vector<SceneItemComponent*> EntityChargePlayer::getDependencies() {
   return {
-    (characterController = item->getComponent<CharacterController2D>())
+    (characterController = item->getComponent<CharacterController2D>()),
+    (this->entityMove = item->getComponent<EntityMove>())
   };
 }
 
 void EntityChargePlayer::onStart() {
   assertNotNull(characterController);
+  assertNotNull(this->entityMove);
 
   useEvent([&](float_t delta) {
     // Get the direction to move in
@@ -26,7 +28,7 @@ void EntityChargePlayer::onStart() {
     if(player == nullptr) return;
     
     // Get the direction to move in
-    glm::vec2 pos = glm::vec2(
+    glm::vec2 diff = glm::vec2(
       player->transform->getLocalPosition().x,
       player->transform->getLocalPosition().z
     ) - glm::vec2(
@@ -34,14 +36,10 @@ void EntityChargePlayer::onStart() {
       transform->getLocalPosition().z
     );
 
-    // Conver to an angle and then convert back into a 2D vector. This mimics a
+    if(glm::distance(glm::vec2(), diff) <= 2.0f) {
-    // user essentially "moving the analogue stick in this direction"
+      this->entityMove->direction = glm::vec2(0, 0);
-    
+    } else {
-    if(mathAbs(pos.x) > 1.0f || mathAbs(pos.y) > 1.0f) {
+      this->entityMove->direction = diff;
-      float_t angle = atan2(pos.y, pos.x);
-      glm::vec2 movement(cos(angle), sin(angle));
-      transform->setLocalRotation(glm::quat(glm::vec3(0, -angle + 1.5708f, 0)));
-      characterController->velocity += movement * delta * moveSpeed;
     }
   }, getScene()->eventSceneUpdate);
 }

src/dawnrose/scene/components/entity/EntityChargePlayer.hpp

@@ -7,16 +7,15 @@
 #include "scene/SceneItemComponent.hpp"
 #include "scene/components/physics/2d/CharacterController2D.hpp"
 #include "scene/components/PlayerController.hpp"
+#include "scene/components/entity/EntityMove.hpp"
 
 namespace Dawn {
   class EntityChargePlayer : public SceneItemComponent {
     protected:
       CharacterController2D *characterController = nullptr;
+      EntityMove *entityMove = nullptr;
 
     public:
-      // @optional
-      float_t moveSpeed = 30.0f;
-
       EntityChargePlayer(SceneItem* item);
       std::vector<SceneItemComponent*> getDependencies() override;
       void onStart() override;

src/dawnrose/scene/components/entity/EntityFaction.cpp

@@ -0,0 +1,12 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "EntityFaction.hpp"
+
+using namespace Dawn;
+
+EntityFaction::EntityFaction(SceneItem* item) : SceneItemComponent(item) {
+  
+}

src/dawnrose/scene/components/entity/EntityFaction.hpp

@@ -0,0 +1,23 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "scene/SceneItemComponent.hpp"
+
+namespace Dawn {
+  enum Faction {
+    FACTION_NONE,
+    FACTION_ENEMY,
+    FACTION_PLAYER
+  };
+
+  class EntityFaction : public SceneItemComponent {
+    public:
+      // @optional
+      enum Faction faction = FACTION_NONE;
+
+      EntityFaction(SceneItem* item);
+  };
+}

src/dawnrose/scene/components/entity/EntityHealth.cpp

@@ -11,7 +11,15 @@ EntityHealth::EntityHealth(SceneItem* item) : SceneItemComponent(item) {
   
 }
 
+std::vector<SceneItemComponent*> EntityHealth::getDependencies() {
+  return {
+    this->characterController = this->item->getComponent<CharacterController2D>(),
+    this->entityFaction = this->item->getComponent<EntityFaction>()
+  };
+}
+
 void EntityHealth::onStart() {
+  // Update
   useEvent([&](float_t delta){
     if(this->invincibleTime > 0.0f) {
       this->invincibleTime -= delta;
@@ -21,6 +29,32 @@ void EntityHealth::onStart() {
       this->stunTime -= delta;
     }
   }, getScene()->eventSceneUpdate);
+
+  
+  // Hurt Hazard Processing
+  useEvent([&](struct CharacterController2DCollisionEventInfo info) {
+    if(this->isInvincible()) return;
+
+    auto hurtHazard = info.collider->item->getComponent<HurtHazard>();
+    if(hurtHazard == nullptr) return;
+    if(
+      entityFaction != nullptr &&
+      hurtHazard->faction == this->entityFaction->faction
+    ) return;
+
+    glm::vec2 back = glm::vec2(
+      info.collider->transform->getLocalPosition().x,
+      info.collider->transform->getLocalPosition().z
+    ) - glm::vec2(
+      this->transform->getLocalPosition().x,
+      this->transform->getLocalPosition().z
+    );
+
+    this->characterController->velocity = back * -hitKnockback;
+    this->damage({
+      .amount = hurtHazard->damage
+    });
+  }, this->characterController->eventCollision);
 }
 
 bool_t EntityHealth::isInvincible() {

src/dawnrose/scene/components/entity/EntityHealth.hpp

@@ -5,6 +5,9 @@
 
 #pragma once
 #include "scene/SceneItemComponent.hpp"
+#include "scene/components/entity/EntityFaction.hpp"
+#include "scene/components/physics/2d/CharacterController2D.hpp"
+#include "scene/components/HurtHazard.hpp"
 
 namespace Dawn {
   struct DamageInformation {
@@ -14,6 +17,10 @@ namespace Dawn {
   };
 
   class EntityHealth : public SceneItemComponent {
+    protected:
+      EntityFaction *entityFaction = nullptr;
+      CharacterController2D *characterController = nullptr;
+
     public:
       // @optional
       int32_t health = 10;
@@ -23,8 +30,11 @@ namespace Dawn {
       float_t invincibleTime = 0.0f;
       // @optional
       float_t stunTime = 0.0f;
+      // @optional
+      float_t hitKnockback = 20.0f;
       
       EntityHealth(SceneItem* item);
+      std::vector<SceneItemComponent*> getDependencies() override;
       void onStart() override;
 
       /**

src/dawnrose/scene/components/entity/EntityMove.cpp

@@ -14,7 +14,8 @@ EntityMove::EntityMove(SceneItem* item) : SceneItemComponent(item) {
 std::vector<SceneItemComponent*> EntityMove::getDependencies() {
   return {
     (characterController = item->getComponent<CharacterController2D>()),
-    (this->entityHealth = item->getComponent<EntityHealth>())
+    (this->entityHealth = item->getComponent<EntityHealth>()),
+    (this->entitySwordAttack = item->getComponent<EntitySwordAttack>())
   };
 }
 
@@ -23,8 +24,9 @@ void EntityMove::onStart() {
   assertNotNull(this->entityHealth);
 
   useEvent([&](float_t delta) {
-    // Don't move if stunned.
+    // Don't move if stunned or attacking.
     if(entityHealth->isStunned()) return;
+    if(entitySwordAttack != nullptr && entitySwordAttack->isAttacking()) return;
 
     // Don't move if no move.
     if(direction.x == 0 && direction.y == 0) return;

src/dawnrose/scene/components/entity/EntityMove.hpp

@@ -7,12 +7,14 @@
 #include "scene/SceneItemComponent.hpp"
 #include "scene/components/physics/2d/CharacterController2D.hpp"
 #include "scene/components/entity/EntityHealth.hpp"
+#include "scene/components/entity/EntitySwordAttack.hpp"
 
 namespace Dawn {
   class EntityMove : public SceneItemComponent {
     protected:
       CharacterController2D *characterController = nullptr;
       EntityHealth *entityHealth = nullptr;
+      EntitySwordAttack *entitySwordAttack = nullptr;
       
     public:
       // @optional

src/dawnrose/scene/components/entity/EntitySwordAttack.cpp

@@ -0,0 +1,49 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "EntitySwordAttack.hpp"
+#include "prefabs/SwordHitbox.hpp"
+
+using namespace Dawn;
+
+EntitySwordAttack::EntitySwordAttack(SceneItem* item) :
+  SceneItemComponent(item),
+  attackTime(0.0f)
+{
+  
+}
+
+void EntitySwordAttack::onStart() {
+  attackHitbox = SwordHitbox::create(getScene());
+  attackHitbox->transform.setLocalPosition(glm::vec3(999999999, 0, 0));
+  attackHitbox->transform.setParent(this->transform);
+
+  useEvent([&](float_t delta) {
+    if(this->attackTime > 0.0f) {
+      this->attackTime = this->attackTime - delta;
+    }
+  }, getScene()->eventSceneUpdate);
+
+  useEffect([&]{
+    if(attackTime <= 0) {
+      attackHitbox->transform.setLocalPosition(glm::vec3(999999999, 0, 0));
+    } else {
+      attackHitbox->transform.setLocalPosition(this->attackOffset);
+    }
+  }, attackTime);
+}
+
+void EntitySwordAttack::attack() {
+  auto entityFaction = this->item->getComponent<EntityFaction>();
+  auto hazard = attackHitbox->getComponent<HurtHazard>();
+  this->attackTime = swingTime;
+  if(hazard != nullptr && entityFaction != nullptr) {
+    hazard->faction = entityFaction->faction;
+  }
+}
+
+bool_t EntitySwordAttack::isAttacking() {
+  return this->attackTime > 0.0f;
+}

src/dawnrose/scene/components/entity/EntitySwordAttack.hpp

@@ -0,0 +1,30 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "scene/SceneItemComponent.hpp"
+#include "scene/components/entity/EntityFaction.hpp"
+
+namespace Dawn {
+  class EntitySwordAttack : public SceneItemComponent {
+    protected:
+      SceneItem *attackHitbox = nullptr;
+
+    public:
+      // @optional
+      StateProperty<float_t> attackTime;
+
+      // @optional
+      glm::vec3 attackOffset = glm::vec3(0, 0, 1);
+
+      // @optional
+      float_t swingTime = 0.5f;
+
+      EntitySwordAttack(SceneItem* item);
+      void onStart() override;
+      void attack();
+      bool_t isAttacking();
+  };
+}

src/dawntools/prefabtool/PrefabComponentParser.cpp

@@ -59,6 +59,8 @@ int32_t PrefabComponentParser::onParse(
       parser = vec3Parser;
     } else if(type == "int32_t" || type == "int") {
       parser = intParser;
+    } else if(type.starts_with("enum")) {
+      parser = rawParser;
     } else if(type.find("*") == (type.size() - 1)) {
       type = type.substr(0, type.size() - 1);
       parser = rawParser;
@@ -66,7 +68,7 @@ int32_t PrefabComponentParser::onParse(
       name = name.substr(1, name.size());
       parser = rawParser;
     } else {
-      *error = "Unkown parser for type: " + type + "::" + name;
+      *error = "Unknown parser for type: " + type + "::" + name;
       return 1;
     }