flewkey/cuberite-2a
1
0
Fork 0
Code Releases Activity

Added the End height and composition generators.

Browse Source 
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
This commit is contained in:
madmaxoft@gmail.com 2013-06-22 18:41:08 +00:00
parent c8fc397b43
commit 9dd0486faf
11 changed files with 445 additions and 24 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
VC2008/MCServer.vcproj
View File

@ -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"
>

72
source/Bindings.cpp
View File

@ -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);

2
source/Bindings.h
View File

@ -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 */

41
source/BlockID.cpp
View File

@ -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
{

29
source/BlockID.h
View File

@ -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

13
source/Generating/ComposableGenerator.cpp
View File

@ -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));
}

217
source/Generating/EndGen.cpp Normal file
View File

@ -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
}

69
source/Generating/EndGen.h Normal file
View File

@ -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;
} ;

6
source/Generating/FinishGen.cpp
View File

@ -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;

5
source/World.cpp
View File

@ -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;
}

7
source/World.h
View File

@ -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