Added systems support

5 files changed, 166 insertions, 15 deletions

diff --git a/src/bitset.c b/src/bitset.c
index 0d2f66a..1fcafd6 100644
--- a/src/bitset.c
+++ b/src/bitset.c
@@ -36,6 +36,17 @@ bitset_and(bitset_t b1, bitset_t b2)
 	return bitAnd;
 }
 
+void
+bitarena_copy(bitarena_t *arena, bitset_t bitset, int index)
+{
+	bitset_t tmp = bitarena_at(arena, index);
+	for (int i = 0; i < BITSET_BYTES; ++i)
+	{
+		tmp[i] = bitset[i];
+		// arena->arena[index + i] = bitset[i];
+	}
+}
+
 int
 bitset_isZero(bitset_t bitset)
 {
diff --git a/src/bitset.h b/src/bitset.h
index 0c5092d..f0b7fa5 100644
--- a/src/bitset.h
+++ b/src/bitset.h
@@ -26,6 +26,12 @@ bitarena_at(bitarena_t *arena, int idx);
 bitset_t
 bitset_and(bitset_t b1, bitset_t b2);
 
+void
+bitarena_copy(bitarena_t *arena, bitset_t bitset, int index);
+
+bitset_t
+bitset_create();
+
 int
 bitset_isZero(bitset_t bitset);
 
diff --git a/src/main.c b/src/main.c
index e09cd18..b82308e 100644
--- a/src/main.c
+++ b/src/main.c
@@ -5,6 +5,12 @@
 #include "storage.h"
 #include "bitset.h"
 
+enum component_t
+{
+	C_TRANSFORM = (int) 0,
+	C_COLLIDER,
+};
+
 typedef struct
 {
 	int x;
@@ -25,6 +31,28 @@ typedef struct
 } collider_t;
 
 void
+sys_collide(storage_t *storage, entity_t eid)
+{
+	printf("Inside collide, id = %i\n", eid);
+	transform_t *transform = GET_COMPONENT(storage, transform_t, eid);
+	collider_t *collider = GET_COMPONENT(storage, collider_t, eid);
+	printTransform(transform);
+	printf("\n");
+}
+
+void
+sys_move(storage_t *storage, entity_t eid)
+{
+	printf("Inside move, id = %i\n", eid);
+	transform_t *transform = GET_COMPONENT(storage, transform_t, eid);
+	printTransform(transform);
+	printf("\n");
+}
+
+
+// Engine functions
+
+void
 initStorage(storage_t *storage)
 {
 	storage->componentsStored = 0;
@@ -32,6 +60,10 @@ initStorage(storage_t *storage)
 	storage->objects = (component_pair_t *) malloc(MAX_COMPONENTS * sizeof(component_pair_t));
 	bitarena_init(&storage->objectSignatures, MAX_OBJECTS);
 
+	storage->systemsStored = 0;
+	storage->systems = (system_t *) malloc(4096 * sizeof(system_t));
+	bitarena_init(&storage->systemSignatures, 4096);
+
 	REGISTER_COMPONENT(storage, transform_t);
 	REGISTER_COMPONENT(storage, collider_t);
 }
@@ -39,30 +71,83 @@ initStorage(storage_t *storage)
 void
 loadScene(storage_t *storage)
 {
-	bitset_t s1 = bitarena_at(&storage->objectSignatures, 0);
-	bitset_t s2 = bitarena_at(&storage->objectSignatures, 1);
+	// bitset_t s1 = bitarena_at(&storage->objectSignatures, 0);
+	// bitset_t s2 = bitarena_at(&storage->objectSignatures, 1);
 
-	bitset_set(s1, 9);
-	bitset_set(s2, 9);
+	// bitset_set(s1, 9);
+	// bitset_set(s2, 9);
 
-	bitset_print(s1);
-	bitset_print(s2);
+	// bitset_print(s1);
+	// bitset_print(s2);
+
+	// bitset_t sAnd = bitset_and(s1, s2);
+	// printf("Bitset is zero: %i\n", bitset_isZero(sAnd));
+	// printf("Bitset is equals: %i\n", bitset_equals(s1, s2));
 
-	bitset_t sAnd = bitset_and(s1, s2);
-	printf("Bitset is zero: %i\n", bitset_isZero(sAnd));
-	printf("Bitset is equals: %i\n", bitset_equals(s1, s2));
-	
 	entity_t e1 = createEntity(storage);
+	ADD_COMPONENT(storage, e1, transform_t);
+	ADD_COMPONENT(storage, e1, collider_t);
+
 	transform_t *t1 = GET_COMPONENT(storage, transform_t, e1);
 	t1->x = 13;
 	t1->y = 37;
-	printTransform(t1);
+	// printTransform(t1);
+
+	collider_t *c1 = GET_COMPONENT(storage, collider_t, e1);
+	c1->height = 50;
+	c1->width = 50;
+	c1->collisionsCount = 5;
 
 	entity_t e2 = createEntity(storage);
+	ADD_COMPONENT(storage, e2, transform_t);
+	
 	transform_t *t2 = GET_COMPONENT(storage, transform_t, e2);
 	t2->x = 14;
 	t2->y = 88;
-	printTransform(t2);
+	// printTransform(t2);
+
+	entity_t e3 = createEntity(storage);
+	ADD_COMPONENT(storage, e3, transform_t);
+	
+	transform_t *t3 = GET_COMPONENT(storage, transform_t, e3);
+	t3->x = 228;
+	t3->y = 123;
+	// printTransform(t3);
+
+	{
+		char *components[] = {"transform_t", "collider_t", NULL};
+		bitset_t bitset = createSignature(storage, components);
+		// printf("Collide bitset: ");
+		// bitset_print(bitset);
+		registerSystem(storage, sys_collide, bitset);
+	}
+
+	{
+		char *components[] = {"transform_t", NULL};
+		bitset_t bitset = createSignature(storage, components);
+		// printf("Move bitset: ");
+		// bitset_print(bitset);
+		registerSystem(storage, sys_move, bitset);
+	}
+}
+
+void
+update(storage_t *storage)
+{
+	for (entity_t i = 0; i < storage->objectsStored; ++i)
+	{
+		for (int j = 0; j < storage->systemsStored; ++j)
+		{
+			bitset_t objBitset = bitarena_at(&storage->objectSignatures, i);
+			bitset_t sysBitset = bitarena_at(&storage->systemSignatures, j);
+			bitset_t bitAnd = bitset_and(objBitset, sysBitset);
+
+			if (bitset_equals(bitAnd, sysBitset))
+			{
+				storage->systems[j](storage, i);
+			}
+		}
+	}
 }
 
 int
@@ -71,5 +156,7 @@ main()
 	storage_t storage;
 	initStorage(&storage);
 	loadScene(&storage);
+	update(&storage);
+
 	return 0;
 }
diff --git a/src/storage.c b/src/storage.c
index 3b715ee..1935ae7 100644
--- a/src/storage.c
+++ b/src/storage.c
@@ -1,4 +1,5 @@
 #include "storage.h"
+#include "bitset.h"
 
 component_pair_t *
 findPair(storage_t *this, const char *name)
@@ -26,12 +27,42 @@ createEntity(storage_t *this)
 	return idx;
 }
 
+void
+registerSystem(storage_t *storage, system_t system, bitset_t components)
+{
+	int idx = storage->systemsStored++;
+	storage->systems[idx] = system;
+	bitarena_copy(&storage->systemSignatures, components, idx);
+}
+
+bitset_t
+createSignature(storage_t *storage, char **components)
+{
+	bitset_t bitset = bitset_create();
+
+	for (int i = 0; components[i] != NULL; ++i)
+	{
+		const char *componentName = components[i];
+		component_pair_t *pair = findPair(storage, componentName);
+		if (pair == NULL)
+		{
+			return NULL;
+		}
+		else
+		{
+			bitset_set(bitset, pair->idx);
+		}
+	}
+	return bitset;
+}
+
 // Not intended for use outside of macros
 void
 internal_registerComponent(storage_t *storage, const char *name, size_t size)
 {
 	unsigned int componentIdx = storage->componentsStored++;
 	storage->objects[componentIdx] = (component_pair_t) {
+		.idx = componentIdx,
 		.name = name,
 		.objectSize = size,
 		.objects = malloc(sizeof(char) * size * MAX_OBJECTS)
@@ -48,6 +79,8 @@ internal_addComponent(storage_t *this, entity_t idx, const char *name)
 	}
 
 	// TODO: add bitset implementation
+	bitset_t bitset = bitarena_at(&this->objectSignatures, idx);
+	bitset_set(bitset, pair->idx);
 
 	return &pair->objects[idx];
 }
diff --git a/src/storage.h b/src/storage.h
index f7f5cd9..2601ef7 100644
--- a/src/storage.h
+++ b/src/storage.h
@@ -19,22 +19,30 @@
 #define REGISTER_COMPONENT(storage, componentType) internal_registerComponent(storage, #componentType, sizeof(componentType))
 #define ADD_COMPONENT(storage, idx, componentType) internal_addComponent(storage, idx, #componentType)
 
+typedef struct storage_t storage_t;
 typedef unsigned int entity_t;
+typedef void (*system_t)(storage_t *storage, entity_t eid);
 
 typedef struct
 {
+	int idx;
 	const char *name;
 	size_t objectSize;
 	char *objects;
 } component_pair_t;
 
-typedef struct
+struct storage_t
 {
 	unsigned int componentsStored;
-	unsigned int objectsStored;
+
+	size_t objectsStored;
 	component_pair_t *objects;
 	bitarena_t objectSignatures;
-} storage_t;
+
+	size_t systemsStored;
+	system_t *systems;
+	bitarena_t systemSignatures;
+};
 
 component_pair_t * // NULL if pair is not found
 findPair(storage_t *this, const char *name);
@@ -42,6 +50,12 @@ findPair(storage_t *this, const char *name);
 entity_t
 createEntity(storage_t *this);
 
+void
+registerSystem(storage_t *storage, system_t system, bitset_t components);
+
+bitset_t
+createSignature(storage_t *storage, char **components);
+
 // Not intended for use outside of macros
 void
 internal_registerComponent(storage_t *storage, const char *name, size_t size);