src/server/biomes.c

   1 #include <math.h>
   2 #include "server/biomes.h"
   3 #include "server/server_terrain.h"
   4 #include "server/terrain_gen.h"
   5
   6 Biome get_biome(v2s32 pos, f64 *factor)
   7 {
   8         for (Biome i = 0; i < COUNT_BIOME; i++) {
   9                 BiomeDef *def = &biomes[i];
  10                 f64 f = def->probability == 1.0 ? 1.0
  11                         : (smooth2d(U32(pos.x) / def->threshold, U32(pos.y) / def->threshold, 0, seed + def->offset) * 0.5 - 0.5 + def->probability) / def->probability;
  12
  13                 if (f > 0.0) {
  14                         if (factor)
  15                                 *factor = f;
  16                         return i;
  17                 }
  18         }
  19
  20         return COUNT_BIOME;
  21 }
  22
  23 // mountain biome
  24
  25 static s32 height_mountain(BiomeArgsHeight *args)
  26 {
  27         return pow((args->height + 96) * pow(((smooth2d(U32(args->pos.x) / 48.0, U32(args->pos.y) / 48.0, 0, seed + SO_MOUNTAIN_HEIGHT) + 1.0) * 256.0 + 128.0), args->factor), 1.0 / (args->factor + 1.0)) - 96;
  28 }
  29
  30 static NodeType generate_mountain(BiomeArgsGenerate *args)
  31 {
  32         return args->diff <= 0 ? NODE_STONE : NODE_AIR;
  33 }
  34
  35 // ocean biome
  36
  37 typedef enum {
  38         OCEAN_EDGE,
  39         OCEAN_BEACH,
  40         OCEAN_MAIN,
  41         OCEAN_DEEP,
  42         COUNT_OCEAN
  43 } OceanLevel;
  44
  45 static f64 ocean_level_start[COUNT_OCEAN] = {
  46         0.0,
  47         0.1,
  48         0.2,
  49         0.5,
  50 };
  51
  52 typedef struct {
  53         bool has_vulcano;
  54         v2s32 vulcano_pos;
  55 } OceanChunkData;
  56
  57 typedef struct {
  58         bool vulcano;
  59         bool vulcano_crater;
  60         s32 vulcano_height;
  61         s32 vulcano_crater_top;
  62         NodeType vulcano_stone;
  63 } OceanRowData;
  64
  65 static const f64 vulcano_radius = 256.0;
  66 static const f64 vulcano_diameter = vulcano_radius * 2.0;
  67
  68 static OceanLevel get_ocean_level(f64 factor)
  69 {
  70         if (factor >= ocean_level_start[OCEAN_DEEP])
  71                 return OCEAN_DEEP;
  72         else if (factor >= ocean_level_start[OCEAN_MAIN])
  73                 return OCEAN_MAIN;
  74         else if (factor >= ocean_level_start[OCEAN_BEACH])
  75                 return OCEAN_BEACH;
  76
  77         return OCEAN_EDGE;
  78 }
  79
  80 static f64 get_ocean_level_factor(f64 factor, OceanLevel level)
  81 {
  82         f64 start, end;
  83         start = ocean_level_start[level];
  84         end = ++level == COUNT_OCEAN ? 1.0 : ocean_level_start[level];
  85
  86         return (factor - start) / (end - start);
  87 }
  88
  89 static f64 distance(v2s32 a, v2s32 b)
  90 {
  91         return sqrt(pow(a.x - b.x, 2) + pow(a.y - b.y, 2));
  92 }
  93
  94 static s32 calculate_ocean_floor(f64 factor, s32 height)
  95 {
  96         switch (get_ocean_level(factor)) {
  97                 case OCEAN_EDGE:
  98                         return f64_mix(height + 1, 0, pow(get_ocean_level_factor(factor, OCEAN_EDGE), 0.8));
  99
 100                 case OCEAN_BEACH:
 101                         return 0;
 102
 103                 case OCEAN_MAIN:
 104                         return f64_mix(0, -10, pow(get_ocean_level_factor(factor, OCEAN_MAIN), 0.5));
 105
 106                 case OCEAN_DEEP:
 107                         return f64_mix(-10, -50, pow(get_ocean_level_factor(factor, OCEAN_DEEP), 0.5));
 108
 109                 default:
 110                         break;
 111         }
 112
 113         return height;
 114 }
 115
 116 static void chunk_ocean(BiomeArgsChunk *args)
 117 {
 118         OceanChunkData *chunk_data = args->chunk_data;
 119
 120         chunk_data->vulcano_pos = (v2s32) {
 121                 floor((f64) args->chunk->pos.x * CHUNK_SIZE / vulcano_diameter + 0.5) * vulcano_diameter,
 122                 floor((f64) args->chunk->pos.z * CHUNK_SIZE / vulcano_diameter + 0.5) * vulcano_diameter
 123         };
 124
 125         f64 factor;
 126         chunk_data->has_vulcano = noise2d(chunk_data->vulcano_pos.x, chunk_data->vulcano_pos.y, 0, seed + SO_VULCANO) > 0.0
 127                 && get_biome((v2s32) {chunk_data->vulcano_pos.x, chunk_data->vulcano_pos.y}, &factor) == BIOME_OCEAN
 128                 && get_ocean_level(factor) == OCEAN_DEEP;
 129 }
 130
 131 static void row_ocean(BiomeArgsRow *args)
 132 {
 133         OceanChunkData *chunk_data = args->chunk_data;
 134         OceanRowData *row_data = args->row_data;
 135
 136         row_data->vulcano = false;
 137
 138         if (chunk_data->has_vulcano) {
 139                 f64 dist = distance(args->pos, chunk_data->vulcano_pos);
 140
 141                 if (dist < vulcano_radius) {
 142                         f64 crater_factor = pow(asin(1.0 - dist / vulcano_radius), 2.0);
 143                         f64 vulcano_height = (pnoise2d(U32(args->pos.x) / 100.0, U32(args->pos.y) / 100.0, 0.2, 2, seed + SO_VULCANO_HEIGHT) * 0.5 + 0.5) * 128.0 * crater_factor + 1.0 - 30.0;
 144                         bool is_crater = vulcano_height > 0;
 145
 146                         if (!is_crater)
 147                                 vulcano_height = f64_min(vulcano_height + 5.0, 0.0);
 148
 149                         if (vulcano_height < 0)
 150                                 vulcano_height *= 2.0;
 151
 152                         row_data->vulcano = true;
 153                         row_data->vulcano_crater = is_crater;
 154                         row_data->vulcano_height = floor(vulcano_height + 0.5);
 155                         row_data->vulcano_crater_top = 50 + floor((pnoise2d(U32(args->pos.x) / 3.0, U32(args->pos.y) / 3.0, 0.0, 1, seed + SO_VULCANO_CRATER_TOP) * 0.5 + 0.5) * 3.0 + 0.5);
 156                         row_data->vulcano_stone = is_crater
 157                                 ? ((pnoise2d(U32(args->pos.x) / 16.0, U32(args->pos.y) / 16.0, 0.85, 3, seed + SO_VULCANO_STONE) * 0.5 + 0.5) * crater_factor > 0.4
 158                                         ? NODE_VULCANO_STONE
 159                                         : NODE_STONE)
 160                                 : NODE_SAND;
 161                 }
 162         }
 163 }
 164
 165 static s32 height_ocean(BiomeArgsHeight *args)
 166 {
 167         OceanRowData *row_data = args->row_data;
 168
 169         s32 ocean_floor = calculate_ocean_floor(args->factor, args->height);
 170         return row_data->vulcano ? f64_max(ocean_floor, row_data->vulcano_height) : ocean_floor;
 171 }
 172
 173 NodeType ocean_get_node_at(v3s32 pos, s32 diff, void *_row_data)
 174 {
 175         OceanRowData *row_data = _row_data;
 176
 177         if (row_data->vulcano && row_data->vulcano_crater) {
 178                 if (diff <= -5)
 179                         return pos.y <= 45 ? NODE_LAVA : NODE_AIR;
 180                 else if (diff <= 0)
 181                         return pos.y <= row_data->vulcano_crater_top ? row_data->vulcano_stone : NODE_AIR;
 182                 else
 183                         return NODE_AIR;
 184         } else {
 185                 if (diff <= -5)
 186                         return NODE_STONE;
 187                 else if (diff <= 0)
 188                         return NODE_SAND;
 189                 else if (pos.y <= 0)
 190                         return NODE_WATER;
 191         }
 192
 193         return NODE_AIR;
 194 }
 195
 196 static NodeType generate_ocean(BiomeArgsGenerate *args)
 197 {
 198         return ocean_get_node_at(args->pos, args->diff, args->row_data);
 199 }
 200
 201 // hills biome
 202
 203 static bool boulder_touching_ground(v3s32 pos, s32 diff)
 204 {
 205         for (s32 dir = diff > 0 ? -1 : +1; dir > 0 ? diff <= 0 : diff >= 0; pos.y += dir, diff += dir) {
 206                 if (smooth3d(U32(pos.x) / 12.0, U32(pos.y) / 6.0, U32(pos.z) / 12.0, 0, seed + SO_BOULDER) < 0.8)
 207                         return false;
 208         }
 209
 210         return true;
 211 }
 212
 213 static s32 height_hills(BiomeArgsHeight *args)
 214 {
 215         return args->height;
 216 }
 217
 218 static NodeType generate_hills(BiomeArgsGenerate *args)
 219 {
 220         if (boulder_touching_ground(args->pos, args->diff))
 221                 return NODE_STONE;
 222
 223         if (args->diff <= -5)
 224                 return NODE_STONE;
 225         else if (args->diff <= -1)
 226                 return NODE_DIRT;
 227         else if (args->diff <= 0)
 228                 return NODE_GRASS;
 229
 230         return NODE_AIR;
 231 }
 232
 233 BiomeDef biomes[COUNT_BIOME] = {
 234         {
 235                 .probability = 0.2,
 236                 .offset = SO_MOUNTAIN,
 237                 .threshold = 1024.0,
 238                 .snow = true,
 239                 .height = &height_mountain,
 240                 .generate = &generate_mountain,
 241                 .chunk_data_size = 0,
 242                 .chunk = NULL,
 243                 .row_data_size = 0,
 244                 .row = NULL,
 245         },
 246         {
 247                 .probability = 0.2,
 248                 .offset = SO_OCEAN,
 249                 .threshold = 2048.0,
 250                 .snow = false,
 251                 .height = &height_ocean,
 252                 .generate = &generate_ocean,
 253                 .chunk_data_size = sizeof(OceanChunkData),
 254                 .chunk = &chunk_ocean,
 255                 .row_data_size = sizeof(OceanRowData),
 256                 .row = &row_ocean,
 257         },
 258         {
 259                 .probability = 1.0,
 260                 .offset = SO_NONE,
 261                 .threshold = 0.0,
 262                 .snow = true,
 263                 .height = &height_hills,
 264                 .generate = &generate_hills,
 265                 .chunk_data_size = 0,
 266                 .chunk = NULL,
 267                 .row_data_size = 0,
 268                 .row = NULL,
 269         },
 270 };