Moved entitydir to direction_t

src/dusk/entity/CMakeLists.txt

@@ -6,6 +6,7 @@
 # Sources
 target_sources(${DUSK_TARGET_NAME}
   PRIVATE
+    direction.c
     entity.c
     player.c
     npc.c

src/dusk/entity/direction.c

@@ -0,0 +1,53 @@
+/**
+ * Copyright (c) 2025 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "direction.h"
+#include "assert/assert.h"
+
+float_t directionToAngle(const direction_t dir) {
+  switch(dir) {
+    case DIRECTION_NORTH: return (M_PI_2);
+    case DIRECTION_SOUTH: return -(M_PI_2);
+    case DIRECTION_EAST: return 0;
+    case DIRECTION_WEST: return (M_PI);
+    default: return 0; // Should never happen
+  }
+}
+
+void directionGetCoordinates(
+  const direction_t dir,
+  int8_t *x, int8_t *y
+) {
+  assertNotNull(x, "X coordinate pointer cannot be NULL");
+  assertNotNull(y, "Y coordinate pointer cannot be NULL");
+
+  switch(dir) {
+    case DIRECTION_NORTH:
+      *x = 0;
+      *y = -1;
+      break;
+
+    case DIRECTION_SOUTH:
+      *x = 0;
+      *y = 1;
+      break;
+
+    case DIRECTION_EAST:
+      *x = 1;
+      *y = 0;
+      break;
+
+    case DIRECTION_WEST:
+      *x = -1;
+      *y = 0;
+      break;
+
+    default:
+      assertUnreachable("Invalid direction");
+      break;
+  }
+}

src/dusk/entity/direction.h

@@ -0,0 +1,41 @@
+/**
+ * Copyright (c) 2025 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "dusk.h"
+
+typedef enum {
+  DIRECTION_SOUTH = 0,
+  DIRECTION_EAST = 1,
+  DIRECTION_WEST = 2,
+  DIRECTION_NORTH = 3,
+
+  DIRECTION_UP = DIRECTION_NORTH,
+  DIRECTION_DOWN = DIRECTION_SOUTH,
+  DIRECTION_LEFT = DIRECTION_WEST,
+  DIRECTION_RIGHT = DIRECTION_EAST,
+} direction_t;
+
+/**
+ * Converts a direction to an angle in float_t format.
+ * 
+ * @param dir The direction to convert.
+ * @return The angle corresponding to the direction.
+ */
+float_t directionToAngle(const direction_t dir);
+
+/**
+ * Gets the relative coordinates for a given direction.
+ * 
+ * @param dir The direction to get coordinates for.
+ * @param x Pointer to store the x coordinate.
+ * @param y Pointer to store the y coordinate.
+ */
+void directionGetCoordinates(
+  const direction_t dir,
+  int8_t *x, int8_t *y
+);

src/dusk/entity/entity.c

@@ -82,7 +82,7 @@ void entityMove(entity_t *entity, const uint8_t moveSpeed) {
   );
 
   int8_t x = 0, y = 0;
-  entityDirGetCoordinates(entity->dir, &x, &y);
+  directionGetCoordinates(entity->dir, &x, &y);
 
   // entity in way?
   entity_t *ent = entityGetAt(entity->x + x, entity->y + y);
@@ -95,46 +95,12 @@ void entityMove(entity_t *entity, const uint8_t moveSpeed) {
   entity->moveSpeed = moveSpeed;
 }
 
-void entityDirGetCoordinates(
+void entityTurn(entity_t *entity, const direction_t dir) {
-  const entitydir_t dir,
-  int8_t *x, int8_t *y
-) {
-  assertNotNull(x, "X coordinate pointer cannot be NULL");
-  assertNotNull(y, "Y coordinate pointer cannot be NULL");
-
-  switch(dir) {
-    case ENTITY_DIR_NORTH:
-      *x = 0;
-      *y = -1;
-      break;
-
-    case ENTITY_DIR_SOUTH:
-      *x = 0;
-      *y = 1;
-      break;
-
-    case ENTITY_DIR_EAST:
-      *x = 1;
-      *y = 0;
-      break;
-
-    case ENTITY_DIR_WEST:
-      *x = -1;
-      *y = 0;
-      break;
-
-    default:
-      assertUnreachable("Invalid entity direction");
-      break;
-  }
-}
-
-void entityTurn(entity_t *entity, const entitydir_t dir) {
   assertNotNull(entity, "Entity pointer cannot be NULL");
   assertTrue(entity->type != ENTITY_TYPE_NULL, "Entity type NULL");
   assertTrue(entity->type < ENTITY_TYPE_COUNT, "Entity type out of bounds");
   assertTrue(
-    dir >= ENTITY_DIR_SOUTH && dir <= ENTITY_DIR_NORTH, "Invalid direction"
+    dir >= DIRECTION_SOUTH && dir <= DIRECTION_NORTH, "Invalid direction"
   );
   assertFalse(
     entityIsMoving(entity), "Entity is already moving, cannot turn"
@@ -163,13 +129,3 @@ entity_t * entityGetAt(
 
   return NULL;
 }
-
-float_t entityDirToAngle(const entitydir_t dir) {
-  switch(dir) {
-    case ENTITY_DIR_NORTH: return (M_PI_2);
-    case ENTITY_DIR_SOUTH: return -(M_PI_2);
-    case ENTITY_DIR_EAST: return 0;
-    case ENTITY_DIR_WEST: return (M_PI);
-    default: return 0; // Should never happen
-  }
-}

src/dusk/entity/entity.h

@@ -6,6 +6,7 @@
  */
 
 #pragma once
+#include "direction.h"
 #include "player.h"
 #include "npc.h"
 
@@ -13,18 +14,6 @@
 #define ENTITY_TURN_DURATION 0.075f // Duration for turning in seconds
 #define ENTITY_MOVE_DURATION 0.1f // Duration for moving 1 tile, in seconds.
 
-typedef enum {
-  ENTITY_DIR_SOUTH = 0,
-  ENTITY_DIR_EAST = 1,
-  ENTITY_DIR_WEST = 2,
-  ENTITY_DIR_NORTH = 3,
-
-  ENTITY_DIR_UP = ENTITY_DIR_NORTH,
-  ENTITY_DIR_DOWN = ENTITY_DIR_SOUTH,
-  ENTITY_DIR_LEFT = ENTITY_DIR_WEST,
-  ENTITY_DIR_RIGHT = ENTITY_DIR_EAST,
-} entitydir_t;
-
 typedef enum {
   ENTITY_TYPE_NULL = 0,
   ENTITY_TYPE_PLAYER = 1,
@@ -39,7 +28,7 @@ typedef struct _entity_t {
   uint8_t moveSpeed;
 
   entitytype_t type;
-  entitydir_t dir;
+  direction_t dir;
 
 
   union {
@@ -72,14 +61,6 @@ void entityLoad(entity_t *entity, const entity_t *source);
  */
 void entityUpdate(entity_t *entity);
 
-/**
- * Converts an entity direction to an angle in float_t format.
- * 
- * @param dir The entity direction to convert.
- * @return The angle corresponding to the entity direction.
- */
-float_t entityDirToAngle(const entitydir_t dir);
-
 /**
  * Moves the entity by the specified x and y offsets.
  * 
@@ -88,25 +69,13 @@ float_t entityDirToAngle(const entitydir_t dir);
  */
 void entityMove(entity_t *entity, const uint8_t moveSpeed);
 
-/**
- * Gets the coordinates of the entity direction.
- * 
- * @param dir The entity direction to get coordinates for.
- * @param x Pointer to store the x coordinate.
- * @param y Pointer to store the y coordinate.
- */
-void entityDirGetCoordinates(
-  const entitydir_t dir,
-  int8_t *x, int8_t *y
-);
-
 /**
  * Turns the entity to face the specified direction.
  * 
  * @param entity Pointer to the entity to turn.
  * @param dir The direction to turn the entity to.
  */
-void entityTurn(entity_t *entity, const entitydir_t dir);
+void entityTurn(entity_t *entity, const direction_t dir);
 
 /**
  * Returns whether or not an entity is currently moving.

src/dusk/entity/player.c

@@ -47,32 +47,32 @@ void playerEntityUpdate(entity_t *entity) {
   const uint8_t moveSpeed = inputIsDown(INPUT_BIND_CANCEL) ? PLAYER_SPEED_RUN : PLAYER_SPEED_WALK;
 
   if(inputIsDown(INPUT_BIND_UP)) {
-    if(entity->dir != ENTITY_DIR_NORTH) {
+    if(entity->dir != DIRECTION_NORTH) {
-      entityTurn(entity, ENTITY_DIR_NORTH);
+      entityTurn(entity, DIRECTION_NORTH);
       return;
     }
     entityMove(entity, moveSpeed);
     return;
 
   } else if(inputIsDown(INPUT_BIND_DOWN)) {
-    if(entity->dir != ENTITY_DIR_SOUTH) {
+    if(entity->dir != DIRECTION_SOUTH) {
-      entityTurn(entity, ENTITY_DIR_SOUTH);
+      entityTurn(entity, DIRECTION_SOUTH);
       return;
     }
 
     entityMove(entity, moveSpeed);
     return;
   } else if(inputIsDown(INPUT_BIND_LEFT)) {
-    if(entity->dir != ENTITY_DIR_WEST) {
+    if(entity->dir != DIRECTION_WEST) {
-      entityTurn(entity, ENTITY_DIR_WEST);
+      entityTurn(entity, DIRECTION_WEST);
       return;
     }
     entityMove(entity, moveSpeed);
     return;
 
   } else if(inputIsDown(INPUT_BIND_RIGHT)) {
-    if(entity->dir != ENTITY_DIR_EAST) {
+    if(entity->dir != DIRECTION_EAST) {
-      entityTurn(entity, ENTITY_DIR_EAST);
+      entityTurn(entity, DIRECTION_EAST);
       return;
     }
 
@@ -83,7 +83,7 @@ void playerEntityUpdate(entity_t *entity) {
   // Interact
   if(inputPressed(INPUT_BIND_ACTION)) {
     int8_t x, y;
-    entityDirGetCoordinates(entity->dir, &x, &y);
+    directionGetCoordinates(entity->dir, &x, &y);
     entity_t *ent = entityGetAt(entity->x + x, entity->y + y);
 
     if(ent != NULL && ENTITY_CALLBACKS[ent->type].interact != NULL) {

tools/mapcompile/entityParser.py

@@ -27,7 +27,7 @@ def parseEntity(obj, chunkData):
   
   obj['localX'] = obj['x'] - (chunkData['topLeftTileX'] * TILE_WIDTH_HEIGHT)
   obj['localY'] = obj['y'] - (chunkData['topLeftTileY'] * TILE_WIDTH_HEIGHT)
-  obj['dir'] = 'ENTITY_DIR_SOUTH'
+  obj['dir'] = 'DIRECTION_SOUTH'
   obj['type'] = entType
 
   def getProperty(propName):