diff options
Diffstat (limited to '')
| -rw-r--r-- | src/Generating/ComposableGenerator.cpp | 124 | ||||
| -rw-r--r-- | src/Generating/FinishGen.cpp | 367 | ||||
| -rw-r--r-- | src/Generating/FinishGen.h | 166 | ||||
| -rw-r--r-- | src/Generating/StructGen.cpp | 110 | ||||
| -rw-r--r-- | src/Generating/StructGen.h | 48 |
5 files changed, 548 insertions, 267 deletions
diff --git a/src/Generating/ComposableGenerator.cpp b/src/Generating/ComposableGenerator.cpp index eb1d0e1ee..3e27280ce 100644 --- a/src/Generating/ComposableGenerator.cpp +++ b/src/Generating/ComposableGenerator.cpp @@ -330,6 +330,10 @@ void cComposableGenerator::InitFinishGens(cIniFile & a_IniFile) { m_FinishGens.push_back(cFinishGenPtr(new cStructGenDirectOverhangs(Seed))); } + else if (NoCaseCompare(*itr, "DirtPockets") == 0) + { + m_FinishGens.push_back(std::make_shared<cFinishGenOrePockets>(Seed + 1, cFinishGenOrePockets::DefaultNaturalPatches())); + } else if (NoCaseCompare(*itr, "DistortedMembraneOverhangs") == 0) { m_FinishGens.push_back(cFinishGenPtr(new cStructGenDistortedMembraneOverhangs(Seed))); @@ -397,52 +401,7 @@ void cComposableGenerator::InitFinishGens(cIniFile & a_IniFile) } else if (NoCaseCompare(*itr, "NaturalPatches") == 0) { - cStructGenOreNests::OreList Ores; - - // Dirt vein - cStructGenOreNests::OreInfo DirtVein; - DirtVein.BlockType = E_BLOCK_DIRT; - DirtVein.MaxHeight = 127; - DirtVein.NumNests = 20; - DirtVein.NestSize = 32; - Ores.push_back(DirtVein); - - // Gravel vein - cStructGenOreNests::OreInfo GravelVein; - GravelVein.BlockType = E_BLOCK_GRAVEL; - GravelVein.MaxHeight = 127; - GravelVein.NumNests = 20; - GravelVein.NestSize = 32; - Ores.push_back(GravelVein); - - // Granite vein - cStructGenOreNests::OreInfo GraniteVein; - GraniteVein.BlockType = E_BLOCK_STONE; - GraniteVein.BlockMeta = 1; - GraniteVein.MaxHeight = 127; - GraniteVein.NumNests = 20; - GraniteVein.NestSize = 32; - Ores.push_back(GraniteVein); - - // Diorite vein - cStructGenOreNests::OreInfo DioriteVein; - DioriteVein.BlockType = E_BLOCK_STONE; - DioriteVein.BlockMeta = 3; - DioriteVein.MaxHeight = 127; - DioriteVein.NumNests = 20; - DioriteVein.NestSize = 32; - Ores.push_back(DioriteVein); - - // Andesite vein - cStructGenOreNests::OreInfo AndesiteVein; - AndesiteVein.BlockType = E_BLOCK_STONE; - AndesiteVein.BlockMeta = 5; - AndesiteVein.MaxHeight = 127; - AndesiteVein.NumNests = 20; - AndesiteVein.NestSize = 32; - Ores.push_back(AndesiteVein); - - m_FinishGens.push_back(cFinishGenPtr(new cStructGenOreNests(Seed, Ores, E_BLOCK_STONE))); + m_FinishGens.push_back(std::make_shared<cFinishGenOreNests>(Seed + 1, cFinishGenOreNests::DefaultNaturalPatches())); } else if (NoCaseCompare(*itr, "NetherClumpFoliage") == 0) { @@ -457,72 +416,19 @@ void cComposableGenerator::InitFinishGens(cIniFile & a_IniFile) } else if (NoCaseCompare(*itr, "NetherOreNests") == 0) { - cStructGenOreNests::OreList Ores; - - // Quartz vein - cStructGenOreNests::OreInfo QuartzVein; - QuartzVein.BlockType = E_BLOCK_NETHER_QUARTZ_ORE; - QuartzVein.MaxHeight = 255; - QuartzVein.NumNests = 80; - QuartzVein.NestSize = 8; - Ores.push_back(QuartzVein); - - m_FinishGens.push_back(cFinishGenPtr(new cStructGenOreNests(Seed, Ores, E_BLOCK_NETHERRACK))); - + m_FinishGens.push_back(std::make_shared<cFinishGenOreNests>(Seed + 2, cFinishGenOreNests::DefaultNetherOres())); } else if (NoCaseCompare(*itr, "OreNests") == 0) { - cStructGenOreNests::OreList Ores; - - // Coal vein - cStructGenOreNests::OreInfo CoalVein; - CoalVein.BlockType = E_BLOCK_COAL_ORE; - CoalVein.MaxHeight = 127; - CoalVein.NumNests = 50; - CoalVein.NestSize = 10; - Ores.push_back(CoalVein); - - // Iron vein - cStructGenOreNests::OreInfo IronVein; - IronVein.BlockType = E_BLOCK_IRON_ORE; - IronVein.MaxHeight = 64; - IronVein.NumNests = 14; - IronVein.NestSize = 6; - Ores.push_back(IronVein); - - // Gold vein - cStructGenOreNests::OreInfo GoldVein; - GoldVein.BlockType = E_BLOCK_GOLD_ORE; - GoldVein.MaxHeight = 32; - GoldVein.NumNests = 2; - GoldVein.NestSize = 6; - Ores.push_back(GoldVein); - - // Redstone vein - cStructGenOreNests::OreInfo RedstoneVein; - RedstoneVein.BlockType = E_BLOCK_REDSTONE_ORE; - RedstoneVein.MaxHeight = 16; - RedstoneVein.NumNests = 4; - RedstoneVein.NestSize = 6; - Ores.push_back(RedstoneVein); - - // Lapis vein - cStructGenOreNests::OreInfo LapisVein; - LapisVein.BlockType = E_BLOCK_LAPIS_ORE; - LapisVein.MaxHeight = 30; - LapisVein.NumNests = 2; - LapisVein.NestSize = 5; - Ores.push_back(LapisVein); - - // Diamond vein - cStructGenOreNests::OreInfo DiamondVein; - DiamondVein.BlockType = E_BLOCK_DIAMOND_ORE; - DiamondVein.MaxHeight = 15; - DiamondVein.NumNests = 1; - DiamondVein.NestSize = 4; - Ores.push_back(DiamondVein); - - m_FinishGens.push_back(cFinishGenPtr(new cStructGenOreNests(Seed, Ores, E_BLOCK_STONE))); + m_FinishGens.push_back(std::make_shared<cFinishGenOreNests>(Seed + 3, cFinishGenOreNests::DefaultOverworldOres())); + } + else if (NoCaseCompare(*itr, "OrePockets") == 0) + { + auto gen = std::make_shared<cFinishGenOrePockets>(Seed + 2, cFinishGenOrePockets::DefaultOverworldOres()); + if (gen->Initialize(a_IniFile)) + { + m_FinishGens.push_back(gen); + } } else if (NoCaseCompare(*itr, "POCPieces") == 0) { diff --git a/src/Generating/FinishGen.cpp b/src/Generating/FinishGen.cpp index 513c2bd49..8066a497e 100644 --- a/src/Generating/FinishGen.cpp +++ b/src/Generating/FinishGen.cpp @@ -1395,3 +1395,370 @@ eMonsterType cFinishGenPassiveMobs::GetRandomMob(cChunkDesc & a_ChunkDesc) + +//////////////////////////////////////////////////////////////////////////////// +// cFinishGenOres: + +void cFinishGenOres::GenFinish(cChunkDesc & a_ChunkDesc) +{ + int seq = 1; + + // Generate the ores from the ore list. + for (const auto & ore: m_OreInfos) + { + GenerateOre( + a_ChunkDesc, + ore.m_BlockType, ore.m_BlockMeta, + ore.m_MaxHeight, ore.m_NumNests, ore.m_NestSize, + seq + ); + seq++; + } +} + + + + + +const cFinishGenOres::OreInfos & cFinishGenOres::DefaultOverworldOres(void) +{ + static OreInfos res + { + // OreType, OreMeta, MaxHeight, NumNests, NestSize + {E_BLOCK_COAL_ORE, 0, 127, 20, 16}, + {E_BLOCK_IRON_ORE, 0, 64, 20, 8}, + {E_BLOCK_GOLD_ORE, 0, 32, 2, 8}, + {E_BLOCK_REDSTONE_ORE, 0, 16, 8, 7}, + {E_BLOCK_DIAMOND_ORE, 0, 15, 1, 7}, + {E_BLOCK_LAPIS_ORE, 0, 30, 1, 6}, + }; + return res; +} + + + + + +const cFinishGenOres::OreInfos & cFinishGenOres::DefaultNetherOres(void) +{ + static OreInfos res; + if (res.empty()) + { + // Hasn't been initialized yet, emplace the defaults: + // OreType, OreMeta, MaxHeight, NumNests, NestSize + res.emplace_back(E_BLOCK_NETHER_QUARTZ_ORE, 0, 127, 20, 8); + } + return res; +} + + + + + +const cFinishGenOres::OreInfos & cFinishGenOres::DefaultNaturalPatches(void) +{ + static OreInfos res; + if (res.empty()) + { + // Hasn't been initialized yet, emplace the defaults: + // OreType, OreMeta, MaxHeight, NumNests, NestSize + res.emplace_back(E_BLOCK_DIRT, 0, 127, 20, 32); + res.emplace_back(E_BLOCK_GRAVEL, 0, 127, 10, 32); + res.emplace_back(E_BLOCK_STONE, E_META_STONE_GRANITE, 127, 20, 32); + res.emplace_back(E_BLOCK_STONE, E_META_STONE_DIORITE, 127, 20, 32); + res.emplace_back(E_BLOCK_STONE, E_META_STONE_ANDESITE, 127, 20, 32); + } + return res; +} + + + + + +//////////////////////////////////////////////////////////////////////////////// +// cFinishGenOreNests: + +void cFinishGenOreNests::GenerateOre( + cChunkDesc & a_ChunkDesc, + BLOCKTYPE a_OreType, NIBBLETYPE a_OreMeta, + int a_MaxHeight, int a_NumNests, int a_NestSize, + int a_Seq +) +{ + // This function generates several "nests" of ore, each nest consisting of number of ore blocks relatively adjacent to each other. + // It does so by making a random XYZ walk and adding ore along the way in cuboids of different (random) sizes + // Only "terraformable" blocks get replaced with ore, all other blocks stay (so the nest can actually be smaller than specified). + + auto chunkX = a_ChunkDesc.GetChunkX(); + auto chunkZ = a_ChunkDesc.GetChunkZ(); + auto & blockTypes = a_ChunkDesc.GetBlockTypes(); + auto & blockMetas = a_ChunkDesc.GetBlockMetasUncompressed(); + for (int i = 0; i < a_NumNests; i++) + { + int nestRnd = m_Noise.IntNoise3DInt(chunkX + i, a_Seq, chunkZ + 64 * i) / 8; + int BaseX = nestRnd % cChunkDef::Width; + nestRnd /= cChunkDef::Width; + int BaseZ = nestRnd % cChunkDef::Width; + nestRnd /= cChunkDef::Width; + int BaseY = nestRnd % a_MaxHeight; + nestRnd /= a_MaxHeight; + int NestSize = a_NestSize + (nestRnd % (a_NestSize / 4)); // The actual nest size may be up to 1 / 4 larger + int Num = 0; + while (Num < NestSize) + { + // Put a cuboid around [BaseX, BaseY, BaseZ] + int rnd = m_Noise.IntNoise3DInt(chunkX + 64 * i, 2 * a_Seq + Num, chunkZ + 32 * i) / 8; + int xsize = rnd % 2; + int ysize = (rnd / 4) % 2; + int zsize = (rnd / 16) % 2; + rnd >>= 8; + for (int x = xsize; x >= 0; --x) + { + int BlockX = BaseX + x; + if (cChunkDef::IsValidWidth(BlockX)) + { + Num++; // So that the cycle finishes even if the base coords wander away from the chunk + continue; + } + for (int y = ysize; y >= 0; --y) + { + int BlockY = BaseY + y; + if (!cChunkDef::IsValidHeight(BlockY)) + { + Num++; // So that the cycle finishes even if the base coords wander away from the chunk + continue; + } + for (int z = zsize; z >= 0; --z) + { + int BlockZ = BaseZ + z; + if (cChunkDef::IsValidWidth(BlockZ)) + { + Num++; // So that the cycle finishes even if the base coords wander away from the chunk + continue; + } + + int Index = cChunkDef::MakeIndexNoCheck(BlockX, BlockY, BlockZ); + auto blockType = blockTypes[Index]; + if ((blockType == E_BLOCK_STONE) || (blockType == E_BLOCK_NETHERRACK)) + { + blockTypes[Index] = a_OreType; + blockMetas[Index] = a_OreMeta; + } + Num++; + } // for z + } // for y + } // for x + + // Move the base to a neighbor voxel + switch (rnd % 4) + { + case 0: BaseX--; break; + case 1: BaseX++; break; + } + switch ((rnd >> 3) % 4) + { + case 0: BaseY--; break; + case 1: BaseY++; break; + } + switch ((rnd >> 6) % 4) + { + case 0: BaseZ--; break; + case 1: BaseZ++; break; + } + } // while (Num < NumBlocks) + } // for i - NumNests +} + + + + + +//////////////////////////////////////////////////////////////////////////////// +// cFinishGenOrePockets: + +bool cFinishGenOrePockets::Initialize(cIniFile & a_IniFile) +{ + // TODO + return true; +} + + + + + +void cFinishGenOrePockets::GenerateOre( + cChunkDesc & a_ChunkDesc, + BLOCKTYPE a_OreType, NIBBLETYPE a_OreMeta, + int a_MaxHeight, int a_NumNests, int a_NestSize, + int a_Seq +) +{ + // This function generates several "pockets" of the specified ore + // Each chunk can contain only pockets that are generated for that chunk, or for its XM / ZM neighbors. + + // Generate for the 3 neighbors in the XP / ZP direction as well, so that pockets crossing the boundaries are accounted for as well: + int chunkZ = a_ChunkDesc.GetChunkZ(); + int chunkX = a_ChunkDesc.GetChunkX(); + imprintChunkOrePockets(chunkX - 1, chunkZ - 1, a_ChunkDesc, a_OreType, a_OreMeta, a_MaxHeight, a_NumNests, a_NestSize, a_Seq); + imprintChunkOrePockets(chunkX - 1, chunkZ, a_ChunkDesc, a_OreType, a_OreMeta, a_MaxHeight, a_NumNests, a_NestSize, a_Seq); + imprintChunkOrePockets(chunkX, chunkZ - 1, a_ChunkDesc, a_OreType, a_OreMeta, a_MaxHeight, a_NumNests, a_NestSize, a_Seq); + imprintChunkOrePockets(chunkX, chunkZ, a_ChunkDesc, a_OreType, a_OreMeta, a_MaxHeight, a_NumNests, a_NestSize, a_Seq); +} + + + + + +void cFinishGenOrePockets::imprintChunkOrePockets( + int a_ChunkX, int a_ChunkZ, + cChunkDesc & a_ChunkDesc, + BLOCKTYPE a_OreType, NIBBLETYPE a_OreMeta, + int a_MaxHeight, int a_NumNests, int a_NestSize, + int a_Seq +) +{ + // Pick a starting coord for each nest: + int baseBlockX = a_ChunkX * cChunkDef::Width; + int baseBlockZ = a_ChunkZ * cChunkDef::Width; + for (int i = 0; i < a_NumNests; i++) + { + int nestRnd = m_Noise.IntNoise3DInt(a_ChunkX + i, a_Seq, a_ChunkZ + 64 * i) / 7; + int baseX = (nestRnd % cChunkDef::Width) + baseBlockX; + nestRnd /= cChunkDef::Width; + int baseZ = (nestRnd % cChunkDef::Width) + baseBlockZ; + nestRnd /= cChunkDef::Width; + int baseY = nestRnd % a_MaxHeight; + nestRnd /= a_MaxHeight; + imprintPocket( + a_ChunkDesc, + baseX, baseY, baseZ, + a_NestSize, i + 200 * a_Seq, + a_OreType, a_OreMeta + ); + } // for i - NumNests +} + + + + + +void cFinishGenOrePockets::imprintPocket( + cChunkDesc & a_ChunkDesc, + int a_MinPocketX, int a_PocketY, int a_MinPocketZ, + int a_NestSize, int a_Seq, + BLOCKTYPE a_OreType, NIBBLETYPE a_OreMeta +) +{ + // A line segment in a random direction is chosen. Then, several spheres are formed along this line segment, + // with their diameters diminishing towards the line ends (one half of a sinusoid) + + double x1 = static_cast<double>(a_MinPocketX) + 0.5; + double y1 = static_cast<double>(a_PocketY) + 0.5; + double z1 = static_cast<double>(a_MinPocketZ) + 0.5; + int rnd = m_Noise.IntNoise2DInt(a_MinPocketX + 7 * a_Seq, a_MinPocketZ + a_PocketY * 11) / 7; + double angle = static_cast<double>(rnd % 256) / (256.0 * M_PI / 2.0); // range [0 .. pi / 2] + rnd /= 256; + double length = static_cast<double>(a_NestSize) / 4.0; + double x2 = x1 + sin(angle) * length; // Always larger than x1 + double z2 = z1 + cos(angle) * length; // Always larger than z1 + double y2 = y1 + static_cast<double>((rnd % 3) - 1); // Up to 1 block away from y1 + + // Iterate over the line segment in a total of a_NestSize steps: + double stepX = (x2 - x1) / static_cast<double>(a_NestSize); + double stepY = (y2 - y1) / static_cast<double>(a_NestSize); + double stepZ = (z2 - z1) / static_cast<double>(a_NestSize); + double stepR = M_PI / static_cast<double>(a_NestSize); + double size = static_cast<double>(a_NestSize) / 16.0; + for (int i = 0; i < a_NestSize; ++i) + { + double iDbl = static_cast<double>(i); + double sphereX = x1 + stepX * iDbl; + double sphereY = y1 + stepY * iDbl; + double sphereZ = z1 + stepZ * iDbl; + double radius = (sin(stepR * iDbl) + 1.0) * size + 1.0; + imprintSphere(a_ChunkDesc, sphereX, sphereY, sphereZ, radius, a_OreType, a_OreMeta); + } // for i +} + + + + + +void cFinishGenOrePockets::imprintSphere( + cChunkDesc & a_ChunkDesc, + double a_SphereX, double a_SphereY, double a_SphereZ, double a_Radius, + BLOCKTYPE a_OreType, NIBBLETYPE a_OreMeta +) +{ + // Get the sphere's bounding box, unioned with the chunk's bounding box (possibly empty): + int baseX = a_ChunkDesc.GetChunkX() * cChunkDef::Width; + int baseZ = a_ChunkDesc.GetChunkZ() * cChunkDef::Width; + int minX = std::max(FloorC(a_SphereX - a_Radius), baseX); + int minY = std::max(FloorC(a_SphereY - a_Radius), 0); + int minZ = std::max(FloorC(a_SphereZ - a_Radius), baseZ); + int maxX = std::min(CeilC(a_SphereX + a_Radius), baseX + cChunkDef::Width - 1); + int maxY = std::min(CeilC(a_SphereY + a_Radius), cChunkDef::Height - 1); + int maxZ = std::min(CeilC(a_SphereZ + a_Radius), baseZ + cChunkDef::Width - 1); + + /* + // DEBUG: + int blockX = FloorC(a_SphereX); + int blockY = FloorC(a_SphereY); + int blockZ = FloorC(a_SphereZ); + if ( + (blockX >= baseX) && (blockX < baseX + cChunkDef::Width) && + (blockY >= 0) && (blockY < cChunkDef::Height) && + (blockZ >= baseZ) && (blockZ < baseZ + cChunkDef::Width) + ) + { + // LOGD("Imprinting a sphere center at {%d, %d, %d}", blockX, blockY, blockZ); + a_ChunkDesc.SetBlockTypeMeta(blockX - baseX, blockY, blockZ - baseZ, a_OreType, a_OreMeta); + } + return; + //*/ + + // Imprint the parts of the sphere intersecting the chunk: + double radiusSq = a_Radius * a_Radius / 4.0; + for (int y = minY; y <= maxY; y++) + { + double relY = static_cast<double>(y) + 0.5 - a_SphereY; + double relYSq = relY * relY; + if (relYSq > radiusSq) + { + // outside the sphere, bail out + continue; + } + for (int z = minZ; z <= maxZ; z++) + { + double relZ = static_cast<double>(z) + 0.5 - a_SphereZ; + double relZSq = relZ * relZ; + if (relZSq + relYSq > radiusSq) + { + // outside the sphere, bail out + continue; + } + for (int x = minX; x <= maxX; x++) + { + double relX = static_cast<double>(x) + 0.5 - a_SphereX; + double relXSq = relX * relX; + if (relZSq + relYSq + relXSq > radiusSq) + { + // outside the sphere, bail out + continue; + } + int bX = x - baseX; + int bZ = z - baseZ; + auto blockType = a_ChunkDesc.GetBlockType(bX, y, bZ); + if ((blockType == E_BLOCK_STONE) || (blockType == E_BLOCK_NETHERRACK)) + { + a_ChunkDesc.SetBlockTypeMeta(bX, y, bZ, a_OreType, a_OreMeta); + } + } // for x + } // for z + } // for y +} + + + + + diff --git a/src/Generating/FinishGen.h b/src/Generating/FinishGen.h index aa2d0a12d..4541887ec 100644 --- a/src/Generating/FinishGen.h +++ b/src/Generating/FinishGen.h @@ -398,3 +398,169 @@ protected: + +/** Base class for generators that have an ore list attached to them. +Provides the storage and parsing for the ore list, as well as the generic plumbing for generating individual ores. +Descendants should override GenerateOre() to provide the specific ore generation technique. +Note that this class uses the "Nest" terminology for individual packs of ore, it doesn't imply any shape or algorithm. */ +class cFinishGenOres: + public cFinishGen +{ + typedef cFinishGen Super; + +public: + struct OreInfo + { + BLOCKTYPE m_BlockType; // The type of the nest. + NIBBLETYPE m_BlockMeta; // The block meta + int m_MaxHeight; // The highest possible a nest can occur + int m_NumNests; // How many nests per chunk + int m_NestSize; // The amount of blocks a nest can have. + + OreInfo() : + m_BlockType(0), + m_BlockMeta(0), + m_MaxHeight(0), + m_NumNests(0), + m_NestSize(0) + { + } + + OreInfo(BLOCKTYPE a_OreType, NIBBLETYPE a_OreMeta, int a_MaxHeight, int a_NumNests, int a_NestSize) : + m_BlockType(a_OreType), + m_BlockMeta(a_OreMeta), + m_MaxHeight(a_MaxHeight), + m_NumNests(a_NumNests), + m_NestSize(a_NestSize) + { + } + }; + + typedef std::vector<OreInfo> OreInfos; + + cFinishGenOres(int a_Seed, const OreInfos & a_OreInfos): + m_Noise(a_Seed), + m_Seed(a_Seed), + m_OreInfos(a_OreInfos) + { + } + + // cFinishGen overrides: + virtual void GenFinish(cChunkDesc & a_ChunkDesc) override; + + /** Returns a vector of OreInfo structures describing the default Overworld ores, usable in the constructor. */ + static const OreInfos & DefaultOverworldOres(void); + + /** Returns a vector of OreInfo structures describing the default Nether ores, usable in the constructor. */ + static const OreInfos & DefaultNetherOres(void); + + /** Returns a vector of OreInfo structures describing the default Overworld non-ore pockets (dirt, diorite etc), usable in the constructor. */ + static const OreInfos & DefaultNaturalPatches(void); + +protected: + /** The noise used for generating. */ + cNoise m_Noise; + + /** The seed for the generating noise. */ + int m_Seed; + + /** All the ores enabled in this generator. */ + OreInfos m_OreInfos; + + + /** Generates a single ore in the specified chunk image. + a_Seq is the sequencing number (used as a complement to seed to make each ore in the same chunk have different nests) */ + virtual void GenerateOre( + cChunkDesc & a_ChunkDesc, + BLOCKTYPE a_OreType, NIBBLETYPE a_OreMeta, + int a_MaxHeight, int a_NumNests, int a_NestSize, + int a_Seq + ) = 0; + + // TODO: Helper function to parse a config string into m_OreInfos +}; + + + + + +class cFinishGenOreNests : + public cFinishGenOres +{ + typedef cFinishGenOres Super; + +public: + cFinishGenOreNests(int a_Seed, const OreInfos & a_OreInfos): + Super(a_Seed, a_OreInfos) + {} + +protected: + + // cFinishGenOreClumps overrides: + virtual void GenerateOre( + cChunkDesc & a_ChunkDesc, + BLOCKTYPE a_OreType, NIBBLETYPE a_OreMeta, + int a_MaxHeight, int a_NumNests, int a_NestSize, + int a_Seq + ) override; +} ; + + + + + +class cFinishGenOrePockets: + public cFinishGenOres +{ + typedef cFinishGenOres Super; + +public: + cFinishGenOrePockets(int a_Seed, const OreInfos & a_OreInfos): + Super(a_Seed, a_OreInfos) + {} + + /** Reads the configuration from the specified INI file. + Returns true on success, false and logs errors to console on failure. */ + bool Initialize(cIniFile & a_IniFile); + +protected: + + // cFinishGenOreClumps overrides: + virtual void GenerateOre( + cChunkDesc & a_ChunkDesc, + BLOCKTYPE a_OreType, NIBBLETYPE a_OreMeta, + int a_MaxNestHeight, int a_NumNests, int a_NestSize, + int a_Seq + ) override; + + /** Calculates the pockets for the specified chunk and imprints them into the specified ChunkDesc (not necessarily the same chunk). + a_Seq is the sequence number of the ore, to provide another source of randomness. */ + void imprintChunkOrePockets( + int a_ChunkX, int a_ChunkZ, + cChunkDesc & a_ChunkDesc, + BLOCKTYPE a_OreType, NIBBLETYPE a_OreMeta, + int a_MaxHeight, int a_NumNests, int a_NestSize, + int a_Seq + ); + + /** Imprints a single pocket of the specified ore at the specified coords into the chunk. + The pocket shape has its minimum X and Z coords specified, Y can be anywhere around the specified Y coord. + a_Seq is the sequence number of the ore, to provide another source of randomness. */ + void imprintPocket( + cChunkDesc & a_ChunkDesc, + int a_MinPocketX, int a_PocketY, int a_MinPocketZ, + int a_NestSize, int a_Seq, + BLOCKTYPE a_OreType, NIBBLETYPE a_OreMeta + ); + + /** Imprints a single sphere of the specified ore at the specified coords. */ + void imprintSphere( + cChunkDesc & a_ChunkDesc, + double a_SphereX, double a_SphereY, double a_SphereZ, double a_Radius, + BLOCKTYPE a_OreType, NIBBLETYPE a_OreMeta + ); +}; + + + + diff --git a/src/Generating/StructGen.cpp b/src/Generating/StructGen.cpp index 3b04f66b7..29cab86f1 100644 --- a/src/Generating/StructGen.cpp +++ b/src/Generating/StructGen.cpp @@ -273,116 +273,6 @@ int cStructGenTrees::GetNumTrees( //////////////////////////////////////////////////////////////////////////////// -// cStructGenOreNests: - -void cStructGenOreNests::GenFinish(cChunkDesc & a_ChunkDesc) -{ - int ChunkX = a_ChunkDesc.GetChunkX(); - int ChunkZ = a_ChunkDesc.GetChunkZ(); - cChunkDef::BlockTypes & BlockTypes = a_ChunkDesc.GetBlockTypes(); - cChunkDesc::BlockNibbleBytes & BlockMetas = a_ChunkDesc.GetBlockMetasUncompressed(); - - int seq = 1; - - // Generate the ores from the ore list. - for (OreList::const_iterator itr = m_OreList.begin(); itr != m_OreList.end(); ++itr) - { - GenerateOre(ChunkX, ChunkZ, itr->BlockType, itr->BlockMeta, itr->MaxHeight, itr->NumNests, itr->NestSize, BlockTypes, BlockMetas, seq); - seq++; - } -} - - - - - -void cStructGenOreNests::GenerateOre(int a_ChunkX, int a_ChunkZ, BLOCKTYPE a_OreType, NIBBLETYPE a_BlockMeta, int a_MaxHeight, int a_NumNests, int a_NestSize, cChunkDef::BlockTypes & a_BlockTypes, cChunkDesc::BlockNibbleBytes & a_BlockMetas, int a_Seq) -{ - // This function generates several "nests" of ore, each nest consisting of number of ore blocks relatively adjacent to each other. - // It does so by making a random XYZ walk and adding ore along the way in cuboids of different (random) sizes - // Only stone gets replaced with ore, all other blocks stay (so the nest can actually be smaller than specified). - - for (int i = 0; i < a_NumNests; i++) - { - int Nestrnd = m_Noise.IntNoise3DInt(a_ChunkX + i, a_Seq, a_ChunkZ + 64 * i) / 8; - int BaseX = Nestrnd % cChunkDef::Width; - Nestrnd /= cChunkDef::Width; - int BaseZ = Nestrnd % cChunkDef::Width; - Nestrnd /= cChunkDef::Width; - int BaseY = Nestrnd % a_MaxHeight; - Nestrnd /= a_MaxHeight; - int NestSize = a_NestSize + (Nestrnd % (a_NestSize / 4)); // The actual nest size may be up to 1 / 4 larger - int Num = 0; - while (Num < NestSize) - { - // Put a cuboid around [BaseX, BaseY, BaseZ] - int rnd = m_Noise.IntNoise3DInt(a_ChunkX + 64 * i, 2 * a_Seq + Num, a_ChunkZ + 32 * i) / 8; - int xsize = rnd % 2; - int ysize = (rnd / 4) % 2; - int zsize = (rnd / 16) % 2; - rnd >>= 8; - for (int x = xsize; x >= 0; --x) - { - int BlockX = BaseX + x; - if ((BlockX < 0) || (BlockX >= cChunkDef::Width)) - { - Num++; // So that the cycle finishes even if the base coords wander away from the chunk - continue; - } - for (int y = ysize; y >= 0; --y) - { - int BlockY = BaseY + y; - if ((BlockY < 0) || (BlockY >= cChunkDef::Height)) - { - Num++; // So that the cycle finishes even if the base coords wander away from the chunk - continue; - } - for (int z = zsize; z >= 0; --z) - { - int BlockZ = BaseZ + z; - if ((BlockZ < 0) || (BlockZ >= cChunkDef::Width)) - { - Num++; // So that the cycle finishes even if the base coords wander away from the chunk - continue; - } - - int Index = cChunkDef::MakeIndexNoCheck(BlockX, BlockY, BlockZ); - if (a_BlockTypes[Index] == m_ToReplace) - { - a_BlockTypes[Index] = a_OreType; - a_BlockMetas[Index] = a_BlockMeta; - } - Num++; - } // for z - } // for y - } // for x - - // Move the base to a neighbor voxel - switch (rnd % 4) - { - case 0: BaseX--; break; - case 1: BaseX++; break; - } - switch ((rnd >> 3) % 4) - { - case 0: BaseY--; break; - case 1: BaseY++; break; - } - switch ((rnd >> 6) % 4) - { - case 0: BaseZ--; break; - case 1: BaseZ++; break; - } - } // while (Num < NumBlocks) - } // for i - NumNests -} - - - - - - -//////////////////////////////////////////////////////////////////////////////// // cStructGenLakes: void cStructGenLakes::GenFinish(cChunkDesc & a_ChunkDesc) diff --git a/src/Generating/StructGen.h b/src/Generating/StructGen.h index 796abf0f5..b5cfcb07c 100644 --- a/src/Generating/StructGen.h +++ b/src/Generating/StructGen.h @@ -72,54 +72,6 @@ protected: -class cStructGenOreNests : - public cFinishGen -{ -public: - struct OreInfo - { - BLOCKTYPE BlockType; // The type of the nest. - NIBBLETYPE BlockMeta; // The block meta - int MaxHeight; // The highest possible a nest can occur - int NumNests; // How many nests per chunk - int NestSize; // The amount of blocks a nest can have. - - OreInfo() : - BlockType(0), - BlockMeta(0), - MaxHeight(0), - NumNests(0), - NestSize(0) - { - } - }; - - typedef std::vector<OreInfo> OreList; - - cStructGenOreNests(int a_Seed, OreList a_OreList, BLOCKTYPE a_ToReplace) : - m_Noise(a_Seed), - m_Seed(a_Seed), - m_OreList(a_OreList), - m_ToReplace(a_ToReplace) - {} - -protected: - cNoise m_Noise; - int m_Seed; - - OreList m_OreList; // A list of possible ores. - BLOCKTYPE m_ToReplace; - - // cFinishGen override: - virtual void GenFinish(cChunkDesc & a_ChunkDesc) override; - - void GenerateOre(int a_ChunkX, int a_ChunkZ, BLOCKTYPE a_OreType, NIBBLETYPE a_BlockMeta, int a_MaxHeight, int a_NumNests, int a_NestSize, cChunkDef::BlockTypes & a_BlockTypes, cChunkDesc::BlockNibbleBytes & a_BlockMetas, int a_Seq); -} ; - - - - - class cStructGenLakes : public cFinishGen { |