Normal Class Reference

Public Member Functions
	__construct (array $options=[])
	getName ()
	getWaterHeight ()
	getSettings ()
	pickBiome ($x, $z)
	init (ChunkManager $level, Random $random)
	generateChunk ($chunkX, $chunkZ)
	populateChunk ($chunkX, $chunkZ)
	getSpawn ()
Public Member Functions inherited from Generator
	getWaterHeight ()
	__construct (array $settings=[])
	init (ChunkManager $level, Random $random)
	generateChunk ($chunkX, $chunkZ)
	populateChunk ($chunkX, $chunkZ)
	getSettings ()
	getName ()
	getSpawn ()

Data Fields
const	NAME = "Normal"

Protected Attributes
	$populators = []
	$level
	$random
	$waterHeight = 62
	$bedrockDepth = 5
	$generationPopulators = []
	$noiseBase
	$selector

Additional Inherited Members
Static Public Member Functions inherited from Generator
static	addGenerator ($object, $name)
static	getGeneratorList ()
static	getGenerator ($name)
static	getGeneratorName ($class)
static	getFastNoise1D (Noise $noise, $xSize, $samplingRate, $x, $y, $z)
static	getFastNoise2D (Noise $noise, $xSize, $zSize, $samplingRate, $x, $y, $z)
static	getFastNoise3D (Noise $noise, $xSize, $ySize, $zSize, $xSamplingRate, $ySamplingRate, $zSamplingRate, $x, $y, $z)

Constructor & Destructor Documentation

__construct()

__construct

(

array

$options = []

)

                                                    {
        if(self::$GAUSSIAN_KERNEL === null){
            self::generateKernel();
        }
    }

Member Function Documentation

generateChunk()

generateChunk	(		$chunkX,
			$chunkZ
	)

                                                   {
        $this->random->setSeed(0xdeadbeef ^ ($chunkX << 8) ^ $chunkZ ^ $this->level->getSeed());

        $noise = Generator::getFastNoise3D($this->noiseBase, 16, 128, 16, 4, 8, 4, $chunkX * 16, 0, $chunkZ * 16);

        $chunk = $this->level->getChunk($chunkX, $chunkZ);

        $biomeCache = [];

        for($x = 0; $x < 16; ++$x){
            for($z = 0; $z < 16; ++$z){
                $minSum = 0;
                $maxSum = 0;
                $weightSum = 0;

                $biome = $this->pickBiome($chunkX * 16 + $x, $chunkZ * 16 + $z);
                $chunk->setBiomeId($x, $z, $biome->getId());

                for($sx = -self::$SMOOTH_SIZE; $sx <= self::$SMOOTH_SIZE; ++$sx){
                    for($sz = -self::$SMOOTH_SIZE; $sz <= self::$SMOOTH_SIZE; ++$sz){

                        $weight = self::$GAUSSIAN_KERNEL[$sx + self::$SMOOTH_SIZE][$sz + self::$SMOOTH_SIZE];

                        if($sx === 0 and $sz === 0){
                            $adjacent = $biome;
                        }else{
                            $index = Level::chunkHash($chunkX * 16 + $x + $sx, $chunkZ * 16 + $z + $sz);
                            if(isset($biomeCache[$index])){
                                $adjacent = $biomeCache[$index];
                            }else{
                                $biomeCache[$index] = $adjacent = $this->pickBiome($chunkX * 16 + $x + $sx, $chunkZ * 16 + $z + $sz);
                            }
                        }

                        $minSum += ($adjacent->getMinElevation() - 1) * $weight;
                        $maxSum += $adjacent->getMaxElevation() * $weight;

                        $weightSum += $weight;
                    }
                }

                $minSum /= $weightSum;
                $maxSum /= $weightSum;

                $solidLand = false;
                for($y = 127; $y >= 0; --$y){
                    if($y === 0){
                        $chunk->setBlockId($x, $y, $z, Block::BEDROCK);
                        continue;
                    }

                    // A noiseAdjustment of 1 will guarantee ground, a noiseAdjustment of -1 will guarantee air.
                    //$effHeight = min($y - $smoothHeight - $minSum,
                    $noiseAdjustment = 2 * (($maxSum - $y) / ($maxSum - $minSum)) - 1;


                    // To generate caves, we bring the noiseAdjustment down away from 1.
                    $caveLevel = $minSum - 10;
                    $distAboveCaveLevel = max(0, $y - $caveLevel); // must be positive

                    $noiseAdjustment = min($noiseAdjustment, 0.4 + ($distAboveCaveLevel / 10));
                    $noiseValue = $noise[$x][$z][$y] + $noiseAdjustment;

                    if($noiseValue > 0){
                        $chunk->setBlockId($x, $y, $z, Block::STONE);
                        $solidLand = true;
                    }elseif($y <= $this->waterHeight && $solidLand == false){
                        $chunk->setBlockId($x, $y, $z, Block::STILL_WATER);
                    }
                }
            }
        }

        foreach($this->generationPopulators as $populator){
            $populator->populate($this->level, $chunkX, $chunkZ, $this->random);
        }
    }

getName()

getName

(

)

                              : string{
        return self::NAME;
    }

getSettings()

getSettings

(

)

                                 {
        return [];
    }

getSpawn()

getSpawn

(

)

                              {
        return new Vector3(127.5, 128, 127.5);
    }

getWaterHeight()

getWaterHeight

(

)

                                     : int{
        return $this->waterHeight;
    }

init()

init	(	ChunkManager	$level,
		Random	$random
	)

                                                             {
        $this->level = $level;
        $this->random = $random;
        $this->random->setSeed($this->level->getSeed());
        $this->noiseBase = new Simplex($this->random, 4, 1 / 4, 1 / 32);
        $this->random->setSeed($this->level->getSeed());
        $this->selector = new BiomeSelector($this->random, function($temperature, $rainfall){
            if($rainfall < 0.25){
                if($temperature < 0.7){
                    return Biome::OCEAN;
                }elseif($temperature < 0.85){
                    return Biome::RIVER;
                }else{
                    return Biome::SWAMP;
                }
            }elseif($rainfall < 0.60){
                if($temperature < 0.25){
                    return Biome::ICE_PLAINS;
                }elseif($temperature < 0.75){
                    return Biome::PLAINS;
                }else{
                    return Biome::DESERT;
                }
            }elseif($rainfall < 0.80){
                if($temperature < 0.25){
                    return Biome::TAIGA;
                }elseif($temperature < 0.75){
                    return Biome::FOREST;
                }else{
                    return Biome::BIRCH_FOREST;
                }
            }else{
                if($temperature < 0.25){
                    return Biome::MOUNTAINS;
                }elseif($temperature < 0.70){
                    return Biome::SMALL_MOUNTAINS;
                }else{
                    return Biome::RIVER;
                }
            }
        }, Biome::getBiome(Biome::OCEAN));

        $this->selector->addBiome(Biome::getBiome(Biome::OCEAN));
        $this->selector->addBiome(Biome::getBiome(Biome::PLAINS));
        $this->selector->addBiome(Biome::getBiome(Biome::DESERT));
        $this->selector->addBiome(Biome::getBiome(Biome::MOUNTAINS));
        $this->selector->addBiome(Biome::getBiome(Biome::FOREST));
        $this->selector->addBiome(Biome::getBiome(Biome::TAIGA));
        $this->selector->addBiome(Biome::getBiome(Biome::SWAMP));
        $this->selector->addBiome(Biome::getBiome(Biome::RIVER));
        $this->selector->addBiome(Biome::getBiome(Biome::ICE_PLAINS));
        $this->selector->addBiome(Biome::getBiome(Biome::SMALL_MOUNTAINS));
        $this->selector->addBiome(Biome::getBiome(Biome::BIRCH_FOREST));
        $this->selector->addBiome(Biome::getBiome(Biome::BEACH));
        $this->selector->addBiome(Biome::getBiome(Biome::MESA));

        $this->selector->recalculate();

        $cover = new GroundCover();
        $this->generationPopulators[] = $cover;

        $cave = new Cave();
        $this->populators[] = $cave;

        $ores = new Ore();
        $ores->setOreTypes([
            new OreType(new CoalOre(), 20, 16, 0, 128),
            new OreType(New IronOre(), 20, 8, 0, 64),
            new OreType(new RedstoneOre(), 8, 7, 0, 16),
            new OreType(new LapisOre(), 1, 6, 0, 32),
            new OreType(new GoldOre(), 2, 8, 0, 32),
            new OreType(new DiamondOre(), 1, 7, 0, 16),
            new OreType(new Dirt(), 20, 32, 0, 128),
            new OreType(new Stone(Stone::GRANITE), 20, 32, 0, 128),
            new OreType(new Stone(Stone::DIORITE), 20, 32, 0, 128),
            new OreType(new Stone(Stone::ANDESITE), 20, 32, 0, 128),
            new OreType(new Gravel(), 10, 16, 0, 128)
        ]);
        $this->populators[] = $ores;
    }

pickBiome()

pickBiome	(		$x,
			$z
	)

                                     {
        $hash = $x * 2345803 ^ $z * 9236449 ^ $this->level->getSeed();
        $hash *= $hash + 223;
        $xNoise = $hash >> 20 & 3;
        $zNoise = $hash >> 22 & 3;
        if($xNoise == 3){
            $xNoise = 1;
        }
        if($zNoise == 3){
            $zNoise = 1;
        }

        return $this->selector->pickBiome($x + $xNoise - 1, $z + $zNoise - 1);
    }

populateChunk()

populateChunk	(		$chunkX,
			$chunkZ
	)

                                                   {
        $this->random->setSeed(0xdeadbeef ^ ($chunkX << 8) ^ $chunkZ ^ $this->level->getSeed());
        foreach($this->populators as $populator){
            $populator->populate($this->level, $chunkX, $chunkZ, $this->random);
        }

        $chunk = $this->level->getChunk($chunkX, $chunkZ);
        $biome = Biome::getBiome($chunk->getBiomeId(7, 7));
        $biome->populateChunk($this->level, $chunkX, $chunkZ, $this->random);
    }

Field Documentation

$bedrockDepth

$bedrockDepth = 5

protected

$generationPopulators

$generationPopulators = []

protected

$level

$level

protected

$noiseBase

$noiseBase

protected

$populators

$populators = []

protected

$random

$random

protected

$selector

$selector

protected

$waterHeight

$waterHeight = 62

protected

NAME

const NAME = "Normal"

---

The documentation for this class was generated from the following file:

• src/pocketmine/level/generator/normal/Normal.php