build.bash

@@ -7,13 +7,6 @@ gcc -g3 -o dependencies/build/glad.o \
     -I dependencies/include/ -Wall
 
 gcc -g3 -o techneck.elf \
-    code/source-c/*.c \
+    code/source-c/*.c code/source-c/entity/*.c code/source-c/utility/*.c code/source-c/physics/*.c dependencies/build/glad.o \
-    code/source-c/entity/*.c \
-    code/source-c/utility/*.c \
-    code/source-c/world/*.c \
-    code/source-c/world/update/*.c \
-    code/source-c/world/generator/*.c \
-    code/source-c/physics/*.c \
-    dependencies/build/glad.o \
     -I dependencies/include -I code/source-c/ -lGL -lSDL2 -lm -Wall
 

code/source-c/chunk.c

@@ -1,4 +1,4 @@
-#include <world/chunk.h>
+#include <chunk.h>
 
 #include <glad/glad.h>
 #include <stddef.h>
@@ -38,10 +38,6 @@ void tc_draw_chunkloader_zone(tc_chunkloader_s *loader)
     tc_chunklist_s     *list = &loader->chunklist;
     for(tc_chunklist_entry_s *current = list->first; current != NULL; current = current->next)
     {
-        if(current->entity == NULL)
-        {
-            return;
-        }
         tc_send_pointer_to_entity(current->entity, "draw", 0);
     }
     

code/source-c/chunk.h

@@ -3,7 +3,7 @@
 #define TC_CHUNK_H
 
 #include <utility/location.h>
-#include <entity/entity.h>
+#include <entity.h>
 
 typedef struct  tc_chunk                tc_chunk_s;
 typedef struct  tc_chunkloader                  tc_chunkloader_s;

code/source-c/chunk_pool.h

@@ -3,7 +3,7 @@
 #define TC_CHUNK_POOL_H
 
 #include <utility/utility.h>
-#include <world/chunk.h>
+#include <chunk.h>
 
 typedef struct  tc_chunk_pool           tc_chunk_pool_s;
 typedef struct  tc_chunk_pool_entry     tc_chunk_pool_entry_s;

code/source-c/chunkloader.c

@@ -1,6 +1,5 @@
-#include <world/world.h>
+#include "world.h"
-#include <entity/entity.h>
+#include "entity.h"
-#include <state.h>
 
 #include <stdlib.h>
 #include <stdio.h>
@@ -96,6 +95,7 @@ void tc_chunklist_add_item(tc_chunklist_s *list, tc_entity_s *chunk)
     new_entry.entity                    = chunk;
     new_entry.next                      = list->first;
     (*list->first_free)                 = new_entry;
+    list->first                         = list->first_free;
     
     // Link everything together
     
@@ -104,7 +104,6 @@ void tc_chunklist_add_item(tc_chunklist_s *list, tc_entity_s *chunk)
     list->first_free->previous          = NULL;
     
     // Finally assign it
-    list->first                         = list->first_free;
     list->first_free                    = tc_chunklist_find_first_free(list);
 }
 
@@ -118,9 +117,6 @@ void tc_chunklist_remove_item(tc_chunklist_s *list, tc_entity_s *chunk)
     if(entry->previous != NULL)
         entry->previous->next           = entry->next;
     
-    if(entry->next != NULL)
-        entry->next->previous           = entry->previous;
-    
     entry->entity                   = NULL;
     list->first_free            = entry;
 }
@@ -134,7 +130,7 @@ tc_chunkloader_s tc_create_chunkloader(tc_chunk_location_s location)
     loader.extent.y             = UPDATE_DISTANCE * 2 + 1;
     loader.extent.z             = UPDATE_DISTANCE * 2 + 1;
     loader.center               = location;
-    loader.chunklist            = tc_create_chunklist(512);
+    loader.chunklist            = tc_create_chunklist(200);
     loader.needs_reload         = FALSE;
     
     return loader;
@@ -153,13 +149,13 @@ void tc_delete_chunkloader(tc_chunkloader_s loader)
 
 bool_t tc_coord_is_within_loaders_range(tc_chunkloader_s *loader, tc_vec3i_s coord)
 {
-    if(coord.x < ((loader->center.grid_coords.x - loader->extent.x / 2)-1))     return FALSE;
+    if(coord.x < (loader->center.grid_coords.x - loader->extent.x / 2))     return FALSE;
-    if(coord.y < ((loader->center.grid_coords.y - loader->extent.y / 2)-1))     return FALSE;
+    if(coord.y < (loader->center.grid_coords.y - loader->extent.y / 2))     return FALSE;
-    if(coord.z < ((loader->center.grid_coords.z - loader->extent.z / 2)-1))     return FALSE;
+    if(coord.z < (loader->center.grid_coords.z - loader->extent.z / 2))     return FALSE;
     
-    if(coord.x > ((loader->center.grid_coords.x + loader->extent.x / 2)+1))     return FALSE;
+    if(coord.x > (loader->center.grid_coords.x + loader->extent.x / 2))     return FALSE;
-    if(coord.y > ((loader->center.grid_coords.y + loader->extent.y / 2)+1))     return FALSE;
+    if(coord.y > (loader->center.grid_coords.y + loader->extent.y / 2))     return FALSE;
-    if(coord.z > ((loader->center.grid_coords.z + loader->extent.z / 2)+1))     return FALSE;
+    if(coord.z > (loader->center.grid_coords.z + loader->extent.z / 2))     return FALSE;
     
     return TRUE;
 }
@@ -182,9 +178,7 @@ void tc_unload_chunk_at(tc_chunkloader_s *loader, tc_chunk_location_s location)
     if(entity == NULL) return;
     
     tc_chunk_s             *chunk           = entity->specific;
-    tc_world_s             *world           = location.world;
     
-    tc_run_hooklist(&world->on_chunk_unload, entity);
     --chunk->refcounter;
     
     if(chunk->refcounter < 1)

code/source-c/default_terrain_generator.c

@@ -1,4 +1,4 @@
-#include <world/world.h>
+#include "world.h"
 
 bool_t tc_generate_default_terrain_chunk(tc_worldgen_s *gen, tc_chunk_s *chunk)
 {

code/source-c/entity.c

@@ -14,9 +14,6 @@ tc_entity_registry_s tc_init_entity_registry()
     registry.num_intervals          = 0;
     registry.intervals              = calloc(sizeof(tc_interval_s *), registry.intervals_capacity);
     registry.pool                   = tc_create_entity_pool(512);
-    registry.tags_capacity          = 512;
-    registry.num_tags               = 0;
-    registry.tags                   = calloc(sizeof(tc_entity_tag_s), registry.tags_capacity);
     
     return registry;
 }
@@ -328,8 +325,7 @@ void tc_send_pointer_to_entity(tc_entity_s *entity, char *event_name, void *poin
     tc_entity_event_s event;
     event.identifier        = event_name;
     event.value.pointer     = pointer;
-    tc_entity_type_s   *type            = entity->type;
+    entity->type->functions.fn_send_event(entity, event);
-    type->functions.fn_send_event(entity, event);
 }
 
 void tc_send_string_to_entity(tc_entity_s *entity, char *event_name, char *string)
@@ -379,75 +375,6 @@ void tc_tick_intervals()
     }
 }
 
-
-
-tc_entity_tag_s * tc_get_tag(char *name)
-{
-    for(u32_t tag_index = 0; tag_index < tc_game_state_g.entity_registry.num_tags; ++tag_index)
-    {
-        if(!strcmp(tc_game_state_g.entity_registry.tags[tag_index].name, name))
-            return &tc_game_state_g.entity_registry.tags[tag_index];
-    }
-    return NULL;
-}
-
-tc_entity_tag_s * tc_allocate_tag(char *name)
-{
-    if(tc_game_state_g.entity_registry.num_tags
-        >=
-       tc_game_state_g.entity_registry.tags_capacity
-      ) {
-        tc_game_state_g.entity_registry.tags_capacity      *= 2;
-        tc_game_state_g.entity_registry.tags                =
-            realloc(tc_game_state_g.entity_registry.tags, sizeof(tc_entity_tag_s) * tc_game_state_g.entity_registry.tags_capacity);
-    }
-    tc_entity_tag_s *tag = &tc_game_state_g.entity_registry.tags[tc_game_state_g.entity_registry.num_tags];
-    
-    tag->name               = name;
-    tag->users_capacity     = 64;
-    tag->num_users          = 0;
-    tag->users              = calloc(sizeof(tc_entity_s *), tag->users_capacity);
-    ++tag->num_users;
-    
-    return tag;
-    
-}
-tc_entity_tag_s * tc_get_or_allocate_tag(char *name)
-{
-    tc_entity_tag_s *tag = tc_get_tag(name);
-    if(tag == NULL) return tc_allocate_tag(name);
-    return tag;
-}
-
-void tc_add_user_to_tag(tc_entity_tag_s *tag, tc_entity_s *entity)
-{
-    if(tag->num_users >= tag->users_capacity)
-    {
-        tag->users_capacity        *= 2;
-        tag->users = realloc(tag->users, sizeof(tc_entity_s *) * tag->users_capacity);
-    }
-    tag->users[tag->num_users] = entity;
-    ++tag->num_users;
-}
-
-void tc_tag_entity(tc_entity_s *entity, char *name)
-{
-    tc_entity_tag_s *tag = tc_get_or_allocate_tag(name);
-    tc_add_user_to_tag(tag, entity);
-}
-
-u32_t tc_count_entitites_with_tag(char *name)
-{
-    return tc_get_tag(name)->num_users;
-}
-
-void tc_list_entities_with_tag(char *name, tc_entity_s **entities, u32_t max)
-{
-    tc_entity_tag_s        *tag             = tc_get_tag(name);
-    
-    memcpy(entities, tag->users, tc_min(max, tag->num_users) * sizeof(tc_entity_s *));
-}
-
 /*
 void tc_draw_all_entities_of_type(char *name)
 {

code/source-c/entity.h

@@ -2,8 +2,8 @@
 #ifndef TC_ENTITY_H
 #define TC_ENTITY_H
 
-#include <utility/location.h>
+#include "utility/location.h"
-#include <utility/utility.h>
+#include "utility/utility.h"
 
 typedef struct tc_interval                  tc_interval_s;
 typedef struct tc_entity_event              tc_entity_event_s;
@@ -13,7 +13,6 @@ typedef struct tc_entity                    tc_entity_s;
 typedef struct tc_entity_pool               tc_entity_pool_s;
 typedef struct tc_entity_pool_entry         tc_entity_pool_entry_s;
 typedef struct tc_entity_registry           tc_entity_registry_s;
-typedef struct tc_entity_tag                tc_entity_tag_s;
 
 typedef void (*tc_entity_create_fn)          (tc_entity_s *entity, void *userdata);
 typedef void (*tc_entity_delete_fn)          (tc_entity_s *entity);
@@ -52,16 +51,6 @@ struct tc_entity_type
     tc_entity_s               **instances;
 };
 
-struct tc_entity_tag
-{
-    char                       *name;
-    
-    u32_t                       users_capacity;
-    u32_t                       num_users;
-    tc_entity_s               **users;
-    
-};
-
 struct tc_entity_attribute
 {
     char                       *name;
@@ -127,10 +116,6 @@ struct tc_entity_registry
     u32_t                       intervals_capacity;
     u32_t                       num_intervals;
     tc_interval_s              *intervals;
-    
-    u32_t                       tags_capacity;
-    u32_t                       num_tags;
-    tc_entity_tag_s            *tags;
 };
 
 tc_entity_pool_s *              tc_create_entity_pool           (u32_t capacity);
@@ -152,22 +137,17 @@ char *                          tc_get_string_from_entity       (tc_entity_s *en
 i64_t                           tc_get_integer_from_entity      (tc_entity_s *entity, char *attr_name);
 f64_t                           tc_get_float_from_entity        (tc_entity_s *entity, char *attr_name);
 
-void                            tc_tag_entity                   (tc_entity_s *entity, char *name);
-
 void                            tc_send_pointer_to_entity       (tc_entity_s *entity, char *event_name, void *pointer);
 void                            tc_send_string_to_entity        (tc_entity_s *entity, char *event_name, char   *string);
 void                            tc_send_integer_to_entity       (tc_entity_s *entity, char *event_name, i64_t integer);
 void                            tc_send_float_to_entity         (tc_entity_s *entity, char *event_name, f64_t  floating);
 
-// void                            tc_schedule_interval            (tc_entity_s *entity, float wanted_delta, void (*fn_interval)(tc_entity_s *entity));
+void                            tc_schedule_interval            (tc_entity_s *entity, float wanted_delta, void (*fn_interval)(tc_entity_s *entity));
-// void                            tc_tick_intervals               ();
+void                            tc_tick_intervals               ();
 void                            tc_draw_all_entities_of_type    (char *name);
 
 tc_entity_s *                   tc_allocate_entity              ();
 void                            tc_deallocate_entity            (tc_entity_s *entity);
 
-u32_t                           tc_count_entitites_with_tag     (char *name);
-void                            tc_list_entities_with_tag       (char *name, tc_entity_s **entities, u32_t max);
-
 #endif // TC_ENTITY_H
 

code/source-c/entity/chunk.c

@@ -1,7 +1,7 @@
 #include <entity/registration.h>
-#include <world/chunk_pool.h>
+#include <chunk_pool.h>
-#include <world/chunk.h>
+#include <chunk.h>
-#include <world/world.h>
+#include <world.h>
 #include <state.h>
 
 #include <glad/glad.h>
@@ -32,9 +32,6 @@ void tc_create_chunk_entity(tc_entity_s *entity, void *userdata)
 void tc_delete_chunk_entity(tc_entity_s *entity)
 {
     tc_chunk_s             *chunk               = entity->specific;
-    tc_world_s             *world           = chunk->location.world;
-    tc_run_hooklist(&world->on_chunk_delete, entity);
-    
     if(chunk->vao != 0)         glDeleteVertexArrays(1, &chunk->vao);
     if(chunk->vbo != 0)         glDeleteBuffers(1, &chunk->vbo);
     
@@ -42,10 +39,8 @@ void tc_delete_chunk_entity(tc_entity_s *entity)
     if(chunk->vertex_uvs != NULL)           free(chunk->vertex_uvs);
     
     tc_physics_entity_s    *physics_body        = tc_get_pointer_from_entity(entity, "physics_body");
-    if(physics_body != 0)
-    {
     tc_remove_physics_entity(physics_body);
-    }
+    
     tc_deallocate_chunk(entity->specific);
 }
 

code/source-c/entity/registration.h

@@ -2,7 +2,7 @@
 #ifndef TC_ENTITY_REGISTRATION_H
 #define TC_ENTITY_REGISTRATION_H
 
-#include <entity/entity.h>
+#include "../entity.h"
 
 void        tc_register_chunk_entity        ();
 void        tc_register_player_entity       ();

code/source-c/initialization.c

@@ -1,7 +1,6 @@
-#include <state.h>
+#include "state.h"
-#include <world/world.h>
+#include "world.h"
-#include <entity/registration.h>
+#include "entity/registration.h"
-#include <world/update/world_update.h>
 
 #include <SDL2/SDL.h>
 
@@ -63,11 +62,7 @@ void tc_load_textures()
 
 void tc_init()
 {
-    tc_start_world_updater();
     tc_init_renderer(&tc_game_state_g);
-    
-    
-    tc_promise_s            main_world_promise          = tc_worldupdate_register_world        ();
     tc_game_state_g.asset_storage       = tc_init_asset_storage("assets/");
     tc_load_textures();
     tc_game_state_g.block_registry      = tc_init_blocks();
@@ -79,7 +74,7 @@ void tc_init()
     tc_add_to_hooklist(&tc_game_state_g.on_world_create, (tc_fn_hook) &tc_create_world_physics, NULL);
     
     tc_init_worlds();
-    // tc_game_state_g.main_world          = tc_new_world(&tc_default_terrain_generator_g);
+    tc_game_state_g.main_world          = tc_new_world(&tc_default_terrain_generator_g);
     tc_game_state_g.player              = tc_create_entity("player", NULL);
     tc_game_state_g.viewer              = tc_game_state_g.player;
     
@@ -94,7 +89,7 @@ void tc_init()
 
 void tc_cleanup()
 {
-    // tc_unload_world(tc_game_state_g.main_world);
+    tc_unload_world(tc_game_state_g.main_world);
     tc_cleanup_chunk_pool();
     SDL_GL_DeleteContext(tc_game_state_g.renderer.gl_context);
     SDL_DestroyWindow(tc_game_state_g.renderer.window);

code/source-c/main.c

@@ -83,7 +83,7 @@ void render()
     tc_shader_uniform_mat4f(&tc_game_state_g.renderer.draw_shader, "projection_matrix", projection_matrix);
     tc_shader_uniform_mat4f(&tc_game_state_g.renderer.draw_shader, "view_matrix", view_matrix);
     
-    // tc_draw_world(tc_game_state_g.main_world);
+    tc_draw_world(tc_game_state_g.main_world);
     
     SDL_GL_SwapWindow(tc_game_state_g.renderer.window);
 }
@@ -284,11 +284,11 @@ bool update()
     tc_move_viewer_to(camera_position.x, camera_position.y, camera_position.z);
     tc_rotate_viewer_to(camera_rotation.x, camera_rotation.y, camera_rotation.z);
     
-    // tc_game_state_g.main_world->spawn_loader->center.grid_coords.x        = ((int32_t) camera_position.x) / 32 - UPDATE_DISTANCE;
+    tc_game_state_g.main_world->spawn_loader->center.grid_coords.x        = ((int32_t) camera_position.x) / 32 - UPDATE_DISTANCE;
-    // tc_game_state_g.main_world->spawn_loader->center.grid_coords.y        = ((int32_t) camera_position.y) / 32 - UPDATE_DISTANCE;
+    tc_game_state_g.main_world->spawn_loader->center.grid_coords.y        = ((int32_t) camera_position.y) / 32 - UPDATE_DISTANCE;
-    // tc_game_state_g.main_world->spawn_loader->center.grid_coords.z        = - ((int32_t) camera_position.z) / 32 - UPDATE_DISTANCE;
+    tc_game_state_g.main_world->spawn_loader->center.grid_coords.z        = - ((int32_t) camera_position.z) / 32 - UPDATE_DISTANCE;
     
-    // tc_update_world(tc_game_state_g.main_world);
+    tc_update_world(tc_game_state_g.main_world);
     
     return true;
 }

code/source-c/noise.c

@@ -1,4 +1,4 @@
-#include <utility/utility.h>
+#include "world.h"
 
 int tc_perlin_permutation[] = {
     151, 160, 137,  91,  90,  15, 131,  13, 201,  95,  96,  53, 194, 233,   7, 225,

code/source-c/physics/physics.c

@@ -21,8 +21,6 @@ void tc_add_physics_object(tc_physics_simulation_s *simulation, tc_physics_entit
 
 void tc_add_physics_object_to(tc_physics_entity_s *container, tc_physics_entity_s *object)
 {
-    if(container != NULL) object->super = container;
-    
     if((container->value.group.num_entities+1)
         >=
        container->value.group.entities_capacity
@@ -78,7 +76,7 @@ i32_t tc_physics_find_entity_in_group(tc_physics_entity_s *group, tc_physics_ent
     i32_t index = 0;
     while(index < group->value.group.num_entities)
     {
-        if(group->value.group.entities[group->value.group.num_entities]
+        if(entity->super->value.group.entities[group->value.group.num_entities]
             ==
            entity
           ) return index;
@@ -101,18 +99,15 @@ void tc_remove_physics_entity(tc_physics_entity_s *entity)
 {
     if(entity->super == NULL) return;
     
+    tc_free_physics_entity(entity);
+    
     // Fill up the gap created inside the entities-array.
     
-    tc_physics_entity_s        *super           = entity->super;
-    
     i32_t                       index           = 0;
-    if((index = tc_physics_find_entity_in_group(super, entity)) == -1) return;
+    if((index = tc_physics_find_entity_in_group(entity->super, entity)) == -1) return;
     
-    super->value.group.entities[index]  = 
+    entity->super->value.group.entities[index]  = 
-        super->value.group.entities[super->value.group.num_entities-1];
+        entity->super->value.group.entities[entity->super->value.group.num_entities-1];
-    --super->value.group.num_entities;
-    
-    tc_free_physics_entity(entity);
 }
 
 

code/source-c/physics/simulation.h

@@ -6,7 +6,7 @@
 
 #include <physics/primitives.h>
 #include <utility/utility.h>
-#include <entity/entity.h>
+#include <entity.h>
 
 typedef struct  tc_physics_entity               tc_physics_entity_s;
 typedef struct  tc_entity_physics_attributes    tc_entity_physics_attributes_s;

code/source-c/state.h

@@ -8,9 +8,9 @@
 
 #include <assets.h>
 #include <shaders.h>
-#include <entity/entity.h>
+#include <entity.h>
 #include <blocks.h>
-#include <world/world.h>
+#include <world.h>
 #include <utility/utility.h>
 
 typedef struct tc_camera
@@ -37,7 +37,7 @@ typedef struct
     tc_asset_storage_s      asset_storage;
     tc_block_registry_s     block_registry;
     tc_entity_registry_s    entity_registry;
-    // tc_world_s             *main_world;
+    tc_world_s             *main_world;
     tc_entity_s            *viewer;
     tc_entity_s            *player;
     

code/source-c/utility/math.c

@@ -10,9 +10,3 @@ f32_t tc_rad_to_deg(f32_t radians)
     return radians / (3.1415*2.0f) * 360.0f;
 }
 
-i64_t tc_min(i64_t first, i64_t second)
-{
-    if(first < second) return first;
-    return second;
-}
-

code/source-c/utility/math.h

@@ -72,8 +72,6 @@ struct tc_mat3f
 f32_t       tc_deg_to_rad           (f32_t degrees);
 f32_t       tc_rad_to_deg           (f32_t radians);
 
-i64_t       tc_min                  (i64_t first, i64_t second);
-
 bool_t      tc_vec4f_equ            (tc_vec4f_s vector_1, tc_vec4f_s vector_2);
 bool_t      tc_vec3f_equ            (tc_vec3f_s vector_1, tc_vec3f_s vector_2);
 bool_t      tc_vec2f_equ            (tc_vec2f_s vector_1, tc_vec2f_s vector_2);

code/source-c/utility/promise.h

@@ -1,15 +0,0 @@
-
-#ifndef TC_PROMISE_H
-#define TC_PROMISE_H
-
-#include <utility/utility.h>
-
-typedef struct
-{
-    u64_t           issueing_tick;
-    u32_t           identifier;
-    
-} tc_promise_s;
-
-#endif
-

code/source-c/world.c

@@ -1,4 +1,4 @@
-#include <world/world.h>
+#include <world.h>
 #include <state.h>
 
 #include <stdlib.h>
@@ -48,9 +48,6 @@ tc_chunkloader_s tc_create_spawn_loader(tc_world_s *world)
     
     tc_chunkloader_s        loader              = tc_create_chunkloader(loader_location);
     loader.is_rendered          = TRUE;
-    loader.extent.x             = 9.0f;
-    loader.extent.z             = 9.0f;
-    loader.extent.y             = 3.0f;
     
     return loader;
 }
@@ -62,7 +59,6 @@ tc_world_s * tc_new_world(tc_worldgen_s *generator)
     world->before_chunk_generate    = tc_new_hooklist(16);
     world->after_chunk_generate     = tc_new_hooklist(16);
     world->on_chunk_delete          = tc_new_hooklist(16);
-    world->on_chunk_unload          = tc_new_hooklist(16);
     world->on_chunk_update          = tc_new_hooklist(16);
     world->worldgen                 = &tc_default_terrain_generator_g;
     world->num_loaders              = 1;

code/source-c/world.h

@@ -8,9 +8,9 @@
 #include <hook.h>
 #include <physics/simulation.h>
 #include <utility/math.h>
-#include <entity/entity.h>
+#include <entity.h>
-#include <world/chunk.h>
+#include <chunk.h>
-#include <world/chunk_pool.h>
+#include <chunk_pool.h>
 
 
 #define UPDATE_DISTANCE 2
@@ -52,9 +52,8 @@ struct tc_world
     tc_hooklist_s               on_chunk_create;
     tc_hooklist_s               before_chunk_generate;
     tc_hooklist_s               after_chunk_generate;
-    tc_hooklist_s               on_chunk_update;
-    tc_hooklist_s               on_chunk_unload;
     tc_hooklist_s               on_chunk_delete;
+    tc_hooklist_s               on_chunk_update;
 };
 
 extern tc_worldgen_s tc_default_terrain_generator_g;

code/source-c/world/update/internal.h

@@ -1,103 +0,0 @@
-
-#ifndef TC_WORLD_UPDATER_INTERNAL_H
-#define TC_WORLD_UPDATER_INTERNAL_H
-
-#include <world/world.h>
-#include <utility/location.h>
-#include <utility/promise.h>
-
-typedef struct  tc_world_updater_queue              tc_world_updater_queue_s;
-typedef struct  tc_world_updater_command            tc_world_updater_command_s;
-
-typedef enum
-{
-    TC_WORLD_UPDATER_COMMAND_UNKNOWN,
-    TC_WORLD_UPDATER_COMMAND_MOVE_CHUNKLOADER,
-    TC_WORLD_UPDATER_COMMAND_PLACE_BLOCK,
-    TC_WORLD_UPDATER_COMMAND_STOP,
-    TC_WORLD_UPDATER_COMMAND_ADD_WORLD,
-    TC_WORLD_UPDATER_COMMAND_ADD_CHUNKLOADER,
-    TC_WORLD_UPDATER_COMMAND_DELETE_CHUNKLOADER,
-    TC_WORLD_UPDATER_COMMAND_GET_WORLD,
-    TC_WORLD_UPDATER_COMMAND_GET_CHUNKLOADER,
-    TC_WORLD_UPDATER_COMMAND_GET_CHUNKLIST
-    
-} tc_world_update_command_e;
-
-struct tc_world_updater_command
-{
-    tc_world_updater_command_s             *next;
-    tc_world_updater_command_s             *previous;
-    
-    tc_world_update_command_e               type;
-    
-    union command
-    {
-        struct move_chunkloader_command
-        {
-            u32_t                                   loader_id;
-            tc_chunk_location_s                     new_location;
-        } move_chunkloader;
-        
-        struct place_block_command
-        {
-            tc_block_s                              block;
-            tc_block_location_s                     location;
-            
-        } place_block;
-        
-        struct get_item
-        {
-            u32_t                                   index;
-            u32_t                                   promise;
-            
-        } get_item;
-        
-    } specific;
-    
-    bool_t                                  is_used;
-};
-
-struct tc_world_updater_queue
-{
-    tc_world_updater_command_s             *first;
-    tc_world_updater_command_s             *last;
-    bool_t                                  in_action;
-    
-    u32_t                                   capacity;
-    tc_world_updater_command_s             *commands;
-};
-
-void                                tc_worldupdate_initialize_promises  ();
-tc_world_updater_queue_s            tc_new_world_updater_queue          (u32_t capacity);
-bool_t                              tc_issue_world_updater_command      (
-    tc_world_updater_queue_s *queue, tc_world_updater_command_s command
-);
-
-tc_world_updater_command_s          tc_world_updater_query_next_command
-    (tc_world_updater_queue_s *queue);
-
-
-tc_promise_s                        tc_worldupdate_reserve_world_promise            ();
-tc_promise_s                        tc_worldupdate_reserve_chunkloader_promise      ();
-tc_promise_s                        tc_worldupdate_reserve_chunklist_promise        ();
-
-void                                tc_worldupate_set_world_promise         (u32_t identifier, tc_world_s *world);
-void                                tc_worldupate_set_chunkloader_promise   (u32_t identifier, tc_chunkloader_s *chunkloader);
-void                                tc_worldupate_set_chunklist_promise     (u32_t identifier, tc_chunklist_s *chunklist);
-
-tc_world_updater_queue_s            tc_new_world_updater_queue
-    (u32_t capacity);
-
-void                                tc_worldupdater_execute_move_chunkloader    (tc_world_updater_command_s command);
-void                                tc_worldupdater_execute_place_block         (tc_world_updater_command_s command);
-void                                tc_worldupdater_execute_stop                (tc_world_updater_command_s command);
-void                                tc_worldupdater_execute_add_world           (tc_world_updater_command_s command);
-void                                tc_worldupdater_execute_add_chunkloader     (tc_world_updater_command_s command);
-void                                tc_worldupdater_execute_delete_chunkloader  (tc_world_updater_command_s command);
-void                                tc_worldupdater_execute_get_world           (tc_world_updater_command_s command);
-void                                tc_worldupdater_execute_get_chunkloader     (tc_world_updater_command_s command);
-void                                tc_worldupdater_execute_get_chunklist       (tc_world_updater_command_s command);
-
-#endif // TC_WORLD_UPDATER_INTERNAL_H
-

code/source-c/world/update/promise_reservation.c

@@ -1,217 +0,0 @@
-#include <world/update/world_update.h>
-
-#include <stddef.h>
-#include <stdlib.h>
-
-u32_t       tc_promise_identifier_counter           = 0;
-
-typedef struct
-{
-    u32_t                   identifier;
-    tc_world_s             *world;
-    
-} tc_worldupdate_world_promise_s;
-
-typedef struct
-{
-    u32_t                   identifier;
-    tc_chunkloader_s       *chunkloader;
-    
-} tc_worldupdate_chunkloader_promise_s;
-
-typedef struct
-{
-    u32_t                   identifier;
-    tc_chunklist_s          *chunklist;
-    
-} tc_worldupdate_chunklist_promise_s;
-
-tc_worldupdate_world_promise_s         *tc_worldupdate_worlds_promise_registry              = NULL;
-tc_worldupdate_chunkloader_promise_s   *tc_worldupdate_chunkloader_promise_registry         = NULL;
-tc_worldupdate_chunklist_promise_s     *tc_worldupdate_chunklist_promise_registry           = NULL;
-
-#define TC_WORLDUPDATE_PROMISE_REGISTRY_SIZE 4096
-
-void tc_worldupdate_initialize_promises()
-{
-    tc_worldupdate_worlds_promise_registry          = calloc(sizeof(tc_worldupdate_world_promise_s),        TC_WORLDUPDATE_PROMISE_REGISTRY_SIZE);
-    tc_worldupdate_chunkloader_promise_registry     = calloc(sizeof(tc_worldupdate_chunkloader_promise_s),  TC_WORLDUPDATE_PROMISE_REGISTRY_SIZE);
-    tc_worldupdate_chunklist_promise_registry       = calloc(sizeof(tc_worldupdate_chunklist_promise_s),    TC_WORLDUPDATE_PROMISE_REGISTRY_SIZE);
-}
-
-
-
-tc_promise_s tc_worldupdate_reserve_world_promise()
-{
-    u32_t       index       = 0;
-    while(index < TC_WORLDUPDATE_PROMISE_REGISTRY_SIZE)
-    {
-        tc_worldupdate_world_promise_s         *entry       = &tc_worldupdate_worlds_promise_registry[index];
-        if(entry->identifier == 0)
-            if(entry->world != NULL)
-            {
-                ++tc_promise_identifier_counter;
-                tc_promise_s        promise;
-                promise.identifier      = tc_promise_identifier_counter;
-                entry->identifier       = promise.identifier;
-                entry->world            = NULL;
-                
-                return promise;
-            }
-        
-        ++index;
-    }
-    tc_promise_s            promise;
-    promise.identifier          = 0;
-    promise.issueing_tick       = 0;
-    return promise;
-}
-
-tc_promise_s tc_worldupdate_reserve_chunkloader_promise()
-{
-    u32_t       index       = 0;
-    while(index < TC_WORLDUPDATE_PROMISE_REGISTRY_SIZE)
-    {
-        tc_worldupdate_chunkloader_promise_s         *entry       = &tc_worldupdate_chunkloader_promise_registry[index];
-        if(entry->identifier == 0)
-            if(entry->chunkloader != NULL)
-            {
-                ++tc_promise_identifier_counter;
-                tc_promise_s        promise;
-                promise.identifier      = tc_promise_identifier_counter;
-                entry->identifier       = promise.identifier;
-                entry->chunkloader      = NULL;
-                
-                return promise;
-            }
-        
-        ++index;
-    }
-    tc_promise_s            promise;
-    promise.identifier          = 0;
-    promise.issueing_tick       = 0;
-    return promise;
-}
-
-tc_promise_s tc_worldupdate_reserve_chunklist_promise()
-{
-    u32_t       index       = 0;
-    while(index < TC_WORLDUPDATE_PROMISE_REGISTRY_SIZE)
-    {
-        tc_worldupdate_chunklist_promise_s         *entry       = &tc_worldupdate_chunklist_promise_registry[index];
-        if(entry->identifier == 0)
-            if(entry->chunklist != NULL)
-            {
-                ++tc_promise_identifier_counter;
-                tc_promise_s        promise;
-                promise.identifier      = tc_promise_identifier_counter;
-                entry->identifier       = promise.identifier;
-                entry->chunklist        = NULL;
-                
-                return promise;
-            }
-        
-        ++index;
-    }
-    tc_promise_s            promise;
-    promise.identifier          = 0;
-    promise.issueing_tick       = 0;
-    return promise;
-}
-
-
-
-const tc_world_s * tc_worldupdate_claim_world_promise(tc_promise_s promise)
-{
-    u32_t       index       = 0;
-    while(index < TC_WORLDUPDATE_PROMISE_REGISTRY_SIZE)
-    {
-        tc_worldupdate_world_promise_s         *entry       = &tc_worldupdate_worlds_promise_registry[index];
-        if(entry->identifier == promise.identifier)
-            if(entry->world != NULL)
-            {
-                entry->identifier       = 0;
-                return entry->world;
-            }
-        
-        ++index;
-    }
-    return NULL;
-}
-
-const tc_chunkloader_s * tc_worldupdate_claim_chunkloader_promise(tc_promise_s promise)
-{
-    u32_t       index       = 0;
-    while(index < TC_WORLDUPDATE_PROMISE_REGISTRY_SIZE)
-    {
-        tc_worldupdate_chunkloader_promise_s   *entry       = &tc_worldupdate_chunkloader_promise_registry[index];
-        if(entry->identifier == promise.identifier)
-            if(entry->chunkloader != NULL)
-            {
-                entry->identifier       = 0;
-                return entry->chunkloader;
-            }
-        
-        ++index;
-    }
-    return NULL;
-}
-
-const tc_chunklist_s * tc_worldupdate_claim_chunks_promise(tc_promise_s promise)
-{
-    u32_t       index       = 0;
-    while(index < TC_WORLDUPDATE_PROMISE_REGISTRY_SIZE)
-    {
-        tc_worldupdate_chunklist_promise_s     *entry       = &tc_worldupdate_chunklist_promise_registry[index];
-        if(entry->identifier == promise.identifier)
-            if(entry->chunklist != NULL)
-            {
-                entry->identifier       = 0;
-                return entry->chunklist;
-            }
-        
-        ++index;
-    }
-    return NULL;
-}
-
-
-
-void tc_worldupate_set_world_promise(u32_t identifier, tc_world_s *world)
-{
-    u32_t       index       = 0;
-    while(index < TC_WORLDUPDATE_PROMISE_REGISTRY_SIZE)
-    {
-        tc_worldupdate_world_promise_s   *entry       = &tc_worldupdate_worlds_promise_registry[index];
-        if(entry->identifier == identifier)
-            entry->world = world;
-        
-        ++index;
-    }
-}
-
-void tc_worldupate_set_chunkloader_promise(u32_t identifier, tc_chunkloader_s *chunkloader)
-{u32_t       index       = 0;
-    while(index < TC_WORLDUPDATE_PROMISE_REGISTRY_SIZE)
-    {
-        tc_worldupdate_chunkloader_promise_s   *entry       = &tc_worldupdate_chunkloader_promise_registry[index];
-        if(entry->identifier == identifier)
-            entry->chunkloader = chunkloader;
-        
-        ++index;
-    }
-}
-
-void tc_worldupate_set_chunklist_promise(u32_t identifier, tc_chunklist_s *chunklist)
-{
-    u32_t       index       = 0;
-    while(index < TC_WORLDUPDATE_PROMISE_REGISTRY_SIZE)
-    {
-        tc_worldupdate_chunklist_promise_s   *entry       = &tc_worldupdate_chunklist_promise_registry[index];
-        if(entry->identifier == identifier)
-            entry->chunklist = chunklist;
-        
-        ++index;
-    }
-}
-

code/source-c/world/update/queue.c

@@ -1,76 +0,0 @@
-#include <world/update/internal.h>
-
-#include <stddef.h>
-#include <stdlib.h>
-#include <string.h>
-
-tc_world_updater_queue_s tc_new_world_updater_queue(u32_t capacity)
-{
-    tc_world_updater_queue_s queue;
-    queue.capacity              = capacity;
-    queue.commands              = calloc(sizeof(tc_world_updater_command_s), capacity);
-    queue.first                 = NULL;
-    queue.last                  = NULL;
-    queue.in_action             = FALSE;
-    
-    return queue;
-}
-
-// tc_allocate_world_updater_command: Returns a pointer to a command-slot in the given queue.
-//  Sub-function of tc_issue_world_updater_command
-tc_world_updater_command_s * tc_allocate_world_updater_command(tc_world_updater_queue_s *queue)
-{
-    u32_t                           command_index       = 0;
-    while(command_index < queue->capacity)
-    {
-        if(!queue->commands[command_index].is_used)
-            return &queue->commands[command_index];
-        
-        ++command_index;
-    }
-    return NULL;
-}
-
-bool_t tc_issue_world_updater_command(tc_world_updater_queue_s *queue, tc_world_updater_command_s command)
-{
-    while(queue->in_action) continue;
-    queue->in_action            = TRUE;
-    
-    tc_world_updater_command_s     *queue_command       = tc_allocate_world_updater_command(queue);
-    if(queue_command == NULL) return FALSE;
-    
-    command.is_used             = TRUE;
-    (*queue_command)            = command;
-    queue_command->previous     = queue->last;
-    queue_command->next         = NULL;
-    
-    if(queue->last != NULL) queue->last->next = queue_command;
-    if(queue->first == NULL) queue->first = queue_command;
-    queue->last                 = queue_command;
-    
-    queue->in_action            = FALSE;
-    
-    return TRUE;
-}
-
-tc_world_updater_command_s tc_world_updater_query_next_command(tc_world_updater_queue_s *queue)
-{
-    while(queue->in_action) continue;
-    queue->in_action            = TRUE;
-    
-    tc_world_updater_command_s     *queue_command       = queue->first;
-    tc_world_updater_command_s      command;
-    memset(&command, 0x00, sizeof(tc_world_updater_command_s));
-    
-    if(queue_command != NULL)
-    {
-        command              = *queue_command;
-        
-        queue_command->is_used      = FALSE;
-    }
-    queue->in_action            = FALSE;
-    
-    return command;
-}
-
-

code/source-c/world/update/respond.c

@@ -1,65 +0,0 @@
-#include <world/update/internal.h>
-
-void tc_worldupdater_execute_move_chunkloader(tc_world_updater_command_s command)
-{
-    
-    
-    
-}
-
-void tc_worldupdater_execute_place_block(tc_world_updater_command_s command)
-{
-    
-    
-    
-}
-
-void tc_worldupdater_execute_stop(tc_world_updater_command_s command)
-{
-    
-    
-    
-}
-
-void tc_worldupdater_execute_add_world(tc_world_updater_command_s command)
-{
-    
-    
-    
-}
-
-void tc_worldupdater_execute_add_chunkloader(tc_world_updater_command_s command)
-{
-    
-    
-    
-}
-
-void tc_worldupdater_execute_delete_chunkloader(tc_world_updater_command_s command)
-{
-    
-    
-    
-}
-
-void tc_worldupdater_execute_get_world(tc_world_updater_command_s command)
-{
-    
-    
-    
-}
-
-void tc_worldupdater_execute_get_chunkloader(tc_world_updater_command_s command)
-{
-    
-    
-    
-}
-
-void tc_worldupdater_execute_get_chunklist(tc_world_updater_command_s command)
-{
-    
-    
-    
-}
-

code/source-c/world/update/world_configuration.h

@@ -1,16 +0,0 @@
-
-#ifndef TC_WORLD_CONFIGURATION_H
-#define TC_WORLD_CONFIGURATION_H
-
-#include <world/world.h>
-#include <world/chunk.h>
-#include <utility/location.h>
-#include <utility/promise.h>
-
-void                        tc_activate_world               (u32_t identifier);
-void                        tc_deactivate_world             (u32_t identifier);
-
-void                        tc_update_world                 (u32_t identifier);
-
-#endif TC_WORLD_CONFIGURATION_H
-

code/source-c/world/update/world_update.c

@@ -1,212 +0,0 @@
-#include <world/update/world_update.h>
-#include <world/update/internal.h>
-
-typedef struct tc_world_registry
-{
-    u32_t                       worlds_capacity;
-    u32_t                       num_worlds;
-    tc_world_s                 *worlds;
-    
-} tc_world_registry_s;
-
-typedef struct tc_world_updater
-{
-    bool_t                      running;
-    tc_world_updater_queue_s    queue;
-    tc_world_registry_s         world_registry;
-    
-    SDL_Thread                 *sdl_thread;
-    
-} tc_world_updater_s;
-
-tc_world_updater_s             *tc_world_updater_g          = NULL;
-
-#define TICKS_PER_SECOND 2
-#define WORLD_UPDATES_PER_SECOND 0.5
-
-void tc_update_all_worlds(tc_world_registry_s *registry)
-{
-    for(u32_t world_index = 0; world_index < registry->num_worlds; ++world_index)
-    {
-        tc_world_s                 *world               = &registry->worlds[world_index];
-        tc_update_world(world);
-    }
-}
-
-void tc_world_updater_run(void *data)
-{
-    u64_t                           tick_at_start   = 0;
-    
-    u64_t                           world_update_count      = 0;
-    
-    tc_world_updater_s             *updater         = data;
-    updater->running                    = TRUE;
-    while(updater->running)
-    {
-        tick_at_start                   = SDL_GetTicks();
-        
-        if((tick_at_start / WORLD_UPDATES_PER_SECOND) == world_update_count)
-        {
-            
-            ++world_update_count;
-        }
-        
-        if(tc_world_updater_g->queue.in_action)
-        {
-            while(tc_world_updater_g->queue.in_action) continue;
-        }
-        
-        tc_world_updater_command_s      command =
-            tc_world_updater_query_next_command(&tc_world_updater_g->queue);
-        
-        switch(command.type)
-        {
-            case TC_WORLD_UPDATER_COMMAND_UNKNOWN: break;
-            case TC_WORLD_UPDATER_COMMAND_MOVE_CHUNKLOADER:         tc_worldupdater_execute_move_chunkloader(command);
-            case TC_WORLD_UPDATER_COMMAND_PLACE_BLOCK:              tc_worldupdater_execute_place_block(command);
-            case TC_WORLD_UPDATER_COMMAND_STOP:                     tc_worldupdater_execute_stop(command);
-            case TC_WORLD_UPDATER_COMMAND_ADD_WORLD:                tc_worldupdater_execute_add_world(command);
-            case TC_WORLD_UPDATER_COMMAND_ADD_CHUNKLOADER:          tc_worldupdater_execute_add_chunkloader(command);
-            case TC_WORLD_UPDATER_COMMAND_DELETE_CHUNKLOADER:       tc_worldupdater_execute_delete_chunkloader(command);
-            case TC_WORLD_UPDATER_COMMAND_GET_WORLD:                tc_worldupdater_execute_get_world(command);
-            case TC_WORLD_UPDATER_COMMAND_GET_CHUNKLOADER:          tc_worldupdater_execute_get_chunkloader(command);
-            case TC_WORLD_UPDATER_COMMAND_GET_CHUNKLIST:            tc_worldupdater_execute_get_chunklist(command);
-        }
-        
-        u64_t                           tick_at_end             = SDL_GetTicks();
-        
-        
-        
-        SDL_Delay((1000 / TICKS_PER_SECOND) - (tick_at_end - tick_at_start));
-    }
-}
-
-tc_world_registry_s tc_new_world_registry()
-{
-    tc_world_registry_s             registry;
-    registry.num_worlds                 = 0;
-    registry.worlds_capacity            = 64;
-    registry.worlds                     = calloc(sizeof(tc_world_s), registry.worlds_capacity);
-    
-    return registry;
-}
-
-void tc_start_world_updater()
-{
-    tc_worldupdate_initialize_promises(4096);
-    
-    tc_world_updater_g                  = malloc(sizeof(tc_world_updater_s));
-    tc_world_updater_g->world_registry  = tc_new_world_registry();
-    tc_world_updater_g->sdl_thread      = SDL_CreateThread((SDL_ThreadFunction) &tc_world_updater_run, "w_update", &tc_world_updater_g);
-    tc_world_updater_g->queue           = tc_new_world_updater_queue(4096);
-    
-    SDL_DetachThread(tc_world_updater_g->sdl_thread);
-}
-
-tc_promise_s tc_worldupdate_register_world()
-{
-    tc_promise_s        promise             = tc_worldupdate_reserve_world_promise();
-    
-    
-    return promise;
-}
-
-tc_promise_s tc_worldupdate_add_chunkloader()
-{
-    tc_promise_s                    promise         = tc_worldupdate_reserve_chunkloader_promise();
-    tc_world_updater_command_s      command;
-    command.type                        = TC_WORLD_UPDATER_COMMAND_ADD_CHUNKLOADER;
-    tc_issue_world_updater_command(&tc_world_updater_g->queue, command);
-    
-    return promise;
-}
-
-void tc_worldupdate_delete_chunkloader(u32_t loader_id)
-{
-    tc_world_updater_command_s      command;
-    command.type                        = TC_WORLD_UPDATER_COMMAND_DELETE_CHUNKLOADER;
-    command.specific.get_item.index     = loader_id;
-    
-    tc_issue_world_updater_command(&tc_world_updater_g->queue, command);
-}
-
-u32_t tc_worldupdate_get_chunkloader_count_of_world(u32_t world_id)
-{
-    return 0; // TODO
-}
-
-u32_t tc_worldupdate_get_world_count()
-{
-    return 0; // TODO
-}
-
-tc_promise_s tc_worldupdate_get_world(u32_t index)
-{
-    tc_promise_s                    promise         = tc_worldupdate_reserve_world_promise();
-    tc_world_updater_command_s      command;
-    command.type                        = TC_WORLD_UPDATER_COMMAND_GET_WORLD;
-    command.specific.get_item.index     = index;
-    command.specific.get_item.promise   = promise.identifier;
-    
-    tc_issue_world_updater_command(&tc_world_updater_g->queue, command);
-    
-    return promise;
-}
-
-
-tc_promise_s tc_worldupdate_get_chunkloader_of_world(u32_t world_id, u32_t index)
-{
-    tc_promise_s                    promise         = tc_worldupdate_reserve_chunkloader_promise();
-    tc_world_updater_command_s      command;
-    command.type                        = TC_WORLD_UPDATER_COMMAND_GET_CHUNKLOADER;
-    command.specific.get_item.index     = index;
-    command.specific.get_item.promise   = promise.identifier;
-    
-    tc_issue_world_updater_command(&tc_world_updater_g->queue, command);
-    
-    return promise;
-}
-
-tc_promise_s tc_worldupdate_get_chunks_of_chunkloader(u32_t loader_id)
-{
-    tc_promise_s                    promise         = tc_worldupdate_reserve_chunklist_promise();
-    tc_world_updater_command_s      command;
-    command.type                        = TC_WORLD_UPDATER_COMMAND_GET_CHUNKLIST;
-    command.specific.get_item.index     = loader_id;
-    command.specific.get_item.promise   = promise.identifier;
-    
-    tc_issue_world_updater_command(&tc_world_updater_g->queue, command);
-    
-    return promise;
-}
-
-
-
-void tc_worldupdate_move_chunkloader_to(u32_t loader_id, tc_chunk_location_s location)
-{
-    tc_world_updater_command_s      command;
-    command.type                                    = TC_WORLD_UPDATER_COMMAND_MOVE_CHUNKLOADER;
-    command.specific.move_chunkloader.loader_id     = loader_id;
-    command.specific.move_chunkloader.new_location  = location;
-    
-    tc_issue_world_updater_command(&tc_world_updater_g->queue, command);
-}
-
-void tc_worldupdate_place_block(tc_block_location_s location, tc_block_s block)
-{
-    tc_world_updater_command_s      command;
-    command.type                                    = TC_WORLD_UPDATER_COMMAND_PLACE_BLOCK;
-    command.specific.place_block.location           = location;
-    command.specific.place_block.block              = block;
-    
-    tc_issue_world_updater_command(&tc_world_updater_g->queue, command);
-}
-
-void tc_worldupdate_stop()
-{
-    tc_world_updater_command_s      command;
-    command.type                        = TC_WORLD_UPDATER_COMMAND_STOP;
-    
-    tc_issue_world_updater_command(&tc_world_updater_g->queue, command);
-}
-

code/source-c/world/update/world_update.h

@@ -1,36 +0,0 @@
-
-#ifndef TC_WORLD_UPDATE_H
-#define TC_WORLD_UPDATE_H
-
-#include <SDL2/SDL.h>
-
-#include <world/world.h>
-#include <world/chunk.h>
-#include <utility/location.h>
-#include <utility/promise.h>
-
-void                        tc_start_world_updater                          ();
-
-tc_promise_s                tc_worldupdate_register_world                   ();
-void                        tc_worldupdate_remove_world                     (u32_t world_id);
-
-tc_promise_s                tc_worldupdate_add_chunkloader                  ();
-void                        tc_worldupdate_delete_chunkloader               (u32_t loader_id);
-
-u32_t                       tc_worldupdate_get_world_count                  ();
-tc_promise_s                tc_worldupdate_get_world                        (u32_t index);
-
-u32_t                       tc_worldupdate_get_chunkloader_count_of_world   (u32_t world_id);
-tc_promise_s                tc_worldupdate_get_chunkloader_of_world         (u32_t world_id, u32_t index);
-tc_promise_s                tc_worldupdate_get_chunks_of_chunkloader        (u32_t loader_id);
-
-void                        tc_worldupdate_move_chunkloader_to              (u32_t loader_id, tc_chunk_location_s location);
-void                        tc_worldupdate_place_block                      (tc_block_location_s location, tc_block_s block);
-void                        tc_worldupdate_stop                             ();
-
-const tc_world_s *          tc_worldupdate_claim_world_promise              (tc_promise_s promise);
-const tc_chunkloader_s *    tc_worldupdate_claim_chunkloader_promise        (tc_promise_s promise);
-const tc_chunklist_s *      tc_worldupdate_claim_chunks_promise             (tc_promise_s promise);
-
-#endif
-

code/source-c/world_physics.c

@@ -1,11 +1,9 @@
-#include <world/world.h>
+#include <world.h>
-
 #include <stddef.h> // For NULL
 #include <stdio.h>
 
 void tc_initialize_chunk_physics(tc_entity_s *chunk_entity, void *userdata)
 {
-    
     tc_chunk_s                     *chunk               = chunk_entity->specific;
     tc_world_s                     *world               = chunk->location.world;
     tc_physics_simulation_s        *simulation          = world->physics;
@@ -43,19 +41,10 @@ void tc_initialize_chunk_physics(tc_entity_s *chunk_entity, void *userdata)
     tc_set_pointer_for_entity(chunk_entity, "physics_body", chunk_body);
 }
 
-void tc_free_chunk_physics(tc_entity_s *chunk_entity, void *userdata)
-{
-    tc_physics_entity_s            *body                =
-        tc_get_pointer_from_entity(chunk_entity, "physics_body");
-    
-    tc_remove_physics_entity(body);
-}
-
 void tc_create_world_physics(tc_world_s *world, void *userdata)
 {
     world->physics              = tc_new_physics_simulation();
     tc_add_to_hooklist(&world->on_chunk_create, (tc_fn_hook) tc_initialize_chunk_physics, NULL);
-    // tc_add_to_hooklist(&world->on_chunk_update, (tc_fn_hook) tc_initialize_chunk_physics, NULL);
+    tc_add_to_hooklist(&world->on_chunk_update, (tc_fn_hook) tc_initialize_chunk_physics, NULL);
-    tc_add_to_hooklist(&world->on_chunk_delete, (tc_fn_hook) tc_free_chunk_physics, NULL);
 }