From 6f42a6e19546e672639ebb38fe852b43fba5ff40 Mon Sep 17 00:00:00 2001 From: Dominic Masters Date: Mon, 18 Aug 2025 22:28:22 -0500 Subject: [PATCH] Moved entitydir to direction_t --- src/dusk/entity/CMakeLists.txt | 1 + src/dusk/entity/direction.c | 53 ++++++++++++++++++++++++++++++++ src/dusk/entity/direction.h | 41 ++++++++++++++++++++++++ src/dusk/entity/entity.c | 50 ++---------------------------- src/dusk/entity/entity.h | 37 ++-------------------- src/dusk/entity/player.c | 18 +++++------ tools/mapcompile/entityParser.py | 2 +- 7 files changed, 111 insertions(+), 91 deletions(-) create mode 100644 src/dusk/entity/direction.c create mode 100644 src/dusk/entity/direction.h diff --git a/src/dusk/entity/CMakeLists.txt b/src/dusk/entity/CMakeLists.txt index c48e5a5..fe59ea9 100644 --- a/src/dusk/entity/CMakeLists.txt +++ b/src/dusk/entity/CMakeLists.txt @@ -6,6 +6,7 @@ # Sources target_sources(${DUSK_TARGET_NAME} PRIVATE + direction.c entity.c player.c npc.c diff --git a/src/dusk/entity/direction.c b/src/dusk/entity/direction.c new file mode 100644 index 0000000..e4f0e5e --- /dev/null +++ b/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; + } +} \ No newline at end of file diff --git a/src/dusk/entity/direction.h b/src/dusk/entity/direction.h new file mode 100644 index 0000000..65d6f2e --- /dev/null +++ b/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 +); \ No newline at end of file diff --git a/src/dusk/entity/entity.c b/src/dusk/entity/entity.c index 5eebd37..973e336 100644 --- a/src/dusk/entity/entity.c +++ b/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( - 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) { +void entityTurn(entity_t *entity, const direction_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 - } -} \ No newline at end of file diff --git a/src/dusk/entity/entity.h b/src/dusk/entity/entity.h index 255b8ed..afa6f59 100644 --- a/src/dusk/entity/entity.h +++ b/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. diff --git a/src/dusk/entity/player.c b/src/dusk/entity/player.c index 4208ebf..d296bf6 100644 --- a/src/dusk/entity/player.c +++ b/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) { - entityTurn(entity, ENTITY_DIR_NORTH); + if(entity->dir != DIRECTION_NORTH) { + entityTurn(entity, DIRECTION_NORTH); return; } entityMove(entity, moveSpeed); return; } else if(inputIsDown(INPUT_BIND_DOWN)) { - if(entity->dir != ENTITY_DIR_SOUTH) { - entityTurn(entity, ENTITY_DIR_SOUTH); + if(entity->dir != DIRECTION_SOUTH) { + entityTurn(entity, DIRECTION_SOUTH); return; } entityMove(entity, moveSpeed); return; } else if(inputIsDown(INPUT_BIND_LEFT)) { - if(entity->dir != ENTITY_DIR_WEST) { - entityTurn(entity, ENTITY_DIR_WEST); + if(entity->dir != DIRECTION_WEST) { + entityTurn(entity, DIRECTION_WEST); return; } entityMove(entity, moveSpeed); return; } else if(inputIsDown(INPUT_BIND_RIGHT)) { - if(entity->dir != ENTITY_DIR_EAST) { - entityTurn(entity, ENTITY_DIR_EAST); + if(entity->dir != DIRECTION_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) { diff --git a/tools/mapcompile/entityParser.py b/tools/mapcompile/entityParser.py index 53336e5..df2e1d1 100644 --- a/tools/mapcompile/entityParser.py +++ b/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):