6 #include "server/database.h"
7 #include "server/mapgen.h"
8 #include "server/server_map.h"
9 #include "signal_handlers.h"
12 struct ServerMap server_map;
13 static Server *server;
17 // send a block to a client and reset block request
18 static void send_block(Client *client, MapBlock *block)
20 MapBlockExtraData *extra = block->extra;
22 pthread_mutex_lock(&client->mtx);
23 if (client->state == CS_ACTIVE)
24 (void) (write_u32(client->fd, CC_BLOCK) && write_v3s32(client->fd, block->pos) && write_u64(client->fd, extra->size) && write(client->fd, extra->data, extra->size) != -1);
25 pthread_mutex_unlock(&client->mtx);
28 // send block to near clients
29 // block mutex has to be locked
30 static void send_block_to_near(MapBlock *block)
32 MapBlockExtraData *extra = block->extra;
34 if (extra->state == MBS_GENERATING)
40 map_serialize_block(block, &extra->data, &extra->size);
41 database_save_block(block);
43 if (extra->state == MBS_CREATED)
46 pthread_rwlock_rdlock(&server->players_rwlck);
47 ITERATE_LIST(&server->players, pair) {
48 Client *client = pair->value;
50 if (within_simulation_distance(client->pos, block->pos, server->config.simulation_distance))
51 send_block(client, block);
53 pthread_rwlock_unlock(&server->players_rwlck);
56 // list_clear_func callback for sending changed blocks to near clients
57 static void list_send_block(void *key, unused void *value, unused void *arg)
59 MapBlock *block = key;
61 pthread_mutex_lock(&block->mtx);
62 send_block_to_near(block);
63 pthread_mutex_unlock(&block->mtx);
66 // pthread start routine for mapgen thread
67 static void *mapgen_thread(void *arg)
69 MapBlock *block = arg;
70 MapBlockExtraData *extra = block->extra;
72 pthread_mutex_lock(&block->mtx);
73 extra->state = MBS_GENERATING;
74 pthread_mutex_unlock(&block->mtx);
76 List changed_blocks = list_create(NULL);
77 list_put(&changed_blocks, block, NULL);
79 mapgen_generate_block(block, &changed_blocks);
81 pthread_mutex_lock(&block->mtx);
82 extra->state = MBS_READY;
83 pthread_mutex_unlock(&block->mtx);
85 list_clear_func(&changed_blocks, &list_send_block, NULL);
87 pthread_mutex_lock(&server_map.joining_threads_mtx);
88 if (! server_map.joining_threads) {
89 pthread_mutex_lock(&server_map.mapgen_threads_mtx);
90 list_delete(&server_map.mapgen_threads, &extra->mapgen_thread);
91 pthread_mutex_unlock(&server_map.mapgen_threads_mtx);
93 pthread_mutex_unlock(&server_map.joining_threads_mtx);
98 // launch mapgen thread for block
99 // block mutex has to be locked
100 static void launch_mapgen_thread(MapBlock *block)
102 pthread_mutex_lock(&server_map.mapgen_threads_mtx);
103 pthread_t *thread_ptr = &((MapBlockExtraData *) block->extra)->mapgen_thread;
104 pthread_create(thread_ptr, NULL, mapgen_thread, block);
105 list_put(&server_map.mapgen_threads, thread_ptr, NULL);
106 pthread_mutex_unlock(&server_map.mapgen_threads_mtx);
109 // list_clear_func callback used to join running generator threads on shutdown
110 static void list_join_thread(void *key, unused void *value, unused void *arg)
112 pthread_join(*(pthread_t *) key, NULL);
116 // note: all these functions require the block mutex to be locked, which is always the case when a map callback is invoked
118 // callback for initializing a newly created block
119 // load block from database or initialize state, mgstage buffer and data
120 static void on_create_block(MapBlock *block)
122 MapBlockExtraData *extra = block->extra = malloc(sizeof(MapBlockExtraData));
124 if (! database_load_block(block)) {
125 extra->state = MBS_CREATED;
129 block->data[x][y][z] = map_node_create(NODE_AIR);
130 extra->mgs_buffer[x][y][z] = MGS_VOID;
135 // callback for deleting a block
137 static void on_delete_block(MapBlock *block)
139 MapBlockExtraData *extra = block->extra;
147 // callback for determining whether a block should be returned by map_get_block
148 // hold back blocks that are not fully generated except when the create flag is set to true
149 static bool on_get_block(MapBlock *block, bool create)
151 MapBlockExtraData *extra = block->extra;
153 if (extra->state < MBS_READY && ! create)
159 // callback for deciding whether a set_node call succeeds or not
160 // reject set_node calls that try to override nodes placed by later mapgen stages, else update mgs buffer - also make sure block is inserted into changed blocks list
161 static bool on_set_node(MapBlock *block, v3u8 offset, unused MapNode *node, void *arg)
163 MapgenSetNodeArg *msn_arg = arg;
172 MapgenStage *old_mgs = &((MapBlockExtraData *) block->extra)->mgs_buffer[offset.x][offset.y][offset.z];
174 if (mgs >= *old_mgs) {
178 list_put(msn_arg->changed_blocks, block, NULL);
186 // callback for when a block changes
187 // send block to near clients if not part of map generation
188 static void on_after_set_node(MapBlock *block, unused v3u8 offset, void *arg)
191 send_block_to_near(block);
194 // join all map generation threads
195 static void join_mapgen_threads()
197 pthread_mutex_lock(&server_map.joining_threads_mtx);
198 server_map.joining_threads = true;
199 pthread_mutex_unlock(&server_map.joining_threads_mtx);
201 pthread_mutex_lock(&server_map.mapgen_threads_mtx);
202 list_clear_func(&server_map.mapgen_threads, &list_join_thread, NULL);
203 pthread_mutex_unlock(&server_map.mapgen_threads_mtx);
205 pthread_mutex_lock(&server_map.joining_threads_mtx);
206 server_map.joining_threads = false;
207 pthread_mutex_unlock(&server_map.joining_threads_mtx);
210 // generate a hut for new players to spawn in
211 static void generate_spawn_hut()
213 List changed_blocks = list_create(NULL);
215 for (s32 x = -4; x <= +4; x++) {
216 for (s32 y = 0; y <= 3; y++) {
217 for (s32 z = -3; z <= +2; z++) {
218 mapgen_set_node((v3s32) {x, server_map.spawn_height + y, z}, (MapNode) {NODE_AIR}, MGS_PLAYER, &changed_blocks);
223 for (s32 x = -5; x <= +5; x++) {
224 for (s32 z = -4; z <= +3; z++) {
225 mapgen_set_node((v3s32) {x, server_map.spawn_height - 1, z}, (MapNode) {NODE_WOOD}, MGS_PLAYER, &changed_blocks);
226 mapgen_set_node((v3s32) {x, server_map.spawn_height + 4, z}, (MapNode) {NODE_WOOD}, MGS_PLAYER, &changed_blocks);
230 for (s32 y = 0; y <= 3; y++) {
231 for (s32 x = -5; x <= +5; x++) {
232 mapgen_set_node((v3s32) {x, server_map.spawn_height + y, -4}, (MapNode) {((y == 1 || y == 2) && ((x >= -3 && x <= -1) || (x >= +1 && x <= +2))) ? NODE_AIR : NODE_WOOD}, MGS_PLAYER, &changed_blocks);
233 mapgen_set_node((v3s32) {x, server_map.spawn_height + y, +3}, (MapNode) {((y == 1 || y == 2) && ((x >= -3 && x <= -2) || (x >= +1 && x <= +3))) ? NODE_AIR : NODE_WOOD}, MGS_PLAYER, &changed_blocks);
237 for (s32 y = 0; y <= 3; y++) {
238 for (s32 z = -3; z <= +2; z++) {
239 mapgen_set_node((v3s32) {-5, server_map.spawn_height + y, z}, (MapNode) {NODE_WOOD}, MGS_PLAYER, &changed_blocks);
240 mapgen_set_node((v3s32) {+5, server_map.spawn_height + y, z}, (MapNode) {((y != 3) && (z == -1 || z == +0)) ? NODE_AIR : NODE_WOOD}, MGS_PLAYER, &changed_blocks);
253 for (int i = 0; i < 6; i++) {
254 for (s32 y = server_map.spawn_height - 2;; y--) {
255 v3s32 pos = {posts[i].x, y, posts[i].y};
256 Node node = map_get_node(server_map.map, pos).type;
259 if (node != NODE_AIR)
265 if (node_definitions[node].solid)
268 mapgen_set_node(pos, (MapNode) {node == NODE_LAVA ? NODE_VULCANO_STONE : NODE_WOOD}, MGS_PLAYER, &changed_blocks);
272 list_clear_func(&changed_blocks, &list_send_block, NULL);
277 // ServerMap singleton constructor
278 void server_map_init(Server *srv)
282 server_map.map = map_create((MapCallbacks) {
283 .create_block = &on_create_block,
284 .delete_block = &on_delete_block,
285 .get_block = &on_get_block,
286 .set_node = &on_set_node,
287 .after_set_node = &on_after_set_node,
289 server_map.joining_threads = false;
290 server_map.mapgen_threads = list_create(NULL);
291 pthread_mutex_init(&server_map.joining_threads_mtx, NULL);
292 pthread_mutex_init(&server_map.mapgen_threads_mtx, NULL);
295 // ServerMap singleton destructor
296 void server_map_deinit()
298 join_mapgen_threads();
299 pthread_mutex_destroy(&server_map.joining_threads_mtx);
300 pthread_mutex_destroy(&server_map.mapgen_threads_mtx);
301 map_delete(server_map.map);
304 // handle block request from client (thread safe)
305 void server_map_requested_block(Client *client, v3s32 pos)
307 if (within_simulation_distance(client->pos, pos, server->config.simulation_distance)) {
308 MapBlock *block = map_get_block(server_map.map, pos, true);
310 pthread_mutex_lock(&block->mtx);
311 MapBlockExtraData *extra = block->extra;
313 switch (extra->state) {
315 launch_mapgen_thread(block);
322 send_block(client, block);
324 pthread_mutex_unlock(&block->mtx);
328 // prepare spawn region
329 void server_map_prepare_spawn()
332 s32 dist = server->config.simulation_distance;
333 s32 total = (dist * 2 + 1);
334 total *= total * total;
335 s32 last_percentage = -1;
337 for (s32 x = -dist; x <= (s32) dist; x++) {
338 for (s32 y = -dist; y <= (s32) dist; y++) {
339 for (s32 z = -dist; z <= (s32) dist; z++) {
341 join_mapgen_threads();
345 MapBlock *block = map_get_block(server_map.map, (v3s32) {x, y, z}, true);
347 pthread_mutex_lock(&block->mtx);
348 if (((MapBlockExtraData *) block->extra)->state == MBS_CREATED)
349 launch_mapgen_thread(block);
350 pthread_mutex_unlock(&block->mtx);
354 s32 percentage = 100.0 * done / total;
356 if (percentage > last_percentage) {
357 last_percentage = percentage;
358 printf("Preparing spawn... %d%%\n", percentage);
364 join_mapgen_threads();
366 s64 saved_spawn_height;
367 if (database_load_meta("spawn_height", &saved_spawn_height)) {
368 server_map.spawn_height = saved_spawn_height;
370 s32 spawn_height = -1;
372 while (map_get_node(server_map.map, (v3s32) {0, ++spawn_height, 0}).type != NODE_AIR);
375 server_map.spawn_height = spawn_height + 5;
376 generate_spawn_hut();
377 database_save_meta("spawn_height", server_map.spawn_height);