mirror of
https://github.com/Cubitect/cubiomes.git
synced 2025-09-23 19:55:34 -04:00
Updated biome generation for current 1.13 snapshots.
This commit is contained in:
Cubitect
parent
cf8c903145
commit
f490ff6fbf
98
finders.h
98
finders.h
@ -377,104 +377,6 @@ int64_t filterAllMajorBiomes(
|
||||
const unsigned int sZ
|
||||
);
|
||||
|
||||
/********************** C copy of the Java Random methods **********************
|
||||
*/
|
||||
|
||||
static inline void setSeed(int64_t *seed)
|
||||
{
|
||||
*seed = (*seed ^ 0x5DEECE66DLL) & ((1LL << 48) - 1);
|
||||
}
|
||||
|
||||
static inline int next(int64_t *seed, const int bits)
|
||||
{
|
||||
*seed = (*seed * 0x5DEECE66DLL + 0xBLL) & ((1LL << 48) - 1);
|
||||
return (int) (*seed >> (48 - bits));
|
||||
}
|
||||
|
||||
static inline int nextInt(int64_t *seed, const int n)
|
||||
{
|
||||
int bits, val;
|
||||
const int m = n - 1;
|
||||
|
||||
if((m & n) == 0) return (int) ((n * (long)next(seed, 31)) >> 31);
|
||||
|
||||
do {
|
||||
bits = next(seed, 31);
|
||||
val = bits % n;
|
||||
}
|
||||
while(bits - val + m < 0);
|
||||
return val;
|
||||
}
|
||||
|
||||
static inline int64_t nextint64_t(int64_t *seed)
|
||||
{
|
||||
return ((int64_t) next(seed, 32) << 32) + next(seed, 32);
|
||||
}
|
||||
|
||||
static inline float nextFloat(int64_t *seed)
|
||||
{
|
||||
return next(seed, 24) / (float) (1 << 24);
|
||||
}
|
||||
|
||||
static inline double nextDouble(int64_t *seed)
|
||||
{
|
||||
return (((int64_t) next(seed, 26) << 27) + next(seed, 27)) / (double) (1LL << 53);
|
||||
}
|
||||
|
||||
|
||||
|
||||
// Custom, faster alternative for the first and second call to nextInt(24)
|
||||
|
||||
static inline int firstInt24(int64_t seed)
|
||||
{
|
||||
seed ^= 0x5deece66d;
|
||||
seed = (seed * 0x5deece66d) & 0xffffffffffff;
|
||||
seed >>= 17;
|
||||
return seed % 24;
|
||||
}
|
||||
|
||||
static inline int secondInt24(int64_t seed)
|
||||
{
|
||||
seed ^= 0x5deece66d;
|
||||
seed = (seed * 0x5deece66d + 0xB) & 0xffffffffffff;
|
||||
seed = (seed * 0x5deece66d) & 0xffffffffffff;
|
||||
seed >>= 17;
|
||||
return seed % 24;
|
||||
}
|
||||
|
||||
/**
|
||||
* invSeed48()
|
||||
* -----------
|
||||
* Returns the previous 48-bit seed which will generate 'nseed'.
|
||||
* The upper 16 bits are ignored, both here and in the generator.
|
||||
*/
|
||||
static inline int64_t invSeed48(int64_t nseed)
|
||||
{
|
||||
const int64_t x = 0x5deece66d;
|
||||
const int64_t xinv = 0xdfe05bcb1365LL;
|
||||
const int64_t y = 0xbLL;
|
||||
const int64_t m48 = 0xffffffffffffLL;
|
||||
|
||||
int64_t a = nseed >> 32;
|
||||
int64_t b = nseed & 0xffffffffLL;
|
||||
if(b & 0x80000000LL) a++;
|
||||
|
||||
int64_t q = ((b << 16) - y - (a << 16)*x) & m48;
|
||||
for(int64_t k = 0; k <= 5; k++)
|
||||
{
|
||||
int64_t d = (x - (q + (k << 48))) % x;
|
||||
d = (d + x) % x; // force the modulo and keep it positive
|
||||
if(d < 65536)
|
||||
{
|
||||
int64_t c = ((q + d) * xinv) & m48;
|
||||
if(c < 65536)
|
||||
{
|
||||
return ((((a << 16) + c) - y) * xinv) & m48;
|
||||
}
|
||||
}
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
|
||||
static inline const char *int2binstr(int x, int bit)
|
||||
|
||||
43
generator.c
43
generator.c
@ -23,6 +23,7 @@ void setupLayer(int scale, Layer *l, Layer *p, int s, void (*getMap)(Layer *laye
|
||||
l->p = p;
|
||||
l->p2 = NULL;
|
||||
l->getMap = getMap;
|
||||
l->oceanRnd = NULL;
|
||||
}
|
||||
|
||||
void setupMultiLayer(int scale, Layer *l, Layer *p1, Layer *p2, int s, void (*getMap)(Layer *layer, int *out, int x, int z, int w, int h))
|
||||
@ -32,15 +33,16 @@ void setupMultiLayer(int scale, Layer *l, Layer *p1, Layer *p2, int s, void (*ge
|
||||
l->p = p1;
|
||||
l->p2 = p2;
|
||||
l->getMap = getMap;
|
||||
l->oceanRnd = NULL;
|
||||
}
|
||||
|
||||
|
||||
LayerStack setupGenerator()
|
||||
{
|
||||
return setupGeneratorMC17();
|
||||
}
|
||||
|
||||
|
||||
|
||||
LayerStack setupGeneratorMC17()
|
||||
{
|
||||
if(biomes[plains].id == 0)
|
||||
@ -120,7 +122,7 @@ LayerStack setupGeneratorMC113()
|
||||
|
||||
LayerStack g;
|
||||
|
||||
g.layerNum = 53;
|
||||
g.layerNum = 52;
|
||||
g.layers = (Layer*) malloc(sizeof(Layer)*g.layerNum);
|
||||
|
||||
// SCALE LAYER PARENT SEED LAYER_FUNCTION
|
||||
@ -178,20 +180,18 @@ LayerStack setupGeneratorMC113()
|
||||
setupMultiLayer(4, &g.layers[42], &g.layers[33], &g.layers[41], 100, mapRiverMix);
|
||||
|
||||
// ocean variants
|
||||
// This branch is connected to layer 7, but makes no use of it.
|
||||
// I.e this branch is independent of previous layers.
|
||||
setupLayer( 256, &g.layers[43], &g.layers[ 7], 2, mapOceanTemp);
|
||||
setupLayer( 256, &g.layers[44], &g.layers[43], 2, mapEdgeOcean);
|
||||
setupLayer( 128, &g.layers[45], &g.layers[44], 2001, mapZoom);
|
||||
setupLayer( 64, &g.layers[46], &g.layers[45], 2002, mapZoom);
|
||||
setupLayer( 32, &g.layers[47], &g.layers[46], 2003, mapZoom);
|
||||
setupLayer( 16, &g.layers[48], &g.layers[47], 2004, mapZoom);
|
||||
setupLayer( 8, &g.layers[49], &g.layers[48], 2005, mapZoom);
|
||||
setupLayer( 4, &g.layers[50], &g.layers[49], 2006, mapZoom);
|
||||
setupLayer( 256, &g.layers[43], NULL, 2, mapOceanTemp);
|
||||
g.layers[43].oceanRnd = (OceanRnd *) malloc(sizeof(OceanRnd));
|
||||
setupLayer( 128, &g.layers[44], &g.layers[43], 2001, mapZoom);
|
||||
setupLayer( 64, &g.layers[45], &g.layers[44], 2002, mapZoom);
|
||||
setupLayer( 32, &g.layers[46], &g.layers[45], 2003, mapZoom);
|
||||
setupLayer( 16, &g.layers[47], &g.layers[46], 2004, mapZoom);
|
||||
setupLayer( 8, &g.layers[48], &g.layers[47], 2005, mapZoom);
|
||||
setupLayer( 4, &g.layers[49], &g.layers[48], 2006, mapZoom);
|
||||
|
||||
setupMultiLayer(4, &g.layers[51], &g.layers[42], &g.layers[50], 100, mapOceanMix);
|
||||
setupMultiLayer(4, &g.layers[50], &g.layers[42], &g.layers[49], 100, mapOceanMix);
|
||||
|
||||
setupLayer(1, &g.layers[52], &g.layers[51], 10, mapVoronoiZoom);
|
||||
setupLayer(1, &g.layers[51], &g.layers[50], 10, mapVoronoiZoom);
|
||||
|
||||
return g;
|
||||
}
|
||||
@ -212,13 +212,19 @@ static void getMaxArea(Layer *layer, int areaX, int areaZ, int *maxX, int *maxZ)
|
||||
areaX = (areaX >> 2) + 2;
|
||||
areaZ = (areaZ >> 2) + 2;
|
||||
}
|
||||
else if(layer->getMap == mapOceanMix)
|
||||
{
|
||||
areaX += 17;
|
||||
areaZ += 17;
|
||||
}
|
||||
else
|
||||
{
|
||||
if( layer->getMap != mapIsland &&
|
||||
layer->getMap != mapSpecial &&
|
||||
layer->getMap != mapBiome &&
|
||||
layer->getMap != mapRiverInit &&
|
||||
layer->getMap != mapRiverMix )
|
||||
layer->getMap != mapRiverMix &&
|
||||
layer->getMap != mapOceanTemp)
|
||||
{
|
||||
areaX += 2;
|
||||
areaZ += 2;
|
||||
@ -243,6 +249,13 @@ int calcRequiredBuf(Layer *layer, int areaX, int areaZ)
|
||||
|
||||
void freeGenerator(LayerStack g)
|
||||
{
|
||||
int i;
|
||||
for(i = 0; i < g.layerNum; i++)
|
||||
{
|
||||
if(g.layers[i].oceanRnd != NULL)
|
||||
free(g.layers[i].oceanRnd);
|
||||
}
|
||||
|
||||
free(g.layers);
|
||||
}
|
||||
|
||||
|
||||
10
generator.h
10
generator.h
@ -56,7 +56,6 @@ enum
|
||||
|
||||
// 1.13 layers
|
||||
L13_OCEAN_TEMP_256 = 43,
|
||||
L13_EDGE_OCEAN_256,
|
||||
L13_ZOOM_128,
|
||||
L13_ZOOM_64,
|
||||
L13_ZOOM_32,
|
||||
@ -70,12 +69,6 @@ enum
|
||||
};
|
||||
|
||||
|
||||
/*
|
||||
typedef struct LayerStack
|
||||
{
|
||||
|
||||
} Generator;*/
|
||||
|
||||
STRUCT(LayerStack)
|
||||
{
|
||||
Layer *layers;
|
||||
@ -88,9 +81,6 @@ LayerStack setupGeneratorMC17();
|
||||
LayerStack setupGeneratorMC113();
|
||||
|
||||
|
||||
// Sets the top level layer of a generator.
|
||||
void setTopLevel(LayerStack *g, int topLevel);
|
||||
|
||||
// Cleans up and frees the generator layers
|
||||
void freeGenerator(LayerStack g);
|
||||
|
||||
|
||||
108
javarnd.h
Normal file
108
javarnd.h
Normal file
@ -0,0 +1,108 @@
|
||||
#ifndef JAVARND_H_
|
||||
#define JAVARND_H_
|
||||
|
||||
#include <stdint.h>
|
||||
|
||||
|
||||
/********************** C copy of the Java Random methods **********************
|
||||
*/
|
||||
|
||||
static inline void setSeed(int64_t *seed)
|
||||
{
|
||||
*seed = (*seed ^ 0x5DEECE66DLL) & ((1LL << 48) - 1);
|
||||
}
|
||||
|
||||
static inline int next(int64_t *seed, const int bits)
|
||||
{
|
||||
*seed = (*seed * 0x5DEECE66DLL + 0xBLL) & ((1LL << 48) - 1);
|
||||
return (int) (*seed >> (48 - bits));
|
||||
}
|
||||
|
||||
static inline int nextInt(int64_t *seed, const int n)
|
||||
{
|
||||
int bits, val;
|
||||
const int m = n - 1;
|
||||
|
||||
if((m & n) == 0) return (int) ((n * (long)next(seed, 31)) >> 31);
|
||||
|
||||
do {
|
||||
bits = next(seed, 31);
|
||||
val = bits % n;
|
||||
}
|
||||
while(bits - val + m < 0);
|
||||
return val;
|
||||
}
|
||||
|
||||
static inline int64_t nextint64_t(int64_t *seed)
|
||||
{
|
||||
return ((int64_t) next(seed, 32) << 32) + next(seed, 32);
|
||||
}
|
||||
|
||||
static inline float nextFloat(int64_t *seed)
|
||||
{
|
||||
return next(seed, 24) / (float) (1 << 24);
|
||||
}
|
||||
|
||||
static inline double nextDouble(int64_t *seed)
|
||||
{
|
||||
return (((int64_t) next(seed, 26) << 27) + next(seed, 27)) / (double) (1LL << 53);
|
||||
}
|
||||
|
||||
|
||||
|
||||
// Custom, faster alternative for the first and second call to nextInt(24)
|
||||
|
||||
static inline int firstInt24(int64_t seed)
|
||||
{
|
||||
seed ^= 0x5deece66d;
|
||||
seed = (seed * 0x5deece66d) & 0xffffffffffff;
|
||||
seed >>= 17;
|
||||
return seed % 24;
|
||||
}
|
||||
|
||||
static inline int secondInt24(int64_t seed)
|
||||
{
|
||||
seed ^= 0x5deece66d;
|
||||
seed = (seed * 0x5deece66d + 0xB) & 0xffffffffffff;
|
||||
seed = (seed * 0x5deece66d) & 0xffffffffffff;
|
||||
seed >>= 17;
|
||||
return seed % 24;
|
||||
}
|
||||
|
||||
/**
|
||||
* invSeed48()
|
||||
* -----------
|
||||
* Returns the previous 48-bit seed which will generate 'nseed'.
|
||||
* The upper 16 bits are ignored, both here and in the generator.
|
||||
*/
|
||||
static inline int64_t invSeed48(int64_t nseed)
|
||||
{
|
||||
const int64_t x = 0x5deece66d;
|
||||
const int64_t xinv = 0xdfe05bcb1365LL;
|
||||
const int64_t y = 0xbLL;
|
||||
const int64_t m48 = 0xffffffffffffLL;
|
||||
|
||||
int64_t a = nseed >> 32;
|
||||
int64_t b = nseed & 0xffffffffLL;
|
||||
if(b & 0x80000000LL) a++;
|
||||
|
||||
int64_t q = ((b << 16) - y - (a << 16)*x) & m48;
|
||||
for(int64_t k = 0; k <= 5; k++)
|
||||
{
|
||||
int64_t d = (x - (q + (k << 48))) % x;
|
||||
d = (d + x) % x; // force the modulo and keep it positive
|
||||
if(d < 65536)
|
||||
{
|
||||
int64_t c = ((q + d) * xinv) & m48;
|
||||
if(c < 65536)
|
||||
{
|
||||
return ((((a << 16) + c) - y) * xinv) & m48;
|
||||
}
|
||||
}
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
|
||||
|
||||
#endif /* JAVARND_H_ */
|
||||
262
layers.c
262
layers.c
@ -3,6 +3,10 @@
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
|
||||
|
||||
static void oceanRndInit(OceanRnd *rnd, int64_t seed);
|
||||
|
||||
|
||||
void initAddBiome(int id, int tempCat, int biometype, float temp, float height)
|
||||
{
|
||||
if(id & (~0xff)) return;
|
||||
@ -115,6 +119,9 @@ void setWorldSeed(Layer *layer, int64_t seed)
|
||||
if(layer->p != NULL)
|
||||
setWorldSeed(layer->p, seed);
|
||||
|
||||
if(layer->oceanRnd != NULL)
|
||||
oceanRndInit(layer->oceanRnd, seed);
|
||||
|
||||
layer->worldSeed = seed;
|
||||
layer->worldSeed *= layer->worldSeed * 6364136223846793005LL + 1442695040888963407LL;
|
||||
layer->worldSeed += layer->baseSeed;
|
||||
@ -1241,88 +1248,123 @@ void mapRiverMix(Layer *l, int * __restrict out, int areaX, int areaZ, int areaW
|
||||
}
|
||||
|
||||
|
||||
/* Corner lookup tables for ocean PRNG */
|
||||
const double e[] = {1.0, -1.0, 1.0, -1.0, 1.0, -1.0, 1.0, -1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, -1.0, 0.0};
|
||||
const double f[] = {1.0, 1.0, -1.0, -1.0, 0.0, 0.0, 0.0, 0.0, 1.0, -1.0, 1.0, -1.0, 1.0, -1.0, 1.0, -1.0};
|
||||
const double g[] = {0.0, 0.0, 0.0, 0.0, 1.0, 1.0, -1.0, -1.0, 1.0, 1.0, -1.0, -1.0, 0.0, 1.0, 0.0, -1.0};
|
||||
const double h[] = {1.0, -1.0, 1.0, -1.0, 1.0, -1.0, 1.0, -1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, -1.0, 0.0};
|
||||
const double i[] = {0.0, 0.0, 0.0, 0.0, 1.0, 1.0, -1.0, -1.0, 1.0, 1.0, -1.0, -1.0, 0.0, 1.0, 0.0, -1.0};
|
||||
|
||||
void mapOceanTemp(Layer *l, int * __restrict out, int areaX, int areaZ, int areaWidth, int areaHeight)
|
||||
/* oceanRndInit
|
||||
* ------------
|
||||
* Initialises data for the ocean temperature types using the world seed.
|
||||
* This function is called when the world seed is applied in setWorldSeed().
|
||||
*/
|
||||
static void oceanRndInit(OceanRnd *rnd, int64_t seed)
|
||||
{
|
||||
// The new ocean branch doesn't actually depend on previous layers.
|
||||
memset(rnd, 0, sizeof(*rnd));
|
||||
setSeed(&seed);
|
||||
rnd->a = nextDouble(&seed) * 256.0;
|
||||
rnd->b = nextDouble(&seed) * 256.0;
|
||||
rnd->c = nextDouble(&seed) * 256.0;
|
||||
|
||||
//int pX = areaX - 1;
|
||||
//int pZ = areaZ - 1;
|
||||
//int pWidth = areaWidth + 2;
|
||||
//int pHeight = areaHeight + 2;
|
||||
int x, z;
|
||||
|
||||
//l->p->getMap(l->p, out, pX, pZ, pWidth, pHeight);
|
||||
|
||||
for(z = 0; z < areaHeight; z++)
|
||||
int n2 = 0;
|
||||
while (n2 < 256)
|
||||
{
|
||||
for(x = 0; x < areaWidth; x++)
|
||||
{
|
||||
setChunkSeed(l, (int64_t)(x + areaX), (int64_t)(z + areaZ));
|
||||
|
||||
int v11;
|
||||
|
||||
float tmp = (float)mcNextInt(l, 100) / 100.0f;
|
||||
|
||||
if(tmp < 0.05f)
|
||||
v11 = warmOcean;
|
||||
else if(tmp < 0.4f)
|
||||
v11 = lukewarmOcean;
|
||||
else if(tmp < 0.675f)
|
||||
v11 = ocean;
|
||||
else if(tmp < 0.95f)
|
||||
v11 = coldOcean;
|
||||
else if(tmp < 1.0f)
|
||||
v11 = frozenOcean;
|
||||
else
|
||||
v11 = ocean;
|
||||
|
||||
out[x + z*areaWidth] = v11;
|
||||
}
|
||||
rnd->d[n2] = n2;
|
||||
n2++;
|
||||
}
|
||||
for (n2 = 0; n2 < 256; ++n2)
|
||||
{
|
||||
int n3 = nextInt(&seed, 256 - n2) + n2;
|
||||
int n4 = rnd->d[n2];
|
||||
rnd->d[n2] = rnd->d[n3];
|
||||
rnd->d[n3] = n4;
|
||||
rnd->d[n2 + 256] = rnd->d[n2];
|
||||
}
|
||||
}
|
||||
|
||||
void mapEdgeOcean(Layer *l, int * __restrict out, int areaX, int areaZ, int areaWidth, int areaHeight)
|
||||
static double fddd(const double d2, const double d3, const double d4)
|
||||
{
|
||||
int pX = areaX - 1;
|
||||
int pZ = areaZ - 1;
|
||||
int pWidth = areaWidth + 2;
|
||||
int pHeight = areaHeight + 2;
|
||||
int x, z;
|
||||
return d3 + d2 * (d4 - d3);
|
||||
}
|
||||
|
||||
l->p->getMap(l->p, out, pX, pZ, pWidth, pHeight);
|
||||
static double faiddd(const int n2, const double d2, const double d3, const double d4)
|
||||
{
|
||||
int n3 = n2 & 15;
|
||||
return e[n3] * d2 + f[n3] * d3 + g[n3] * d4;
|
||||
}
|
||||
|
||||
static double getOceanTemp(const OceanRnd *rnd, double d2, double d3, double d4)
|
||||
{
|
||||
double d5 = d2 + rnd->a;
|
||||
double d6 = d3 + rnd->b;
|
||||
double d7 = d4 + rnd->c;
|
||||
int n2 = (int)d5;
|
||||
int n3 = (int)d6;
|
||||
int n4 = (int)d7;
|
||||
if (d5 < (double)n2) {
|
||||
--n2;
|
||||
}
|
||||
if (d6 < (double)n3) {
|
||||
--n3;
|
||||
}
|
||||
if (d7 < (double)n4) {
|
||||
--n4;
|
||||
}
|
||||
int n5 = n2 & 255;
|
||||
int n6 = n3 & 255;
|
||||
int n7 = n4 & 255;
|
||||
d5 -= (double)n2;
|
||||
double d8 = d5 * d5 * d5 * (d5 * ((d5) * 6.0 - 15.0) + 10.0);
|
||||
d6 -= (double)n3;
|
||||
double d9 = d6 * d6 * d6 * (d6 * ((d6) * 6.0 - 15.0) + 10.0);
|
||||
d7 -= (double)n4;
|
||||
double d10 = d7 * d7 * d7 * (d7 * ((d7) * 6.0 - 15.0) + 10.0);
|
||||
|
||||
int n8 = rnd->d[n5] + n6;
|
||||
int n9 = rnd->d[n8] + n7;
|
||||
int n10 = rnd->d[n8 + 1] + n7;
|
||||
int n11 = rnd->d[n5 + 1] + n6;
|
||||
int n12 = rnd->d[n11] + n7;
|
||||
int n13 = rnd->d[n11 + 1] + n7;
|
||||
return (
|
||||
fddd( d10,
|
||||
fddd( d9,
|
||||
fddd(d8, faiddd(rnd->d[n9], d5, d6, d7), faiddd(rnd->d[n12], d5 - 1.0, d6, d7)),
|
||||
fddd(d8, faiddd(rnd->d[n10], d5, d6 - 1.0, d7), faiddd(rnd->d[n13], d5 - 1.0, d6 - 1.0, d7))
|
||||
),
|
||||
fddd( d9,
|
||||
fddd(d8, faiddd(rnd->d[n9 + 1], d5, d6, d7 - 1.0), faiddd(rnd->d[n12 + 1], d5 - 1.0, d6, d7 - 1.0)),
|
||||
fddd(d8, faiddd(rnd->d[n10 + 1], d5, d6 - 1.0, d7 - 1.0), faiddd(rnd->d[n13 + 1], d5 - 1.0, d6 - 1.0, d7 - 1.0))
|
||||
)
|
||||
)
|
||||
);
|
||||
}
|
||||
|
||||
void mapOceanTemp(Layer *l, int * __restrict out, int areaX, int areaZ, int areaWidth, int areaHeight)
|
||||
{
|
||||
int x, z;
|
||||
OceanRnd *rnd = l->oceanRnd;
|
||||
|
||||
for(z = 0; z < areaHeight; z++)
|
||||
{
|
||||
for(x = 0; x < areaWidth; x++)
|
||||
{
|
||||
int v11 = out[x+1 + (z+1)*pWidth];
|
||||
int v11;
|
||||
|
||||
if(v11 == warmOcean)
|
||||
{
|
||||
int v10 = out[x+1 + (z+0)*pWidth];
|
||||
int v21 = out[x+2 + (z+1)*pWidth];
|
||||
int v01 = out[x+0 + (z+1)*pWidth];
|
||||
int v12 = out[x+1 + (z+2)*pWidth];
|
||||
double tmp = getOceanTemp(rnd, (x + areaX) / 8.0, (z + areaZ) / 8.0, 0);
|
||||
|
||||
if(v10 == frozenOcean || v21 == frozenOcean || v01 == frozenOcean || v12 == frozenOcean)
|
||||
{
|
||||
v11 = ocean;
|
||||
}
|
||||
}
|
||||
|
||||
if(v11 == frozenOcean)
|
||||
{
|
||||
int v10 = out[x+1 + (z+0)*pWidth];
|
||||
int v21 = out[x+2 + (z+1)*pWidth];
|
||||
int v01 = out[x+0 + (z+1)*pWidth];
|
||||
int v12 = out[x+1 + (z+2)*pWidth];
|
||||
|
||||
if(v10 == warmOcean || v21 == warmOcean || v01 == warmOcean || v12 == warmOcean)
|
||||
{
|
||||
v11 = ocean;
|
||||
}
|
||||
}
|
||||
if(tmp > 0.4)
|
||||
v11 = warmOcean;
|
||||
else if(tmp > 0.2)
|
||||
v11 = lukewarmOcean;
|
||||
else if(tmp < -0.4)
|
||||
v11 = frozenOcean;
|
||||
else if(tmp < -0.2)
|
||||
v11 = coldOcean;
|
||||
else
|
||||
v11 = ocean;
|
||||
|
||||
out[x + z*areaWidth] = v11;
|
||||
}
|
||||
@ -1332,8 +1374,9 @@ void mapEdgeOcean(Layer *l, int * __restrict out, int areaX, int areaZ, int area
|
||||
|
||||
void mapOceanMix(Layer *l, int * __restrict out, int areaX, int areaZ, int areaWidth, int areaHeight)
|
||||
{
|
||||
int idx;
|
||||
int *buf = (int*)malloc(areaWidth*areaHeight*sizeof(int));
|
||||
int landX = areaX-8, landZ = areaZ-8;
|
||||
int landWidth = areaWidth+17, landHeight = areaHeight+17;
|
||||
int *map1, *map2;
|
||||
|
||||
if(l->p2 == NULL)
|
||||
{
|
||||
@ -1341,37 +1384,82 @@ void mapOceanMix(Layer *l, int * __restrict out, int areaX, int areaZ, int areaW
|
||||
exit(1);
|
||||
}
|
||||
|
||||
l->p->getMap(l->p, out, areaX, areaZ, areaWidth, areaHeight);
|
||||
memcpy(buf, out, areaWidth*areaHeight*sizeof(int));
|
||||
l->p->getMap(l->p, out, landX, landZ, landWidth, landHeight);
|
||||
map1 = (int *) malloc(landWidth*landHeight*sizeof(int));
|
||||
memcpy(map1, out, landWidth*landHeight*sizeof(int));
|
||||
|
||||
l->p2->getMap(l->p2, out, areaX, areaZ, areaWidth, areaHeight);
|
||||
map2 = (int *) malloc(areaWidth*areaHeight*sizeof(int));
|
||||
memcpy(map2, out, areaWidth*areaHeight*sizeof(int));
|
||||
|
||||
for(idx = 0; idx < areaHeight*areaWidth; idx++)
|
||||
|
||||
int x, z;
|
||||
|
||||
for(z = 0; z < areaHeight; z++)
|
||||
{
|
||||
if(!isOceanic(buf[idx]) || !isOceanic(out[idx]))
|
||||
for(x = 0; x < areaWidth; x++)
|
||||
{
|
||||
out[idx] = buf[idx];
|
||||
}
|
||||
else if(buf[idx] == deepOcean)
|
||||
{
|
||||
if(out[idx] == lukewarmOcean)
|
||||
out[idx] = lukewarmDeepOcean;
|
||||
else if(out[idx] == ocean)
|
||||
out[idx] = deepOcean;
|
||||
else if(out[idx] == coldOcean)
|
||||
out[idx] = coldDeepOcean;
|
||||
else if(out[idx] == frozenOcean)
|
||||
out[idx] = frozenDeepOcean;
|
||||
int n4 = map1[(x+8) + (z+8)*landWidth]; // main land branch
|
||||
int n5 = map2[x + z*areaWidth]; // ocean branch
|
||||
|
||||
if(!isOceanic(n4))
|
||||
{
|
||||
out[x + z*areaWidth] = n4;
|
||||
continue;
|
||||
}
|
||||
|
||||
for(int i2 = -8; i2 <= 8; i2 += 4)
|
||||
{
|
||||
for(int i3 = -8; i3 <= 8; i3 += 4)
|
||||
{
|
||||
int n8 = map1[(x+i2+8) + (z+i3+8)*landWidth];
|
||||
|
||||
if(isOceanic(n8)) continue;
|
||||
|
||||
if(n5 == warmOcean)
|
||||
{
|
||||
out[x + z*areaWidth] = lukewarmOcean;
|
||||
goto loop_x;
|
||||
}
|
||||
|
||||
if(n5 != frozenOcean) continue;
|
||||
|
||||
out[x + z*areaWidth] = coldOcean;
|
||||
goto loop_x;
|
||||
}
|
||||
}
|
||||
|
||||
if (n4 == deepOcean) {
|
||||
if (n5 == lukewarmOcean) {
|
||||
out[x + z*areaWidth] = lukewarmDeepOcean;
|
||||
continue;
|
||||
}
|
||||
if (n5 == ocean) {
|
||||
out[x + z*areaWidth] = deepOcean;
|
||||
continue;
|
||||
}
|
||||
if (n5 == coldOcean) {
|
||||
out[x + z*areaWidth] = coldDeepOcean;
|
||||
continue;
|
||||
}
|
||||
if (n5 == frozenOcean) {
|
||||
out[x + z*areaWidth] = frozenDeepOcean;
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
||||
out[x + z*areaWidth] = n5;
|
||||
|
||||
loop_x:;
|
||||
}
|
||||
}
|
||||
|
||||
free(buf);
|
||||
free(map1);
|
||||
free(map2);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
void mapVoronoiZoom(Layer *l, int * __restrict out, int areaX, int areaZ, int areaWidth, int areaHeight)
|
||||
{
|
||||
areaX -= 2;
|
||||
|
||||
36
layers.h
36
layers.h
@ -1,6 +1,8 @@
|
||||
#ifndef LAYER_H_
|
||||
#define LAYER_H_
|
||||
|
||||
#include "javarnd.h"
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <stdint.h>
|
||||
#include <inttypes.h>
|
||||
@ -44,7 +46,9 @@ enum BiomeTempCategory {
|
||||
Oceanic, Warm, Lush, Cold, Freezing, Unknown
|
||||
};
|
||||
|
||||
STRUCT(Biome) {
|
||||
|
||||
STRUCT(Biome)
|
||||
{
|
||||
int id;
|
||||
int type;
|
||||
double height;
|
||||
@ -52,26 +56,40 @@ STRUCT(Biome) {
|
||||
int tempCat;
|
||||
};
|
||||
|
||||
STRUCT(Layer) {
|
||||
int64_t baseSeed; // Generator seed (depends only on hierarchy of generator)
|
||||
int64_t worldSeed; // based on the seed of the world
|
||||
|
||||
int64_t chunkSeed; // randomiser seed
|
||||
STRUCT(OceanRnd)
|
||||
{
|
||||
int d[512];
|
||||
double a, b, c;
|
||||
};
|
||||
|
||||
int scale; // map scale of this layer (map entry = scale x scale blocks)
|
||||
STRUCT(Layer)
|
||||
{
|
||||
int64_t baseSeed; // Generator seed (depends only on layer hierarchy)
|
||||
int64_t worldSeed; // based on the seed of the world
|
||||
|
||||
int64_t chunkSeed; // randomiser seed
|
||||
|
||||
OceanRnd *oceanRnd; // world seed dependent data for ocean temperatures
|
||||
|
||||
int scale; // map scale of this layer (map entry = scale x scale blocks)
|
||||
|
||||
void (*getMap)(Layer *layer, int *out, int x, int z, int w, int h);
|
||||
|
||||
Layer *p, *p2;
|
||||
Layer *p, *p2; // parent layers
|
||||
};
|
||||
|
||||
|
||||
extern Biome biomes[256];
|
||||
|
||||
|
||||
/* initBiomes() has to be called before any of the generators can be used */
|
||||
void initBiomes();
|
||||
|
||||
|
||||
/* setWorldSeed
|
||||
* ------------
|
||||
* Applies the given world seed to the layer and all dependent layers.
|
||||
*/
|
||||
void setWorldSeed(Layer *layer, int64_t seed);
|
||||
|
||||
|
||||
@ -386,9 +404,7 @@ void mapRareBiome(Layer *l, int * __restrict out, int x, int z, int w, int h);
|
||||
void mapShore(Layer *l, int * __restrict out, int x, int z, int w, int h);
|
||||
void mapRiverMix(Layer *l, int * __restrict out, int x, int z, int w, int h);
|
||||
|
||||
// TODO: 1.13 updated again and these functions are outdated!
|
||||
void mapOceanTemp(Layer *l, int * __restrict out, int areaX, int areaZ, int areaWidth, int areaHeight);
|
||||
void mapEdgeOcean(Layer *l, int * __restrict out, int areaX, int areaZ, int areaWidth, int areaHeight);
|
||||
void mapOceanMix(Layer *l, int * __restrict out, int areaX, int areaZ, int areaWidth, int areaHeight);
|
||||
|
||||
void mapVoronoiZoom(Layer *l, int * __restrict out, int x, int z, int w, int h);
|
||||
|
||||
@ -216,7 +216,7 @@ void getBiomeColourMap(uint *colbuf, const unsigned char biomeColour[256][3],
|
||||
|
||||
void viewmap(Layer *layer, unsigned char biomeColour[256][3], int areaX, int areaZ, uint areaWidth, uint areaHeight, uint pixscale)
|
||||
{
|
||||
int *ints = allocCache(layer, areaWidth+10, areaHeight+1);
|
||||
int *ints = allocCache(layer, areaWidth, areaHeight);
|
||||
|
||||
// generate the biome ints
|
||||
genArea(layer, ints, areaX, areaZ, areaWidth, areaHeight);
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user