pke: level: BucketContainer -> pk_bkt_arr_t & name

1 files changed, 28 insertions, 36 deletions

diff --git a/src/level.cpp b/src/level.cpp
index 57faf80..d05009c 100644
--- a/src/level.cpp
+++ b/src/level.cpp
@@ -6,45 +6,46 @@
 #include "pk.h"
 
 struct level_mstr {
-	BucketContainer<PkeLevel, LevelHandle> bc;
+	pk_bkt_arr_t<pke_level> bc;
 } level_mstr;
 
-void PkeLevel_Init() {
-	Buckets_Init(level_mstr.bc);
+void pke_level_init() {
+	new (&level_mstr.bc) pk_bkt_arr_t<pke_level>{};
 }
 
-void PkeLevel_Teardown() {
-	Buckets_Destroy(level_mstr.bc);
+void pke_level_teardown() {
+	pk_bkt_arr_teardown(&level_mstr.bc);
 }
 
 /*
-PkeLevel *PkeLevel_Get_Inner(LevelHandle handle) {
+pke_level *pke_level_Get_Inner(LevelHandle handle) {
 	if ( || handle.itemIndex >= level_mstr.bc.limits.itemIndex || (handle.bucketIndex == handle.bucketIndex) {
 	}
 	return &level_mstr.bc.buckets[handle.bucketIndex][handle.itemIndex];
 }
 */
 
-PkeLevel *PkeLevel_Create(const char *levelName) {
+pke_level *pke_level_create(const char *levelName) {
 	NULL_CHAR_ARR(safe_name, LEVEL_NAME_MAX_LEN + 1);
 
 	size_t len = strlen(levelName);
 	size_t start = len <= (LEVEL_NAME_MAX_LEN - 1) ? 0 : len - (LEVEL_NAME_MAX_LEN - 1);
 	sprintf(safe_name, pke_level_name_printf_format, levelName + start);
 
-	PkeLevel *lvl = PkeLevel_GetByName(levelName);
+	pke_level *lvl = pke_level_get_by_name(levelName);
 	if (lvl != nullptr) {
-		fprintf(stderr, "[PkeLevel_Create] Failed to create new level: name already exists.");
+		fprintf(stderr, "[pke_level_Create] Failed to create new level: name already exists.");
 		return nullptr;
 	}
 
-	LevelHandle level_handle = Buckets_NewHandle(level_mstr.bc);
+	LevelHandle level_handle { pk_bkt_arr_new_handle(&level_mstr.bc) };
 	if (level_handle == LevelHandle_MAX) {
-		fprintf(stderr, "[PkeLevel_Create] Failed to create new level handle from BucketContainer");
+		fprintf(stderr, "[pke_level_Create] Failed to create new level handle from BucketContainer");
 		return nullptr;
 	}
 
 	lvl = &level_mstr.bc[level_handle];
+	new (lvl) pke_level{};
 	ECS_CreateEntity(lvl);
 
 	if (lvl->bkt == nullptr) {
@@ -54,45 +55,36 @@ PkeLevel *PkeLevel_Create(const char *levelName) {
 	return lvl;
 }
 
-PkeLevel *PkeLevel_Get(LevelHandle handle) {
+pke_level *pke_level_get(LevelHandle handle) {
 	return &level_mstr.bc[handle];
 }
 
-PkeLevel *PkeLevel_GetByName(const char *levelName) {
+pke_level *pke_level_get_by_name(const char *levelName) {
 	NULL_CHAR_ARR(safe_name, LEVEL_NAME_MAX_LEN + 1);
 	auto len = strlen(levelName);
 	auto start = len <= (LEVEL_NAME_MAX_LEN - 1) ? 0 : len - (LEVEL_NAME_MAX_LEN - 1);
 	sprintf(safe_name, pke_level_name_printf_format, levelName + start);
 
-	pk_handle_bucket_index_T b;
-	pk_handle_item_index_T i, ii;
-	for (b = 0; b < level_mstr.bc.pkeHandle.bucketIndex; ++b) {
-		ii = level_mstr.bc.pkeHandle.bucketIndex == b ? level_mstr.bc.pkeHandle.itemIndex : level_mstr.bc.limits.itemIndex;
-		for (i = 0; i < ii; ++i) {
-			if (memcmp(safe_name, level_mstr.bc.buckets[b][i].name, LEVEL_NAME_MAX_LEN) == 0) {
-				return &level_mstr.bc.buckets[b][i];
-			}
-		}
-	}
-	return nullptr;
-}
+	using LevelFindFn = pk_tmpln_2<bool, const struct pke_level *, const struct pke_level *, const void *, const void *>;
+	LevelFindFn scene_find_cb{};
+	scene_find_cb.func = [&safe_name](const struct pke_level *user_obj_data, const struct pke_level *arr_obj_data) {
+		(void)user_obj_data;
+		return memcmp(safe_name, arr_obj_data->name, PK_MIN(strlen(safe_name), LEVEL_NAME_MAX_LEN)) == 0;
+	};
 
-pk_handle_bucket_index_T pke_level_get_bucket_count() {
-	return level_mstr.bc.pkeHandle.bucketIndex + 1;
+	LevelHandle handle { pk_bkt_arr_find_first_handle(&level_mstr.bc, &LevelFindFn::invoke, &scene_find_cb, NULL) };
+	if (handle == LevelHandle_MAX) return nullptr;
+	return &level_mstr.bc[handle];
 }
 
-struct PkeLevel *pke_level_get_levels(pk_handle_bucket_index_T bucket_index, pk_handle_item_index_T *item_count) {
-	assert(bucket_index <= level_mstr.bc.pkeHandle.bucketIndex);
-	assert(item_count != nullptr);
-	*item_count = bucket_index == level_mstr.bc.pkeHandle.bucketIndex ? level_mstr.bc.pkeHandle.itemIndex : level_mstr.bc.limits.itemIndex;
-	return level_mstr.bc.buckets[bucket_index];
+struct pk_bkt_arr *pke_level_get_levels() {
+	return &level_mstr.bc;
 }
 
-void PkeLevel_Remove(LevelHandle handle) {
-	PkeLevel *lvl = &level_mstr.bc[handle];
+void pke_level_remove(LevelHandle handle) {
+	pke_level *lvl = &level_mstr.bc[handle];
 	assert(lvl == nullptr && "Failed to find level to remove by requested LevelHandle");
-	// TODO mark bucket slot as open
 	ECS_MarkForRemoval(lvl);
 	pk_bucket_reset(lvl->bkt);
-	lvl->levelHandle = LevelHandle_MAX;
+	pk_bkt_arr_free_handle(&level_mstr.bc, handle);
 }