Added basic player movement.

include/dawn/dawn.h

@@ -17,6 +17,7 @@
 #include "file/asset.h"
 
 #include "game/game.h"
+#include "game/gametime.h"
 
 #include "input/input.h"
 

include/dawn/game/gametime.h

@@ -0,0 +1,38 @@
+/**
+ * Copyright (c) 2021 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+
+#define GAMETIME_STEP 0.016
+
+typedef struct {
+  /**
+   * Current time (as a float of seconds since game start).
+   * 
+   * When time is initialized this will start at a fixed value of 2/60ths of a 
+   * second, regardless of what engine the game is running.
+   * 
+   * This is to avoid any divide by zero errors.
+   */
+  float current;
+
+  /**
+   * Last Time (as a float of seconds since the game start).
+   * 
+   * This value will start at 1/60th of a second regardless of engine the game
+   * is running on to avoid divide by zero errors.
+   */
+  float last;
+
+  /**
+   * Fixed timestep that occured since the last frame. Typically locked to 1/60
+   * steps per second.
+   */
+  float delta;
+} gametime_t;
+
+extern gametime_t TIME_STATE;

include/dawn/input/input.h

@@ -9,10 +9,10 @@
 
 
 /** Inputs */
-#define GAME_INPUT_UP          (inputbind_t)0x01
+#define INPUT_UP          (inputbind_t)0x01
-#define GAME_INPUT_DOWN        (inputbind_t)0x02
+#define INPUT_DOWN        (inputbind_t)0x02
-#define GAME_INPUT_LEFT        (inputbind_t)0x03
+#define INPUT_LEFT        (inputbind_t)0x03
-#define GAME_INPUT_RIGHT       (inputbind_t)0x04
+#define INPUT_RIGHT       (inputbind_t)0x04
 
 #define INPUT_NULL (inputbind_t)0x00
 #define INPUT_BIND_COUNT 128

include/dawn/world/entity/entity.h

@@ -7,17 +7,50 @@
 
 #pragma once
 #include "../../libs.h"
+#include "../../display/spritebatch.h"
 
+/** Entity ID Definitions */
+#define ENTITY_TYPE_NULL 0x00
+#define ENTITY_TYPE_PLAYER 0x01
+
+/** Max count of entities in the world */
 #define ENTITY_COUNT 64
 
+/** Count of different types of entities */
+#define ENTITY_TYPE_COUNT ENTITY_TYPE_PLAYER + 1
+
+/** Unique Entity ID */
+typedef uint8_t entityid_t;
+
+/** Unique Entity ID for the Entity Type */
+typedef uint8_t entitytypeid_t;
+
+/** Entity Definition */
 typedef struct {
+  entitytypeid_t type;
   int32_t gridX, gridY, gridZ;
   int32_t oldGridX, oldGridY, oldGridZ;
   float positionX, positionY, positionZ;
 } entity_t;
 
+/** Definition for an entity type */
 typedef struct {
-  entity_t entities[ENTITY_COUNT]
+  void (*entityInit)(entityid_t entityId, entity_t *entity);
+  void (*entityUpdate)(entityid_t entityId, entity_t *entity);
+  void (*entityDispose)(entityid_t entityId, entity_t *entity);
+} entitytype_t;
+
+/** Entity State Management */
+typedef struct {
+  /** Entities within the state */
+  entity_t entities[ENTITY_COUNT];
+
+  /** Sprite Batch in the state */
+  spritebatch_t *spriteBatch;
 } entitystate_t;
 
-extern entitystate_t ENTITY_STATE;
+/** Global Entity State */
+extern entitystate_t ENTITY_STATE;
+
+/** Global Entity Type Definitions */
+extern entitytype_t ENTITY_TYPES[ENTITY_TYPE_COUNT];

src/game/game.c

@@ -14,6 +14,7 @@ bool gameInit() {
   GAME_STATE.name = GAME_NAME;
 
   // Init the renderer.
+  gameTimeInit();
   renderInit();
   inputInit();
   worldInit();
@@ -23,11 +24,14 @@ bool gameInit() {
     "shaders/test.vert", "shaders/test.frag"
   );
 
+  entityInit(0x00, 0x01);
+
   // Init the input manger.
   return true;
 }
 
 bool gameUpdate() {
+  gameTimeUpdate();
   renderFrameStart();
   inputUpdate();
 
@@ -35,7 +39,7 @@ bool gameUpdate() {
   shaderUse(GAME_STATE.shaderWorld);
 
   // Set up the camera.
-  int32_t d = 50;
+  int32_t d = 10;
   cameraLookAt(&GAME_STATE.cameraWorld,  d, d, d,  0, 0, 0);
   cameraPerspective(&GAME_STATE.cameraWorld, 45.0f,
     ((float)RENDER_STATE.width) / ((float)RENDER_STATE.height),

src/game/game.h

@@ -5,12 +5,14 @@
 
 #pragma once
 #include <dawn/dawn.h>
+#include "gametime.h"
 #include "../display/render.h"
 #include "../display/camera.h"
 #include "../display/shader.h"
 #include "../file/asset.h"
 #include "../input/input.h"
 #include "../world/world.h"
+#include "../world/entity/entity.h"
 
 /**
  * Initialize the game context.

src/game/gametime.c

@@ -0,0 +1,22 @@
+/**
+ * Copyright (c) 2021 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "gametime.h"
+
+gametime_t TIME_STATE;
+
+void gameTimeInit() {
+  TIME_STATE.delta = GAMETIME_STEP;
+  TIME_STATE.last = GAMETIME_STEP;
+  TIME_STATE.current = GAMETIME_STEP + GAMETIME_STEP;
+}
+
+void gameTimeUpdate() {
+  TIME_STATE.last = TIME_STATE.current;
+  TIME_STATE.current = TIME_STATE.current + GAMETIME_STEP;
+  TIME_STATE.delta = TIME_STATE.current - TIME_STATE.last;
+}

src/game/gametime.h

@@ -0,0 +1,19 @@
+/**
+ * Copyright (c) 2021 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include <dawn/dawn.h>
+
+/**
+ * Initializes the gametime global time tracking.
+ */
+void gameTimeInit();
+
+/**
+ * Ticks the current game time.
+ */
+void gameTimeUpdate();

src/input/input.c

@@ -94,7 +94,7 @@ inputval_t inputGetAxis(inputbind_t binding) {
 float inputGetFullAxis(inputbind_t positive,
   inputbind_t negative
 ) {
-  return INPUT_STATE.current[negative] + INPUT_STATE.current[positive];
+  return -INPUT_STATE.current[negative] + INPUT_STATE.current[positive];
 }
 
 float inputGetAccuated(inputbind_t binding) {

src/platform/glfw/glwfwplatform.c

@@ -30,7 +30,15 @@ int32_t main() {
   // Init the game
   if(gameInit()) {
     // Bind initial keys
-    inputBind(INPUT_NULL, (inputsource_t)GLFW_KEY_ESCAPE);
+    inputBind(INPUT_NULL,     (inputsource_t)GLFW_KEY_ESCAPE);
+    inputBind(INPUT_UP,       (inputsource_t)GLFW_KEY_UP);
+    inputBind(INPUT_DOWN,     (inputsource_t)GLFW_KEY_DOWN);
+    inputBind(INPUT_LEFT,     (inputsource_t)GLFW_KEY_LEFT);
+    inputBind(INPUT_RIGHT,    (inputsource_t)GLFW_KEY_RIGHT);
+    inputBind(INPUT_UP,       (inputsource_t)GLFW_KEY_W);
+    inputBind(INPUT_DOWN,     (inputsource_t)GLFW_KEY_S);
+    inputBind(INPUT_LEFT,     (inputsource_t)GLFW_KEY_A);
+    inputBind(INPUT_RIGHT,    (inputsource_t)GLFW_KEY_D);
 
     // Init the render resolution
     renderSetResolution(WINDOW_WIDTH_DEFAULT, WINDOW_HEIGHT_DEFAULT);

src/world/entity/common.c

@@ -0,0 +1,49 @@
+/**
+ * Copyright (c) 2021 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "common.h"
+
+void entityCommonMove(entityid_t id, entity_t *entity, int32_t x, int32_t y, int32_t z) {
+  int32_t newX, newY, newZ, chunkIndex, tileIndex;
+  tileid_t tileId;
+
+  // Determine the new coordinates.
+  newX = entity->gridX + x;
+  newY = entity->gridY + y;
+  newZ = entity->gridZ + z;
+
+  // Can we move there, tile check first then entity check.
+  tilegetresult_t result = tileGet(newX, newY, newZ);
+  chunkIndex = chunkGet(result.chunkX, result.chunkY, result.chunkZ);
+  if(chunkIndex == -1) return;
+  tileIndex = chunkGetTile(result.localX, result.localY, result.localZ);
+  
+  tileId = MAP_STATE.chunkList[chunkIndex]->tiles[tileIndex];
+  if(tileId == TILE_NULL) return;
+
+  // Update the old and new positions
+  entity->oldGridX = entity->gridX;
+  entity->oldGridY = entity->gridY;
+  entity->oldGridZ = entity->gridZ;
+  entity->gridX = newX;
+  entity->gridY = newY;
+  entity->gridZ = newZ;
+}
+
+void entityCommonRender(entityid_t id, entity_t *entity) {
+  float d = TIME_STATE.delta * ENTITY_COMMON_MOVE_SPEED;
+  entity->positionX += (entity->gridX - entity->positionX) * d;
+  entity->positionY += (entity->gridY - entity->positionY) * d;
+  entity->positionZ += (entity->gridZ - entity->positionZ) * d;
+
+  // Render sprite
+  spriteBatchQuad(ENTITY_STATE.spriteBatch, -1,
+    entity->positionX, entity->positionY, entity->positionZ,
+    1, 1,
+    0, 0, 1, 1
+  );
+}

src/world/entity/common.h

@@ -0,0 +1,16 @@
+/**
+ * Copyright (c) 2021 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include <dawn/dawn.h>
+#include "../../display/spritebatch.h"
+#include "../map/tile.h"
+
+#define ENTITY_COMMON_MOVE_SPEED 10
+
+void entityCommonMove(entityid_t id, entity_t *entity, int32_t x, int32_t y, int32_t z);
+void entityCommonRender(entityid_t id, entity_t *entity);

src/world/entity/entity.c

@@ -10,5 +10,59 @@
 entitystate_t ENTITY_STATE;
 
 void entityStateInit() {
-  memset(ENTITY_STATE.entities, NULL, sizeof(entity_t) * ENTITY_COUNT);
+  memset(ENTITY_STATE.entities, 0, sizeof(entity_t) * ENTITY_COUNT);
+  ENTITY_STATE.spriteBatch = spriteBatchCreate(ENTITY_COUNT);
+}
+
+void entityStateRender() {
+  entityid_t i;
+  entity_t *entity;
+
+  // Flush the batch.
+  spriteBatchFlush(ENTITY_STATE.spriteBatch);
+
+  // Render the entities.
+  for(i = 0; i < ENTITY_COUNT; i++) {
+    entity = ENTITY_STATE.entities + i;
+    if(entity->type == ENTITY_TYPE_NULL) break;
+    ENTITY_TYPES[entity->type].entityUpdate(i, entity);
+  }
+
+  // Draw the sprite batch.
+  shaderUsePosition(GAME_STATE.shaderWorld, 0, 0, 0, 0, 0, 0);
+  spriteBatchDraw(ENTITY_STATE.spriteBatch, 0, -1);
+}
+
+void entityStateDispose() {
+  entityid_t i;
+  entity_t *entity;
+
+  for(i = 0; i < ENTITY_COUNT; i++) {
+    entity = ENTITY_STATE.entities + i;
+    if(entity->type == ENTITY_TYPE_NULL) break;
+    entityDispose(i);
+  }
+
+  spriteBatchDispose(ENTITY_STATE.spriteBatch);
+}
+
+void entityInit(entityid_t id, entitytypeid_t type) {
+  entity_t *entity = ENTITY_STATE.entities + id;
+  entity->type = type;
+
+  // Reset values
+  entity->gridX = entity->gridY = entity->gridZ = 0;
+  entity->oldGridX = entity->oldGridY = entity->oldGridZ = 0;
+  entity->positionX = entity->positionY = entity->positionZ = 0;
+
+  // Init
+  if(ENTITY_TYPES[type].entityInit == NULL) return;
+  ENTITY_TYPES[type].entityInit(id, entity);
+}
+
+void entityDispose(entityid_t id) {
+  entity_t *entity = ENTITY_STATE.entities + id;
+  entity->type = ENTITY_TYPE_NULL;
+  if(ENTITY_TYPES[entity->type].entityDispose == NULL) return;
+  ENTITY_TYPES[entity->type].entityDispose(id, entity);
 }

src/world/entity/entity.h

@@ -7,5 +7,36 @@
 
 #pragma once
 #include <dawn/dawn.h>
+#include "entitytypes.h"
+#include "../../display/spritebatch.h"
+#include "../../display/shader.h"
 
-void entityStateInit();
+/**
+ * Initializes the entity state system.
+ */
+void entityStateInit();
+
+/**
+ * Render the entity state system.
+ */
+void entityStateRender();
+
+/**
+ * Dispose and clean up the entity state system.
+ */
+void entityStateDispose();
+
+/**
+ * Initializes an entity into the entity state.
+ * 
+ * @param id The Entity ID  within the entity state system.
+ * @param type The Entity type to initialize.
+ */
+void entityInit(entityid_t id, entitytypeid_t type);
+
+/**
+ * Disposes the entity from the entity state.
+ * 
+ * @param id The entity id to dispose.
+ */
+void entityDispose(entityid_t id);

src/world/entity/entitytypes.c

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) 2021 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "entitytypes.h"
+
+entitytype_t ENTITY_TYPES[ENTITY_TYPE_COUNT] = {
+  // ENTITY_TYPE_NULL
+  { .entityInit = NULL, .entityUpdate = NULL, .entityDispose = NULL },
+
+  // ENTITY_TYPE_PLAYER
+  {
+    .entityInit = &playerInit,
+    .entityUpdate = &playerUpdate,
+    .entityDispose = &playerDispose
+  }
+};

src/world/entity/entitytypes.h

@@ -0,0 +1,10 @@
+/**
+ * Copyright (c) 2021 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include <dawn/dawn.h>
+#include "player.h"

src/world/entity/player.c

@@ -0,0 +1,29 @@
+/**
+ * Copyright (c) 2021 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "player.h"
+
+void playerInit(entityid_t id, entity_t *entity) {
+}
+
+void playerUpdate(entityid_t id, entity_t *entity) {
+  if(inputIsPressed(INPUT_UP)) {
+    entityCommonMove(id, entity, 0, 1, 0);
+  } else if(inputIsPressed(INPUT_DOWN)) {
+    entityCommonMove(id, entity, 0, -1, 0);
+  } else if(inputIsPressed(INPUT_LEFT)) {
+    entityCommonMove(id, entity, -1, 0, 0);
+  } else if(inputIsPressed(INPUT_RIGHT)) {
+    entityCommonMove(id, entity, 1, 0, 0);
+  }
+
+  // Render sprite
+  entityCommonRender(id, entity);
+}
+
+void playerDispose(entityid_t id, entity_t *entity) {
+}

src/world/entity/player.h

@@ -0,0 +1,15 @@
+/**
+ * Copyright (c) 2021 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include <dawn/dawn.h>
+#include "common.h"
+#include "../../input/input.h"
+
+void playerInit(entityid_t entityId, entity_t *entity);
+void playerUpdate(entityid_t entityId, entity_t *entity);
+void playerDispose(entityid_t entityId, entity_t *entity);

src/world/map/chunk.c

@@ -12,12 +12,15 @@ void chunkLoad(chunk_t *chunk, int32_t x, int32_t y, int32_t z) {
   tiledef_t *tileDef;
   int32_t i, indiceCount, verticeCount, tx, ty, tz;
 
+  chunk->tiles[0] = 1;
+  chunk->tiles[1] = 1;
+  chunk->tiles[16] = 1;
+
   // Start by loading the tiles and figuring out how big we need to make the
   // primitive that the chunk uses.
   indiceCount = 0, verticeCount = 0;
   for(i = 0; i < CHUNK_TILE_COUNT; i++) {
     //TODO: Actually load the tileId here
-    chunk->tiles[i] = x + y + z + 1;
     tileId = chunk->tiles[i];
     if(tileId == TILE_NULL) continue;
 
@@ -67,4 +70,18 @@ void chunkUnload(chunk_t *chunk) {
   if(chunk->primitive == NULL) return;
   primitiveDispose(chunk->primitive);
   chunk->primitive = NULL;
+}
+
+int32_t chunkGet(int32_t x, int32_t y, int32_t z) {
+  int32_t i = (
+    mathMod(x - MAP_STATE.x, MAP_WIDTH) +
+    (mathMod(y - MAP_STATE.y, MAP_HEIGHT) * MAP_WIDTH) +
+    (mathMod(z - MAP_STATE.z, MAP_DEPTH) * MAP_WIDTH * MAP_HEIGHT)
+  );
+  if(i < 0 || i > MAP_CHUNK_COUNT) return -1;
+  return i;
+}
+
+int32_t chunkGetTile(int32_t x, int32_t y, int32_t z) {
+  return x + (y * CHUNK_WIDTH) + (z * CHUNK_WIDTH * CHUNK_HEIGHT);
 }

src/world/map/chunk.h

@@ -8,6 +8,7 @@
 #pragma once
 #include <dawn/dawn.h>
 #include "../../display/primitive.h"
+#include "../../util/math.h"
 #include "tile.h"
 
 /**
@@ -25,4 +26,24 @@ void chunkLoad(chunk_t *chunk, int32_t x, int32_t y, int32_t z);
  * 
  * @param chunk Chunk to unload.
  */
-void chunkUnload(chunk_t *chunk);
+void chunkUnload(chunk_t *chunk);
+
+/**
+ * Gets the chunk index from an absolute coordinate.
+ * 
+ * @param x Absolute chunk X.
+ * @param y Absolute chunk Y.
+ * @param z Absolute chunk Z.
+ * @returns The index for that chunk. -1 if out of bounds of the current list.
+ */
+int32_t chunkGet(int32_t x, int32_t y, int32_t z);
+
+/**
+ * Gets the tile index from a local tile coordinate.
+ * 
+ * @param x The local X coordinate of the tile.
+ * @param y The local Y coordinate of the tile.
+ * @param z The local Z coordinate of the tile.
+ * @return The index within the chunk that the tile resides.
+ */
+int32_t chunkGetTile(int32_t x, int32_t y, int32_t z);

src/world/map/tile.c

@@ -18,4 +18,20 @@ void tileRender(
     x+1, y+1, div->x1, div->y1,
     verticeStart, indiceStart
   );
+}
+
+tilegetresult_t tileGet(int32_t x, int32_t y, int32_t z) {
+  tilegetresult_t result;
+
+  // First, determine the chunk that I belong to.
+  result.chunkX = x / CHUNK_WIDTH;
+  result.chunkY = y / CHUNK_HEIGHT;
+  result.chunkZ = z / CHUNK_DEPTH;
+  
+  // And determine the local coordinates
+  result.localX = mathMod(x, CHUNK_WIDTH);
+  result.localY = mathMod(y, CHUNK_HEIGHT);
+  result.localZ = mathMod(z, CHUNK_DEPTH);
+
+  return result;
 }

src/world/map/tile.h

@@ -8,9 +8,16 @@
 #pragma once
 #include <dawn/dawn.h>
 #include "../../display/primitives/quad.h"
+#include "../../util/math.h"
+
+typedef struct {
+  int32_t chunkX, chunkY, chunkZ, localX, localY, localZ;
+} tilegetresult_t;
 
 void tileRender(
   chunk_t *chunk, tileid_t id, tiledef_t *tileDef,
   int32_t i, int32_t x, int32_t y, int32_t z,
   int32_t verticeStart, int32_t indiceStart
-);
+);
+
+tilegetresult_t tileGet(int32_t x, int32_t y, int32_t z);

src/world/world.c

@@ -14,8 +14,10 @@ void worldInit() {
 
 void worldRender() {
   mapRender();
+  entityStateRender();
 }
 
 void worldDispose() {
+  entityStateDispose();
   mapDispose();
 }