Added the End height and composition generators.

Also made the dimension in world.ini specifiable by a string. Exported StringToDimension() and StringToBiome() to Lua API.

git-svn-id: http://mc-server.googlecode.com/svn/trunk@1621 0a769ca7-a7f5-676a-18bf-c427514a06d6

VC2008/MCServer.vcproj

@@ -1716,6 +1716,14 @@
 					RelativePath="..\source\Generating\DistortedHeightmap.h"
 					>
 				</File>
+				<File
+					RelativePath="..\source\Generating\EndGen.cpp"
+					>
+				</File>
+				<File
+					RelativePath="..\source\Generating\EndGen.h"
+					>
+				</File>
 				<File
 					RelativePath="..\source\Generating\FinishGen.cpp"
 					>

source/Bindings.cpp

@@ -1,6 +1,6 @@
 /*
 ** Lua binding: AllToLua
-** Generated automatically by tolua++-1.0.92 on 06/21/13 23:03:07.
+** Generated automatically by tolua++-1.0.92 on 06/22/13 19:31:23.
 */
 
 #ifndef __cplusplus
@@ -2532,6 +2532,66 @@ static int tolua_AllToLua_ItemToFullString00(lua_State* tolua_S)
 }
 #endif //#ifndef TOLUA_DISABLE
 
+/* function: StringToBiome */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_StringToBiome00
+static int tolua_AllToLua_StringToBiome00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+     !tolua_iscppstring(tolua_S,1,0,&tolua_err) ||
+     !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+  goto tolua_lerror;
+ else
+#endif
+ {
+  const AString a_BiomeString = ((const AString)  tolua_tocppstring(tolua_S,1,0));
+  {
+   EMCSBiome tolua_ret = (EMCSBiome)  StringToBiome(a_BiomeString);
+   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
+   tolua_pushcppstring(tolua_S,(const char*)a_BiomeString);
+  }
+ }
+ return 2;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'StringToBiome'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* function: StringToDimension */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_StringToDimension00
+static int tolua_AllToLua_StringToDimension00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+     !tolua_iscppstring(tolua_S,1,0,&tolua_err) ||
+     !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+  goto tolua_lerror;
+ else
+#endif
+ {
+  const AString a_DimensionString = ((const AString)  tolua_tocppstring(tolua_S,1,0));
+  {
+   eDimension tolua_ret = (eDimension)  StringToDimension(a_DimensionString);
+   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
+   tolua_pushcppstring(tolua_S,(const char*)a_DimensionString);
+  }
+ }
+ return 2;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'StringToDimension'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
 /* get function: g_BlockLightValue */
 #ifndef TOLUA_DISABLE_tolua_get_AllToLua_g_BlockLightValue
 static int tolua_get_AllToLua_g_BlockLightValue(lua_State* tolua_S)
@@ -10795,7 +10855,7 @@ static int tolua_AllToLua_cWorld_GetDimension00(lua_State* tolua_S)
   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetDimension'", NULL);
 #endif
   {
-   cWorld::eDimension tolua_ret = (cWorld::eDimension)  self->GetDimension();
+   eDimension tolua_ret = (eDimension)  self->GetDimension();
    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
   }
  }
@@ -27713,11 +27773,16 @@ TOLUA_API int tolua_AllToLua_open (lua_State* tolua_S)
   tolua_constant(tolua_S,"E_ENTITY_TYPE_OCELOT",E_ENTITY_TYPE_OCELOT);
   tolua_constant(tolua_S,"E_ENTITY_TYPE_IRON_GOLEM",E_ENTITY_TYPE_IRON_GOLEM);
   tolua_constant(tolua_S,"E_ENTITY_TYPE_VILLAGER",E_ENTITY_TYPE_VILLAGER);
+  tolua_constant(tolua_S,"dimNether",dimNether);
+  tolua_constant(tolua_S,"dimOverworld",dimOverworld);
+  tolua_constant(tolua_S,"dimEnd",dimEnd);
   tolua_function(tolua_S,"BlockStringToType",tolua_AllToLua_BlockStringToType00);
   tolua_function(tolua_S,"StringToItem",tolua_AllToLua_StringToItem00);
   tolua_function(tolua_S,"ItemToString",tolua_AllToLua_ItemToString00);
   tolua_function(tolua_S,"ItemTypeToString",tolua_AllToLua_ItemTypeToString00);
   tolua_function(tolua_S,"ItemToFullString",tolua_AllToLua_ItemToFullString00);
+  tolua_function(tolua_S,"StringToBiome",tolua_AllToLua_StringToBiome00);
+  tolua_function(tolua_S,"StringToDimension",tolua_AllToLua_StringToDimension00);
   tolua_array(tolua_S,"g_BlockLightValue",tolua_get_AllToLua_g_BlockLightValue,tolua_set_AllToLua_g_BlockLightValue);
   tolua_array(tolua_S,"g_BlockSpreadLightFalloff",tolua_get_AllToLua_g_BlockSpreadLightFalloff,tolua_set_AllToLua_g_BlockSpreadLightFalloff);
   tolua_array(tolua_S,"g_BlockTransparent",tolua_get_AllToLua_g_BlockTransparent,tolua_set_AllToLua_g_BlockTransparent);
@@ -28144,9 +28209,6 @@ TOLUA_API int tolua_AllToLua_open (lua_State* tolua_S)
   tolua_endmodule(tolua_S);
   tolua_cclass(tolua_S,"cWorld","cWorld","",NULL);
   tolua_beginmodule(tolua_S,"cWorld");
-   tolua_constant(tolua_S,"dimNether",cWorld::dimNether);
-   tolua_constant(tolua_S,"dimOverworld",cWorld::dimOverworld);
-   tolua_constant(tolua_S,"dimEnd",cWorld::dimEnd);
    tolua_function(tolua_S,"GetClassStatic",tolua_AllToLua_cWorld_GetClassStatic00);
    tolua_function(tolua_S,"GetTime",tolua_AllToLua_cWorld_GetTime00);
    tolua_function(tolua_S,"GetTicksUntilWeatherChange",tolua_AllToLua_cWorld_GetTicksUntilWeatherChange00);

source/Bindings.h

@@ -1,6 +1,6 @@
 /*
 ** Lua binding: AllToLua
-** Generated automatically by tolua++-1.0.92 on 06/21/13 23:03:08.
+** Generated automatically by tolua++-1.0.92 on 06/22/13 19:31:24.
 */
 
 /* Exported function */

source/BlockID.cpp

@@ -290,6 +290,7 @@ EMCSBiome StringToBiome(const AString & a_BiomeString)
 		{biHell,             "Hell"},
 		{biHell,             "Nether"},
 		{biSky,              "Sky"},
+		{biSky,              "End"},
 		{biFrozenOcean,      "FrozenOcean"},
 		{biFrozenRiver,      "FrozenRiver"},
 		{biIcePlains,        "IcePlains"},
@@ -320,6 +321,46 @@ EMCSBiome StringToBiome(const AString & a_BiomeString)
 
 
 
+eDimension StringToDimension(const AString & a_DimensionString)
+{
+	int res = atoi(a_DimensionString.c_str());
+	if ((res != 0) || (a_DimensionString == "0"))
+	{
+		// It was a valid number
+		return (eDimension)res;
+	}
+	
+	// Convert using a built-in map:
+	static struct
+	{
+		eDimension m_Dimension;
+		const char * m_String;
+	} DimensionMap [] =
+	{
+		{ dimOverworld, "Overworld"},
+		{ dimOverworld, "Normal"},
+		{ dimOverworld, "World"},
+		{ dimNether,    "Nether"},
+		{ dimNether,    "Hell"},  // Alternate name for End
+		{ dimEnd,       "End"},
+		{ dimEnd,       "Sky"},  // Old name for End
+	} ;
+	for (int i = 0; i < ARRAYCOUNT(DimensionMap); i++)
+	{
+		if (NoCaseCompare(DimensionMap[i].m_String, a_DimensionString) == 0)
+		{
+			return DimensionMap[i].m_Dimension;
+		}
+	}  // for i - DimensionMap[]
+	
+	// Not found
+	return (eDimension)-1000;
+}
+
+
+
+
+
 // This is actually just some code that needs to run at program startup, so it is wrapped into a global var's constructor:
 class cBlockPropertiesInitializer
 {

source/BlockID.h

@@ -602,6 +602,18 @@ enum
 	E_ENTITY_TYPE_IRON_GOLEM    = 99,
 	E_ENTITY_TYPE_VILLAGER      = 120,
 } ;
+
+
+
+
+enum eDimension
+{
+	dimNether    = -1,
+	dimOverworld = 0,
+	dimEnd       = 1,
+} ;
+
+
 // tolua_end
 
 
@@ -614,24 +626,31 @@ class cItem;
 
 
 
+// tolua_begin
+
 /// Translates a blocktype string into blocktype. Takes either a number or an items.ini alias as input. Returns -1 on failure.
-extern BLOCKTYPE BlockStringToType(const AString & a_BlockTypeString);  // tolua_export
+extern BLOCKTYPE BlockStringToType(const AString & a_BlockTypeString);
 
 /// Translates an itemtype string into an item. Takes either a number, number^number, number:number or an items.ini alias as input. Returns true if successful.
-extern bool StringToItem(const AString & a_ItemTypeString, cItem & a_Item);  // tolua_export
+extern bool StringToItem(const AString & a_ItemTypeString, cItem & a_Item);
 
 /// Translates a full item into a string. If the ItemType is not recognized, the ItemType number is output into the string.
-extern AString ItemToString(const cItem & a_Item);  // tolua_export
+extern AString ItemToString(const cItem & a_Item);
 
 /// Translates itemtype into a string. If the type is not recognized, the itemtype number is output into the string.
-extern AString ItemTypeToString(short a_ItemType);  // tolua_export
+extern AString ItemTypeToString(short a_ItemType);
 
 /// Translates a full item into a fully-specified string (including meta and count). If the ItemType is not recognized, the ItemType number is output into the string.
-extern AString ItemToFullString(const cItem & a_Item);  // tolua_export
+extern AString ItemToFullString(const cItem & a_Item);
 
 /// Translates a biome string to biome enum. Takes either a number or a biome alias (built-in). Returns -1 on failure.
 extern EMCSBiome StringToBiome(const AString & a_BiomeString);
 
+/// Translates a dimension string to dimension enum. Takes either a number or a dimension alias (built-in). Returns -1000 on failure
+extern eDimension StringToDimension(const AString & a_DimensionString);
+
+// tolua_end
+
 
 
 

source/Generating/ComposableGenerator.cpp

@@ -19,6 +19,7 @@
 
 #include "Caves.h"
 #include "DistortedHeightmap.h"
+#include "EndGen.h"
 #include "MineShafts.h"
 #include "Noise3DGenerator.h"
 #include "Ravines.h"
@@ -250,6 +251,11 @@ void cComposableGenerator::InitHeightGen(cIniFile & a_IniFile)
 		m_HeightGen = new cDistortedHeightmap(Seed, *m_BiomeGen);
 		((cDistortedHeightmap *)m_HeightGen)->Initialize(a_IniFile);
 	}
+	else if (NoCaseCompare(HeightGenName, "End") == 0)
+	{
+		m_HeightGen = new cEndGen(Seed);
+		((cEndGen *)m_HeightGen)->Initialize(a_IniFile);
+	}
 	else if (NoCaseCompare(HeightGenName, "Noise3D") == 0)
 	{
 		m_HeightGen = new cNoise3DComposable(Seed);
@@ -337,6 +343,11 @@ void cComposableGenerator::InitCompositionGen(cIniFile & a_IniFile)
 		m_CompositionGen = new cDistortedHeightmap(m_ChunkGenerator.GetSeed(), *m_BiomeGen);
 		((cDistortedHeightmap *)m_CompositionGen)->Initialize(a_IniFile);
 	}
+	else if (NoCaseCompare(CompoGenName, "end") == 0)
+	{
+		m_CompositionGen = new cEndGen(m_ChunkGenerator.GetSeed());
+		((cEndGen *)m_CompositionGen)->Initialize(a_IniFile);
+	}
 	else if (NoCaseCompare(CompoGenName, "nether") == 0)
 	{
 		m_CompositionGen = new cCompoGenNether(m_ChunkGenerator.GetSeed());
@@ -469,7 +480,7 @@ void cComposableGenerator::InitFinishGens(cIniFile & a_IniFile)
 		// Finishers, alpha-sorted:
 		if (NoCaseCompare(*itr, "BottomLava") == 0)
 		{
-			int DefaultBottomLavaLevel = (m_World->GetDimension() == cWorld::dimNether) ? 30 : 10;
+			int DefaultBottomLavaLevel = (m_World->GetDimension() == dimNether) ? 30 : 10;
 			int BottomLavaLevel = a_IniFile.GetValueSetI("Generator", "BottomLavaLevel", DefaultBottomLavaLevel);
 			m_FinishGens.push_back(new cFinishGenBottomLava(BottomLavaLevel));
 		}

source/Generating/EndGen.cpp

@@ -0,0 +1,217 @@
+
+// EndGen.cpp
+
+// Implements the cEndGen class representing the generator for the End, both as a HeightGen and CompositionGen
+
+#include "Globals.h"
+#include "EndGen.h"
+#include "../../iniFile/iniFile.h"
+#include "../LinearUpscale.h"
+
+
+
+
+
+enum
+{
+	// Interpolation cell size:
+	INTERPOL_X = 4,
+	INTERPOL_Y = 4,
+	INTERPOL_Z = 4,
+	
+	// Size of chunk data, downscaled before interpolation:
+	DIM_X = 16  / INTERPOL_X + 1,
+	DIM_Y = 256 / INTERPOL_Y + 1,
+	DIM_Z = 16  / INTERPOL_Z + 1,
+} ;
+
+
+
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// cEndGen:
+
+cEndGen::cEndGen(int a_Seed) :
+	m_Seed(a_Seed),
+	m_IslandSizeX(256),
+	m_IslandSizeY(96),
+	m_IslandSizeZ(256),
+	m_FrequencyX(80),
+	m_FrequencyY(80),
+	m_FrequencyZ(80)
+{
+	m_Perlin.AddOctave(1, 1);
+	m_Perlin.AddOctave(2, 0.5);
+	m_Perlin.AddOctave(4, 0.25);
+}
+
+
+
+
+
+void cEndGen::Initialize(cIniFile & a_IniFile)
+{
+	m_IslandSizeX = a_IniFile.GetValueSetI("Generator", "EndGenIslandSizeX", m_IslandSizeX);
+	m_IslandSizeY = a_IniFile.GetValueSetI("Generator", "EndGenIslandSizeY", m_IslandSizeY);
+	m_IslandSizeZ = a_IniFile.GetValueSetI("Generator", "EndGenIslandSizeZ", m_IslandSizeZ);
+
+	m_FrequencyX = (NOISE_DATATYPE)a_IniFile.GetValueSetF("Generator", "EndGenFrequencyX", m_FrequencyX);
+	m_FrequencyY = (NOISE_DATATYPE)a_IniFile.GetValueSetF("Generator", "EndGenFrequencyY", m_FrequencyY);
+	m_FrequencyZ = (NOISE_DATATYPE)a_IniFile.GetValueSetF("Generator", "EndGenFrequencyZ", m_FrequencyZ);
+	
+	// Recalculate the min and max chunk coords of the island
+	m_MaxChunkX = (m_IslandSizeX + cChunkDef::Width - 1) / cChunkDef::Width;
+	m_MinChunkX = -m_MaxChunkX;
+	m_MaxChunkZ = (m_IslandSizeZ + cChunkDef::Width - 1) / cChunkDef::Width;
+	m_MinChunkZ = -m_MaxChunkZ;
+}
+
+
+
+
+
+/// Unless the LastChunk coords are equal to coords given, prepares the internal state (noise array)
+void cEndGen::PrepareState(int a_ChunkX, int a_ChunkZ)
+{
+	ASSERT(!IsChunkOutsideRange(a_ChunkX, a_ChunkZ));  // Should be filtered before calling this function
+	
+	if ((m_LastChunkX == a_ChunkX) && (m_LastChunkZ == a_ChunkZ))
+	{
+		return;
+	}
+	
+	m_LastChunkX = a_ChunkX;
+	m_LastChunkZ = a_ChunkZ;
+	
+	GenerateNoiseArray();
+}
+
+
+
+
+
+/// Generates the m_NoiseArray array for the current chunk
+void cEndGen::GenerateNoiseArray(void)
+{
+	NOISE_DATATYPE NoiseData[DIM_X * DIM_Y * DIM_Z];  // [x + DIM_X * z + DIM_X * DIM_Z * y]
+	NOISE_DATATYPE Workspace[DIM_X * DIM_Y * DIM_Z];  // [x + DIM_X * z + DIM_X * DIM_Z * y]
+	
+	// Generate the downscaled noise:
+	NOISE_DATATYPE StartX = ((NOISE_DATATYPE)(m_LastChunkX       * cChunkDef::Width)) / m_FrequencyX;
+	NOISE_DATATYPE EndX   = ((NOISE_DATATYPE)((m_LastChunkX + 1) * cChunkDef::Width)) / m_FrequencyX;
+	NOISE_DATATYPE StartZ = ((NOISE_DATATYPE)(m_LastChunkZ       * cChunkDef::Width)) / m_FrequencyZ;
+	NOISE_DATATYPE EndZ   = ((NOISE_DATATYPE)((m_LastChunkZ + 1) * cChunkDef::Width)) / m_FrequencyZ;
+	NOISE_DATATYPE StartY = 0;
+	NOISE_DATATYPE EndY   = ((NOISE_DATATYPE)257) / m_FrequencyY;
+	m_Perlin.Generate3D(NoiseData, DIM_X, DIM_Z, DIM_Y, StartX, EndX, StartZ, EndZ, StartY, EndY, Workspace);
+	
+	// Add distance:
+	int idx = 0;
+	for (int y = 0; y < DIM_Y; y++)
+	{
+		NOISE_DATATYPE ValY = (NOISE_DATATYPE)(2 * INTERPOL_Y * y - m_IslandSizeY) / m_IslandSizeY;
+		ValY = ValY * ValY;
+		for (int z = 0; z < DIM_Z; z++)
+		{
+			NOISE_DATATYPE ValZ = (NOISE_DATATYPE)(m_LastChunkZ * cChunkDef::Width + (z * cChunkDef::Width / (DIM_Z - 1))) / m_IslandSizeZ;
+			ValZ = ValZ * ValZ;
+			for (int x = 0; x < DIM_X; x++)
+			{
+				// NOISE_DATATYPE ValX = StartX + (EndX - StartX) * x / (DIM_X - 1);
+				NOISE_DATATYPE ValX = (NOISE_DATATYPE)(m_LastChunkX * cChunkDef::Width + (x * cChunkDef::Width / (DIM_X - 1))) / m_IslandSizeX;
+				ValX = ValX * ValX;
+				NoiseData[idx++] += ValX + ValZ + ValY;
+			}  // for x
+		}  // for z
+	}  // for y
+	
+	// Upscale into real chunk size:
+	LinearUpscale3DArray(NoiseData, DIM_X, DIM_Z, DIM_Y, m_NoiseArray, INTERPOL_X, INTERPOL_Z, INTERPOL_Y);
+}
+
+
+
+
+	
+/// Returns true if the chunk is outside of the island's dimensions
+bool cEndGen::IsChunkOutsideRange(int a_ChunkX, int a_ChunkZ)
+{
+	return (
+		(a_ChunkX < m_MinChunkX) || (a_ChunkX > m_MaxChunkX) ||
+		(a_ChunkZ < m_MinChunkZ) || (a_ChunkZ > m_MaxChunkZ)
+	);		
+}
+
+
+
+
+
+void cEndGen::GenHeightMap(int a_ChunkX, int a_ChunkZ, cChunkDef::HeightMap & a_HeightMap)
+{
+	if (IsChunkOutsideRange(a_ChunkX, a_ChunkZ))
+	{
+		for (int i = 0; i < ARRAYCOUNT(a_HeightMap); i++)
+		{
+			a_HeightMap[i] = 0;
+		}
+		return;
+	}
+	
+	PrepareState(a_ChunkX, a_ChunkZ);
+	
+	int MaxY = std::min((int)(1.75 * m_IslandSizeY + 1), cChunkDef::Height - 1);
+	for (int z = 0; z < cChunkDef::Width; z++)
+	{
+		for (int x = 0; x < cChunkDef::Width; x++)
+		{
+			cChunkDef::SetHeight(a_HeightMap, x, z, MaxY);
+			for (int y = MaxY; y > 0; y--)
+			{
+				if (m_NoiseArray[y * 17 * 17 + z * 17 + x] <= 0)
+				{
+					cChunkDef::SetHeight(a_HeightMap, x, z, y);
+					break;
+				}
+			}  // for y
+		}  // for x
+	}  // for z
+}
+
+
+
+
+
+void cEndGen::ComposeTerrain(cChunkDesc & a_ChunkDesc)
+{
+	if (IsChunkOutsideRange(a_ChunkDesc.GetChunkX(), a_ChunkDesc.GetChunkZ()))
+	{
+		a_ChunkDesc.FillBlocks(E_BLOCK_AIR, 0);
+		return;
+	}
+	
+	PrepareState(a_ChunkDesc.GetChunkX(), a_ChunkDesc.GetChunkZ());
+	
+	int MaxY = std::min((int)(1.75 * m_IslandSizeY + 1), cChunkDef::Height - 1);
+	for (int z = 0; z < cChunkDef::Width; z++)
+	{
+		for (int x = 0; x < cChunkDef::Width; x++)
+		{
+			for (int y = MaxY; y > 0; y--)
+			{
+				if (m_NoiseArray[y * 17 * 17 + z * 17 + x] <= 0)
+				{
+					a_ChunkDesc.SetBlockTypeMeta(x, y, z, E_BLOCK_END_STONE, 0);
+				}
+				else
+				{
+					a_ChunkDesc.SetBlockTypeMeta(x, y, z, E_BLOCK_AIR, 0);
+				}
+			}  // for y
+		}  // for x
+	}  // for z
+}
+
+
+
+

source/Generating/EndGen.h

@@ -0,0 +1,69 @@
+
+// EndGen.h
+
+// Declares the cEndGen class representing the generator for the End, both as a HeightGen and CompositionGen
+
+
+
+
+
+#pragma once
+
+#include "ComposableGenerator.h"
+#include "../Noise.h"
+
+
+
+
+
+class cEndGen :
+	public cTerrainHeightGen,
+	public cTerrainCompositionGen
+{
+public:
+	cEndGen(int a_Seed);
+	
+	void Initialize(cIniFile & a_IniFile);
+	
+protected:
+
+	/// Seed for the noise
+	int m_Seed;
+	
+	/// The Perlin noise used for generating
+	cPerlinNoise m_Perlin;
+
+	// XYZ size of the "island", in blocks:
+	int m_IslandSizeX;
+	int m_IslandSizeY;
+	int m_IslandSizeZ;
+	
+	// XYZ Frequencies of the noise functions:
+	NOISE_DATATYPE m_FrequencyX;
+	NOISE_DATATYPE m_FrequencyY;
+	NOISE_DATATYPE m_FrequencyZ;
+	
+	// Minimum and maximum chunk coords for chunks inside the island area. Chunks outside won't get calculated at all
+	int m_MinChunkX, m_MaxChunkX;
+	int m_MinChunkZ, m_MaxChunkZ;
+	
+	// Noise array for the last chunk (in the noise range)
+	int m_LastChunkX;
+	int m_LastChunkZ;
+	NOISE_DATATYPE m_NoiseArray[17 * 17 * 257];  // x + 17 * z + 17 * 17 * y
+	
+	/// Unless the LastChunk coords are equal to coords given, prepares the internal state (noise array)
+	void PrepareState(int a_ChunkX, int a_ChunkZ);
+	
+	/// Generates the m_NoiseArray array for the current chunk
+	void GenerateNoiseArray(void);
+	
+	/// Returns true if the chunk is outside of the island's dimensions
+	bool IsChunkOutsideRange(int a_ChunkX, int a_ChunkZ);
+		
+	// cTerrainHeightGen overrides:
+	virtual void GenHeightMap(int a_ChunkX, int a_ChunkZ, cChunkDef::HeightMap & a_HeightMap) override;
+
+	// cTerrainCompositionGen overrides:
+	virtual void ComposeTerrain(cChunkDesc & a_ChunkDesc) override;
+} ;

source/Generating/FinishGen.cpp

@@ -531,19 +531,19 @@ cFinishGenFluidSprings::cFinishGenFluidSprings(int a_Seed, BLOCKTYPE a_Fluid, cI
 	int DefaultChance;
 	switch (a_World.GetDimension())
 	{
-		case cWorld::dimNether:
+		case dimNether:
 		{
 			DefaultHeightDistribution = IsWater ? DEF_NETHER_WATER_SPRINGS : DEF_NETHER_LAVA_SPRINGS;
 			DefaultChance = IsWater ? 0 : 15;
 			break;
 		}
-		case cWorld::dimOverworld:
+		case dimOverworld:
 		{
 			DefaultHeightDistribution = IsWater ? DEF_OVERWORLD_WATER_SPRINGS : DEF_OVERWORLD_LAVA_SPRINGS;
 			DefaultChance = IsWater ? 24 : 9;
 			break;
 		}
-		case cWorld::dimEnd:
+		case dimEnd:
 		{
 			DefaultHeightDistribution = IsWater ? DEF_END_WATER_SPRINGS : DEF_END_LAVA_SPRINGS;
 			DefaultChance = 0;

source/World.cpp

@@ -215,7 +215,8 @@ cWorld::cWorld(const AString & a_WorldName) :
 
 	cIniFile IniFile(m_IniFileName);
 	IniFile.ReadFile();
-	m_Dimension = (eDimension)(IniFile.GetValueSetI("General", "Dimension", 0));
+	AString Dimension = IniFile.GetValueSet("General", "Dimension", "Overworld");
+	m_Dimension = StringToDimension(Dimension);
 	switch (m_Dimension)
 	{
 		case dimNether:
@@ -226,7 +227,7 @@ cWorld::cWorld(const AString & a_WorldName) :
 		}
 		default:
 		{
-			LOGWARNING("Unknown dimension: %d. Setting to Overworld (0)", m_Dimension);
+			LOGWARNING("Unknown dimension: \"%s\". Setting to Overworld", Dimension.c_str());
 			m_Dimension = dimOverworld;
 			break;
 		}

source/World.h

@@ -59,13 +59,6 @@ class cWorld
 {
 public:
 
-	enum eDimension
-	{
-		dimNether = -1,
-		dimOverworld = 0,
-		dimEnd = 1,
-	} ;
-
 	// tolua_end
 	
 	/// A simple RAII locker for the chunkmap - locks the chunkmap in its constructor, unlocks it in the destructor