LerpedWeightedIndex2DMap GetOrLoadLerpedLandformMap(IMapChunk mapchunk, int regionX, int regionZ)
{
LerpedWeightedIndex2DMap map;
// 1. Load?
LandformMapByRegion.TryGetValue(regionZ * regionMapSize + regionX, out map);
if (map != null)
{
return(map);
}
IntMap lmap = mapchunk.MapRegion.LandformMap;
// 2. Create
map = LandformMapByRegion[regionZ * regionMapSize + regionX]
= new LerpedWeightedIndex2DMap(lmap.Data, lmap.Size, TerraGenConfig.landFormSmoothingRadius, lmap.TopLeftPadding, lmap.BottomRightPadding);
return(map);
}
private void OnChunkColumnGen(IServerChunk[] chunks, int chunkX, int chunkZ, ITreeAttribute chunkGenParams = null)
{
landforms = NoiseLandforms.landforms;
IMapChunk mapchunk = chunks[0].MapChunk;
int climateUpLeft;
int climateUpRight;
int climateBotLeft;
int climateBotRight;
IntMap climateMap = chunks[0].MapChunk.MapRegion.ClimateMap;
int regionChunkSize = api.WorldManager.RegionSize / chunksize;
float fac = (float)climateMap.InnerSize / regionChunkSize;
int rlX = chunkX % regionChunkSize;
int rlZ = chunkZ % regionChunkSize;
climateUpLeft = climateMap.GetUnpaddedInt((int)(rlX * fac), (int)(rlZ * fac));
climateUpRight = climateMap.GetUnpaddedInt((int)(rlX * fac + fac), (int)(rlZ * fac));
climateBotLeft = climateMap.GetUnpaddedInt((int)(rlX * fac), (int)(rlZ * fac + fac));
climateBotRight = climateMap.GetUnpaddedInt((int)(rlX * fac + fac), (int)(rlZ * fac + fac));
int freezingTemp = TerraGenConfig.DescaleTemperature(-17);
IntMap landformMap = mapchunk.MapRegion.LandformMap;
// Amount of pixels for each chunk (probably 1, 2, or 4) in the land form map
float chunkPixelSize = landformMap.InnerSize / regionChunkSize;
// Adjusted lerp for the noiseWidth
float chunkPixelStep = chunkPixelSize / noiseWidth;
// Start coordinates for the chunk in the region map
float baseX = (chunkX % regionChunkSize) * chunkPixelSize;
float baseZ = (chunkZ % regionChunkSize) * chunkPixelSize;
LerpedWeightedIndex2DMap landLerpMap = GetOrLoadLerpedLandformMap(chunks[0].MapChunk, chunkX / regionChunkSize, chunkZ / regionChunkSize);
// Terrain octaves
double[] octNoiseX0, octNoiseX1, octNoiseX2, octNoiseX3;
double[] octThX0, octThX1, octThX2, octThX3;
// So it seems we have some kind of off-by-one error here?
// When the slope of a mountain goes up (in positive z or x direction), particularly at large word heights (512+)
// then the last blocks (again in postive x/z dir) are below of where they should be?
// I have no idea why, but this offset seems to greatly mitigate the issue
float weirdOffset = 0.25f;
chunkPixelSize += weirdOffset;
GetInterpolatedOctaves(landLerpMap[baseX, baseZ], out octNoiseX0, out octThX0);
GetInterpolatedOctaves(landLerpMap[baseX + chunkPixelSize, baseZ], out octNoiseX1, out octThX1);
GetInterpolatedOctaves(landLerpMap[baseX, baseZ + chunkPixelSize], out octNoiseX2, out octThX2);
GetInterpolatedOctaves(landLerpMap[baseX + chunkPixelSize, baseZ + chunkPixelSize], out octNoiseX3, out octThX3);
double[] terrainNoise3d = GetTerrainNoise3D(octNoiseX0, octNoiseX1, octNoiseX2, octNoiseX3, octThX0, octThX1, octThX2, octThX3, chunkX * noiseWidth, 0, chunkZ * noiseWidth);
// Store heightmap in the map chunk
ushort[] rainheightmap = chunks[0].MapChunk.RainHeightMap;
ushort[] terrainheightmap = chunks[0].MapChunk.WorldGenTerrainHeightMap;
// Terrain thresholds
double tnoiseY0;
double tnoiseY1;
double tnoiseY2;
double tnoiseY3;
double tnoiseGainY0;
double tnoiseGainY1;
double tnoiseGainY2;
double tnoiseGainY3;
double thNoiseX0;
double thNoiseX1;
double thNoiseGainX0;
double thNoiseGainX1;
double thNoiseGainZ0;
double thNoiseZ0;
float[] terrainThresholdsX0 = new float[api.WorldManager.MapSizeY];
float[] terrainThresholdsX1 = new float[api.WorldManager.MapSizeY];
float[] terrainThresholdsX2 = new float[api.WorldManager.MapSizeY];
float[] terrainThresholdsX3 = new float[api.WorldManager.MapSizeY];
for (int xN = 0; xN < noiseWidth; xN++)
{
for (int zN = 0; zN < noiseWidth; zN++)
{
// Landform thresholds
LoadInterpolatedThresholds(landLerpMap[baseX + xN * chunkPixelStep, baseZ + zN * chunkPixelStep], terrainThresholdsX0);
LoadInterpolatedThresholds(landLerpMap[baseX + (xN + 1) * chunkPixelStep, baseZ + zN * chunkPixelStep], terrainThresholdsX1);
LoadInterpolatedThresholds(landLerpMap[baseX + xN * chunkPixelStep, baseZ + (zN + 1) * chunkPixelStep], terrainThresholdsX2);
LoadInterpolatedThresholds(landLerpMap[baseX + (xN + 1) * chunkPixelStep, baseZ + (zN + 1) * chunkPixelStep], terrainThresholdsX3);
for (int yN = 0; yN < noiseHeight; yN++)
{
// Terrain noise
tnoiseY0 = terrainNoise3d[NoiseIndex3d(xN, yN, zN)];
tnoiseY1 = terrainNoise3d[NoiseIndex3d(xN, yN, zN + 1)];
tnoiseY2 = terrainNoise3d[NoiseIndex3d(xN + 1, yN, zN)];
tnoiseY3 = terrainNoise3d[NoiseIndex3d(xN + 1, yN, zN + 1)];
tnoiseGainY0 = (terrainNoise3d[NoiseIndex3d(xN, yN + 1, zN)] - tnoiseY0) * lerpDeltaVert;
tnoiseGainY1 = (terrainNoise3d[NoiseIndex3d(xN, yN + 1, zN + 1)] - tnoiseY1) * lerpDeltaVert;
tnoiseGainY2 = (terrainNoise3d[NoiseIndex3d(xN + 1, yN + 1, zN)] - tnoiseY2) * lerpDeltaVert;
tnoiseGainY3 = (terrainNoise3d[NoiseIndex3d(xN + 1, yN + 1, zN + 1)] - tnoiseY3) * lerpDeltaVert;
for (int y = 0; y < lerpVer; y++)
{
int posY = yN * lerpVer + y;
int chunkY = posY / chunksize;
int localY = posY % chunksize;
// For Terrain noise
double tnoiseX0 = tnoiseY0;
double tnoiseX1 = tnoiseY1;
double tnoiseGainX0 = (tnoiseY2 - tnoiseY0) * lerpDeltaHor;
double tnoiseGainX1 = (tnoiseY3 - tnoiseY1) * lerpDeltaHor;
// Landform thresholds lerp
thNoiseX0 = terrainThresholdsX0[posY];
thNoiseX1 = terrainThresholdsX2[posY];
thNoiseGainX0 = (terrainThresholdsX1[posY] - thNoiseX0) * lerpDeltaHor;
thNoiseGainX1 = (terrainThresholdsX3[posY] - thNoiseX1) * lerpDeltaHor;
for (int x = 0; x < lerpHor; x++)
{
// For terrain noise
double tnoiseZ0 = tnoiseX0;
double tnoiseGainZ0 = (tnoiseX1 - tnoiseX0) * lerpDeltaHor;
// Landform
thNoiseZ0 = thNoiseX0;
thNoiseGainZ0 = (thNoiseX1 - thNoiseX0) * lerpDeltaHor;
for (int z = 0; z < lerpHor; z++)
{
int lX = xN * lerpHor + x;
int lZ = zN * lerpHor + z;
int mapIndex = ChunkIndex2d(lX, lZ);
int chunkIndex = ChunkIndex3d(lX, localY, lZ);
chunks[chunkY].Blocks[chunkIndex] = 0;
if (posY == 0)
{
chunks[chunkY].Blocks[chunkIndex] = GlobalConfig.mantleBlockId;
continue;
}
if (tnoiseZ0 > thNoiseZ0)
{
terrainheightmap[mapIndex] = rainheightmap[mapIndex] = (ushort)Math.Max(rainheightmap[mapIndex], posY);
chunks[chunkY].Blocks[chunkIndex] = GlobalConfig.defaultRockId;
}
else
{
if (posY < TerraGenConfig.seaLevel)
{
terrainheightmap[mapIndex] = rainheightmap[mapIndex] = (ushort)Math.Max(rainheightmap[mapIndex], posY);
if (posY == TerraGenConfig.seaLevel - 1)
{
int temp = (GameMath.BiLerpRgbColor(((float)lX) / chunksize, ((float)lZ) / chunksize, climateUpLeft, climateUpRight, climateBotLeft, climateBotRight) >> 16) & 0xff;
float distort = (float)distort2dx.Noise(chunkX * chunksize + lX, chunkZ * chunksize + lZ) / 20f;
float tempf = TerraGenConfig.GetScaledAdjustedTemperatureFloat(temp, 0) + distort;
// dominionsmod
chunks[chunkY].Blocks[chunkIndex] = (tempf < -17) ? GlobalConfig.lakeIceBlockId : saltWater;
}
else
{
// dominionsmod
chunks[chunkY].Blocks[chunkIndex] = saltWater;
}
}
else
{
chunks[chunkY].Blocks[chunkIndex] = 0;
}
}
tnoiseZ0 += tnoiseGainZ0;
thNoiseZ0 += thNoiseGainZ0;
}
tnoiseX0 += tnoiseGainX0;
tnoiseX1 += tnoiseGainX1;
thNoiseX0 += thNoiseGainX0;
thNoiseX1 += thNoiseGainX1;
}
tnoiseY0 += tnoiseGainY0;
tnoiseY1 += tnoiseGainY1;
tnoiseY2 += tnoiseGainY2;
tnoiseY3 += tnoiseGainY3;
}
}
}
}
int ymax = 0;
for (int i = 0; i < rainheightmap.Length; i++)
{
ymax = Math.Max(ymax, rainheightmap[i]);
}
chunks[0].MapChunk.YMax = (ushort)ymax;
}
