Add shovel

diff --git a/meshes/shovel.gox b/meshes/shovel.gox
new file mode 100644 (file)
index 0000000..76d6155
Binary files /dev/null and b/meshes/shovel.gox differ

diff --git a/meshes/shovel.txt b/meshes/shovel.txt
new file mode 100644 (file)
index 0000000..808bc2a
--- /dev/null
+++ b/meshes/shovel.txt
@@ -0,0 +1,22 @@
+# Goxel 0.10.6
+# One line per voxel
+# X Y Z RRGGBB
+0 0 0 503612
+0 0 1 503612
+0 0 2 584120
+0 0 3 43351e
+0 0 4 503612
+0 0 5 503612
+0 0 6 4a3312
+0 0 7 5c421a
+0 0 8 5a380e
+0 0 9 959595
+1 0 9 a0a0a0
+0 0 10 959595
+1 0 10 959595
+0 0 11 7e7e7e
+1 0 11 a0a0a0
+0 0 12 a0a0a0
+-1 0 9 7e7e7e
+-1 0 10 959595
+-1 0 11 959595

diff --git a/src/client/client_entity.c b/src/client/client_entity.c
index 6415cece8503c0124aa834871527272fc3dc5a0a..806d519c3681678f1f1c6dda2eca0c9b13c81a8d 100644 (file)
--- a/src/client/client_entity.c
+++ b/src/client/client_entity.c
@@ -167,15 +167,15 @@ void client_entity_deinit()
 
 bool client_entity_gfx_init()
 {
-       char *shader_defs;
-       asprintf(&shader_defs, "#define VIEW_DISTANCE %lf\n", client_config.view_distance);
+       char *shader_def;
+       asprintf(&shader_def, "#define VIEW_DISTANCE %lf\n", client_config.view_distance);
 
-       if (!shader_program_create(RESSOURCE_PATH "shaders/3d/entity", &shader_prog, shader_defs)) {
+       if (!shader_program_create(RESSOURCE_PATH "shaders/3d/entity", &shader_prog, shader_def)) {
                fprintf(stderr, "[error] failed to create entity shader program\n");
                return false;
        }
 
-       free(shader_defs);
+       free(shader_def);
 
        loc_VP = glGetUniformLocation(shader_prog, "VP"); GL_DEBUG
        loc_depthOffset = glGetUniformLocation(shader_prog, "depthOffset"); GL_DEBUG

diff --git a/src/client/client_inventory.c b/src/client/client_inventory.c
index a48e3a7df528ec3c911a0dcd988367251c2a1587..9c888370ce50c9cfe9f5e250b141ab164e5550b4 100644 (file)
--- a/src/client/client_inventory.c
+++ b/src/client/client_inventory.c
@@ -17,15 +17,15 @@ static LightShader _3d_light_shader;
 
 bool client_inventory_init()
 {
-       char *_3d_shader_defs;
-       asprintf(&_3d_shader_defs, "#define VIEW_DISTANCE %lf\n", client_config.view_distance);
+       char *_3d_shader_def;
+       asprintf(&_3d_shader_def, "#define VIEW_DISTANCE %lf\n", client_config.view_distance);
 
-       if (!shader_program_create(RESSOURCE_PATH "shaders/3d/item", &_3d_shader_prog, _3d_shader_defs)) {
+       if (!shader_program_create(RESSOURCE_PATH "shaders/3d/item", &_3d_shader_prog, _3d_shader_def)) {
                fprintf(stderr, "[error] failed to create 3D item shader program\n");
                return false;
        }
 
-       free(_3d_shader_defs);
+       free(_3d_shader_def);
 
        _3d_loc_VP = glGetUniformLocation(_3d_shader_prog, "VP");
        _3d_loc_depthOffset = glGetUniformLocation(_3d_shader_prog, "depthOffset");

diff --git a/src/client/client_item.c b/src/client/client_item.c
index 3e6d47b4cb0cc513d5ff5accc9456cf9dd0ce4c1..5685cbf604706dd63831e0a155b3cd6a56f374fa 100644 (file)
--- a/src/client/client_item.c
+++ b/src/client/client_item.c
@@ -5,10 +5,10 @@
 static bool use_dig(__attribute__((unused)) ItemStack *stack)
 {
        return interact_pointed.exists
-               && (node_defs[interact_pointed.node].dig_class & item_defs[stack->type].dig_class);
+               && (node_def[interact_pointed.node].dig_class & item_def[stack->type].dig_class);
 }
 
-ClientItemDef client_item_defs[COUNT_ITEM] = {
+ClientItemDef client_item_def[COUNT_ITEM] = {
        // unknown
        {
                .mesh_path = RESSOURCE_PATH "meshes/unknown.txt",
@@ -33,23 +33,29 @@ ClientItemDef client_item_defs[COUNT_ITEM] = {
                .mesh = {0},
                .use = &use_dig,
        },
+       // shovel
+       {
+               .mesh_path = RESSOURCE_PATH "meshes/shovel.txt",
+               .mesh = {0},
+               .use = &use_dig,
+       },
 };
 
 void client_item_init()
 {
        for (ItemType i = 0; i < COUNT_ITEM; i++)
-               if (client_item_defs[i].mesh_path)
-                       mesh_load(&client_item_defs[i].mesh, client_item_defs[i].mesh_path);
+               if (client_item_def[i].mesh_path)
+                       mesh_load(&client_item_def[i].mesh, client_item_def[i].mesh_path);
 }
 
 void client_item_deinit()
 {
        for (ItemType i = 0; i < COUNT_ITEM; i++)
-               if (client_item_defs[i].mesh_path)
-                       mesh_destroy(&client_item_defs[i].mesh);
+               if (client_item_def[i].mesh_path)
+                       mesh_destroy(&client_item_def[i].mesh);
 }
 
 Mesh *client_item_mesh(ItemType type)
 {
-       return client_item_defs[type].mesh_path ? &client_item_defs[type].mesh : NULL;
+       return client_item_def[type].mesh_path ? &client_item_def[type].mesh : NULL;
 }

diff --git a/src/client/client_item.h b/src/client/client_item.h
index bffb251585baa0c72fc22ebb9d34c53895a46af4..cbd633462af027da739d48a1a5d8d203a28b5fba 100644 (file)
--- a/src/client/client_item.h
+++ b/src/client/client_item.h
@@ -12,7 +12,7 @@ typedef struct {
        bool (*use)(ItemStack *stack);
 } ClientItemDef;
 
-extern ClientItemDef client_item_defs[];
+extern ClientItemDef client_item_def[];
 
 void client_item_init();
 void client_item_deinit();

diff --git a/src/client/client_node.c b/src/client/client_node.c
index 56c646e3757f711cb0ff16d47f32f92bb6f59c00..5285c53985b982625c364392d595935811f69a6e 100644 (file)
--- a/src/client/client_node.c
+++ b/src/client/client_node.c
@@ -38,7 +38,7 @@ static void render_color(NodeArgsRender *args)
        args->vertex.color = ((ColorData *) args->node->data)->color;
 }
 
-ClientNodeDef client_node_defs[NODE_UNLOADED] = {
+ClientNodeDef client_node_def[NODE_UNLOADED] = {
        // unknown
        {
                .tiles = TILES_SIMPLE(RESSOURCE_PATH "textures/unknown.png"),
@@ -216,7 +216,7 @@ ClientNodeDef client_node_defs[NODE_UNLOADED] = {
 void client_node_init()
 {
        for (NodeType node = 0; node < NODE_UNLOADED; node++) {
-               ClientNodeDef *def = &client_node_defs[node];
+               ClientNodeDef *def = &client_node_def[node];
 
                if (def->visibility != VISIBILITY_NONE) {
                        Texture *textures[6];

diff --git a/src/client/client_node.h b/src/client/client_node.h
index 57ae62567f4e4beb826ed1805d5daf393d6e0b34..6f23c872b10d2250d5a74662f4cd32962a52caec 100644 (file)
--- a/src/client/client_node.h
+++ b/src/client/client_node.h
@@ -33,7 +33,7 @@ typedef struct {
        char *name;
 } ClientNodeDef;
 
-extern ClientNodeDef client_node_defs[];
+extern ClientNodeDef client_node_def[];
 void client_node_init();
 
 #endif // _CLIENT_NODE_H_

diff --git a/src/client/client_terrain.c b/src/client/client_terrain.c
index 9a3e52f78545a2171cfde8a61d528fd5769ffbb0..2e33b87532e4fd0917f9a8deaf60b1be8bb39652 100644 (file)
--- a/src/client/client_terrain.c
+++ b/src/client/client_terrain.c
@@ -267,9 +267,8 @@ void client_terrain_chunk_received(TerrainChunk *chunk)
        if (meta->state == CHUNK_RECIEVING)
                meta->state = CHUNK_FRESH;
 
-       pthread_mutex_unlock(&chunk->mtx);
-
        client_terrain_meshgen_task(chunk, true);
+       pthread_mutex_unlock(&chunk->mtx);
 
        for (int i = 0; i < 6; i++) {
                TerrainChunk *neighbor = terrain_get_chunk(client_terrain,

diff --git a/src/client/debug_menu.c b/src/client/debug_menu.c
index e3f1a9c2f30edd1d8db30be05e87a2349f911fb5..ddf36c41c2ebf5d13f12071b24a410b1f03f70e6 100644 (file)
--- a/src/client/debug_menu.c
+++ b/src/client/debug_menu.c
@@ -62,7 +62,7 @@ static char *get_entry_text(DebugMenuEntry entry)
                        if (!pnt->exists)
                                return strdup("");
 
-                       pnt_name = client_node_defs[pnt->node].name;
+                       pnt_name = client_node_def[pnt->node].name;
                        break;
 
                case ENTRY_FLIGHT:

diff --git a/src/client/gui.c b/src/client/gui.c
index 05f4fb79df078f15957dcd0fd70697525e5b9ee3..fbe7b9f81bf332372f33dc77e333647d002bce3a 100644 (file)
--- a/src/client/gui.c
+++ b/src/client/gui.c
@@ -88,7 +88,7 @@ static void scale_element(GUIElement *element);
 
 static int cmp_element(const GUIElement *ea, const GUIElement *eb)
 {
-       return f32_cmp(&ea->def.z_index, &eb->def.z_index);
+       return -f32_cmp(&ea->def.z_index, &eb->def.z_index);
 }
 
 static void delete_elements(Array *elements)

diff --git a/src/client/interact.c b/src/client/interact.c
index 9aba87b07c5515281cb0657b84318fc0f72b0080..8048080bff2f7b222ebce3199f5e9b97179d6adc 100644 (file)
--- a/src/client/interact.c
+++ b/src/client/interact.c
@@ -93,7 +93,7 @@ void interact_tick()
                        && !v3s32_equals(interact_pointed.pos, old_pointed)) {
                mat4x4_translate(model,
                        interact_pointed.pos.x, interact_pointed.pos.y, interact_pointed.pos.z);
-               v3f32 *color = &client_node_defs[interact_pointed.node].selection_color;
+               v3f32 *color = &client_node_def[interact_pointed.node].selection_color;
                glProgramUniform3f(shader_prog, loc_color, color->x, color->y, color->z); GL_DEBUG
                debug_menu_changed(ENTRY_POINTED);
        }
@@ -125,7 +125,7 @@ void interact_use(bool left)
        pthread_mutex_lock(&data->mtx_inv);
 
        ItemStack *stack = left ? &data->inventory.left : &data->inventory.right;
-       if (client_item_defs[stack->type].use && client_item_defs[stack->type].use(stack))
+       if (client_item_def[stack->type].use && client_item_def[stack->type].use(stack))
                dragonnet_peer_send_ToServerInteract(client, &(ToServerInteract) {
                        .left = left,
                        .pointed = interact_pointed.exists,

diff --git a/src/client/raycast.c b/src/client/raycast.c
index c1f4a93a385a8ceefbfd02c7b040f4800155534f..d836bdefe03208fcce7362a64daca188b93c34ca 100644 (file)
--- a/src/client/raycast.c
+++ b/src/client/raycast.c
@@ -14,7 +14,7 @@ bool raycast(v3f64 pos, v3f64 dir, f64 len, v3s32 *node_pos, NodeType *node)
                if (*node == NODE_UNLOADED)
                        return false;
 
-               if (client_node_defs[*node].pointable)
+               if (client_node_def[*node].pointable)
                        return true;
 
                f64 vpos[3] = {pos.x, pos.y, pos.z};

diff --git a/src/client/shader.c b/src/client/shader.c
index 1a542715ee53c84ae4c385236e8c5c869af5d13b..632106c04e5f689973f315a640a873dac9020d8b 100644 (file)
--- a/src/client/shader.c
+++ b/src/client/shader.c
@@ -5,7 +5,7 @@
 #include "client/gl_debug.h"
 #include "client/shader.h"
 
-static GLuint compile_shader(GLenum type, const char *path, const char *name, GLuint program, const char *defs)
+static GLuint compile_shader(GLenum type, const char *path, const char *name, GLuint program, const char *def)
 {
        char full_path[strlen(path) + 1 + strlen(name) + 1 + 4 + 1];
        sprintf(full_path, "%s/%s.glsl", path, name);
@@ -53,13 +53,13 @@ static GLuint compile_shader(GLenum type, const char *path, const char *name, GL
 
        const char *code_list[3] = {
                version,
-               defs,
+               def,
                code,
        };
 
        int size_list[3] = {
                18,
-               strlen(defs),
+               strlen(def),
                size,
        };
 
@@ -82,21 +82,21 @@ static GLuint compile_shader(GLenum type, const char *path, const char *name, GL
        return id;
 }
 
-bool shader_program_create(const char *path, GLuint *idptr, const char *defs)
+bool shader_program_create(const char *path, GLuint *idptr, const char *def)
 {
        GLuint id = glCreateProgram(); GL_DEBUG
 
-       if (!defs)
-               defs = "";
+       if (!def)
+               def = "";
 
        GLuint vert, frag;
 
-       if (!(vert = compile_shader(GL_VERTEX_SHADER, path, "vertex", id, defs))) {
+       if (!(vert = compile_shader(GL_VERTEX_SHADER, path, "vertex", id, def))) {
                glDeleteProgram(id); GL_DEBUG
                return false;
        }
 
-       if (!(frag = compile_shader(GL_FRAGMENT_SHADER, path, "fragment", id, defs))) {
+       if (!(frag = compile_shader(GL_FRAGMENT_SHADER, path, "fragment", id, def))) {
                glDeleteShader(vert); GL_DEBUG
                glDeleteProgram(id); GL_DEBUG
                return false;

diff --git a/src/client/shader.h b/src/client/shader.h
index b53b604995d90e83ddf5b61e8de269d1ced41c58..490a7fc8e8b8f47dff1ea0a97f37b523e31498da 100644 (file)
--- a/src/client/shader.h
+++ b/src/client/shader.h
@@ -5,6 +5,6 @@
 #include <GL/gl.h>
 #include <stdbool.h>
 
-bool shader_program_create(const char *path, GLuint *idptr, const char *defs);
+bool shader_program_create(const char *path, GLuint *idptr, const char *def);
 
 #endif // _SHADER_H_

diff --git a/src/client/terrain_gfx.c b/src/client/terrain_gfx.c
index 32380e423f892f280dbbb3ef7ce27dd77074f61a..0883d631fbca61838cc91b50d1bb48bb1b4bf7a2 100644 (file)
--- a/src/client/terrain_gfx.c
+++ b/src/client/terrain_gfx.c
@@ -52,7 +52,7 @@ static ModelShader model_shader;
 
 static inline bool show_face(NodeType self, NodeType nbr)
 {
-       switch (client_node_defs[self].visibility) {
+       switch (client_node_def[self].visibility) {
                case VISIBILITY_CLIP:
                        return true;
 
@@ -60,7 +60,7 @@ static inline bool show_face(NodeType self, NodeType nbr)
                        return nbr != self;
 
                case VISIBILITY_SOLID:
-                       return nbr != NODE_UNLOADED && client_node_defs[nbr].visibility != VISIBILITY_SOLID;
+                       return nbr != NODE_UNLOADED && client_node_def[nbr].visibility != VISIBILITY_SOLID;
 
                default: // impossible
                        break;
@@ -76,7 +76,7 @@ static inline void render_node(ChunkRenderData *data, v3s32 offset)
 
        args.node = &data->chunk->data[offset.x][offset.y][offset.z];
 
-       ClientNodeDef *def = &client_node_defs[args.node->type];
+       ClientNodeDef *def = &client_node_def[args.node->type];
        if (def->visibility == VISIBILITY_NONE)
                return;
 
@@ -179,6 +179,10 @@ static Model *create_chunk_model(TerrainChunk *chunk, bool animate, bool *depend
        CHUNK_ITERATE
                render_node(&data, (v3s32) {x, y, z});
 
+       for (int i = 0; i < 6; i++)
+               if (data.nbrs[i])
+                       depends[i] = true;
+
        if (!data.visible || (!data.batch->textures.siz && !data.batch_transparent->textures.siz)) {
                model_batch_free(data.batch);
                model_batch_free(data.batch_transparent);
@@ -208,10 +212,6 @@ static Model *create_chunk_model(TerrainChunk *chunk, bool animate, bool *depend
                model_batch_free(data.batch_transparent);
        }
 
-       for (int i = 0; i < 6; i++)
-               if (data.nbrs[i])
-                       data.tried_nbrs[i] = true;
-
        return model;
 }
 
@@ -220,20 +220,20 @@ bool terrain_gfx_init()
        GLint texture_units;
        glGetIntegerv(GL_MAX_TEXTURE_UNITS, &texture_units); GL_DEBUG
 
-       char *shader_defs;
-       asprintf(&shader_defs,
+       char *shader_def;
+       asprintf(&shader_def,
                "#define MAX_TEXTURE_UNITS %d\n"
                "#define VIEW_DISTANCE %lf\n",
                texture_units,
                client_config.view_distance
        );
 
-       if (!shader_program_create(RESSOURCE_PATH "shaders/3d/terrain", &shader_prog, shader_defs)) {
+       if (!shader_program_create(RESSOURCE_PATH "shaders/3d/terrain", &shader_prog, shader_def)) {
                fprintf(stderr, "[error] failed to create terrain shader program\n");
                return false;
        }
 
-       free(shader_defs);
+       free(shader_def);
 
        loc_VP = glGetUniformLocation(shader_prog, "VP"); GL_DEBUG
 

diff --git a/src/dig.h b/src/dig.h
index d12d63e99469d52d3abee16e7d99edb3084f586e..3885ae43bb652a73e61e3dff9df1bee9590a29b6 100644 (file)
--- a/src/dig.h
+++ b/src/dig.h
@@ -6,6 +6,7 @@ typedef enum {
        DIG_STONE = 0x01,
        DIG_WOOD = 0x02,
        DIG_DIRT = 0x04,
+       DIG_LEAVES = 0x08,
 } DigClass;
 
 #endif // _DIG_H_

diff --git a/src/item.c b/src/item.c
index 51beaf8ac2d3e7fd46df3521cf8273c9cb8d0dd4..b492aa95b7bec3d33487977147fe497d61154217 100644 (file)
--- a/src/item.c
+++ b/src/item.c
@@ -7,14 +7,14 @@ void item_stack_initialize(ItemStack *stack)
        stack->count = 1;
        stack->data = NULL;
 
-       if (item_defs[stack->type].callbacks.create)
-               item_defs[stack->type].callbacks.create(stack);
+       if (item_def[stack->type].callbacks.create)
+               item_def[stack->type].callbacks.create(stack);
 }
 
 void item_stack_destroy(ItemStack *stack)
 {
-       if (item_defs[stack->type].callbacks.delete)
-               item_defs[stack->type].callbacks.delete(stack);
+       if (item_def[stack->type].callbacks.delete)
+               item_def[stack->type].callbacks.delete(stack);
 
        if (stack->data) {
                free(stack->data);
@@ -28,14 +28,14 @@ void item_stack_set(ItemStack *stack, ItemType type, u32 count, Blob buffer)
 
        stack->type = type;
        stack->count = count;
-       stack->data = item_defs[stack->type].data_size > 0 ?
-               malloc(item_defs[stack->type].data_size) : NULL;
+       stack->data = item_def[stack->type].data_size > 0 ?
+               malloc(item_def[stack->type].data_size) : NULL;
 
-       if (item_defs[stack->type].callbacks.create)
-               item_defs[stack->type].callbacks.create(stack);
+       if (item_def[stack->type].callbacks.create)
+               item_def[stack->type].callbacks.create(stack);
 
-       if (item_defs[stack->type].callbacks.deserialize)
-               item_defs[stack->type].callbacks.deserialize(&buffer, stack->data);
+       if (item_def[stack->type].callbacks.deserialize)
+               item_def[stack->type].callbacks.deserialize(&buffer, stack->data);
 }
 
 void item_stack_serialize(ItemStack *stack, SerializedItemStack *serialized)
@@ -44,8 +44,8 @@ void item_stack_serialize(ItemStack *stack, SerializedItemStack *serialized)
        serialized->count = stack->count;
        serialized->data = (Blob) {0, NULL};
 
-       if (item_defs[stack->type].callbacks.serialize)
-               item_defs[stack->type].callbacks.serialize(&serialized->data, stack->data);
+       if (item_def[stack->type].callbacks.serialize)
+               item_def[stack->type].callbacks.serialize(&serialized->data, stack->data);
 }
 
 void item_stack_deserialize(ItemStack *stack, SerializedItemStack *serialized)
@@ -58,7 +58,7 @@ void item_stack_deserialize(ItemStack *stack, SerializedItemStack *serialized)
        item_stack_set(stack, type, serialized->count, serialized->data);
 }
 
-ItemDef item_defs[COUNT_ITEM] = {
+ItemDef item_def[COUNT_ITEM] = {
        // unknown
        {
                .stackable = false,
@@ -87,4 +87,11 @@ ItemDef item_defs[COUNT_ITEM] = {
                .dig_class = DIG_WOOD,
                .callbacks = {NULL},
        },
+       // shovel
+       {
+               .stackable = false,
+               .data_size = 0,
+               .dig_class = DIG_DIRT,
+               .callbacks = {NULL},
+       },
 };

diff --git a/src/item.h b/src/item.h
index 6d5fd3c51b78f5654837f397cc7345d1fcc8dfa3..c7940063e22261fe935ae44aa58abe03a89d5987 100644 (file)
--- a/src/item.h
+++ b/src/item.h
@@ -11,6 +11,7 @@ typedef enum {
        ITEM_NONE,
        ITEM_PICKAXE,
        ITEM_AXE,
+       ITEM_SHOVEL,
        COUNT_ITEM,
 } ItemType;
 
@@ -39,6 +40,6 @@ void item_stack_set(ItemStack *stack, ItemType type, u32 count, Blob buffer);
 void item_stack_serialize(ItemStack *stack, SerializedItemStack *serialized);
 void item_stack_deserialize(ItemStack *stack, SerializedItemStack *serialized);
 
-extern ItemDef item_defs[];
+extern ItemDef item_def[];
 
 #endif // _ITEM_H_

diff --git a/src/node.c b/src/node.c
index 2786aec15f52033a8415ef8c404465ff5ab5e159..54b62941b2f9b8e5bbe4edf12850631f4876f013 100644 (file)
--- a/src/node.c
+++ b/src/node.c
@@ -3,7 +3,7 @@
 #include "terrain.h"
 #include "types.h"
 
-NodeDef node_defs[NODE_UNLOADED] = {
+NodeDef node_def[NODE_UNLOADED] = {
        // unknown
        {
                .solid = true,
@@ -62,7 +62,7 @@ NodeDef node_defs[NODE_UNLOADED] = {
        {
                .solid = true,
                .data_size = sizeof(ColorData),
-               .dig_class = DIG_NONE,
+               .dig_class = DIG_LEAVES,
                .callbacks = {
                        .create = NULL,
                        .delete = NULL,
@@ -86,7 +86,7 @@ NodeDef node_defs[NODE_UNLOADED] = {
        {
                .solid = true,
                .data_size = sizeof(ColorData),
-               .dig_class = DIG_NONE,
+               .dig_class = DIG_LEAVES,
                .callbacks = {
                        .create = NULL,
                        .delete = NULL,
@@ -110,7 +110,7 @@ NodeDef node_defs[NODE_UNLOADED] = {
        {
                .solid = true,
                .data_size = sizeof(ColorData),
-               .dig_class = DIG_NONE,
+               .dig_class = DIG_LEAVES,
                .callbacks = {
                        .create = NULL,
                        .delete = NULL,

diff --git a/src/node.h b/src/node.h
index 3c622e2d579668c206841ca780112e43d89b0cd6..cdb1a3b8d2e54df36913e4065844896616a3794d 100644 (file)
--- a/src/node.h
+++ b/src/node.h
@@ -39,6 +39,6 @@ typedef struct {
        } callbacks;
 } NodeDef;
 
-extern NodeDef node_defs[];
+extern NodeDef node_def[];
 
 #endif

diff --git a/src/physics.c b/src/physics.c
index a89e89cdec09108abcac254a9551f1faedcf10ac..4074d8b58daf1cfbcea58b6dccc50eed7c0c7375 100644 (file)
--- a/src/physics.c
+++ b/src/physics.c
@@ -20,7 +20,7 @@ static aabb3s32 round_box(aabb3f64 box)
 static bool is_solid(Terrain *terrain, s32 x, s32 y, s32 z)
 {
        NodeType node = terrain_get_node(terrain, (v3s32) {x, y, z}).type;
-       return node == NODE_UNLOADED || node_defs[node].solid;
+       return node == NODE_UNLOADED || node_def[node].solid;
 }
 
 bool physics_ground(Terrain *terrain, bool collide, aabb3f32 box, v3f64 *pos, v3f64 *vel)

diff --git a/src/server/server.c b/src/server/server.c
index 0bd12059ae368dd1a438259b21afe16518f0a171..d856512a00e7c0fa4771d6e0b497d4d10825ef4b 100644 (file)
--- a/src/server/server.c
+++ b/src/server/server.c
@@ -31,8 +31,8 @@ static void on_ToServerInteract(DragonnetPeer *peer, ToServerInteract *pkt)
        pthread_mutex_lock(&player->mtx_inv);
 
        ItemStack *stack = pkt->left ? &player->inventory.left : &player->inventory.right;
-       if (server_item_defs[stack->type].use)
-               server_item_defs[stack->type].use(player, stack, pkt->pointed, pkt->pos);
+       if (server_item_def[stack->type].use)
+               server_item_def[stack->type].use(player, stack, pkt->pointed, pkt->pos);
 
        pthread_mutex_unlock(&player->mtx_inv);
 }

diff --git a/src/server/server_item.c b/src/server/server_item.c
index 26406952c28ff51765674740fd0698162ddb6c05..e411d7efb2325f0a4160d1ff22de671a41aacda2 100644 (file)
--- a/src/server/server_item.c
+++ b/src/server/server_item.c
@@ -12,7 +12,7 @@ static void use_dig(__attribute__((unused)) ServerPlayer *player, ItemStack *sta
        if (node == NODE_UNLOADED)
                return;
 
-       if (!(node_defs[node].dig_class & item_defs[stack->type].dig_class))
+       if (!(node_def[node].dig_class & item_def[stack->type].dig_class))
                return;
 
        terrain_set_node(server_terrain, pos,
@@ -20,7 +20,7 @@ static void use_dig(__attribute__((unused)) ServerPlayer *player, ItemStack *sta
                false, NULL);
 }
 
-ServerItemDef server_item_defs[COUNT_ITEM] = {
+ServerItemDef server_item_def[COUNT_ITEM] = {
        // unknown
        {
                .use = NULL,
@@ -37,4 +37,8 @@ ServerItemDef server_item_defs[COUNT_ITEM] = {
        {
                .use = &use_dig,
        },
+       // shovel
+       {
+               .use = &use_dig,
+       },
 };

diff --git a/src/server/server_item.h b/src/server/server_item.h
index 1c6cfef4b8d573d3a7412909f5227c044e7c54d7..9fe5f2dc6ba02e2dde95b2f00320204577a73207 100644 (file)
--- a/src/server/server_item.h
+++ b/src/server/server_item.h
@@ -10,6 +10,6 @@ typedef struct {
        void (*use)(ServerPlayer *player, ItemStack *stack, bool pointed, v3s32 pos);
 } ServerItemDef;
 
-extern ServerItemDef server_item_defs[];
+extern ServerItemDef server_item_def[];
 
 #endif // _SERVER_ITEM_H_

diff --git a/src/server/server_player.c b/src/server/server_player.c
index c412f04ec1ee48f672c1071f19727b846ef6b59d..815ccc9d9faa8ddd99301710d5020b5eddb23d9f 100644 (file)
--- a/src/server/server_player.c
+++ b/src/server/server_player.c
@@ -117,8 +117,8 @@ static void player_spawn(ServerPlayer *player)
                database_create_player(player->name, player->pos, player->rot);
        }
 
-       item_stack_set(&player->inventory.left, ITEM_NONE + rand() % (ITEM_AXE - ITEM_NONE + 1), 1, (Blob) {0, NULL});
-       item_stack_set(&player->inventory.right, ITEM_NONE + rand() % (ITEM_AXE - ITEM_NONE + 1), 1, (Blob) {0, NULL});
+       item_stack_set(&player->inventory.left, ITEM_NONE + rand() % (COUNT_ITEM - ITEM_NONE), 1, (Blob) {0, NULL});
+       item_stack_set(&player->inventory.right, ITEM_NONE + rand() % (COUNT_ITEM - ITEM_NONE), 1, (Blob) {0, NULL});
 
        // since this is recv thread, we don't need lock_peer
        dragonnet_peer_send_ToClientInfo(player->peer, &(ToClientInfo) {

diff --git a/src/server/server_terrain.c b/src/server/server_terrain.c
index 77b947513d3e3daa0ec2b0c4ca6727f7a3530fb1..71dce28f0ac6955057cb96d3ad65e0cd4849cb5b 100644 (file)
--- a/src/server/server_terrain.c
+++ b/src/server/server_terrain.c
@@ -263,7 +263,7 @@ static void generate_spawn_hut()
                                pos.y++;
                        }
 
-                       if (node_defs[node].solid)
+                       if (node_def[node].solid)
                                break;
 
                        server_terrain_gen_node(pos,

diff --git a/src/server/terrain_gen.c b/src/server/terrain_gen.c
index 6d5a2398e50e1fa876f01f4875006db31abde50e..39e64b3be694bcdf164015aab27b6c67516cdc6d 100644 (file)
--- a/src/server/terrain_gen.c
+++ b/src/server/terrain_gen.c
@@ -95,7 +95,7 @@ void terrain_gen_chunk(TerrainChunk *chunk, List *changed_chunks)
                                        node = NODE_SNOW;
 
                                if (generate_args.diff == 1) for (int i = 0; i < NUM_TREES; i++) {
-                                       TreeDef *def = &tree_defs[i];
+                                       TreeDef *def = &tree_def[i];
 
                                        if (def->condition(&condition_args)
                                                        && noise2d(condition_args.pos.x, condition_args.pos.z, 0, seed + def->offset) * 0.5 + 0.5 < def->probability

diff --git a/src/server/trees.c b/src/server/trees.c
index e013a0d1fe0e0de542b0eba291587f0c56daad02..d5c04d6c2f54a93186035df5edadf3c7f4e4e791 100644 (file)
--- a/src/server/trees.c
+++ b/src/server/trees.c
@@ -201,7 +201,7 @@ static void palm_tree(v3s32 pos, List *changed_chunks)
        voxel_procedural_delete(proc);
 }
 
-TreeDef tree_defs[NUM_TREES] = {
+TreeDef tree_def[NUM_TREES] = {
        // oak
        {
                .spread = 64.0f,

diff --git a/src/server/trees.h b/src/server/trees.h
index 2eeb3f8739d548462d1def1d4c8a5f0368b3c041..e4ee7efc15f7b2025b32b3c5683515de55a96a6e 100644 (file)
--- a/src/server/trees.h
+++ b/src/server/trees.h
@@ -30,6 +30,6 @@ typedef struct {
        void (*generate)(v3s32 pos, List *changed_chunks);
 } TreeDef;
 
-extern TreeDef tree_defs[];
+extern TreeDef tree_def[];
 
 #endif // _TREES_H_

diff --git a/src/terrain.c b/src/terrain.c
index b3b3d386f4148b6d52c5101779574a11983774a3..3897b448fc33137dda4dc0a47b018bf3b31f9f10 100644 (file)
--- a/src/terrain.c
+++ b/src/terrain.c
@@ -166,7 +166,7 @@ Blob terrain_serialize_chunk(TerrainChunk *chunk)
                        },
                };
 
-               NodeDef *def = &node_defs[node->type];
+               NodeDef *def = &node_def[node->type];
 
                if (def->callbacks.serialize)
                        def->callbacks.serialize(&node_data->data, node->data);
@@ -242,7 +242,7 @@ TerrainNode terrain_node_create(NodeType type, Blob buffer)
        if (type >= NODE_UNLOADED)
                type = NODE_UNKNOWN;
 
-       NodeDef *def = &node_defs[type];
+       NodeDef *def = &node_def[type];
 
        TerrainNode node;
        node.type = type;
@@ -259,7 +259,7 @@ TerrainNode terrain_node_create(NodeType type, Blob buffer)
 
 void terrain_node_delete(TerrainNode node)
 {
-       NodeDef *def = &node_defs[node.type];
+       NodeDef *def = &node_def[node.type];
 
        if (def->callbacks.delete)
                def->callbacks.delete(&node);