fix: matching constructors to wii u

i noticed constructor are different. still nothing changed :(

Minecraft.World/AddEdgeLayer.cpp

@@ -3,8 +3,8 @@
 #include "net.minecraft.world.level.biome.h"
 #include "IntCache.h"
 
-AddEdgeLayer::AddEdgeLayer(int64_t seed, std::shared_ptr<Layer> parent, int64_t seedMixup, int mode)
-    : Layer(seedMixup)
+AddEdgeLayer::AddEdgeLayer(int32_t seed, int64_t seedMixup,std::shared_ptr<Layer> parent, int mode)
+    : Layer(seed,seedMixup)
 {
     this->parent = parent;
     this->mode = mode;

Minecraft.World/AddEdgeLayer.h

@@ -14,7 +14,7 @@ private:
 
 
 public:
-    AddEdgeLayer(int64_t seed, std::shared_ptr<Layer> parent, int64_t seedMixup, int mode);
+    AddEdgeLayer(int32_t seed,  int64_t seedMixup, std::shared_ptr<Layer> parent,int mode);
     virtual ~AddEdgeLayer() {}
     intArray getArea(int xo, int yo, int w, int h) override;
 };

Minecraft.World/AddIslandLayer.cpp

@@ -2,7 +2,7 @@
 #include "net.minecraft.world.level.newbiome.layer.h"
 #include "net.minecraft.world.level.biome.h"
 
-AddIslandLayer::AddIslandLayer(int64_t seed, shared_ptr<Layer> parent, int64_t seedMixup) : Layer(seedMixup)
+AddIslandLayer::AddIslandLayer(int32_t seed, int64_t seedMixup,std::shared_ptr<Layer> parent) : Layer(seed,seedMixup)
 {
 	this->parent = parent;
 }

Minecraft.World/AddIslandLayer.h

@@ -5,7 +5,7 @@
 class AddIslandLayer : public Layer
 {
 public:
-	AddIslandLayer(int64_t seed, shared_ptr<Layer> parent, int64_t seedMixup);
+	AddIslandLayer(int32_t seed, int64_t seedMixup,std::shared_ptr<Layer> parent);
 
 	intArray getArea(int xo, int yo, int w, int h);
 };

Minecraft.World/AddMushroomIslandLayer.cpp

@@ -3,7 +3,7 @@
 #include "net.minecraft.world.level.biome.h"
 
 
-AddMushroomIslandLayer::AddMushroomIslandLayer(int64_t seed, shared_ptr<Layer> parent, int64_t seedMixup) : Layer(seedMixup)
+AddMushroomIslandLayer::AddMushroomIslandLayer(int32_t seed,int64_t seedMixup, shared_ptr<Layer> parent) : Layer(seed,seedMixup)
 {
 	this->parent = parent;
 }

Minecraft.World/AddMushroomIslandLayer.h

@@ -4,6 +4,6 @@
 class AddMushroomIslandLayer : public Layer
 {
 public:
-    AddMushroomIslandLayer(int64_t seed, shared_ptr<Layer> parent,int64_t seedMixup);
+    AddMushroomIslandLayer(int32_t seed,int64_t seedMixup,shared_ptr<Layer> parent);
     virtual intArray getArea(int xo, int yo, int w, int h);
 };

Minecraft.World/AddSnowLayer.cpp

@@ -2,7 +2,7 @@
 #include "net.minecraft.world.level.newbiome.layer.h"
 #include "net.minecraft.world.level.biome.h"
 
-AddSnowLayer::AddSnowLayer(int64_t seed, shared_ptr<Layer> parent, int64_t seedMixup) : Layer(seedMixup)
+AddSnowLayer::AddSnowLayer(int32_t seed, int64_t seedMixup, shared_ptr<Layer> parent) : Layer(seed,seedMixup)
 {
 	this->parent = parent;
 }

Minecraft.World/AddSnowLayer.h

@@ -4,6 +4,6 @@
 class AddSnowLayer : public Layer
 {
 public:
-    AddSnowLayer(int64_t seed, shared_ptr<Layer> parent, int64_t seedMixup);
+    AddSnowLayer(int32_t seed, int64_t seedMixup, shared_ptr<Layer> parent);
     virtual intArray getArea(int xo, int yo, int w, int h);
 };

Minecraft.World/BiomeEdgeLayer.cpp

@@ -3,7 +3,7 @@
 #include "net.minecraft.world.level.biome.h"
 #include "IntCache.h"
 
-BiomeEdgeLayer::BiomeEdgeLayer(int64_t seed, shared_ptr<Layer> parent, int64_t seedMixup) : Layer(seedMixup)
+BiomeEdgeLayer::BiomeEdgeLayer(int32_t seed, int64_t seedMixup, shared_ptr<Layer> parent) : Layer(seed,seedMixup)
 {
     this->parent = parent;
 }
@@ -92,3 +92,39 @@ bool BiomeEdgeLayer::isValidTemperatureEdge(int a1biome, int a2biome)
     
     return true; 
 }
+bool BiomeEdgeLayer::checkEdgeStrict(intArray& srcArray, intArray& destArray, int x, int z, int width, int centerBiome, unsigned int targetBiome, int replacementBiome)
+{
+
+    if ((unsigned int)centerBiome != targetBiome)
+    {
+        return false;
+    }
+
+
+    int northIndex = x + (z * (width + 2) + 1);
+    int southIndex = x + ((z + 2) * (width + 2) + 1);
+    int westIndex  = (x + (z + 1) * (width + 2));
+    int eastIndex  = (x + 2 + (z + 1) * (width + 2));
+
+    int biomeNorth = srcArray[northIndex];
+    int biomeSouth = srcArray[southIndex];
+    int biomeWest  = srcArray[westIndex];
+    int biomeEast  = srcArray[eastIndex];
+
+
+    if (Layer::isSame(biomeNorth, targetBiome) &&
+        Layer::isSame(biomeEast, targetBiome) &&
+        Layer::isSame(biomeWest, targetBiome) &&
+        Layer::isSame(biomeSouth, targetBiome))
+    {
+
+        destArray[x + z * width] = centerBiome;
+        return true;
+    }
+    else
+    {
+
+        destArray[x + z * width] = replacementBiome;
+        return true;
+    }
+}

Minecraft.World/BiomeEdgeLayer.h

@@ -4,12 +4,12 @@
 class BiomeEdgeLayer : public Layer
 {
 public:
-    BiomeEdgeLayer(int64_t seed, shared_ptr<Layer> parent, int64_t seedMixup);
+    BiomeEdgeLayer(int32_t seed, int64_t seedMixup, shared_ptr<Layer> parent);
     virtual ~BiomeEdgeLayer() {}
     virtual intArray getArea(int xo, int yo, int w, int h) override;
 
 private:
     static bool isValidTemperatureEdge(int a1biome, int a2biome);
     bool checkEdge(intArray& b, intArray& result, int x, int y, int w, int biome, int target, int replacement);
-    bool checkEdgeStrict(intArray& b, intArray& result, int x, int y, int w, int biome, int target, int replacement);
+    bool checkEdgeStrict(intArray& srcArray, intArray& destArray, int x, int z, int width, int centerBiome, unsigned int targetBiome, int replacementBiome);
 };

Minecraft.World/BiomeInitLayer.cpp

@@ -10,7 +10,7 @@ struct CustomizableSourceSettings {
     int biome;
 };
 
-BiomeInitLayer::BiomeInitLayer(int64_t seed, shared_ptr<Layer> parent, int64_t seedMixup, LevelType *levelType, void* superflatConfig) : Layer(seedMixup)
+BiomeInitLayer::BiomeInitLayer(int32_t seed, int64_t seedMixup, shared_ptr<Layer> parent, LevelType *levelType, void* superflatConfig) : Layer(seed,seedMixup)
 {
     this->parent = parent;
     this->customSettings = nullptr;

Minecraft.World/BiomeInitLayer.h

@@ -18,7 +18,7 @@ private:
     CustomizableSourceSettings* customSettings;
 
 public:
-    BiomeInitLayer(int64_t seed, shared_ptr<Layer> parent, int64_t seedMixup, LevelType *levelType, void* superflatConfig);
+    BiomeInitLayer(int32_t seed,  int64_t seedMixup, shared_ptr<Layer> parent, LevelType *levelType, void* superflatConfig);
     virtual ~BiomeInitLayer();
     intArray getArea(int xo, int yo, int w, int h) override;
 };

Minecraft.World/BiomeOverrideLayer.cpp

@@ -5,7 +5,7 @@
 #include "BiomeOverrideLayer.h"
 
 
-BiomeOverrideLayer::BiomeOverrideLayer(int seedMixup) : Layer(seedMixup)
+BiomeOverrideLayer::BiomeOverrideLayer(int32_t seed, int64_t seedMixup) :Layer(seed, seedMixup)
 {
 	m_biomeOverride = byteArray( width * height );
 

Minecraft.World/BiomeOverrideLayer.h

@@ -13,6 +13,6 @@ private:
 	byteArray m_biomeOverride;
 
 public:
-	BiomeOverrideLayer(int seedMixup);
-	intArray getArea(int xo, int yo, int w, int h);
+	BiomeOverrideLayer(int32_t seed, int64_t seedMixup);
+    intArray getArea(int xo, int yo, int w, int h);
 };

Minecraft.World/DeepOceanLayer.cpp

@@ -3,7 +3,7 @@
 #include "IntCache.h"
 #include "DeepOceanLayer.h"
 
-DeepOceanLayer::DeepOceanLayer(int64_t seed, shared_ptr<Layer> parent, int64_t seedMixup) : Layer(seedMixup)
+DeepOceanLayer::DeepOceanLayer(int32_t seed, int64_t seedMixup, shared_ptr<Layer> parent) : Layer(seed,seedMixup)
 {
 	this->parent = parent;
 }

Minecraft.World/DeepOceanLayer.h

@@ -5,7 +5,7 @@
 class DeepOceanLayer : public Layer
 {
 public:
-	DeepOceanLayer(int64_t seed, shared_ptr<Layer> parent, int64_t seedMixup);
+	DeepOceanLayer(int32_t seed, int64_t seedMixup, shared_ptr<Layer> parent);
 	virtual ~DeepOceanLayer() {}
 	virtual intArray getArea(int xo, int yo, int w, int h) override;
 };

Minecraft.World/DownfallLayer.cpp

@@ -2,7 +2,7 @@
 #include "net.minecraft.world.level.biome.h"
 #include "net.minecraft.world.level.newbiome.layer.h"
 
-DownfallLayer::DownfallLayer(shared_ptr<Layer>parent) : Layer(0)
+DownfallLayer::DownfallLayer(shared_ptr<Layer>parent) : Layer(0,0)
 {
 	this->parent = parent;
 }

Minecraft.World/DownfallMixerLayer.cpp

@@ -2,7 +2,7 @@
 #include "net.minecraft.world.level.biome.h"
 #include "net.minecraft.world.level.newbiome.layer.h"
 
-DownfallMixerLayer::DownfallMixerLayer(shared_ptr<Layer>downfall, shared_ptr<Layer>parent, int layer) : Layer(0)
+DownfallMixerLayer::DownfallMixerLayer(shared_ptr<Layer>downfall, shared_ptr<Layer>parent, int layer) : Layer(0,0)
 {
 	this->parent = parent;
 	this->downfall = downfall;

Minecraft.World/FlatLayer.cpp

@@ -1,7 +1,7 @@
 #include "stdafx.h"
 #include "net.minecraft.world.level.newbiome.layer.h"
 
-FlatLayer::FlatLayer(int val) : Layer(0)
+FlatLayer::FlatLayer(int val) : Layer(0,0)
 {
 	this->val = val;
 }

Minecraft.World/FuzzyZoomLayer.cpp

@@ -2,9 +2,11 @@
 #include "System.h"
 #include "net.minecraft.world.level.newbiome.layer.h"
 
-FuzzyZoomLayer::FuzzyZoomLayer(int64_t seed, shared_ptr<Layer> parent, int64_t seedMixup) : Layer(seedMixup)
+FuzzyZoomLayer::FuzzyZoomLayer(int32_t seed, int64_t seedMixup, shared_ptr<Layer> parent) 
+    : ZoomLayer(seed, seedMixup,parent) 
 {
-	this->parent = parent;
+
+    this->parent = parent; 
 }
 
 intArray FuzzyZoomLayer::getArea(int xo, int yo, int w, int h)
@@ -61,12 +63,12 @@ int FuzzyZoomLayer::random(int a, int b, int c, int d)
 	return d;
 }
 
-shared_ptr<Layer>FuzzyZoomLayer::zoom(int64_t seed, shared_ptr<Layer>sup, int count)
+shared_ptr<Layer> FuzzyZoomLayer::zoom(int32_t seed, int64_t seedMixup, shared_ptr<Layer> sup, int count)
 {
-	shared_ptr<Layer> result = sup;
-	for (int i = 0; i < count; i++)
-	{
-		result = std::make_shared<FuzzyZoomLayer>(seed, result, 0x7D0 + i);
-	}
-	return result;
+    shared_ptr<Layer> result = sup;
+    for (int i = 0; i < count; i++)
+    {
+        result = std::make_shared<ZoomLayer>(seed, seedMixup + i, result);
+    }
+    return result;
 }

Minecraft.World/FuzzyZoomLayer.h

@@ -1,11 +1,11 @@
 #pragma once
 
-#include "Layer.h"
+#include "ZoomLayer.h"
 
-class FuzzyZoomLayer : public Layer
+class FuzzyZoomLayer : public ZoomLayer
 {
 public:
-	FuzzyZoomLayer(int64_t seed, shared_ptr<Layer> parent, int64_t seedMixup);
+	FuzzyZoomLayer(int32_t seed, int64_t seedMixup, shared_ptr<Layer> parent);
     intArray getArea(int xo, int yo, int w, int h);
 
 protected:
@@ -13,5 +13,5 @@ protected:
     int random(int a, int b, int c, int d);
 
 public:
-	static shared_ptr<Layer>zoom(int64_t seed, shared_ptr<Layer>sup, int count);
+	static std::shared_ptr<Layer> zoom(int32_t seed, int64_t seedMixup, std::shared_ptr<Layer> sup, int count);
 };

Minecraft.World/GrowMushroomIslandLayer.cpp

@@ -3,7 +3,7 @@
 #include "net.minecraft.world.level.biome.h"
 
 
-GrowMushroomIslandLayer::GrowMushroomIslandLayer(int64_t seed, shared_ptr<Layer> parent, int64_t seedMixup) : Layer(seedMixup)
+GrowMushroomIslandLayer::GrowMushroomIslandLayer(int32_t seed, int64_t seedMixup, shared_ptr<Layer> parent) : Layer(seed,seedMixup)
 {
 	this->parent = parent;
 }

Minecraft.World/GrowMushroomIslandLayer.h

@@ -4,6 +4,6 @@
 class GrowMushroomIslandLayer : public Layer
 {
 public:
-    GrowMushroomIslandLayer(int64_t seed, shared_ptr<Layer> parent, int64_t seedMixup);
+    GrowMushroomIslandLayer(int32_t seed, int64_t seedMixup, shared_ptr<Layer> parent);
     virtual intArray getArea(int xo, int yo, int w, int h);
 };

Minecraft.World/ImposeContinentsLayer.cpp

@@ -15,7 +15,7 @@ bool dword_10073FD8[100] = {
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0
 };
 
-ImposeContinentsLayer::ImposeContinentsLayer(int64_t seed, shared_ptr<Layer> parent) : Layer(seed)
+ImposeContinentsLayer::ImposeContinentsLayer(int32_t seed,  int64_t seedMixup, shared_ptr<Layer> parent) : Layer(seed,seedMixup)
 {
     this->parent = parent;
 }

Minecraft.World/ImposeContinentsLayer.h

@@ -5,7 +5,7 @@
 class ImposeContinentsLayer : public Layer
 {
 public:
-    ImposeContinentsLayer(int64_t seed, shared_ptr<Layer> parent);
+    ImposeContinentsLayer(int32_t seed, int64_t seedMixup, shared_ptr<Layer> parent);
     virtual ~ImposeContinentsLayer();
 
     virtual intArray getArea(int xo, int yo, int w, int h) override;

Minecraft.World/IslandLayer.cpp

@@ -1,7 +1,7 @@
 #include "stdafx.h"
 #include "net.minecraft.world.level.newbiome.layer.h"
 
-IslandLayer::IslandLayer(int64_t seed, int64_t seedMixup) : Layer(seedMixup)
+IslandLayer::IslandLayer(int32_t seed, int64_t seedMixup) : Layer(seed, seedMixup)
 {
 }
 

Minecraft.World/IslandLayer.h

@@ -5,7 +5,7 @@
 class IslandLayer : public Layer
 {
 public:
-	IslandLayer(int64_t seed, int64_t seedMixup);
+	IslandLayer::IslandLayer(int32_t seed, int64_t seedMixup);
 
 	intArray getArea(int xo, int yo, int w, int h);
 };

Minecraft.World/Layer.cpp

@@ -22,25 +22,30 @@ LayerArray Layer::getDefaultLayers(int64_t seed, LevelType* levelType, void* sup
 {
     int32_t seed32 = (int32_t)seed;
 
-    shared_ptr<Layer> islandLayer = make_shared<IslandLayer>(seed32, 1);
-    islandLayer = make_shared<FuzzyZoomLayer>(seed32, islandLayer, 0x7D0);
-    islandLayer = make_shared<AddIslandLayer>(seed32, islandLayer, 1);
-    islandLayer = make_shared<ZoomLayer>(seed32, islandLayer, 0x7D1);
-    islandLayer = make_shared<AddIslandLayer>(seed32, islandLayer, 2);
-    islandLayer = make_shared<AddIslandLayer>(seed32, islandLayer, 0x32);
-    islandLayer = make_shared<AddIslandLayer>(seed32, islandLayer, 0x46);
-    islandLayer = make_shared<RemoveTooMuchOceanLayer>(seed32, islandLayer, 2);
-    islandLayer = make_shared<AddSnowLayer>(seed32, islandLayer, 2);
-    islandLayer = make_shared<AddIslandLayer>(seed32, islandLayer, 3);
-    islandLayer = make_shared<AddEdgeLayer>(seed32, islandLayer, 2, 0);
-    islandLayer = make_shared<AddEdgeLayer>(seed32, islandLayer, 2, 1);
-    islandLayer = make_shared<AddEdgeLayer>(seed32, islandLayer, 3, 2);
-    islandLayer = make_shared<ZoomLayer>(seed32, islandLayer, 0x7D2);
-    islandLayer = make_shared<ZoomLayer>(seed32, islandLayer, 0x7D3);
-    islandLayer = make_shared<AddIslandLayer>(seed32, islandLayer, 4);
-    islandLayer = make_shared<DeepOceanLayer>(seed32, islandLayer, 4);
 
-    shared_ptr<Layer> baseLayer = ZoomLayer::zoom(seed32, islandLayer, 0x3E8, 0);
+    shared_ptr<Layer> islandLayer = make_shared<IslandLayer>(seed32, 1LL);
+    islandLayer = make_shared<FuzzyZoomLayer>(seed32, 0x7D0LL, islandLayer);
+    islandLayer = make_shared<AddIslandLayer>(seed32, 1LL, islandLayer);
+    islandLayer = make_shared<ZoomLayer>(seed32, 0x7D1LL, islandLayer);
+    islandLayer = make_shared<AddIslandLayer>(seed32, 2LL, islandLayer);
+    islandLayer = make_shared<AddIslandLayer>(seed32, 0x32LL, islandLayer);
+    islandLayer = make_shared<AddIslandLayer>(seed32, 0x46LL, islandLayer);
+    islandLayer = make_shared<RemoveTooMuchOceanLayer>(seed32, 2LL, islandLayer);
+    islandLayer = make_shared<AddSnowLayer>(seed32, 2LL, islandLayer);
+    islandLayer = make_shared<AddIslandLayer>(seed32, 3LL, islandLayer);
+    
+
+    islandLayer = make_shared<AddEdgeLayer>(seed32, 2LL, islandLayer, 0);
+    islandLayer = make_shared<AddEdgeLayer>(seed32, 2LL, islandLayer, 1);
+    islandLayer = make_shared<AddEdgeLayer>(seed32, 3LL, islandLayer, 2);
+    
+    islandLayer = make_shared<ZoomLayer>(seed32, 0x7D2LL, islandLayer);
+    islandLayer = make_shared<ZoomLayer>(seed32, 0x7D3LL, islandLayer);
+    islandLayer = make_shared<AddIslandLayer>(seed32, 4LL, islandLayer);
+    islandLayer = make_shared<DeepOceanLayer>(seed32, 4LL, islandLayer);
+
+
+    shared_ptr<Layer> baseLayer = ZoomLayer::zoom(seed32, 0x3E8LL, islandLayer, 0);
 
     int zoomLevel = 4;
     int riverZoomCount = 4;
@@ -55,111 +60,126 @@ LayerArray Layer::getDefaultLayers(int64_t seed, LevelType* levelType, void* sup
     if (levelType == LevelType::lvl_largeBiomes)
         zoomLevel = 6;
 
-    shared_ptr<Layer> riverInit = make_shared<RiverInitLayer>(seed32, baseLayer, 0x64);
-    shared_ptr<Layer> hillsNoise = ZoomLayer::zoom(seed32, riverInit, 0x3E8, 2);
 
-    shared_ptr<Layer> riverLayerFinal = ZoomLayer::zoom(seed32, riverInit, 0x3E8, 2);
-    riverLayerFinal = ZoomLayer::zoom(seed32, riverLayerFinal, 0x3E8, riverZoomCount);
-    riverLayerFinal = make_shared<RiverLayer>(seed32, riverLayerFinal, 1);
-    riverLayerFinal = make_shared<SmoothLayer>(seed32, riverLayerFinal, 0x3E8);
+    shared_ptr<Layer> riverInit = make_shared<RiverInitLayer>(seed32, 0x64LL, baseLayer);
+    shared_ptr<Layer> hillsNoise = ZoomLayer::zoom(seed32, 0x3E8LL, riverInit, 2);
 
-    shared_ptr<Layer> biomeLayer = make_shared<BiomeInitLayer>(seed32, baseLayer, 0xC8, levelType, superflatConfig);
+    shared_ptr<Layer> riverLayerFinal = ZoomLayer::zoom(seed32, 0x3E8LL, riverInit, 2);
+    riverLayerFinal = ZoomLayer::zoom(seed32, 0x3E8LL, riverLayerFinal, riverZoomCount);
+    riverLayerFinal = make_shared<RiverLayer>(seed32, 1LL, riverLayerFinal);
+    riverLayerFinal = make_shared<SmoothLayer>(seed32, 0x3E8LL, riverLayerFinal);
+
+
+    shared_ptr<Layer> biomeLayer = make_shared<BiomeInitLayer>(seed32, 0xC8LL, baseLayer, levelType, superflatConfig);
 
     {
-    auto testBiome = make_shared<BiomeInitLayer>(seed32, baseLayer, 0xC8, levelType, superflatConfig);
-    testBiome->init((uint32_t)seed);
-    IntCache::releaseAll();
-    intArray testArea = testBiome->getArea(0, 0, 20, 20);
-    app.DebugPrintf("BiomeInitLayer only seed=%d:\n", seed32);
-    for (int z = 0; z < 20; z++) {
-        for (int x = 0; x < 20; x++)
-            app.DebugPrintf("%3d ", testArea[x + z*20]);
-        app.DebugPrintf("\n");
+        auto testBiome = make_shared<BiomeInitLayer>(seed32, 0xC8LL, baseLayer, levelType, superflatConfig);
+        testBiome->init((uint32_t)seed);
+        IntCache::releaseAll();
+        intArray testArea = testBiome->getArea(0, 0, 20, 20);
+        app.DebugPrintf("BiomeInitLayer only seed=%d:\n", seed32);
+        for (int z = 0; z < 20; z++) {
+            for (int x = 0; x < 20; x++)
+                app.DebugPrintf("%3d ", testArea[x + z*20]);
+            app.DebugPrintf("\n");
+        }
+        IntCache::releaseAll();
     }
-    IntCache::releaseAll();
-}
 
-    biomeLayer = make_shared<BiomeEdgeLayer>(seed32, biomeLayer, 0x3E8);
-    biomeLayer = make_shared<RegionHillsLayer>(seed32, biomeLayer, hillsNoise, 0x3E8);
+    biomeLayer = make_shared<BiomeEdgeLayer>(seed32, 0x3E8LL, biomeLayer);
+    
+
+    biomeLayer = make_shared<RegionHillsLayer>(seed32, 0x3E8LL, biomeLayer, hillsNoise);
+    
     {
-    auto testLayer = biomeLayer;
-    testLayer->init((uint32_t)seed);
-    IntCache::releaseAll();
-    intArray testArea = testLayer->getArea(0, 0, 20, 20);
-    app.DebugPrintf("After RegionHillsLayer seed=%d:\n", seed32);
-    for (int z = 0; z < 20; z++) {
-        for (int x = 0; x < 20; x++)
-            app.DebugPrintf("%3d ", testArea[x + z*20]);
-        app.DebugPrintf("\n");
+        auto testLayer = biomeLayer;
+        testLayer->init((uint32_t)seed);
+        IntCache::releaseAll();
+        intArray testArea = testLayer->getArea(0, 0, 20, 20);
+        app.DebugPrintf("After RegionHillsLayer seed=%d:\n", seed32);
+        for (int z = 0; z < 20; z++) {
+            for (int x = 0; x < 20; x++)
+                app.DebugPrintf("%3d ", testArea[x + z*20]);
+            app.DebugPrintf("\n");
+        }
+        IntCache::releaseAll();
     }
-    IntCache::releaseAll();
-}
 
-    biomeLayer = make_shared<RareBiomeSpotLayer>(seed32, biomeLayer, 0x3E9);
+    biomeLayer = make_shared<RareBiomeSpotLayer>(seed32, 0x3E9LL, biomeLayer);
+
 
     for (int i = 0; i < zoomLevel; ++i)
     {
-        biomeLayer = make_shared<ZoomLayer>(seed32, biomeLayer, 0x3E8 + i);
+      
+        biomeLayer = make_shared<ZoomLayer>(seed32, (int64_t)(0x3E8 + i), biomeLayer);
         if (i == 0)
         {
-            biomeLayer = make_shared<AddIslandLayer>(seed32, biomeLayer, 3);
-            biomeLayer = make_shared<AddMushroomIslandLayer>(seed32, biomeLayer, 5);
+            biomeLayer = make_shared<AddIslandLayer>(seed32, 3LL, biomeLayer);
+            biomeLayer = make_shared<AddMushroomIslandLayer>(seed32, 5LL, biomeLayer);
         }
         if (zoomLevel == 1 || i == 1)
         {
-            biomeLayer = make_shared<GrowMushroomIslandLayer>(seed32, biomeLayer, 5);
-            biomeLayer = make_shared<ShoreLayer>(seed32, biomeLayer, 0x3E8);
+            biomeLayer = make_shared<GrowMushroomIslandLayer>(seed32, 5LL, biomeLayer);
+            biomeLayer = make_shared<ShoreLayer>(seed32, 0x3E8LL, biomeLayer);
         }
     }
 
-    biomeLayer = make_shared<SmoothLayer>(seed32, biomeLayer, 0x3E8);
+    biomeLayer = make_shared<SmoothLayer>(seed32, 0x3E8LL, biomeLayer);
+    
     {
-    auto testLayer = biomeLayer;
-    testLayer->init((uint32_t)seed);
-    IntCache::releaseAll();
-    intArray testArea = testLayer->getArea(60, 240, 20, 20);
-    app.DebugPrintf("After zoom loop seed=%d:\n", seed32);
-    for (int z = 0; z < 20; z++) {
-        for (int x = 0; x < 20; x++)
-            app.DebugPrintf("%3d ", testArea[x + z*20]);
-        app.DebugPrintf("\n");
+        auto testLayer = biomeLayer;
+        testLayer->init((uint32_t)seed);
+        IntCache::releaseAll();
+        intArray testArea = testLayer->getArea(60, 240, 20, 20);
+        app.DebugPrintf("After zoom loop seed=%d:\n", seed32);
+        for (int z = 0; z < 20; z++) {
+            for (int x = 0; x < 20; x++)
+                app.DebugPrintf("%3d ", testArea[x + z*20]);
+            app.DebugPrintf("\n");
+        }
+        IntCache::releaseAll();
     }
-    IntCache::releaseAll();
-}
-    shared_ptr<Layer> mixed = make_shared<RiverMixerLayer>(seed32, biomeLayer, riverLayerFinal, 0x64);
-    shared_ptr<Layer> voronoi = make_shared<VoronoiZoom>(seed32, mixed, 0xA);
+    
+
+    shared_ptr<Layer> mixed = make_shared<RiverMixerLayer>(seed32, 0x64LL, biomeLayer, riverLayerFinal);
+    shared_ptr<Layer> voronoi = make_shared<VoronoiZoom>(seed32, 0xALL, mixed);
 
     mixed->init((uint32_t)seed);
     voronoi->init((uint32_t)seed);
 
-IntCache::releaseAll();
-mixed->init((uint32_t)seed);
-intArray testArea = mixed->getArea(0, 200, 60, 60);
-app.DebugPrintf("Biomes 0-60, 200-260 seed=%d:\n", seed32);
-for (int z = 0; z < 60; z++) {
-    for (int x = 0; x < 60; x++)
-        app.DebugPrintf("%3d ", testArea[x + z*60]);
-    app.DebugPrintf("\n");
-}
-IntCache::releaseAll();
+    IntCache::releaseAll();
+    mixed->init((uint32_t)seed);
+    intArray testArea = mixed->getArea(0, 200, 60, 60);
+    app.DebugPrintf("Biomes 0-60, 200-260 seed=%d:\n", seed32);
+    for (int z = 0; z < 60; z++) {
+        for (int x = 0; x < 60; x++)
+            app.DebugPrintf("%3d ", testArea[x + z*60]);
+        app.DebugPrintf("\n");
+    }
+    IntCache::releaseAll();
 
     LayerArray result(3, false);
     result[0] = mixed;
     result[1] = voronoi;
     result[2] = mixed;
 
-
     return result;
 }
-Layer::Layer(int64_t s)
+
+Layer::Layer(int32_t seed, int64_t seedMixup)
 {
-    int64_t sm = (int64_t)(int32_t)s;
-    int64_t a = sm * (0x5851F42D4C957F2DLL * sm + 0x14057B7EF767814FLL) + sm;
-    int64_t b = (0x5851F42D4C957F2DLL * a + 0x14057B7EF767814FLL) * a + sm;
-    this->seedMixup = b * (0x5851F42D4C957F2DLL * b + 0x14057B7EF767814FLL) + sm;
-    this->parent = nullptr;
+
     this->seed = 0;
+
+    this->parent = nullptr;
+
     this->rval = 0;
+
+
+    int64_t a = seedMixup * (0x5851F42D4C957F2DLL * seedMixup + 0x14057B7EF767814FLL) + seedMixup;
+    int64_t b = (0x5851F42D4C957F2DLL * a + 0x14057B7EF767814FLL) * a + seedMixup;
+
+    this->seedMixup = b * (0x5851F42D4C957F2DLL * b + 0x14057B7EF767814FLL) + seedMixup;
 }
 
 void Layer::initRandom(int64_t x, int64_t y)

Minecraft.World/Layer.h

@@ -14,7 +14,7 @@ public:
 
 public:
     static LayerArray getDefaultLayers(int64_t seed, LevelType *levelType, void* superflatConfig = nullptr);
-    Layer(int64_t seedMixup);
+    Layer(int32_t seed, int64_t seedMixup);
     virtual void init(int64_t seed);
     bool isOcean(int biomeId);
     bool isSame(int biomeIdA, int biomeIdB);

Minecraft.World/RareBiomeLayer.cpp

@@ -3,7 +3,7 @@
 #include "IntCache.h"
 #include "RareBiomeLayer.h"
 
-RareBiomeLayer::RareBiomeLayer(int64_t seed, shared_ptr<Layer> parent) : Layer(seed)
+RareBiomeLayer::RareBiomeLayer(int32_t seed, shared_ptr<Layer> parent) : Layer(seed,seedMixup)
 {
 	this->parent = parent;
 }

Minecraft.World/RareBiomeLayer.h

@@ -5,7 +5,7 @@
 class RareBiomeLayer : public Layer
 {
 public:
-	RareBiomeLayer(int64_t seed, shared_ptr<Layer> parent);
+	RareBiomeLayer(int32_t seed, shared_ptr<Layer> parent);
 	virtual ~RareBiomeLayer() {}
 	virtual intArray getArea(int xo, int yo, int w, int h) override;
 };

Minecraft.World/RareBiomeSpotLayer.cpp

@@ -3,7 +3,7 @@
 #include "IntCache.h"
 #include "net.minecraft.world.level.biome.h"
 
-RareBiomeSpotLayer::RareBiomeSpotLayer(int64_t seed, std::shared_ptr<Layer> parent, int64_t seedMixup) : Layer(seedMixup)
+RareBiomeSpotLayer::RareBiomeSpotLayer(int32_t seed, int64_t seedMixup, shared_ptr<Layer> parent) : Layer(seed,seedMixup)
 {
 	this->parent = parent;
 }

Minecraft.World/RareBiomeSpotLayer.h

@@ -5,6 +5,6 @@
 class RareBiomeSpotLayer : public Layer
 {
 public:
-	RareBiomeSpotLayer(int64_t seed, std::shared_ptr<Layer> parent, int64_t seedMixup);
+	RareBiomeSpotLayer(int32_t seed, int64_t seedMixup, shared_ptr<Layer> parent);
 	virtual intArray getArea(int xo, int yo, int w, int h) override;
 };

Minecraft.World/RegionHillsLayer.cpp

@@ -5,16 +5,11 @@
 
 
 
-RegionHillsLayer::RegionHillsLayer(int64_t seed, shared_ptr<Layer> parent) : Layer(seed)
+RegionHillsLayer::RegionHillsLayer(int32_t seed, int64_t seedMixup, shared_ptr<Layer> parent, shared_ptr<Layer> riverNoise) 
+    : Layer(seed, seedMixup) 
 {
-	this->parent = parent;
-	this->riverNoise = nullptr;
-}
-
-RegionHillsLayer::RegionHillsLayer(int64_t seed, shared_ptr<Layer> parent, shared_ptr<Layer> riverNoise, int64_t seedMixup) : Layer(seedMixup)
-{
-	this->parent     = parent;
-	this->riverNoise = riverNoise;
+    this->parent = parent;
+    this->riverNoise = riverNoise;
 }
 
 void RegionHillsLayer::init(int64_t seed)
@@ -84,7 +79,7 @@ intArray RegionHillsLayer::getArea(int xo, int yo, int w, int h)
 				}
 				else if (k == Biome::roofedForest->id)
 				{
-					// Java: roofedForest -> plains 
+					
 					i1 = Biome::plains->id;
 				}
 				else if (k == Biome::taiga->id)

Minecraft.World/RegionHillsLayer.h

@@ -5,11 +5,11 @@
 class RegionHillsLayer : public Layer
 {
 private:
-    shared_ptr<Layer> riverNoise; // second parent: zoomed river init layer used as noise source
+    shared_ptr<Layer> riverNoise;
 
 public:
-    RegionHillsLayer(int64_t seed, shared_ptr<Layer> parent);
-    RegionHillsLayer(int64_t seed, shared_ptr<Layer> parent, shared_ptr<Layer> riverNoise, int64_t seedMixup);
+   
+    RegionHillsLayer(int32_t seed, int64_t seedMixup, shared_ptr<Layer> parent, shared_ptr<Layer> riverNoise);
 
     virtual void init(int64_t seed) override;
     virtual intArray getArea(int xo, int yo, int w, int h) override;

Minecraft.World/RemoveTooMuchOceanLayer.cpp

@@ -3,7 +3,7 @@
 #include "IntCache.h"
 #include "RemoveTooMuchOceanLayer.h"
 
-RemoveTooMuchOceanLayer::RemoveTooMuchOceanLayer(int64_t seed, shared_ptr<Layer> parent, int64_t seedMixup) : Layer(seedMixup)
+RemoveTooMuchOceanLayer::RemoveTooMuchOceanLayer(int32_t seed, int64_t seedMixup, shared_ptr<Layer> parent) : Layer(seed,seedMixup)
 {
     this->parent = parent;
 }

Minecraft.World/RemoveTooMuchOceanLayer.h

@@ -5,7 +5,7 @@
 class RemoveTooMuchOceanLayer : public Layer
 {
 public:
-	RemoveTooMuchOceanLayer(int64_t seed, shared_ptr<Layer> parent, int64_t seedMixup);
+	RemoveTooMuchOceanLayer(int32_t seed, int64_t seedMixup, shared_ptr<Layer> parent);
 	virtual ~RemoveTooMuchOceanLayer() {}
 	virtual intArray getArea(int xo, int yo, int w, int h) override;
 };

Minecraft.World/RiverInitLayer.cpp

@@ -2,7 +2,7 @@
 #include "RiverInitLayer.h"
 #include "net.minecraft.world.level.newbiome.layer.h"
 
-RiverInitLayer::RiverInitLayer(int64_t seed, std::shared_ptr<Layer> parent, int64_t seedMixup) : Layer(seedMixup)
+RiverInitLayer::RiverInitLayer(int32_t seed, int64_t seedMixup, shared_ptr<Layer> parent) : Layer(seed,seedMixup)
 {
 	this->parent = parent;
 }

Minecraft.World/RiverInitLayer.h

@@ -5,7 +5,7 @@
 class RiverInitLayer : public Layer
 {
 public:
-	RiverInitLayer(int64_t seed, std::shared_ptr<Layer> parent, int64_t seedMixup);
+	RiverInitLayer(int32_t seed, int64_t seedMixup, shared_ptr<Layer> parent);
 
 	intArray getArea(int xo, int yo, int w, int h);
 };

Minecraft.World/RiverLayer.cpp

@@ -2,7 +2,7 @@
 #include "net.minecraft.world.level.biome.h"
 #include "net.minecraft.world.level.newbiome.layer.h"
 
-RiverLayer::RiverLayer(int64_t seed, shared_ptr<Layer> parent, int64_t seedMixup) : Layer(seedMixup)
+RiverLayer::RiverLayer(int32_t seed, int64_t seedMixup, shared_ptr<Layer> parent) : Layer(seed,seedMixup)
 {
 	this->parent = parent;
 }

Minecraft.World/RiverLayer.h

@@ -5,6 +5,6 @@
 class RiverLayer : public Layer
 {
 public:
-	RiverLayer(int64_t seed, shared_ptr<Layer> parent, int64_t seedMixup);
+	RiverLayer(int32_t seed, int64_t seedMixup, shared_ptr<Layer> parent);
 	intArray getArea(int xo, int yo, int w, int h);
 };

Minecraft.World/RiverMixerLayer.cpp

@@ -2,10 +2,11 @@
 #include "net.minecraft.world.level.biome.h"
 #include "net.minecraft.world.level.newbiome.layer.h"
 
-RiverMixerLayer::RiverMixerLayer(int64_t seed, shared_ptr<Layer> biomes, shared_ptr<Layer> rivers, int64_t seedMixup) : Layer(seedMixup)
+RiverMixerLayer::RiverMixerLayer(int32_t seed, int64_t seedMixup, std::shared_ptr<Layer> biomes, std::shared_ptr<Layer> rivers)
+    : Layer(seed, seedMixup)
 {
-	this->biomes = biomes;
-	this->rivers = rivers;
+    this->biomes = biomes;
+    this->rivers = rivers;
 }
 
 void RiverMixerLayer::init(int64_t seed)

Minecraft.World/RiverMixerLayer.h

@@ -9,7 +9,7 @@ private:
 	shared_ptr<Layer>rivers;
 
 public:
-	RiverMixerLayer(int64_t seed, shared_ptr<Layer> biomes, shared_ptr<Layer> rivers, int64_t seedMixup);
+	RiverMixerLayer(int32_t seed, int64_t seedMixup, std::shared_ptr<Layer> biomes, std::shared_ptr<Layer> rivers)	;
 
 	virtual void init(int64_t seed);
 	virtual intArray getArea(int xo, int yo, int w, int h);

Minecraft.World/ShoreLayer.cpp

@@ -3,7 +3,7 @@
 #include "net.minecraft.world.level.biome.h"
 #include "IntCache.h"
 
-ShoreLayer::ShoreLayer(int64_t seed, shared_ptr<Layer> parent, int64_t seedMixup) : Layer(seedMixup)
+ShoreLayer::ShoreLayer(int32_t seed, int64_t seedMixup, shared_ptr<Layer> parent) : Layer(seed,seedMixup)
 {
 	this->parent = parent;
 }

Minecraft.World/ShoreLayer.h

@@ -4,7 +4,7 @@
 class ShoreLayer : public Layer
 {
 public:
-    ShoreLayer(int64_t seed, shared_ptr<Layer> parent, int64_t seedMixup);
+    ShoreLayer(int32_t seed,int64_t seedMixup, shared_ptr<Layer> parent );
     virtual intArray getArea(int xo, int yo, int w, int h);
 private:
     void replaceIfNeighborOcean(intArray& b, intArray& result, int x, int y, int w, int old, int replacement);

Minecraft.World/SmoothLayer.cpp

@@ -1,7 +1,7 @@
 #include "stdafx.h"
 #include "net.minecraft.world.level.newbiome.layer.h"
 
-SmoothLayer::SmoothLayer(int64_t seed, shared_ptr<Layer> parent, int64_t seedMixup) : Layer(seedMixup)
+SmoothLayer::SmoothLayer(int32_t seed,  int64_t seedMixup,shared_ptr<Layer> parent) : Layer(seed,seedMixup)
 {
 	this->parent = parent;
 }

Minecraft.World/SmoothLayer.h

@@ -5,7 +5,7 @@
 class SmoothLayer : public Layer
 {
 public:
-	SmoothLayer(int64_t seed, shared_ptr<Layer> parent, int64_t seedMixup);
+	SmoothLayer(int32_t seed,  int64_t seedMixup,shared_ptr<Layer> parent);
 
 	virtual intArray getArea(int xo, int yo, int w, int h);
 };

Minecraft.World/SmoothZoomLayer.cpp

@@ -2,9 +2,10 @@
 #include "net.minecraft.world.level.newbiome.layer.h"
 #include "System.h"
 
-SmoothZoomLayer::SmoothZoomLayer(int64_t seedMixup, shared_ptr<Layer>parent) : Layer(seedMixup)
+SmoothZoomLayer::SmoothZoomLayer(int32_t seed, int64_t seedMixup, shared_ptr<Layer> parent) 
+    : Layer(seed, seedMixup)
 {
-	this->parent = parent;
+    this->parent = parent;
 }
 
 intArray SmoothZoomLayer::getArea(int xo, int yo, int w, int h)
@@ -50,12 +51,13 @@ intArray SmoothZoomLayer::getArea(int xo, int yo, int w, int h)
 	return result;
 }
 
-shared_ptr<Layer>SmoothZoomLayer::zoom(int64_t seed, shared_ptr<Layer>sup, int count)
+shared_ptr<Layer> SmoothZoomLayer::zoom(int32_t seed, int64_t seedMixup, shared_ptr<Layer> sup, int count)
 {
-	shared_ptr<Layer>result = sup;
-	for (int i = 0; i < count; i++)
-	{
-		result = std::make_shared<SmoothZoomLayer>(seed + i, result);
-	}
-	return result;
+    shared_ptr<Layer> result = sup;
+    for (int i = 0; i < count; i++)
+    {
+        
+        result = std::make_shared<SmoothZoomLayer>(seed, seedMixup + i, result);
+    }
+    return result;
 }

Minecraft.World/SmoothZoomLayer.h

@@ -5,8 +5,9 @@
 class SmoothZoomLayer : public Layer
 {
 public:
-	SmoothZoomLayer(int64_t seedMixup, shared_ptr<Layer>parent);
+	public:
+    SmoothZoomLayer(int32_t seed, int64_t seedMixup, std::shared_ptr<Layer> parent);
 
 	virtual intArray getArea(int xo, int yo, int w, int h);
-	static shared_ptr<Layer>zoom(int64_t seed, shared_ptr<Layer>sup, int count);
+	static shared_ptr<Layer>zoom(int32_t seed, int64_t seedMixup, shared_ptr<Layer> sup, int count);
 };

Minecraft.World/SwampRiversLayer.cpp

@@ -3,7 +3,7 @@
 #include "IntCache.h"
 #include "SwampRiversLayer.h"
 
-SwampRiversLayer::SwampRiversLayer(int64_t seed, shared_ptr<Layer> parent) : Layer(seed)
+SwampRiversLayer::SwampRiversLayer(int32_t seed, shared_ptr<Layer> parent) : Layer(seed,seedMixup)
 {
 	this->parent = parent;
 }

Minecraft.World/SwampRiversLayer.h

@@ -5,7 +5,7 @@
 class SwampRiversLayer : public Layer
 {
 public:
-	SwampRiversLayer(int64_t seed, shared_ptr<Layer> parent);
+	SwampRiversLayer(int32_t seed, shared_ptr<Layer> parent);
 
 	intArray getArea(int xo, int yo, int w, int h);
 };

Minecraft.World/TemperatureLayer.cpp

@@ -2,7 +2,7 @@
 #include "net.minecraft.world.level.biome.h"
 #include "net.minecraft.world.level.newbiome.layer.h"
 
-TemperatureLayer::TemperatureLayer(shared_ptr<Layer> parent) : Layer(0)
+TemperatureLayer::TemperatureLayer(shared_ptr<Layer> parent) : Layer(0,0)
 {
 	this->parent = parent;
 }

Minecraft.World/TemperatureMixerLayer.cpp

@@ -2,7 +2,7 @@
 #include "net.minecraft.world.level.biome.h"
 #include "net.minecraft.world.level.newbiome.layer.h"
 
-TemperatureMixerLayer::TemperatureMixerLayer(shared_ptr<Layer>temp, shared_ptr<Layer>parent, int layer) : Layer(0)
+TemperatureMixerLayer::TemperatureMixerLayer(shared_ptr<Layer>temp, shared_ptr<Layer>parent, int layer) : Layer(0,0)
 {
 	this->parent = parent;
 	this->temp = temp;

Minecraft.World/VoronoiZoom.cpp

@@ -2,7 +2,7 @@
 #include "net.minecraft.world.level.newbiome.layer.h"
 #include "System.h"
 
-VoronoiZoom::VoronoiZoom(int64_t seed, shared_ptr<Layer> parent, int64_t seedMixup) : Layer(seedMixup)
+VoronoiZoom::VoronoiZoom(int32_t seed,  int64_t seedMixup, shared_ptr<Layer> parent) : Layer(seed,seedMixup)
 {
     this->parent = parent;
 }

Minecraft.World/VoronoiZoom.h

@@ -5,7 +5,7 @@
 class VoronoiZoom : public Layer
 {
 public:
-	VoronoiZoom(int64_t seed, shared_ptr<Layer> parent, int64_t seedMixup);
+	VoronoiZoom(int32_t seed,  int64_t seedMixup, shared_ptr<Layer> parent);
 
 	virtual intArray getArea(int xo, int yo, int w, int h);
 

Minecraft.World/ZoomLayer.cpp

@@ -2,9 +2,10 @@
 #include "net.minecraft.world.level.newbiome.layer.h"
 #include "System.h"
 
-ZoomLayer::ZoomLayer(int64_t seed, shared_ptr<Layer> parent, int64_t seedMixup) : Layer(seedMixup)
+ZoomLayer::ZoomLayer(int32_t seed, int64_t seedMixup, shared_ptr<Layer> parent) 
+    : Layer(seed, seedMixup) 
 {
-	this->parent = parent;
+    this->parent = parent; 
 }
 
 intArray ZoomLayer::getArea(int xo, int yo, int w, int h)
@@ -70,12 +71,13 @@ int ZoomLayer::random(int a, int b, int c, int d)
     return d;
 }
 
-shared_ptr<Layer>ZoomLayer::zoom(int64_t seed, shared_ptr<Layer> sup, int64_t seedMixup, int count)
+shared_ptr<Layer> ZoomLayer::zoom(int32_t seed, int64_t seedMixup, shared_ptr<Layer> sup, int count)
 {
-	shared_ptr<Layer>result = sup;
-	for (int i = 0; i < count; i++)
-	{
-		result = std::make_shared<ZoomLayer>(seed, result, seedMixup + i);
-	}
-	return result;
+    shared_ptr<Layer> result = sup;
+    for (int i = 0; i < count; i++)
+    {
+        
+        result = std::make_shared<ZoomLayer>(seed, seedMixup + i, result);
+    }
+    return result;
 }

Minecraft.World/ZoomLayer.h

@@ -5,8 +5,7 @@
 class ZoomLayer : public Layer
 {
 public:
-	ZoomLayer(int64_t seed, shared_ptr<Layer> parent,int64_t seedMixup);
-
+	ZoomLayer::ZoomLayer(int32_t seed, int64_t seedMixup, shared_ptr<Layer> parent);
 	virtual intArray getArea(int xo, int yo, int w, int h);
 
 protected:
@@ -14,5 +13,5 @@ protected:
 	int random(int a, int b, int c, int d);
 
 public:
-	static shared_ptr<Layer> zoom(int64_t seed, shared_ptr<Layer> sup, int64_t seedMixup, int count);
+	static shared_ptr<Layer> zoom(int32_t seed, int64_t seedMixup, shared_ptr<Layer> sup, int count);
 };