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-c427514a06d6master
madmaxoft@gmail.com
parent
c8fc397b43
commit
9dd0486faf
|
|
@ -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"
|
||||
>
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
|
|
|
|||
|
|
@ -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 */
|
||||
|
|
|
|||
|
|
@ -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
|
||||
{
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
||||
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -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));
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
|
@ -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;
|
||||
} ;
|
||||
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
Loading…
Reference in New Issue