Testing walking.

src/dawn/assert/assert.hpp

@@ -84,6 +84,17 @@ void assertTrueImplement(
   map.find(key) != map.end(), __VA_ARGS__ \
 )
 
+/**
+ * Asserts that a given map does not have a specific key.
+ * @param map Map to check.
+ * @param key Key to check for.
+ * @param message Message (sprintf format) to send to the logger.
+ * @param args Optional TParam args for the sprintf message to accept.
+ */
+#define assertMapNotHasKey(map, key, ...) assertTrue( \
+  map.find(key) == map.end(), __VA_ARGS__ \
+)
+
 /**
  * Asserts that a given value has a specific flag turned off.
  * 

src/dawnrpg/component/entity/Entity.cpp

@@ -7,6 +7,7 @@
 #include "scene/Scene.hpp"
 #include "assert/assert.hpp"
 #include "util/Easing.hpp"
+#include "component/world/World.hpp"
 
 using namespace Dawn;
 
@@ -19,10 +20,13 @@ const glm::vec3 EntityTilePosition::toWorldSpace() {
 }
 
 void Entity::onInit() {
-  auto world = this->world.lock();
-  assertNotNull(world, "World is no longer active?");
+  listeners.push_back(getScene()->onUnpausedUpdate.listen([this](float_t delta){
+    if(this->turnTime <= 0.0f) return;
+    this->turnTime -= delta;
+    if(this->turnTime <= 0) this->turnTime = 0.0f;
+  }));
 
-  listeners.push_back(getScene()->onUnpausedUpdate.listen([this](float delta) {
+  listeners.push_back(getScene()->onUnpausedUpdate.listen([this](float_t delta){
     if(this->stepTime <= 0.0f) return;
     this->stepTime -= delta * this->stepSpeed;
 
@@ -42,16 +46,26 @@ void Entity::onInit() {
     this->getItem()->setLocalPosition(newLocal);
     this->eventMove.emit();
   }));
+
+  this->getWorld()->entityNotifyInit(this->getItem());
 }
 
 void Entity::onDispose() {
-  
+  this->getWorld()->entityNotifyDispose(this->getItem());
 }
 
-void Entity::move(
+std::shared_ptr<World> Entity::getWorld() {
+  auto world = this->world.lock();
+  assertNotNull(world, "World is no longer active?");
+  return world;
+}
+
+struct EntityStepResult Entity::move(
   const enum EntityDirection direction,
   const float_t stepSpeed
 ) {
+  assertFalse(this->isMoving(), "Entity is already moving.");
+  struct EntityStepResult result;
   struct EntityTilePosition newPosition = this->tilePosition;
 
   switch(direction) {
@@ -71,6 +85,15 @@ void Entity::move(
       assertUnreachable("Invalid direction: %d", direction);
   }
 
+  // Check for entity in way.
+  auto entityInWay = this->getWorld()->getEntityAt(newPosition);
+  if(entityInWay) {
+    result.type = EntityStepResultType::EntityInWay;
+    result.entityInWay = entityInWay;
+    this->turn(direction);
+    return result;
+  }
+
   // Get the tile at the destination, check for height if we are on stairs, etc.
   // If the tile is not walkable, return early.
 
@@ -82,6 +105,11 @@ void Entity::move(
   this->stepSpeed = stepSpeed;
 
   this->eventStepStart.emit();
+  return result;
+}
+
+void Entity::turn(const enum EntityDirection direction) {
+  this->direction = direction;
 }
 
 void Entity::setPosition(struct EntityTilePosition pos) {
@@ -89,8 +117,9 @@ void Entity::setPosition(struct EntityTilePosition pos) {
   this->tilePosition = pos;
   this->lastTilePosition = pos;
   this->getItem()->setLocalPosition(pos.toWorldSpace());
+  this->eventMove.emit();
 }
 
 bool_t Entity::isMoving() {
-  return this->stepTime > 0.0f;
+  return this->stepTime > 0.0f || this->turnTime > 0.0f;
 }

src/dawnrpg/component/entity/Entity.hpp

@@ -6,15 +6,15 @@
 #pragma once
 #include "scene/SceneComponent.hpp"
 #include "event/Event.hpp"
-
-typedef uint32_t entityid_t;
-typedef int64_t entitytileposition_t;
+#include "EntityID.hpp"
+#include "EntityTilePosition.hpp"
 
 #define ENTITY_STEP_SPEED_DEFAULT 3.0f
 #define ENTITY_STEP_SPEED_RUNNING 6.0f
 
 namespace Dawn {
   class World;
+  class Entity;
 
   enum class EntityDirection {
     Up,
@@ -22,22 +22,25 @@ namespace Dawn {
     Left,
     Right
   };
-  
-  struct EntityTilePosition {
-    entitytileposition_t x, y, z;
-    
-    /**
-     * Converts the tile position to a world space position.
-     * 
-     * @return This tile position in world space.
-     */
-    const glm::vec3 toWorldSpace();
+
+  enum class EntityStepResultType {
+    Step,
+    EntityInWay,
+  };
+
+  struct EntityStepResult {
+    enum EntityStepResultType type;
+
+    // I'd love to unionize this but it seems that it's not ideal rn.
+    std::shared_ptr<Entity> entityInWay;
   };
 
   class Entity : public SceneComponent {
     private:
-      struct EntityTilePosition lastTilePosition;
       enum EntityDirection direction = EntityDirection::Down;
+      float_t turnTime = 0.0f;
+
+      struct EntityTilePosition lastTilePosition;
       float_t stepTime = 0.0f;
       float_t stepSpeed = ENTITY_STEP_SPEED_DEFAULT;
 
@@ -45,19 +48,57 @@ namespace Dawn {
       struct EntityTilePosition tilePosition;
 
     public:
+      enum EntityID id = EntityID::Null;
       std::weak_ptr<World> world;
+      
       Event<> eventStepStart;
       Event<> eventStepEnd;
       Event<> eventMove;
       
       void onInit() override;
       void onDispose() override;
-      void move(
+
+      /**
+       * Gets the world this entity is in.
+       * 
+       * @return The world this entity is in.
+       */
+      std::shared_ptr<World> getWorld();
+
+      /**
+       * Moves the entity in the given direction.
+       * 
+       * @param direction The direction to move in.
+       * @param stepSpeed The speed to move at.
+       */
+      struct EntityStepResult move(
         const enum EntityDirection direction,
         const float_t stepSpeed = ENTITY_STEP_SPEED_DEFAULT
       );
+
+      /**
+       * Turns the entity in the given direction. This will have a slight delay
+       * and count as moving.
+       * 
+       * @param direction The direction to turn in.
+       */
+      void turn(const enum EntityDirection direction);
+
+      /**
+       * Safely sets the position of the entity. This will invoke movement
+       * events but not step events, so steps may be cancelled in this context.
+       * 
+       * @param position The new position of the entity.
+       */
       void setPosition(struct EntityTilePosition position);
 
+      /**
+       * Checks if the entity is currently moving (in a step).
+       * 
+       * @return True if the entity is moving, false otherwise.
+       */
       bool_t isMoving();
+
+      friend class World;
   };
 }

src/dawnrpg/component/entity/EntityID.hpp

@@ -0,0 +1,15 @@
+// Copyright (c) 2024 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "Entity.hpp"
+
+namespace Dawn {
+  enum class EntityID : uint32_t {
+    Null = 0,
+    Player = 1,
+    TestEntity = 2
+  };
+}

src/dawnrpg/component/entity/EntityTilePosition.cpp

@@ -0,0 +1,16 @@
+// Copyright (c) 2024 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "EntityTilePosition.hpp"
+
+using namespace Dawn;
+
+const glm::vec3 EntityTilePosition::toWorldSpace() {
+  return glm::vec3(
+    this->x,
+    this->y,
+    this->z
+  );
+}

src/dawnrpg/component/entity/EntityTilePosition.hpp

@@ -0,0 +1,30 @@
+// Copyright (c) 2024 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "dawnlibs.hpp"
+
+namespace Dawn {
+  struct EntityTilePosition {
+    int64_t x, y, z;
+
+    // Overload the equality operator.
+    bool operator==(const EntityTilePosition &other) const {
+      return this->x == other.x && this->y == other.y && this->z == other.z;
+    }
+
+    // Overload the inequality operator.
+    bool operator!=(const EntityTilePosition &other) const {
+      return !(*this == other);
+    }
+    
+    /**
+     * Converts the tile position to a world space position.
+     * 
+     * @return This tile position in world space.
+     */
+    const glm::vec3 toWorldSpace();
+  };
+}

src/dawnrpg/component/entity/Player.cpp

@@ -12,7 +12,7 @@ using namespace Dawn;
 void Player::onInit() {
   Entity::onInit();
 
-  listeners.push_back(getScene()->onUnpausedUpdate.listen([this](float delta) {
+  listeners.push_back(getScene()->onUnpausedUpdate.listen([this](float_t delta){
     if(this->isMoving()) return;
 
     InputManager &im = getGame()->inputManager;

src/dawnrpg/component/world/World.cpp

@@ -4,11 +4,54 @@
 // https://opensource.org/licenses/MIT
 
 #include "World.hpp"
+#include "scene/Scene.hpp"
 
 using namespace Dawn;
 
+void World::entityNotifyInit(std::shared_ptr<SceneItem> item) {
+  auto entity = item->getComponent<Entity>();
+  assertNotNull(entity, "Entity component not found on item.");
+  auto id = entity->id;
+  assertMapNotHasKey(this->entities, id, "Entity already exists in world.");
+  assertTrue(id != EntityID::Null, "Entity ID is invalid.");
+  this->entities[id] = entity;
+}
+
+void World::entityNotifyDispose(std::shared_ptr<SceneItem> item) {
+  auto entity = item->getComponent<Entity>();
+  assertNotNull(entity, "Entity component not found on item.");
+  auto id = entity->id;
+  assertMapHasKey(this->entities, id, "Entity does not exist in world.");
+  assertTrue(id != EntityID::Null, "Entity ID is invalid.");
+  this->entities.erase(id);
+}
+
 void World::onInit() {
+
 }
 
 void World::onDispose() {
+
+}
+
+std::shared_ptr<Entity> World::getEntity(const EntityID id) {
+  assertMapHasKey(this->entities, id, "Entity does not exist in world.");
+  auto ent = this->entities[id];
+  auto lock = ent.lock();
+  if(!lock) {
+    this->entities.erase(id);
+    return nullptr;
+  }
+  assertTrue(lock->id == id, "Entity ID mismatch.");
+  return lock;
+}
+
+std::shared_ptr<Entity> World::getEntityAt(const EntityTilePosition &pos) {
+  for(auto &pair : this->entities) {
+    auto ent = pair.second.lock();
+    if(!ent) continue;
+    if(ent->tilePosition != pos) continue;
+    return ent;
+  }
+  return nullptr;
 }

src/dawnrpg/component/world/World.hpp

@@ -5,14 +5,47 @@
 
 #pragma once
 #include "component/entity/Entity.hpp"
+#include "component/entity/Player.hpp"
 
 namespace Dawn {
   class World : public SceneComponent {
     private:
-      std::map<entityid_t, std::shared_ptr<Entity>> entities; 
+      std::unordered_map<enum EntityID, std::weak_ptr<Entity>> entities;
+
+      /**
+       * Part of the ECS, this function is called when an entity is initialized.
+       * 
+       * @param item Scene Item that has been initialized.
+       */
+      void entityNotifyInit(std::shared_ptr<SceneItem> item);
+
+      /**
+       * Part of the ECS, this function is called when an entity is disposed.
+       * 
+       * @param item Scene Item that has been disposed.
+       */
+      void entityNotifyDispose(std::shared_ptr<SceneItem> entity);
 
     public:
       void onInit() override;
       void onDispose() override;
+
+      /**
+       * Gets the entity with the given ID.
+       * 
+       * @param id The ID of the entity to get.
+       * @return The entity with the given ID.
+       */
+      std::shared_ptr<Entity> getEntity(const EntityID id);
+
+      /**
+       * Gets the entity at the given position.
+       * 
+       * @param pos The position to check for an entity.
+       * @return The entity at the given position, or nullptr.
+       */
+      std::shared_ptr<Entity> getEntityAt(const EntityTilePosition &pos);
+
+      friend class Entity;
   };
 }

src/dawnrpg/prefab/PlayerPrefab.cpp

@@ -17,6 +17,7 @@ struct PlayerPrefab Dawn::createPlayerPrefab(
 
   player.player = player.item->addComponent<Player>();
   player.player->world = world;
+  player.player->id = EntityID::Player;
 
   player.mesh = std::make_shared<Mesh>();
   player.mesh->createBuffers(CUBE_VERTICE_COUNT, CUBE_INDICE_COUNT);

src/dawnrpg/prefab/TestEntityPrefab.cpp

@@ -17,6 +17,7 @@ struct TestEntityPrefab Dawn::createTestEntityPrefab(
 
   entity.entity = entity.item->addComponent<Entity>();
   entity.entity->world = world;
+  entity.entity->id = EntityID::TestEntity;
 
   entity.mesh = std::make_shared<Mesh>();
   entity.mesh->createBuffers(CUBE_VERTICE_COUNT, CUBE_INDICE_COUNT);