src/map.c

   1 #include <stdlib.h>
   2 #include <stdbool.h>
   3 #include <math.h>
   4 #include "binsearch.h"
   5 #include "map.h"
   6 #include "util.h"
   7
   8 Map *map_create()
   9 {
  10         Map *map = malloc(sizeof(Map));
  11         map->sectors = array_create(sizeof(MapSector *));
  12         return map;
  13 }
  14
  15 static MapBlock **get_block_ptr(MapSector *sector, size_t idx)
  16 {
  17         return (MapBlock **) sector->blocks.ptr + idx;
  18 }
  19
  20 static MapSector **get_sector_ptr(Map *map, size_t idx)
  21 {
  22         return (MapSector **) map->sectors.ptr + idx;
  23 }
  24
  25 void map_delete(Map *map)
  26 {
  27         for (size_t s = 0; s < map->sectors.siz; s++) {
  28                 MapSector *sector = *get_sector_ptr(map, s);
  29                 for (size_t b = 0; b < sector->blocks.siz; b++)
  30                         map_free_block(*get_block_ptr(sector, b));
  31                 if (sector->blocks.ptr)
  32                         free(sector->blocks.ptr);
  33                 free(sector);
  34         }
  35         if (map->sectors.ptr)
  36                 free(map->sectors.ptr);
  37         free(map);
  38 }
  39
  40 #define CMPBOUNDS(x) x == 0 ? 0 : x > 0 ? 1 : -1
  41
  42 static s8 sector_compare(void *hash, void *sector)
  43 {
  44         s64 d = *((u64 *) hash) - ((MapSector *) sector)->hash;
  45         return CMPBOUNDS(d);
  46 }
  47
  48 MapSector *map_get_sector(Map *map, v2s32 pos, bool create)
  49 {
  50         u64 hash = ((u64) pos.x << 32) + (u64) pos.y;
  51         BinsearchResult res = binsearch(&hash, map->sectors.ptr, map->sectors.siz, &sector_compare);
  52
  53         if (res.success)
  54                 return *get_sector_ptr(map, res.index);
  55         if (! create)
  56                 return NULL;
  57
  58         MapSector *sector = malloc(sizeof(MapSector));
  59         sector->pos = pos;
  60         sector->hash = hash;
  61         sector->blocks = array_create(sizeof(MapBlock *));
  62
  63         array_insert(&map->sectors, &sector, res.index);
  64
  65         return sector;
  66 }
  67
  68 static s8 block_compare(void *level, void *block)
  69 {
  70         s32 d = *((s32 *) level) - ((MapBlock *) block)->pos.y;
  71         return CMPBOUNDS(d);
  72 }
  73
  74 static MapBlock *allocate_block(v3s32 pos)
  75 {
  76         MapBlock *block = malloc(sizeof(MapBlock));
  77         block->pos = pos;
  78         block->extra = NULL;
  79         return block;
  80 }
  81
  82 MapBlock *map_get_block(Map *map, v3s32 pos, bool create)
  83 {
  84         MapSector *sector = map_get_sector(map, (v2s32) {pos.x, pos.z}, create);
  85         if (! sector)
  86                 return NULL;
  87
  88         BinsearchResult res = binsearch(&pos.y, sector->blocks.ptr, sector->blocks.siz, &block_compare);
  89
  90         if (res.success)
  91                 return *get_block_ptr(sector, res.index);
  92         if (! create)
  93                 return NULL;
  94
  95         MapBlock *block = allocate_block(pos);
  96
  97         MapNode air = map_node_create(NODE_AIR);
  98         ITERATE_MAPBLOCK block->data[x][y][z] = air;
  99
 100         array_insert(&sector->blocks, &block, res.index);
 101
 102         return block;
 103 }
 104
 105 void map_add_block(Map *map, MapBlock *block)
 106 {
 107         MapSector *sector = map_get_sector(map, (v2s32) {block->pos.x, block->pos.z}, true);
 108         BinsearchResult res = binsearch(&block->pos.y, sector->blocks.ptr, sector->blocks.siz, &block_compare);
 109         if (res.success) {
 110                 MapBlock **ptr = get_block_ptr(sector, res.index);
 111                 map_free_block(*ptr);
 112                 *ptr = block;
 113         } else {
 114                 array_insert(&sector->blocks, &block, res.index);
 115         }
 116 }
 117
 118 void map_clear_block(MapBlock *block, v3u8 init_state)
 119 {
 120         for (u8 x = 0; x <= init_state.x; x++)
 121                 for (u8 y = 0; y <= init_state.y; y++)
 122                         for (u8 z = 0; z <= init_state.z; z++)
 123                                 map_node_clear(&block->data[x][y][z]);
 124 }
 125
 126 void map_free_block(MapBlock *block)
 127 {
 128         map_clear_block(block, (v3u8) {15, 15, 15});
 129         free(block);
 130 }
 131
 132 bool map_deserialize_node(int fd, MapNode *node)
 133 {
 134         Node type;
 135
 136         if (! read_u32(fd, &type))
 137                 return false;
 138
 139         if (type > NODE_INVALID)
 140                 type = NODE_INVALID;
 141
 142         *node = map_node_create(type);
 143
 144         return true;
 145 }
 146
 147 bool map_serialize_block(int fd, MapBlock *block)
 148 {
 149         if (! write_v3s32(fd, block->pos))
 150                 return false;
 151
 152         ITERATE_MAPBLOCK {
 153                 if (! write_u32(fd, block->data[x][y][z].type))
 154                         return false;
 155         }
 156
 157         return true;
 158 }
 159
 160 MapBlock *map_deserialize_block(int fd)
 161 {
 162         v3s32 pos;
 163
 164         if (! read_v3s32(fd, &pos))
 165                 return NULL;
 166
 167         MapBlock *block = allocate_block(pos);
 168
 169         ITERATE_MAPBLOCK {
 170                 if (! map_deserialize_node(fd, &block->data[x][y][z])) {
 171                         map_clear_block(block, (v3u8) {x, y, z});
 172                         free(block);
 173                         return NULL;
 174                 }
 175         }
 176
 177         return block;
 178 }
 179
 180 bool map_serialize(int fd, Map *map)
 181 {
 182         for (size_t s = 0; s < map->sectors.siz; s++) {
 183                 MapSector *sector = *get_sector_ptr(map, s);
 184                 for (size_t b = 0; b < sector->blocks.siz; b++)
 185                         if (! map_serialize_block(fd, *get_block_ptr(sector, b)))
 186                                 return false;
 187         }
 188         return true;
 189 }
 190
 191 void map_deserialize(int fd, Map *map)
 192 {
 193         MapBlock *block;
 194
 195         while ((block = map_deserialize_block(fd)) != NULL)
 196                 map_add_block(map, block);
 197 }
 198
 199 v3s32 map_node_to_block_pos(v3s32 pos, v3u8 *offset)
 200 {
 201         if (offset)
 202                 *offset = (v3u8) {(u32) pos.x % 16, (u32) pos.y % 16, (u32) pos.z % 16};
 203         return (v3s32) {floor((double) pos.x / 16.0), floor((double) pos.y / 16.0), floor((double) pos.z / 16.0)};
 204 }
 205
 206 MapNode map_get_node(Map *map, v3s32 pos)
 207 {
 208         v3u8 offset;
 209         v3s32 blockpos = map_node_to_block_pos(pos, &offset);
 210         MapBlock *block = map_get_block(map, blockpos, false);
 211         if (! block)
 212                 return map_node_create(NODE_UNLOADED);
 213         return block->data[offset.x][offset.y][offset.z];
 214 }
 215
 216 void map_set_node(Map *map, v3s32 pos, MapNode node)
 217 {
 218         v3u8 offset;
 219         MapBlock *block = map_get_block(map, map_node_to_block_pos(pos, &offset), true);
 220         MapNode *current_node = &block->data[offset.x][offset.y][offset.z];
 221         map_node_clear(current_node);
 222         *current_node = node;
 223 }
 224
 225 MapNode map_node_create(Node type)
 226 {
 227         return (MapNode) {type, list_create(&list_compare_string)};
 228 }
 229
 230 void map_node_clear(MapNode *node)
 231 {
 232         list_clear(&node->meta);
 233 }