pke: ecs DynArray-s to pk_arr_t

5 files changed, 95 insertions, 90 deletions

diff --git a/editor/editor.cpp b/editor/editor.cpp
index 8526bff..8345964 100644
--- a/editor/editor.cpp
+++ b/editor/editor.cpp
@@ -216,7 +216,7 @@ void PkeEditor_Tick(double delta) {
 		return;
 	}
 
-	if (selectedEntity && EntitiesToBeRemoved.Has(ECS_GetEntity(selectedEntity->entHandle))) {
+	if (selectedEntity && pk_arr_find_first_index(&EntitiesToBeRemoved, ECS_GetEntity(selectedEntity->entHandle), ecs_pk_arr_find_first_matching_pointer) != uint32_t(-1)) {
 		selectedEntity = nullptr;
 	}
 
diff --git a/src/ecs.cpp b/src/ecs.cpp
index 9d0245e..5fd3bfa 100644
--- a/src/ecs.cpp
+++ b/src/ecs.cpp
@@ -34,19 +34,19 @@ struct ECS {
  *
  * Used to build the other "removal" lists.
  */
-DynArray<Entity_Base *> entitiesMarkedForRemoval{16};
+pk_arr_t<Entity_Base *> entitiesMarkedForRemoval;
 /*
  * Public list of entities that will be removed next tick
  *
  * Entity or child of entity that had ECS_MarkForRemoval called
  */
-DynArray<Entity_Base *> EntitiesToBeRemoved{16}; // public
+pk_arr_t<Entity_Base *> EntitiesToBeRemoved;
 /*
  * The entities being removed this tick
  *
  * Each of these entities has gone a full tick in the "to be removed" state
  */
-DynArray<Entity_Base *> entitiesYetToBeRemoved{0, nullptr};
+pk_arr_t<Entity_Base *> entitiesYetToBeRemoved;
 
 /*
  * Entities that have more instances registered than their current
@@ -54,7 +54,11 @@ DynArray<Entity_Base *> entitiesYetToBeRemoved{0, nullptr};
  * 
  * These need to be resized THIS TICK
  */
-DynArray<Entity_Base *> EntitiesWithExcessInstances{16};
+pk_arr_t<Entity_Base *> EntitiesWithExcessInstances;
+
+bool ecs_pk_arr_find_first_matching_pointer(void *search_ptr, void *list_ptr) {
+	return search_ptr == list_ptr;
+}
 
 void ECS_GetEntity_Inner(EntityHandle entHandle, Entity_Base*& ent) {
 	assert(pk_handle_validate(entHandle, ecs.bc.entityPtrs.pkeHandle, ecs.bc.entityPtrs.limits.itemIndex) == PK_HANDLE_VALIDATION_VALID);
@@ -66,18 +70,10 @@ void ECS_Init() {
 	Buckets_Init(ecs.bc.entityPtrs, bcSizes.entityPtrs);
 	Buckets_Init(ecs.bc.grBinds, bcSizes.grBinds);
 	Buckets_Init(ecs.bc.instances, bcSizes.instances);
-	if (entitiesMarkedForRemoval.GetPtr() == CAFE_BABE(Entity_Base*) || entitiesMarkedForRemoval.GetPtr() == nullptr) {
-		new (&entitiesMarkedForRemoval) DynArray<Entity_Base*>{16};
-	}
-	if (EntitiesToBeRemoved.GetPtr() == CAFE_BABE(Entity_Base*) || EntitiesToBeRemoved.GetPtr() == nullptr) {
-		new (&EntitiesToBeRemoved) DynArray<Entity_Base*>{16};
-	}
-	if (entitiesYetToBeRemoved.GetPtr() == CAFE_BABE(Entity_Base*) || entitiesYetToBeRemoved.GetPtr() == nullptr) {
-		new (&entitiesYetToBeRemoved) DynArray<Entity_Base*>{0, nullptr};
-	}
-	if (EntitiesWithExcessInstances.GetPtr() == CAFE_BABE(Entity_Base*) || EntitiesWithExcessInstances.GetPtr() == nullptr) {
-		new (&EntitiesWithExcessInstances) DynArray<Entity_Base*>{16};
-	}
+	pk_arr_reserve(&entitiesMarkedForRemoval, 16);
+	pk_arr_reserve(&EntitiesToBeRemoved, 16);
+	pk_arr_reserve(&entitiesYetToBeRemoved, 16);
+	pk_arr_reserve(&EntitiesWithExcessInstances, 16);
 }
 
 Entity_Base *ECS_CreateGenericEntity() {
@@ -118,19 +114,20 @@ Entity_Base *ECS_GetEntityByUUID(pk_uuid uuid) {
 void ECS_MarkForRemoval(Entity_Base *entity) {
 	assert(entity->handle != EntityHandle_MAX && "Attempting to remove invalid entity");
 	assert(entity->isMarkedForRemoval == false && "Entity already marked for removal");
-	entitiesMarkedForRemoval.Push(entity);
+	pk_arr_append_t(&entitiesMarkedForRemoval, entity);
 }
 
 void ECS_Tick_Early(double delta) {
 	// these reserves might happen 1 tick early, but that's fine
 	(void)delta;
-	bool shouldRun = entitiesMarkedForRemoval.Count() > 0 || EntitiesToBeRemoved.Count() > 0 || entitiesYetToBeRemoved.Count() > 0;
-	entitiesYetToBeRemoved.Reserve(entitiesMarkedForRemoval.Count());
-	EntitiesToBeRemoved.Resize(entitiesMarkedForRemoval.Count());
-	memcpy(EntitiesToBeRemoved.GetPtr(), entitiesMarkedForRemoval.GetPtr(), sizeof(void *) * entitiesMarkedForRemoval.Count());
-	entitiesYetToBeRemoved.Resize(0);
+	bool shouldRun = entitiesMarkedForRemoval.next > 0 || EntitiesToBeRemoved.next > 0 || entitiesYetToBeRemoved.next > 0;
+	pk_arr_reserve(&entitiesYetToBeRemoved, entitiesMarkedForRemoval.reserved);
+	pk_arr_reserve(&EntitiesToBeRemoved, entitiesMarkedForRemoval.reserved);
+	memcpy(EntitiesToBeRemoved.data, entitiesMarkedForRemoval.data, sizeof(void *) * entitiesMarkedForRemoval.next);
+
+	pk_arr_clear(&entitiesYetToBeRemoved);
 	if (!shouldRun) return;
-	entitiesMarkedForRemoval.Resize(0);
+	pk_arr_clear(&entitiesMarkedForRemoval);
 
 	// this has the potential to be slow as balls
 	for (pk_handle_bucket_index_T b = 0; b <= ecs.bc.entityPtrs.pkeHandle.bucketIndex; ++b) {
@@ -142,15 +139,15 @@ void ECS_Tick_Early(double delta) {
 			if (ent->parentHandle != EntityHandle_MAX)
 				parentEnt = ecs.bc.entityPtrs.buckets[ent->parentHandle.bucketIndex][ent->parentHandle.itemIndex];
 			if (ent->isMarkedForRemoval) {
-				entitiesYetToBeRemoved.Push(ent);
+				pk_arr_append_t(&entitiesYetToBeRemoved, ent);
 				ent->handle = EntityHandle_MAX;
 				ent->parentHandle = EntityHandle_MAX;
 				ent->isMarkedForRemoval = false;
-			} else if (EntitiesToBeRemoved.Has(ent)) {
+			} else if (pk_arr_find_first_index(&EntitiesToBeRemoved, ent, ecs_pk_arr_find_first_matching_pointer) != uint32_t(-1)) {
 				ent->isMarkedForRemoval = true;
-			} else if (parentEnt != nullptr && EntitiesToBeRemoved.Has(parentEnt)) {
+			} else if (parentEnt != nullptr && pk_arr_find_first_index(&EntitiesToBeRemoved, parentEnt, ecs_pk_arr_find_first_matching_pointer) != uint32_t(-1)) {
 				ent->isMarkedForRemoval = true;
-				EntitiesToBeRemoved.Push(ent);
+				pk_arr_append_t(&EntitiesToBeRemoved, ent);
 			}
 		}
 	}
@@ -160,17 +157,21 @@ struct updateGrBindsAfter {
 	GrBindsHandle grBindsHandle = GrBindsHandle_MAX;
 	uint32_t count = 0;
 };
-bool DynArrayFindGrBinds(updateGrBindsAfter const &after, const GrBindsHandle &handle) {
-	return after.grBindsHandle == handle;
+bool ecs_pk_arr_find_by_gr_binds_handle(void *search_val, void *list_val) {
+	assert(search_val != nullptr);
+	assert(list_val != nullptr);
+	GrBindsHandle &search_handle = *reinterpret_cast<GrBindsHandle *>(search_val);
+	struct updateGrBindsAfter &list_ref = *reinterpret_cast<struct updateGrBindsAfter *>(list_val);
+	return search_handle == list_ref.grBindsHandle;
 }
 void ECS_Tick(double delta) {
 	int32_t physicsTickCount = Physics_Tick(delta);
 
-	int64_t entityRemovalCount = entitiesYetToBeRemoved.Count();
+	uint32_t entityRemovalCount = entitiesYetToBeRemoved.next;
 	if (physicsTickCount == 0 && entityRemovalCount == 0) return;
 
-	DynArray<updateGrBindsAfter> *updateGrBindsPtr = pk_new<DynArray<updateGrBindsAfter>>(pkeSettings.mem.bkt);
-	DynArray<updateGrBindsAfter> &updateGrBinds = *updateGrBindsPtr;
+	pk_arr_t<updateGrBindsAfter> updateGrBinds;
+	updateGrBinds.bkt = pkeSettings.mem.bkt;
 	for (long b = 0; b <= ecs.bc.instances.pkeHandle.bucketIndex; ++b) {
 		auto &bkt = ecs.bc.instances.buckets[b];
 		long count = ecs.bc.instances.pkeHandle.bucketIndex == b ? ecs.bc.instances.pkeHandle.itemIndex : ecs.bc.instances.limits.itemIndex;
@@ -185,15 +186,18 @@ void ECS_Tick(double delta) {
 				inst.isNeedingUpdated = true;
 			}
 			Entity_Base *ent = ecs.bc.entityPtrs.buckets[inst.entHandle.bucketIndex][inst.entHandle.itemIndex];
-			if (entityRemovalCount > 0 && entitiesYetToBeRemoved.Has(ent)) {
+			if (entityRemovalCount > 0 && pk_arr_find_first_index(&entitiesYetToBeRemoved, ent, ecs_pk_arr_find_first_matching_pointer) != uint32_t(-1)) {
 				if (inst.grBindsHandle != GrBindsHandle_MAX) {
-					int64_t afterIndex = updateGrBinds.FindFirstIndex(DynArrayFindGrBinds, inst.grBindsHandle);
+					uint32_t afterIndex = pk_arr_find_first_index(&updateGrBinds, &inst.grBindsHandle, ecs_pk_arr_find_by_gr_binds_handle);
 					updateGrBindsAfter *after = nullptr;
-					if (afterIndex != -1) {
+					if (afterIndex != uint32_t(-1)) {
 						after = &updateGrBinds[afterIndex];
 					} else {
-						after = &updateGrBinds.Push();
-						after->grBindsHandle = inst.grBindsHandle;
+						struct updateGrBindsAfter tmp{};
+						tmp.grBindsHandle = inst.grBindsHandle;
+						tmp.count = 0;
+						pk_arr_append_t(&updateGrBinds, tmp);
+						after = &updateGrBinds[updateGrBinds.next-1];
 					}
 					after->count += 1;
 				}
@@ -210,9 +214,9 @@ void ECS_Tick(double delta) {
 				inst.bt.motionState = CAFE_BABE(btDefaultMotionState);
 				continue;
 			}
-			if (updateGrBinds.Count() > 0 && inst.instanceHandle != InstanceHandle_MAX) {
-				int64_t afterIndex = updateGrBinds.FindFirstIndex(DynArrayFindGrBinds, inst.grBindsHandle);
-				if (afterIndex > -1) {
+			if (updateGrBinds.next > 0 && inst.instanceHandle != InstanceHandle_MAX) {
+				uint32_t afterIndex = pk_arr_find_first_index(&updateGrBinds, &inst.grBindsHandle, ecs_pk_arr_find_by_gr_binds_handle);
+				if (afterIndex != uint32_t(-1)) {
 					auto &after = updateGrBinds[afterIndex];
 					inst.index -= after.count;
 					inst.isNeedingUpdated = true;
@@ -221,7 +225,7 @@ void ECS_Tick(double delta) {
 		}
 	}
 
-	if (entityRemovalCount > 0 || updateGrBinds.Count() > 0) {
+	if (entityRemovalCount > 0 || updateGrBinds.next > 0) {
 		for (pk_handle_bucket_index_T b = 0; b <= ecs.bc.grBinds.pkeHandle.bucketIndex; ++b) {
 			auto &bkt = ecs.bc.grBinds.buckets[b];
 			long count = ecs.bc.grBinds.pkeHandle.bucketIndex == b ? ecs.bc.grBinds.pkeHandle.itemIndex : ecs.bc.grBinds.limits.itemIndex;
@@ -230,9 +234,9 @@ void ECS_Tick(double delta) {
 				if (grBinds.entHandle == EntityHandle_MAX) {
 					continue;
 				}
-				auto afterIndex = updateGrBinds.FindFirstIndex(DynArrayFindGrBinds, grBinds.grBindsHandle);
+				uint32_t afterIndex = pk_arr_find_first_index(&updateGrBinds, &grBinds.grBindsHandle, ecs_pk_arr_find_by_gr_binds_handle);
 				Entity_Base *ent = ecs.bc.entityPtrs.buckets[grBinds.entHandle.bucketIndex][grBinds.entHandle.itemIndex];
-				if (entitiesYetToBeRemoved.Has(ent)) {
+				if (pk_arr_find_first_index(&entitiesYetToBeRemoved, ent, ecs_pk_arr_find_first_matching_pointer) != uint32_t(-1)) {
 					grBinds.entHandle = EntityHandle_MAX;
 					grBinds.grBindsHandle = GrBindsHandle_MAX;
 					grBinds.vkPipelineLayout = VK_NULL_HANDLE;
@@ -244,7 +248,7 @@ void ECS_Tick(double delta) {
 					 *  as they were created elsewhere.
 					*/
 				}
-				if (afterIndex != -1) {
+				if (afterIndex != uint32_t(-1)) {
 					auto &after = updateGrBinds[afterIndex];
 					grBinds.instanceCounter -= after.count;
 				}
@@ -256,21 +260,20 @@ void ECS_Tick(double delta) {
 struct InstanceBufferCopyChunk {
 	uint64_t startingIndex;
 	uint64_t endingIndex;
-	DynArray<glm::mat4> *mats = nullptr;
+	pk_arr_t<glm::mat4> mats;
 	VkBufferCopy dstBufferCopy;
 };
 struct InstanceBufferCopy {
 	CompGrBinds *grBinds = nullptr;
 	VkDeviceSize runningSize = 0;
-	DynArray<InstanceBufferCopyChunk> *chunks = nullptr;
+	pk_arr_t<InstanceBufferCopyChunk> chunks;
 };
 void ECS_Tick_Late(double delta) {
 	// using a pointer here avoids calling the destructor when the object goes out of scope
 	(void)delta;
 	PKVK_TmpBufferDetails tmpBufferDetails{};
-	DynArray<InstanceBufferCopy> *bufferUpdatesPtr = pk_new<DynArray<InstanceBufferCopy>>(pkeSettings.mem.bkt);
-	new (bufferUpdatesPtr) DynArray<InstanceBufferCopy>(0, pkeSettings.mem.bkt);
-	DynArray<InstanceBufferCopy> &bufferUpdates = *bufferUpdatesPtr;
+	pk_arr_t<InstanceBufferCopy> bufferUpdates;
+	bufferUpdates.bkt = pkeSettings.mem.bkt;
 	for (long b = 0; b <= ecs.bc.instances.pkeHandle.bucketIndex; ++b) {
 		auto &bkt = ecs.bc.instances.buckets[b];
 		long count = ecs.bc.instances.pkeHandle.bucketIndex == b ? ecs.bc.instances.pkeHandle.itemIndex : ecs.bc.instances.limits.itemIndex;
@@ -286,39 +289,38 @@ void ECS_Tick_Late(double delta) {
 			auto &grBinds = ecs.bc.grBinds.buckets[inst.grBindsHandle.bucketIndex][inst.grBindsHandle.itemIndex];
 
 			InstanceBufferCopy *bfrUpdate = nullptr;
-			for (long u = 0; u < bufferUpdates.Count(); ++u) {
+			for (long u = 0; u < bufferUpdates.next; ++u) {
 				if (bufferUpdates[u].grBinds->grBindsHandle == inst.grBindsHandle) {
 					bfrUpdate = &bufferUpdates[u];
 				}
 			}
 			if (bfrUpdate == nullptr) {
-				bufferUpdates.Push({
-					.grBinds = &grBinds,
-				});
-				bfrUpdate = &bufferUpdates[bufferUpdates.Count() - 1];
-				bfrUpdate->chunks = pk_new<DynArray<InstanceBufferCopyChunk>>(pkeSettings.mem.bkt);
-				new (bfrUpdate->chunks) DynArray<InstanceBufferCopyChunk>(4, pkeSettings.mem.bkt);
+				InstanceBufferCopy tmp{};
+				tmp.grBinds = &grBinds;
+				tmp.chunks.bkt = pkeSettings.mem.bkt;
+				pk_arr_append_t(&bufferUpdates, tmp);
+				bfrUpdate = &bufferUpdates[bufferUpdates.next-1];
+				pk_arr_reserve(&bfrUpdate->chunks, 4);
 			}
 
 			InstanceBufferCopyChunk *chunk = nullptr;
-			for (long ii = 0; ii < bfrUpdate->chunks->Count(); ++ii) {
-				if ((*bfrUpdate->chunks)[ii].endingIndex == inst.index - 1) {
-					chunk = &(*bfrUpdate->chunks)[ii];
+			for (long ii = 0; ii < bfrUpdate->chunks.next; ++ii) {
+				if (bfrUpdate->chunks[ii].endingIndex == inst.index - 1) {
+					chunk = &bfrUpdate->chunks[ii];
 					chunk->endingIndex += 1;
 					break;
 				}
 			}
 			if (chunk == nullptr) {
-				bfrUpdate->chunks->Push({
-					.startingIndex = inst.index,
-					.endingIndex = inst.index,
-					.mats = nullptr,
-					.dstBufferCopy = {},
-				});
-				chunk = &(*bfrUpdate->chunks)[bfrUpdate->chunks->Count() - 1];
+				InstanceBufferCopyChunk tmp{};
+				tmp.startingIndex = inst.index;
+				tmp.endingIndex = inst.index;
+				tmp.mats.bkt = pkeSettings.mem.bkt;
+				tmp.dstBufferCopy = {};
+				pk_arr_append_t(&bfrUpdate->chunks, tmp);
+				chunk = &bfrUpdate->chunks[bfrUpdate->chunks.next-1];
 				chunk->dstBufferCopy.dstOffset = sizeof(glm::mat4) * inst.index;
-				chunk->mats = pk_new<DynArray<glm::mat4>>(pkeSettings.mem.bkt);
-				new (chunk->mats) DynArray<glm::mat4>(0, pkeSettings.mem.bkt);
+				pk_arr_reserve(&chunk->mats, 4);
 			}
 
 			btTransform btMatrix_posRot;
@@ -330,21 +332,21 @@ void ECS_Tick_Late(double delta) {
 			glm::vec3 scale;
 			BulletToGlm(inst.bt.rigidBody->getCollisionShape()->getLocalScaling(), scale);
 
-			chunk->mats->Push(glm::scale(glmMat_posRot, scale));
+			pk_arr_append_t(&chunk->mats, glm::scale(glmMat_posRot, scale));
 			bfrUpdate->runningSize += sizeof(glm::mat4);
 			inst.isNeedingUpdated = false;
 		}
 	}
-	while (bufferUpdates.Count() > 0) {
-		InstanceBufferCopy &ibc = bufferUpdates[bufferUpdates.Count() - 1];
+	while (bufferUpdates.next > 0) {
+		InstanceBufferCopy &ibc = bufferUpdates[bufferUpdates.next - 1];
 
 		VkDeviceSize instanceBytes = sizeof(glm::mat4);
 		VkDeviceSize byteCount = ibc.runningSize;
 		PKVK_BeginBuffer(transferFamilyIndex, byteCount, tmpBufferDetails);
 		VkDeviceSize runningOffset = 0;
-		for (long i = 0; i < ibc.chunks->Count(); ++i) {
-			auto &chunk = (*ibc.chunks)[i];
-			memcpy(static_cast<char *>(tmpBufferDetails.deviceData) + runningOffset, chunk.mats->GetPtr(), byteCount);
+		for (long i = 0; i < ibc.chunks.next; ++i) {
+			auto &chunk = ibc.chunks[i];
+			memcpy(static_cast<char *>(tmpBufferDetails.deviceData) + runningOffset, chunk.mats.data, byteCount);
 			chunk.dstBufferCopy.srcOffset = runningOffset;
 			chunk.dstBufferCopy.size = instanceBytes * (chunk.endingIndex - chunk.startingIndex + 1);
 			runningOffset += chunk.dstBufferCopy.size;
@@ -360,8 +362,8 @@ void ECS_Tick_Late(double delta) {
 
 			vkBeginCommandBuffer(tmpBufferDetails.cmdBuffer, &cbbi);
 
-			for (long i = 0; i < ibc.chunks->Count(); ++i) {
-				vkCmdCopyBuffer(tmpBufferDetails.cmdBuffer, tmpBufferDetails.buffer, ibc.grBinds->instanceBD.buffer, 1, &(*ibc.chunks)[i].dstBufferCopy);
+			for (long i = 0; i < ibc.chunks.next; ++i) {
+				vkCmdCopyBuffer(tmpBufferDetails.cmdBuffer, tmpBufferDetails.buffer, ibc.grBinds->instanceBD.buffer, 1, &ibc.chunks[i].dstBufferCopy);
 			}
 
 			vkEndCommandBuffer(tmpBufferDetails.cmdBuffer);
@@ -381,7 +383,7 @@ void ECS_Tick_Late(double delta) {
 			vkResetCommandBuffer(tmpBufferDetails.cmdBuffer, 0);
 		}
 		PKVK_EndBuffer(tmpBufferDetails);
-		bufferUpdates.Pop();
+		pk_arr_remove_at(&bufferUpdates, bufferUpdates.next-1);
 	}
 }
 
@@ -481,7 +483,7 @@ CompInstance *ECS_CreateInstance(Entity_Base *entity, pk_uuid uuid, CompGrBinds
 		comp->index = entityTypeGrBinds->instanceCounter++;
 		comp->isNeedingUpdated = true;
 		if (entityTypeGrBinds->instanceCounter > entityTypeGrBinds->instanceBufferMaxCount) {
-			EntitiesWithExcessInstances.Push(ECS_GetEntity(entityTypeGrBinds->entHandle));
+			pk_arr_append_t(&EntitiesWithExcessInstances, ECS_GetEntity(entityTypeGrBinds->entHandle));
 		}
 	} else if (inst_pos != nullptr) {
 		// TODO leaky
@@ -559,10 +561,10 @@ CompInstance *ECS_GetInstances(pk_handle_bucket_index_T bucketIndex, pk_handle_i
 }
 
 void ECS_Teardown() {
-	EntitiesWithExcessInstances.~DynArray();
-	entitiesYetToBeRemoved.~DynArray();
-	EntitiesToBeRemoved.~DynArray();
-	entitiesMarkedForRemoval.~DynArray();
+	pk_arr_reset(&EntitiesWithExcessInstances);
+	pk_arr_reset(&entitiesYetToBeRemoved);
+	pk_arr_reset(&EntitiesToBeRemoved);
+	pk_arr_reset(&entitiesMarkedForRemoval);
 	Buckets_Destroy(ecs.bc.instances);
 	Buckets_Destroy(ecs.bc.grBinds);
 	Buckets_Destroy(ecs.bc.entityPtrs);
diff --git a/src/ecs.hpp b/src/ecs.hpp
index a934fa2..7be6eac 100644
--- a/src/ecs.hpp
+++ b/src/ecs.hpp
@@ -1,12 +1,11 @@
 #ifndef PKE_ECS_HPP
 #define PKE_ECS_HPP
 
-#include "dynamic-array.hpp"
 #include "pk.h"
 #include "components.hpp"
 
-extern DynArray<Entity_Base *> EntitiesToBeRemoved;
-extern DynArray<Entity_Base *> EntitiesWithExcessInstances;
+extern pk_arr_t<Entity_Base *> EntitiesToBeRemoved;
+extern pk_arr_t<Entity_Base *> EntitiesWithExcessInstances;
 
 void ECS_Init();
 void ECS_Teardown();
@@ -14,6 +13,8 @@ void ECS_Tick_Early(double delta);
 void ECS_Tick(double delta);
 void ECS_Tick_Late(double delta);
 
+bool ecs_pk_arr_find_first_matching_pointer(void *search_ptr, void *list_ptr);
+
 Entity_Base *ECS_CreateGenericEntity();
 EntityHandle ECS_CreateEntity(Entity_Base *entity, Entity_Base *parentEnt = nullptr);
 Entity_Base *ECS_GetEntity(EntityHandle handle);
diff --git a/src/entities.cpp b/src/entities.cpp
index 1ffecb3..9a8b4e1 100644
--- a/src/entities.cpp
+++ b/src/entities.cpp
@@ -2,6 +2,7 @@
 #include "entities.hpp"
 
 #include "bucketed-array.hpp"
+#include "dynamic-array.hpp"
 #include "ecs.hpp"
 #include "game-settings.hpp"
 #include "math-helpers.hpp"
@@ -1243,8 +1244,8 @@ void EntityType_Unload(EntityType &et, CompGrBinds *grBindsArr[1]) {
 
 void EntityType_Tick(double delta) {
 	(void)delta;
-	const auto count = EntitiesToBeRemoved.Count();
-	for (long i = 0; i < count; ++i) {
+	const uint32_t count = EntitiesToBeRemoved.next;
+	for (uint32_t i = 0; i < count; ++i) {
 		auto *entTypePtr = EntityType_FindByEntityHandle(EntitiesToBeRemoved[i]->handle);
 		if (entTypePtr != nullptr) {
 			auto &entType = *entTypePtr;
@@ -1260,8 +1261,8 @@ void EntityType_Tick(double delta) {
 
 void EntityType_Tick_Late(double delta) {
 	(void)delta;
-	while (EntitiesWithExcessInstances.Count() != 0) {
-		auto *entity = EntitiesWithExcessInstances.Pop();
+	while (EntitiesWithExcessInstances.next != 0) {
+		auto *entity = EntitiesWithExcessInstances[EntitiesWithExcessInstances.next-1];
 		auto *etPtr = EntityType_FindByEntityHandle(entity->handle);
 		assert(etPtr != nullptr);
 		auto &et = *etPtr;
diff --git a/src/window.cpp b/src/window.cpp
index 4132577..a099984 100644
--- a/src/window.cpp
+++ b/src/window.cpp
@@ -8,6 +8,7 @@
 
 #include "asset-manager.hpp"
 #include "camera.hpp"
+#include "dynamic-array.hpp"
 #include "ecs.hpp"
 #include "font.hpp"
 #include "game-settings.hpp"