Add inventory.

test/CMakeLists.txt

@@ -3,5 +3,8 @@
 # This software is released under the MIT License.
 # https://opensource.org/licenses/MIT
 
+add_subdirectory(display)
+# add_subdirectory(rpg)
+add_subdirectory(item)
 add_subdirectory(time)
 add_subdirectory(util)

test/display/CMakeLists.txt

@@ -0,0 +1,9 @@
+# Copyright (c) 2026 Dominic Masters
+#
+# This software is released under the MIT License.
+# https://opensource.org/licenses/MIT
+
+include(dusktest)
+
+# Tests
+dusktest(test_color.c)

test/display/test_color.c

@@ -0,0 +1,98 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "dusktest.h"
+#include "display/color.h"
+
+static void test_color3f_create(void **state) {
+  (void)state;
+  
+  color3f_t color = color3f(0.1f, 0.2f, 0.3f);
+  assert_float_equal(color.r, 0.1f, 0.0001f);
+  assert_float_equal(color.g, 0.2f, 0.0001f);
+  assert_float_equal(color.b, 0.3f, 0.0001f);
+}
+
+static void test_color4f_create(void **state) {
+  (void)state;
+  
+  color4f_t color = color4f(0.1f, 0.2f, 0.3f, 0.4f);
+  assert_float_equal(color.r, 0.1f, 0.0001f);
+  assert_float_equal(color.g, 0.2f, 0.0001f);
+  assert_float_equal(color.b, 0.3f, 0.0001f);
+  assert_float_equal(color.a, 0.4f, 0.0001f);
+}
+
+static void test_color3b_create(void **state) {
+  (void)state;
+  
+  color3b_t color = color3b(10, 20, 30);
+  assert_int_equal(color.r, 10);
+  assert_int_equal(color.g, 20);
+  assert_int_equal(color.b, 30);
+}
+
+static void test_color4b_create(void **state) {
+  (void)state;
+  
+  color4b_t color = color4b(10, 20, 30, 40);
+  assert_int_equal(color.r, 10);
+  assert_int_equal(color.g, 20);
+  assert_int_equal(color.b, 30);
+  assert_int_equal(color.a, 40);
+}
+
+static void test_color_create(void **state) {
+  (void)state;
+  
+  color_t color = color(10, 20, 30, 40);
+  assert_int_equal(color.r, 10);
+  assert_int_equal(color.g, 20);
+  assert_int_equal(color.b, 30);
+  assert_int_equal(color.a, 40);
+}
+
+static void test_colorHex_create(void **state) {
+  (void)state;
+  
+  color_t color = colorHex(0x11223344);
+  assert_int_equal(color.r, 0x11);
+  assert_int_equal(color.g, 0x22);
+  assert_int_equal(color.b, 0x33);
+  assert_int_equal(color.a, 0x44);
+
+  color = colorHex(0xFF00FF00);
+  assert_int_equal(color.r, 0xFF);
+  assert_int_equal(color.g, 0x00);
+  assert_int_equal(color.b, 0xFF);
+  assert_int_equal(color.a, 0x00);
+
+  color_t comp = color(255, 0, 255, 0);
+  assert_int_equal(color.r, comp.r);
+  assert_int_equal(color.g, comp.g);
+  assert_int_equal(color.b, comp.b);
+  assert_int_equal(color.a, comp.a);
+
+  color = colorHex(0xFFFFFFFF);
+  assert_int_equal(color.r, COLOR_WHITE.r);
+  assert_int_equal(color.g, COLOR_WHITE.g);
+  assert_int_equal(color.b, COLOR_WHITE.b);
+  assert_int_equal(color.a, COLOR_WHITE.a);
+}
+
+int main(int argc, char **argv) {
+  const struct CMUnitTest tests[] = {
+    cmocka_unit_test(test_color3f_create),
+    cmocka_unit_test(test_color4f_create),
+    cmocka_unit_test(test_color3b_create),
+    cmocka_unit_test(test_color4b_create),
+    cmocka_unit_test(test_color_create),
+    cmocka_unit_test(test_colorHex_create),
+  };
+
+  return cmocka_run_group_tests(tests, NULL, NULL);
+}

test/item/CMakeLists.txt

@@ -0,0 +1,9 @@
+# Copyright (c) 2026 Dominic Masters
+#
+# This software is released under the MIT License.
+# https://opensource.org/licenses/MIT
+
+include(dusktest)
+
+# Tests
+dusktest(test_inventory.c)

test/item/test_inventory.c

@@ -0,0 +1,341 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "dusktest.h"
+#include "item/inventory.h"
+
+static void test_inventoryInit(void **state) {
+  (void)state;
+
+  inventorystack_t storage[5];
+  inventory_t inventory;
+
+  inventoryInit(&inventory, storage, 5);
+
+  // Should setup struct
+  assert_non_null(inventory.storage);
+  assert_int_equal(inventory.storageSize, 5);
+
+  // Should zero the item ids.
+  for(size_t i = 0; i < inventory.storageSize; i++) {
+    assert_int_equal(inventory.storage[i].item, ITEM_ID_NULL);
+    assert_int_equal(inventory.storage[i].quantity, 0);
+  }
+
+  // Should fail when given NULL inventory pointer
+  expect_assert_failure(inventoryInit(NULL, storage, 5));
+
+  // Should fail when given NULL storage pointer
+  expect_assert_failure(inventoryInit(&inventory, NULL, 5));
+
+  // Should fail when given zero storage size
+  expect_assert_failure(inventoryInit(&inventory, storage, 0));
+}
+
+static void test_inventoryItemExists(void **state) {
+  (void)state;
+
+  inventorystack_t storage[5];
+  inventory_t inventory;
+  inventoryInit(&inventory, storage, 5);
+
+  // Initially should not exist
+  assert_false(inventoryItemExists(&inventory, ITEM_ID_POTION));
+
+  // Add item
+  inventorySet(&inventory, ITEM_ID_POTION, 3);
+  assert_true(inventoryItemExists(&inventory, ITEM_ID_POTION));
+
+  // Remove item
+  inventorySet(&inventory, ITEM_ID_POTION, 0);
+  assert_false(inventoryItemExists(&inventory, ITEM_ID_POTION));
+
+  // Should fail when given NULL inventory pointer
+  expect_assert_failure(inventoryItemExists(NULL, ITEM_ID_POTION));
+
+  // Should fail when given NULL storage pointer
+  inventory.storage = NULL;
+  expect_assert_failure(inventoryItemExists(&inventory, ITEM_ID_POTION));
+  inventory.storage = storage;
+
+  // Should fail when given zero storage size
+  inventory.storageSize = 0;
+  expect_assert_failure(inventoryItemExists(&inventory, ITEM_ID_POTION));
+  inventory.storageSize = 5;
+
+  // Should fail when given ITEM_ID_NULL
+  expect_assert_failure(inventoryItemExists(&inventory, ITEM_ID_NULL));
+
+  // Should fail if item has zero quantity somehow
+  inventorySet(&inventory, ITEM_ID_POTION, 3);
+  inventory.storage[0].quantity = 0;
+  expect_assert_failure(inventoryItemExists(&inventory, ITEM_ID_POTION));
+}
+
+static void test_inventorySet(void **state) {
+  (void)state;
+
+  inventorystack_t storage[5];
+  inventory_t inventory;
+  inventoryInit(&inventory, storage, 5);
+
+  // Set item quantity
+  inventorySet(&inventory, ITEM_ID_POTION, 4);
+  assert_int_equal(inventory.storage[0].item, ITEM_ID_POTION);
+  assert_int_equal(inventory.storage[0].quantity, 4);
+
+  // Update item quantity
+  inventorySet(&inventory, ITEM_ID_POTION, 2);
+  assert_int_equal(inventory.storage[0].item, ITEM_ID_POTION);
+  assert_int_equal(inventory.storage[0].quantity, 2);
+
+  // Remove item by setting quantity to 0
+  inventorySet(&inventory, ITEM_ID_POTION, 0);
+  assert_int_equal(inventory.storage[0].item, ITEM_ID_NULL);
+
+  // Setting multiple items should not cause issues
+  inventorySet(&inventory, ITEM_ID_POTION, 1);
+  inventorySet(&inventory, ITEM_ID_POTATO, 5);
+  assert_int_equal(inventory.storage[0].item, ITEM_ID_POTION);
+  assert_int_equal(inventory.storage[0].quantity, 1);
+  assert_int_equal(inventory.storage[1].item, ITEM_ID_POTATO);
+  assert_int_equal(inventory.storage[1].quantity, 5);
+
+  // Setting early item to 0 should shift others down
+  inventorySet(&inventory, ITEM_ID_POTION, 0);
+  assert_int_equal(inventory.storage[0].item, ITEM_ID_POTATO);
+  assert_int_equal(inventory.storage[0].quantity, 5);
+  assert_int_equal(inventory.storage[1].item, ITEM_ID_NULL);
+
+  // Setting non-existing item should add it
+  inventorySet(&inventory, ITEM_ID_POTION, 3);
+  assert_int_equal(inventory.storage[1].item, ITEM_ID_POTION);
+  assert_int_equal(inventory.storage[1].quantity, 3);
+
+  // Should fail when given NULL inventory pointer
+  expect_assert_failure(inventorySet(NULL, ITEM_ID_POTION, 3));
+
+  // Should fail when given NULL storage pointer
+  inventory.storage = NULL;
+  expect_assert_failure(inventorySet(&inventory, ITEM_ID_POTION, 3));
+  inventory.storage = storage;
+
+  // Should fail when given zero storage size
+  inventory.storageSize = 0;
+  expect_assert_failure(inventorySet(&inventory, ITEM_ID_POTION, 3));
+  inventory.storageSize = 5;
+
+  // Should fail when given ITEM_ID_NULL
+  expect_assert_failure(inventorySet(&inventory, ITEM_ID_NULL, 3));
+}
+
+static void test_inventoryAdd(void **state) {
+  (void)state;
+
+  inventorystack_t storage[5];
+  inventory_t inventory;
+  inventoryInit(&inventory, storage, 5);
+
+  // Add item quantity
+  inventoryAdd(&inventory, ITEM_ID_POTION, 4);
+  assert_int_equal(inventory.storage[0].item, ITEM_ID_POTION);
+  assert_int_equal(inventory.storage[0].quantity, 4);
+
+  // Add more to existing item
+  inventoryAdd(&inventory, ITEM_ID_POTION, 3);
+  assert_int_equal(inventory.storage[0].item, ITEM_ID_POTION);
+  assert_int_equal(inventory.storage[0].quantity, 7);
+
+  // Adding item that would overflow should assert
+  expect_assert_failure(inventoryAdd(&inventory, ITEM_ID_POTION, 250));
+
+  // Should fail when given NULL inventory pointer
+  expect_assert_failure(inventoryAdd(NULL, ITEM_ID_POTION, 3));
+
+  // Should fail when given NULL storage pointer
+  inventory.storage = NULL;
+  expect_assert_failure(inventoryAdd(&inventory, ITEM_ID_POTION, 3));
+  inventory.storage = storage;
+
+  // Should fail when given zero storage size
+  inventory.storageSize = 0;
+  expect_assert_failure(inventoryAdd(&inventory, ITEM_ID_POTION, 3));
+  inventory.storageSize = 5;
+
+  // Should fail when given ITEM_ID_NULL
+  expect_assert_failure(inventoryAdd(&inventory, ITEM_ID_NULL, 3));
+}
+
+static void test_inventoryRemove(void **state) {
+  (void)state;
+
+  inventorystack_t storage[5];
+  inventory_t inventory;
+  inventoryInit(&inventory, storage, 5);
+
+  // Add item and then remove it
+  inventorySet(&inventory, ITEM_ID_POTION, 5);
+  inventoryRemove(&inventory, ITEM_ID_POTION);
+  assert_int_equal(inventory.storage[0].item, ITEM_ID_NULL);
+
+  // Removing non-existing item should do nothing
+  inventoryRemove(&inventory, ITEM_ID_POTION);
+  assert_int_equal(inventory.storage[0].item, ITEM_ID_NULL);
+
+  // Should fail when given NULL inventory pointer
+  expect_assert_failure(inventoryRemove(NULL, ITEM_ID_POTION));
+
+  // Should fail when given NULL storage pointer
+  inventory.storage = NULL;
+  expect_assert_failure(inventoryRemove(&inventory, ITEM_ID_POTION));
+  inventory.storage = storage;
+
+  // Should fail when given zero storage size
+  inventory.storageSize = 0;
+  expect_assert_failure(inventoryRemove(&inventory, ITEM_ID_POTION));
+  inventory.storageSize = 5;
+
+  // Should fail when given ITEM_ID_NULL
+  expect_assert_failure(inventoryRemove(&inventory, ITEM_ID_NULL));
+}
+
+static void test_inventoryGetCount(void **state) {
+  (void)state;
+
+  inventorystack_t storage[5];
+  inventory_t inventory;
+  inventoryInit(&inventory, storage, 5);
+
+  // Initially should be zero
+  assert_int_equal(inventoryGetCount(&inventory, ITEM_ID_POTION), 0);
+
+  // Add item and check count
+  inventorySet(&inventory, ITEM_ID_POTION, 4);
+  assert_int_equal(inventoryGetCount(&inventory, ITEM_ID_POTION), 4);
+
+  // Update item quantity and check count
+  inventorySet(&inventory, ITEM_ID_POTION, 2);
+  assert_int_equal(inventoryGetCount(&inventory, ITEM_ID_POTION), 2);
+
+  // Remove item and check count
+  inventorySet(&inventory, ITEM_ID_POTION, 0);
+  assert_int_equal(inventoryGetCount(&inventory, ITEM_ID_POTION), 0);
+
+  // Should fail when given NULL inventory pointer
+  expect_assert_failure(inventoryGetCount(NULL, ITEM_ID_POTION));
+
+  // Should fail when given NULL storage pointer
+  inventory.storage = NULL;
+  expect_assert_failure(inventoryGetCount(&inventory, ITEM_ID_POTION));
+  inventory.storage = storage;
+
+  // Should fail when given zero storage size
+  inventory.storageSize = 0;
+  expect_assert_failure(inventoryGetCount(&inventory, ITEM_ID_POTION));
+  inventory.storageSize = 5;
+
+  // Should fail when given ITEM_ID_NULL
+  expect_assert_failure(inventoryGetCount(&inventory, ITEM_ID_NULL));
+}
+
+static void test_inventoryIsFull(void **state) {
+  (void)state;
+
+  inventorystack_t storage[2];
+  inventory_t inventory;
+  inventoryInit(&inventory, storage, 2);
+
+  // Initially should not be full
+  assert_false(inventoryIsFull(&inventory));
+
+  // Fill inventory
+  inventorySet(&inventory, ITEM_ID_POTION, 1);
+  inventorySet(&inventory, ITEM_ID_POTATO, 1);
+  assert_true(inventoryIsFull(&inventory));
+
+  // Remove one item
+  inventoryRemove(&inventory, ITEM_ID_POTION);
+  assert_false(inventoryIsFull(&inventory));
+
+  // Add one item back
+  inventorySet(&inventory, ITEM_ID_POTION, 1);
+  assert_true(inventoryIsFull(&inventory));
+
+  // Should fail when given NULL inventory pointer
+  expect_assert_failure(inventoryIsFull(NULL));
+
+  // Should fail when given NULL storage pointer
+  inventory.storage = NULL;
+  expect_assert_failure(inventoryIsFull(&inventory));
+  inventory.storage = storage;
+
+  // Should fail when given zero storage size
+  inventory.storageSize = 0;
+  expect_assert_failure(inventoryIsFull(&inventory));
+  inventory.storageSize = 2;
+}
+
+static void test_inventoryItemFull(void **state) {
+  (void)state;
+
+  inventorystack_t storage[2];
+  inventory_t inventory;
+  inventoryInit(&inventory, storage, 2);
+
+  // Initially should not be full
+  assert_false(inventoryItemFull(&inventory, ITEM_ID_POTION));
+
+  // Add some potions, but not too many.
+  inventorySet(&inventory, ITEM_ID_POTION, 100);
+  assert_false(inventoryItemFull(&inventory, ITEM_ID_POTION));
+
+  // Fill with potions
+  inventorySet(&inventory, ITEM_ID_POTION, ITEM_STACK_QUANTITY_MAX);
+  assert_true(inventoryItemFull(&inventory, ITEM_ID_POTION));
+
+  // Add potatoes, should not affect potions
+  inventorySet(&inventory, ITEM_ID_POTATO, 50);
+  assert_true(inventoryItemFull(&inventory, ITEM_ID_POTION));
+  assert_false(inventoryItemFull(&inventory, ITEM_ID_POTATO));
+
+  // Remove some potions
+  inventorySet(&inventory, ITEM_ID_POTION, 200);
+  assert_false(inventoryItemFull(&inventory, ITEM_ID_POTION));
+
+  // Fill with potatoes
+  inventorySet(&inventory, ITEM_ID_POTATO, ITEM_STACK_QUANTITY_MAX);
+  assert_false(inventoryItemFull(&inventory, ITEM_ID_POTION));
+  assert_true(inventoryItemFull(&inventory, ITEM_ID_POTATO));
+
+  // Should fail when given NULL inventory pointer
+  expect_assert_failure(inventoryItemFull(NULL, ITEM_ID_POTION));
+
+  // Should fail when given NULL storage pointer
+  inventory.storage = NULL;
+  expect_assert_failure(inventoryItemFull(&inventory, ITEM_ID_POTION));
+  inventory.storage = storage;
+
+  // Should fail when given zero storage size
+  inventory.storageSize = 0;
+  expect_assert_failure(inventoryItemFull(&inventory, ITEM_ID_POTION));
+  inventory.storageSize = 2;
+}
+
+int main(int argc, char** argv) {
+  const struct CMUnitTest tests[] = {
+    cmocka_unit_test(test_inventoryInit),
+    cmocka_unit_test(test_inventoryItemExists),
+    cmocka_unit_test(test_inventorySet),
+    cmocka_unit_test(test_inventoryAdd),
+    cmocka_unit_test(test_inventoryRemove),
+    cmocka_unit_test(test_inventoryGetCount),
+    cmocka_unit_test(test_inventoryIsFull),
+    cmocka_unit_test(test_inventoryItemFull),
+  };
+
+  return cmocka_run_group_tests(tests, NULL, NULL);
+}

test/rpg/CMakeLists.txt

@@ -0,0 +1,12 @@
+# Copyright (c) 2026 Dominic Masters
+#
+# This software is released under the MIT License.
+# https://opensource.org/licenses/MIT
+
+include(dusktest)
+
+# Tests
+dusktest(test_rpg.c)
+
+# Subdirs
+add_subdirectory(overworld)

test/rpg/overworld/CMakeLists.txt

@@ -0,0 +1,10 @@
+# Copyright (c) 2026 Dominic Masters
+#
+# This software is released under the MIT License.
+# https://opensource.org/licenses/MIT
+
+include(dusktest)
+
+# Tests
+
+# Subdirs

test/rpg/test_rpg.c

@@ -0,0 +1,16 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "dusktest.h"
+
+int main(int argc, char** argv) {
+  const struct CMUnitTest tests[] = {
+    // Add RPG tests here in the future
+  };
+
+  return cmocka_run_group_tests(tests, NULL, NULL);
+}

test/time/test_time.c

@@ -100,17 +100,17 @@ static void test_timeUpdate(void **state) {
   assert_float_equal(TIME.delta, TIME_STEP, 0.0001f); 
   assert_float_equal(TIME.time, TIME_STEP * 4, 0.0001f);
 
-  // Fifth test, despite a small time passing the game should be trying to catch
-  // and running extra ticks
+  // Fifth test, despite a small time passing the game should not start 
+  // trying to run ahead
   SDL_GETTICKS_TICKS = 104; // Simulate 4ms elapsed
   SDL_GETTICKS_CALLED = false;
   timeUpdate();
   assert_true(SDL_GETTICKS_CALLED);
-  assert_false(TIME.dynamicUpdate);
+  assert_true(TIME.dynamicUpdate);
   assert_float_equal(TIME.dynamicDelta, 0.004f, 0.0001f);
   assert_float_equal(TIME.dynamicTime, TIME_STEP + 0.104f, 0.0001f);
   assert_float_equal(TIME.delta, TIME_STEP, 0.0001f); 
-  assert_float_equal(TIME.time, TIME_STEP * 5, 0.0001f);
+  assert_float_equal(TIME.time, TIME_STEP * 4, 0.0001f);
 
   // Time can stand still if needed
   SDL_GETTICKS_CALLED = false;