src/mapgen/mg_ore.h

   1 /*
   2 Minetest
   3 Copyright (C) 2015-2020 paramat
   4 Copyright (C) 2014-2016 kwolekr, Ryan Kwolek <kwolekr@minetest.net>
   5
   6 This program is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU Lesser General Public License as published by
   8 the Free Software Foundation; either version 2.1 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,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU Lesser General Public License for more details.
  15
  16 You should have received a copy of the GNU Lesser General Public License along
  17 with this program; if not, write to the Free Software Foundation, Inc.,
  18 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  19 */
  20
  21 #pragma once
  22
  23 #include <unordered_set>
  24 #include "objdef.h"
  25 #include "noise.h"
  26 #include "nodedef.h"
  27
  28 typedef u16 biome_t;  // copy from mg_biome.h to avoid an unnecessary include
  29
  30 class Noise;
  31 class Mapgen;
  32 class MMVManip;
  33
  34 /////////////////// Ore generation flags
  35
  36 #define OREFLAG_ABSHEIGHT     0x01 // Non-functional but kept to not break flags
  37 #define OREFLAG_PUFF_CLIFFS   0x02
  38 #define OREFLAG_PUFF_ADDITIVE 0x04
  39 #define OREFLAG_USE_NOISE     0x08
  40 #define OREFLAG_USE_NOISE2    0x10
  41
  42 enum OreType {
  43         ORE_SCATTER,
  44         ORE_SHEET,
  45         ORE_PUFF,
  46         ORE_BLOB,
  47         ORE_VEIN,
  48         ORE_STRATUM,
  49 };
  50
  51 extern FlagDesc flagdesc_ore[];
  52
  53 class Ore : public ObjDef, public NodeResolver {
  54 public:
  55         const bool needs_noise;
  56
  57         content_t c_ore;                  // the node to place
  58         std::vector<content_t> c_wherein; // the nodes to be placed in
  59         u32 clust_scarcity; // ore cluster has a 1-in-clust_scarcity chance of appearing at a node
  60         s16 clust_num_ores; // how many ore nodes are in a chunk
  61         s16 clust_size;     // how large (in nodes) a chunk of ore is
  62         s16 y_min;
  63         s16 y_max;
  64         u8 ore_param2;          // to set node-specific attributes
  65         u32 flags = 0;          // attributes for this ore
  66         float nthresh;      // threshold for noise at which an ore is placed
  67         NoiseParams np;     // noise for distribution of clusters (NULL for uniform scattering)
  68         Noise *noise = nullptr;
  69         std::unordered_set<biome_t> biomes;
  70
  71         explicit Ore(bool needs_noise): needs_noise(needs_noise) {}
  72         virtual ~Ore();
  73
  74         virtual void resolveNodeNames();
  75
  76         size_t placeOre(Mapgen *mg, u32 blockseed, v3s16 nmin, v3s16 nmax);
  77         virtual void generate(MMVManip *vm, int mapseed, u32 blockseed,
  78                 v3s16 nmin, v3s16 nmax, biome_t *biomemap) = 0;
  79
  80 protected:
  81         void cloneTo(Ore *def) const;
  82 };
  83
  84 class OreScatter : public Ore {
  85 public:
  86         OreScatter() : Ore(false) {}
  87
  88         ObjDef *clone() const override;
  89
  90         void generate(MMVManip *vm, int mapseed, u32 blockseed,
  91                         v3s16 nmin, v3s16 nmax, biome_t *biomemap) override;
  92 };
  93
  94 class OreSheet : public Ore {
  95 public:
  96         OreSheet() : Ore(true) {}
  97
  98         ObjDef *clone() const override;
  99
 100         u16 column_height_min;
 101         u16 column_height_max;
 102         float column_midpoint_factor;
 103
 104         void generate(MMVManip *vm, int mapseed, u32 blockseed,
 105                         v3s16 nmin, v3s16 nmax, biome_t *biomemap) override;
 106 };
 107
 108 class OrePuff : public Ore {
 109 public:
 110         ObjDef *clone() const override;
 111
 112         NoiseParams np_puff_top;
 113         NoiseParams np_puff_bottom;
 114         Noise *noise_puff_top = nullptr;
 115         Noise *noise_puff_bottom = nullptr;
 116
 117         OrePuff() : Ore(true) {}
 118         virtual ~OrePuff();
 119
 120         void generate(MMVManip *vm, int mapseed, u32 blockseed,
 121                         v3s16 nmin, v3s16 nmax, biome_t *biomemap) override;
 122 };
 123
 124 class OreBlob : public Ore {
 125 public:
 126         ObjDef *clone() const override;
 127
 128         OreBlob() : Ore(true) {}
 129         void generate(MMVManip *vm, int mapseed, u32 blockseed,
 130                         v3s16 nmin, v3s16 nmax, biome_t *biomemap) override;
 131 };
 132
 133 class OreVein : public Ore {
 134 public:
 135         ObjDef *clone() const override;
 136
 137         float random_factor;
 138         Noise *noise2 = nullptr;
 139         int sizey_prev = 0;
 140
 141         OreVein() : Ore(true) {}
 142         virtual ~OreVein();
 143
 144         void generate(MMVManip *vm, int mapseed, u32 blockseed,
 145                         v3s16 nmin, v3s16 nmax, biome_t *biomemap) override;
 146 };
 147
 148 class OreStratum : public Ore {
 149 public:
 150         ObjDef *clone() const override;
 151
 152         NoiseParams np_stratum_thickness;
 153         Noise *noise_stratum_thickness = nullptr;
 154         u16 stratum_thickness;
 155
 156         OreStratum() : Ore(false) {}
 157         virtual ~OreStratum();
 158
 159         void generate(MMVManip *vm, int mapseed, u32 blockseed,
 160                         v3s16 nmin, v3s16 nmax, biome_t *biomemap) override;
 161 };
 162
 163 class OreManager : public ObjDefManager {
 164 public:
 165         OreManager(IGameDef *gamedef);
 166         virtual ~OreManager() = default;
 167
 168         OreManager *clone() const;
 169
 170         const char *getObjectTitle() const
 171         {
 172                 return "ore";
 173         }
 174
 175         static Ore *create(OreType type)
 176         {
 177                 switch (type) {
 178                 case ORE_SCATTER:
 179                         return new OreScatter;
 180                 case ORE_SHEET:
 181                         return new OreSheet;
 182                 case ORE_PUFF:
 183                         return new OrePuff;
 184                 case ORE_BLOB:
 185                         return new OreBlob;
 186                 case ORE_VEIN:
 187                         return new OreVein;
 188                 case ORE_STRATUM:
 189                         return new OreStratum;
 190                 default:
 191                         return nullptr;
 192                 }
 193         }
 194
 195         void clear();
 196
 197         size_t placeAllOres(Mapgen *mg, u32 blockseed, v3s16 nmin, v3s16 nmax);
 198
 199 private:
 200         OreManager() {};
 201 };