Minigolf is pog

src/dawnglfw/input/InputManager.cpp

@@ -75,6 +75,9 @@ void InputManager::init(const std::shared_ptr<Game> game) {
   this->bind(InputBind::Right, GLFW_KEY_RIGHT);
   this->bind(InputBind::Run, GLFW_KEY_LEFT_SHIFT);
   this->bind(InputBind::Run, GLFW_KEY_RIGHT_SHIFT);
+  this->bind(InputBind::Action, GLFW_KEY_SPACE);
+  this->bind(InputBind::Action, GLFW_KEY_ENTER);
+  this->bind(InputBind::Action, GLFW_KEY_E);
 }
 
 float_t InputManager::getInputValue(int32_t axis) {

src/dawnrpg/component/entity/CMakeLists.txt

@@ -6,5 +6,7 @@
 target_sources(${DAWN_TARGET_NAME}
   PRIVATE
     Entity.cpp
+    EntityDirection.cpp
+    EntityTilePosition.cpp
     Player.cpp
 )

src/dawnrpg/component/entity/Entity.cpp

@@ -12,14 +12,6 @@
 
 using namespace Dawn;
 
-const glm::vec3 EntityTilePosition::toWorldSpace() {
-  return glm::vec3(
-    this->x,
-    this->y,
-    this->z
-  );
-}
-
 void Entity::onInit() {
   assertNotNull(this->getMap(), "Entity map cannot be null.");
 
@@ -85,23 +77,12 @@ struct EntityStepResult Entity::move(
   }
 
   auto map = this->getMap();
-  struct EntityTilePosition newPosition = this->tilePosition;
+  struct EntityTilePosition newPosition = (
-  switch(direction) {
+    entityDirectionGetRelativeTilePosition(
-    case EntityDirection::Up:
+      this->tilePosition,
-      newPosition.z--;
+      direction
-      break;
+    )
-    case EntityDirection::Down:
+  );
-      newPosition.z++;
-      break;
-    case EntityDirection::Left:
-      newPosition.x--;
-      break;
-    case EntityDirection::Right:
-      newPosition.x++;
-      break;
-    default:
-      assertUnreachable("Invalid direction: %d", direction);
-  }
 
   // Check for entity in way.
   auto entityInWay = map->getEntityAt(newPosition);

src/dawnrpg/component/entity/Entity.hpp

@@ -6,6 +6,7 @@
 #pragma once
 #include "component/world/Map.hpp"
 #include "event/Event.hpp"
+#include "EntityDirection.hpp"
 
 #define ENTITY_STEP_SPEED_DEFAULT 3.0f
 #define ENTITY_STEP_SPEED_RUNNING 6.0f
@@ -14,14 +15,7 @@
 namespace Dawn {
   class Entity;
 
-  enum class EntityDirection {
+  enum class EntityStepResultType : uint8_t {
-    Up,
-    Down,
-    Left,
-    Right
-  };
-
-  enum class EntityStepResultType {
     Turn,
     Step,
     EntityInWay,
@@ -36,7 +30,6 @@ namespace Dawn {
 
   class Entity : public SceneComponent {
     private:
-      enum EntityDirection direction = EntityDirection::Down;
       float_t turnTime = 0.0f;
 
       struct EntityTilePosition lastTilePosition;
@@ -44,6 +37,7 @@ namespace Dawn {
       float_t stepSpeed = ENTITY_STEP_SPEED_DEFAULT;
 
     protected:
+      enum EntityDirection direction = EntityDirection::Down;
       struct EntityTilePosition tilePosition;
 
     public:

src/dawnrpg/component/entity/EntityDirection.cpp

@@ -0,0 +1,39 @@
+// Copyright (c) 2024 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "assert/assert.hpp"
+#include "EntityDirection.hpp"
+
+using namespace Dawn;
+
+glm::vec3 entityDirectionGetVector(const EntityDirection &dir) {
+  switch(dir) {
+    case EntityDirection::Up: return glm::vec3(0.0f, 1.0f, 0.0f);
+    case EntityDirection::Down: return glm::vec3(0.0f, -1.0f, 0.0f);
+    case EntityDirection::Left: return glm::vec3(-1.0f, 0.0f, 0.0f);
+    case EntityDirection::Right: return glm::vec3(1.0f, 0.0f, 0.0f);
+    default:
+      assertUnreachable("Invalid direction: %d", dir);
+      return glm::vec3(0.0f, 0.0f, 0.0f);
+  }
+}
+
+struct EntityTilePosition entityDirectionGetRelativeTilePosition(
+  const EntityTilePosition &pos,
+  const EntityDirection &dir,
+  int32_t distance
+) {
+  struct EntityTilePosition result = pos;
+  switch(dir) {
+    case EntityDirection::Up: result.y += distance; break;
+    case EntityDirection::Down: result.y -= distance; break;
+    case EntityDirection::Left: result.x -= distance; break;
+    case EntityDirection::Right: result.x += distance; break;
+    default:
+      assertUnreachable("Invalid direction: %d", dir);
+      break;
+  }
+  return result;
+}

src/dawnrpg/component/entity/EntityDirection.hpp

@@ -0,0 +1,37 @@
+// Copyright (c) 2024 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "dawnlibs.hpp"
+#include "EntityTilePosition.hpp"
+
+enum class EntityDirection : uint8_t {
+  Up,
+  Down,
+  Left,
+  Right,
+};
+
+/**
+ * Gets the vector for the given direction.
+ * 
+ * @param dir The direction to get the vector for.
+ * @return The vector for the given direction.
+ */
+glm::vec3 entityDirectionGetVector(const EntityDirection &dir);
+
+/**
+ * Gets the relative tile position for the given direction.
+ * 
+ * @param pos The current position.
+ * @param dir The direction to get the relative position for.
+ * @param distance The distance to get the relative position for.
+ * @return The relative tile position for the given direction.
+ */
+struct Dawn::EntityTilePosition entityDirectionGetRelativeTilePosition(
+  const Dawn::EntityTilePosition &pos,
+  const EntityDirection &dir,
+  int32_t distance = 1
+);

src/dawnrpg/component/entity/Player.cpp

@@ -9,6 +9,17 @@
 
 using namespace Dawn;
 
+void Player::updateCameraPosition() {
+  auto c = camera.lock();
+  if(!c) return;
+  glm::vec3 pos = this->getItem()->getLocalPosition();
+  c->getItem()->lookAt(
+    pos + glm::vec3(0, 8, 1),
+    pos,
+    glm::vec3(0, 1, 0)
+  );
+}
+
 void Player::onInit() {
   Entity::onInit();
 
@@ -27,6 +38,8 @@ void Player::onInit() {
       this->move(EntityDirection::Left, stepSpeed);
     } else if(im.isDown(InputBind::Right)) {
       this->move(EntityDirection::Right, stepSpeed);
+    } else if(im.isDown(InputBind::Action)) {
+      this->interact();
     }
   }));
 
@@ -37,15 +50,16 @@ void Player::onInit() {
   this->updateCameraPosition();
 }
 
-void Player::updateCameraPosition() {
+void Player::interact() {
-  auto c = camera.lock();
+  // Get direction
-  if(!c) return;
+  auto tile = entityDirectionGetRelativeTilePosition(
-  glm::vec3 pos = this->getItem()->getLocalPosition();
+    this->tilePosition, this->direction
-  c->getItem()->lookAt(
-    pos + glm::vec3(0, 8, 1),
-    pos,
-    glm::vec3(0, 1, 0)
   );
+
+  auto at = getMap()->getEntityAt(tile);
+  if(at == nullptr) return;
+
+  std::cout << "Interacting" << std::endl;
 }
 
 void Player::onDispose() {

src/dawnrpg/component/entity/Player.hpp

@@ -17,5 +17,10 @@ namespace Dawn {
 
       void onInit() override;
       void onDispose() override;
+
+      /**
+       * Interacts with whatever is in front of the player.
+       */
+      void interact();
   };
 }

src/dawnrpg/component/world/Map.hpp

@@ -12,7 +12,7 @@ namespace Dawn {
   class Map : public SceneComponent {
     private:
       std::unordered_map<enum EntityID, std::weak_ptr<Entity>> entities;
-
+  
       /**
        * Part of the ECS, this function is called when an entity is initialized.
        * 

src/dawnrpg/input/InputBinds.hpp

@@ -11,6 +11,7 @@ namespace Dawn {
     Down,
     Left,
     Right,
-    Run
+    Run,
+    Action
   };
 }

src/dawnrpg/scenes/WorldScene.cpp

@@ -48,6 +48,6 @@ void Dawn::worldScene(Scene &s) {
   auto player = createPlayerPrefab(map.map);
   player.player->camera = camera;
 
-  // auto test = createTestEntityPrefab(map.map);
+  auto test = createTestEntityPrefab(map.map);
-  // test.entity->setPosition({ 5, 0, 0 });
+  test.entity->setPosition({ 5, 0, 0 });
 }