src/map/mapgen_terrain.c

   1 /************************************************************************
   2 * mapgen_terrain.c
   3 * voxelands - 3d voxel world sandbox game
   4 * Copyright (C) Lisa 'darkrose' Milne 2016 <lisa@ltmnet.com>
   5 *
   6 * This program is free software: you can redistribute it and/or modify
   7 * it under the terms of the GNU General Public License as published by
   8 * the Free Software Foundation, either version 3 of the License, or
   9 * (at your option) any later version.
  10 *
  11 * This program is distributed in the hope that it will be useful, but
  12 * WITHOUT ANY WARRANTY; without even the implied warranty of
  13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  14 * See the GNU General Public License for more details.
  15 *
  16 * You should have received a copy of the GNU General Public License
  17 * along with this program.  If not, see <http://www.gnu.org/licenses/>
  18 ************************************************************************/
  19
  20 #include "common.h"
  21
  22 #define _MAPGEN_LOCAL
  23 #include "map.h"
  24 #include "content_block.h"
  25
  26 typedef struct mg_offsets_s {
  27         int x;
  28         int y;
  29         int z;
  30         int cx;
  31         int cy;
  32         int cz;
  33 } mg_offsets_t;
  34
  35 static block_t terrain_blocks[32][288][32];
  36 static mg_offsets_t terrain_offsets[72] = {
  37         {16,0,16, 0,-80,0},
  38         {0,0,16, -16,-80,0},
  39         {16,0,0, 0,-80,-16},
  40         {0,0,0, -16,-80,-16},
  41         {16,16,16, 0,-64,0},
  42         {0,16,16, -16,-64,0},
  43         {16,16,0, 0,-64,-16},
  44         {0,16,0, -16,-64,-16},
  45         {16,32,16, 0,-48,0},
  46         {0,32,16, -16,-48,0},
  47         {16,32,0, 0,-48,-16},
  48         {0,32,0, -16,-48,-16},
  49         {16,48,16, 0,-32,0},
  50         {0,48,16, -16,-32,0},
  51         {16,48,0, 0,-32,-16},
  52         {0,48,0, -16,-32,-16},
  53         {16,64,16, 0,-16,0},
  54         {0,64,16, -16,-16,0},
  55         {16,64,0, 0,-16,-16},
  56         {0,64,0, -16,-16,-16},
  57         {16,80,16, 0,0,0},
  58         {0,80,16, -16,0,0},
  59         {16,80,0, 0,0,-16},
  60         {0,80,0, -16,0,-16},
  61         {16,96,16, 0,16,0},
  62         {0,96,16, -16,16,0},
  63         {16,96,0, 0,16,-16},
  64         {0,96,0, -16,16,-16},
  65         {16,112,16, 0,32,0},
  66         {0,112,16, -16,32,0},
  67         {16,112,0, 0,32,-16},
  68         {0,112,0, -16,32,-16},
  69         {16,128,16, 0,48,0},
  70         {0,128,16, -16,48,0},
  71         {16,128,0, 0,48,-16},
  72         {0,128,0, -16,48,-16},
  73         {16,144,16, 0,64,0},
  74         {0,144,16, -16,64,0},
  75         {16,144,0, 0,64,-16},
  76         {0,144,0, -16,64,-16},
  77         {16,160,16, 0,80,0},
  78         {0,160,16, -16,80,0},
  79         {16,160,0, 0,80,-16},
  80         {0,160,0, -16,80,-16},
  81         {16,176,16, 0,96,0},
  82         {0,176,16, -16,96,0},
  83         {16,176,0, 0,96,-16},
  84         {0,176,0, -16,96,-16},
  85         {16,192,16, 0,112,0},
  86         {0,192,16, -16,112,0},
  87         {16,192,0, 0,112,-16},
  88         {0,192,0, -16,112,-16},
  89         {16,208,16, 0,128,0},
  90         {0,208,16, -16,128,0},
  91         {16,208,0, 0,128,-16},
  92         {0,208,0, -16,128,-16},
  93         {16,224,16, 0,144,0},
  94         {0,224,16, -16,144,0},
  95         {16,224,0, 0,144,-16},
  96         {0,224,0, -16,144,-16},
  97         {16,240,16, 0,160,0},
  98         {0,240,16, -16,160,0},
  99         {16,240,0, 0,160,-16},
 100         {0,240,0, -16,160,-16},
 101         {16,256,16, 0,176,0},
 102         {0,256,16, -16,176,0},
 103         {16,256,0, 0,176,-16},
 104         {0,256,0, -16,176,-16},
 105         {16,272,16, 0,192,0},
 106         {0,272,16, -16,192,0},
 107         {16,272,0, 0,192,-16},
 108         {0,272,0, -16,192,-16}
 109 };
 110
 111 /* generate a ground-level region (-80 to 208) */
 112 void mapgen_terrain(pos_t *p)
 113 {
 114         int x;
 115         int y;
 116         int z;
 117         int i;
 118         block_t *b;
 119         block_t *cb;
 120         pos_t cp;
 121         chunk_t *ch;
 122
 123         int h = 1+80;
 124
 125         for (x=0; x<32; x++) {
 126                 for (z=0; z<32; z++) {
 127                         /* TODO: get the real height here */
 128                         h = noise_height(p->x+x,p->z+z);
 129                         h += 80;
 130                         for (y=0; y<288; y++) {
 131                                 b = &terrain_blocks[x][y][z];
 132                                 b->param1 = 0;
 133                                 b->param2 = 0;
 134                                 b->param3 = 0;
 135                                 if (y > h) {
 136                                         b->content = CONTENT_AIR;
 137                                 }else if (y < (h-5)) {
 138                                         b->content = CONTENT_STONE;
 139                                 }else if (y == h && y>79) {
 140                                         b->content = CONTENT_GRASS;
 141                                 }else{
 142                                         b->content = CONTENT_MUD;
 143                                 }
 144                         }
 145                 }
 146         }
 147
 148         for (i=0; i<72; i++) {
 149                 cp.x = p->x+terrain_offsets[i].cx;
 150                 cp.y = p->y+terrain_offsets[i].cy;
 151                 cp.z = p->z+terrain_offsets[i].cz;
 152                 ch = mapgen_create_chunk(&cp);
 153                 for (x=0; x<16; x++) {
 154                         for (y=0; y<16; y++) {
 155                                 for (z=0; z<16; z++) {
 156                                         b = &terrain_blocks[x+terrain_offsets[i].x][y+terrain_offsets[i].y][z+terrain_offsets[i].z];
 157                                         cb = &ch->blocks[x][y][z];
 158                                         cb->content = b->content;
 159                                         cb->param1 = b->param1;
 160                                         cb->param2 = b->param2;
 161                                         cb->param3 = b->param3;
 162                                 }
 163                         }
 164                 }
 165
 166                 ch->state &= ~CHUNK_STATE_UNGENERATED;
 167
 168                 map_add_chunk(ch);
 169         }
 170 }