diff options
Diffstat (limited to 'src')
3 files changed, 259 insertions, 101 deletions
diff --git a/src/main/java/gregtech/common/GT_Worldgen_GT_Ore_Layer.java b/src/main/java/gregtech/common/GT_Worldgen_GT_Ore_Layer.java index 564292451d..fa15da33df 100644 --- a/src/main/java/gregtech/common/GT_Worldgen_GT_Ore_Layer.java +++ b/src/main/java/gregtech/common/GT_Worldgen_GT_Ore_Layer.java @@ -105,6 +105,13 @@ public class GT_Worldgen_GT_Ore_Layer //if (!isGenerationAllowed(aWorld, aDimensionType, ((aDimensionType == -1) && (this.mNether)) || ((aDimensionType == 0) && (this.mOverworld)) || ((aDimensionType == 1) && (this.mEnd)) || ((aWorld.provider.getDimensionName().equals("Moon")) && (this.mMoon)) || ((aWorld.provider.getDimensionName().equals("Mars")) && (this.mMars)) ? aDimensionType : aDimensionType ^ 0xFFFFFFFF)) {
if (!isGenerationAllowed(aWorld, aDimensionType, ((aDimensionType == -1) && (this.mNether)) || ((aDimensionType == 0) && (this.mOverworld)) || ((aDimensionType == 1) && (this.mEnd)) ? aDimensionType : aDimensionType ^ 0xFFFFFFFF)) {
+ /*
+ if (debugOrevein) {
+ GT_Log.out.println(
+ "Wrong dimension"
+ );
+ }
+ */
return WRONG_DIMENSION;
}
if (!this.mRestrictBiome.equals("None") && !(this.mRestrictBiome.equals(aBiome))) {
@@ -123,11 +130,13 @@ public class GT_Worldgen_GT_Ore_Layer int wX = Math.max( wXVein, aChunkX + 2); // Bias placement by 2 blocks to prevent worldgen cascade.
int eX = Math.min( eXVein, aChunkX + 2 + 16);
if (wX >= eX) { //No overlap between orevein and this chunk exists in X
+ /*
if (debugOrevein) {
GT_Log.out.println(
"No X overlap"
);
}
+ */
return NO_OVERLAP;
}
// Determine North/Sound ends of orevein
@@ -137,11 +146,13 @@ public class GT_Worldgen_GT_Ore_Layer int nZ = Math.max(nZVein, aChunkZ + 2); // Bias placement by 2 blocks to prevent worldgen cascade.
int sZ = Math.min(sZVein, aChunkZ + 2 + 16);
if (nZ >= sZ) { //No overlap between orevein and this chunk exists in Z
+ /*
if (debugOrevein) {
GT_Log.out.println(
"No Z overlap"
);
}
+ */
return NO_OVERLAP;
}
// Adjust the density down the more chunks we are away from the oreseed. The 5 chunks surrounding the seed should always be max density due to truncation of Math.sqrt().
@@ -256,6 +267,10 @@ public class GT_Worldgen_GT_Ore_Layer " oreseedX="+ aSeedX/16 +
" oreseedZ="+ aSeedZ/16 +
" cY="+tMinY+
+ " wXVein" + wXVein +
+ " eXVein" + eXVein +
+ " nZVein" + nZVein +
+ " sZVein" + sZVein +
" locDen=" + localDensity +
" Den=" + this.mDensity +
" Sec="+placeCount[1]+
@@ -265,6 +280,6 @@ public class GT_Worldgen_GT_Ore_Layer );
}
// Something (at least the bottom layer must have 1 block) must have been placed, return true
- return ORE_PLACED;
+ return ORE_PLACED;
}
}
diff --git a/src/main/java/gregtech/common/GT_Worldgen_Stone.java b/src/main/java/gregtech/common/GT_Worldgen_Stone.java index d7ee1d0bfd..b936998656 100644 --- a/src/main/java/gregtech/common/GT_Worldgen_Stone.java +++ b/src/main/java/gregtech/common/GT_Worldgen_Stone.java @@ -23,81 +23,175 @@ import static gregtech.api.enums.GT_Values.debugStones; public class GT_Worldgen_Stone extends GT_Worldgen_Ore { - public Hashtable<Long, StoneSeeds> validStoneSeeds = new Hashtable(1024); - - class StoneSeeds { - public boolean mExists; - - StoneSeeds( boolean exists ) { - mExists = exists; - } - }; - - class ValidSeeds { - public int mX; - public int mZ; - ValidSeeds( int x, int z) { - this.mX = x; - this.mZ = z; - } - }; + static final double sizeConversion[] = { 1, 1, 1.333333, 1.333333, 2, 2, 2, 2, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4 }; // Bias the sizes towards skinnier boulders, ie more "shafts" than dikes or sills. + + public Hashtable<Long, StoneSeeds> validStoneSeeds = new Hashtable(1024); + + class StoneSeeds { + public boolean mExists; + + StoneSeeds( boolean exists ) { + mExists = exists; + } + }; + + class ValidSeeds { + public int mX; + public int mZ; + ValidSeeds( int x, int z) { + this.mX = x; + this.mZ = z; + } + }; public GT_Worldgen_Stone(String aName, boolean aDefault, Block aBlock, int aBlockMeta, int aDimensionType, int aAmount, int aSize, int aProbability, int aMinY, int aMaxY, Collection<String> aBiomeList, boolean aAllowToGenerateinVoid) { super(aName, aDefault, aBlock, aBlockMeta, aDimensionType, aAmount, aSize, aProbability, aMinY, aMaxY, aBiomeList, aAllowToGenerateinVoid); } public boolean executeWorldgen(World aWorld, Random aRandom, String aBiome, int aDimensionType, int aChunkX, int aChunkZ, IChunkProvider aChunkGenerator, IChunkProvider aChunkProvider) { - XSTR stoneRNG = new XSTR(); - ArrayList<ValidSeeds> stones = new ArrayList(); - + XSTR stoneRNG = new XSTR(); + ArrayList<ValidSeeds> stones = new ArrayList(); + if ( !isGenerationAllowed(aWorld, aDimensionType, this.mDimensionType)) { - return false; + return false; + } + if ( !(this.mBiomeList.isEmpty() || this.mBiomeList.contains(aBiome)) ) { + return false; } - if ( !(this.mBiomeList.isEmpty() || this.mBiomeList.contains(aBiome)) ) { - return false; - } - int windowWidth = (mSize/8)/16 + 1; // Width of chunks to check for a potential stoneseed (I think the real size of the balls is mSize/8, but the code below is difficult to understand) - // Check stone seeds to see if they have been added - for( int x = aChunkX/16 - windowWidth; x < (aChunkX/16 + windowWidth + 1); x++ ) { - for( int z = aChunkZ/16 - windowWidth; z < (aChunkZ/16 + windowWidth + 1); z++ ) { - long hash = (( (long)x << 32) | ( (long)z & 0x00000000ffffffffL )); - if( !validStoneSeeds.containsKey(hash) ) { - // Determine if RNG says to add stone at this chunk - stoneRNG.setSeed((long)aWorld.getSeed() ^ hash); - if ( (this.mProbability <= 1) || (aRandom.nextInt(this.mProbability) == 0) ) { - // Add stone at this chunk - validStoneSeeds.put( hash, new StoneSeeds(true) ); - // Add to generation list - stones.add( new ValidSeeds(x,z) ); - if (debugStones) GT_Log.out.println( - "New stoneseed x="+x+ - " z="+z+ - " mSize="+mSize - ); - } else { - validStoneSeeds.put( hash, new StoneSeeds(false) ); - } - } else { - // This chunk has already been checked, check to see if a boulder exists here - if( validStoneSeeds.get(hash).mExists ) { - // Add to generation list - stones.add( new ValidSeeds(x,z) ); - } - } - } - } - - boolean result = true; - if (stones.size() == 0) { - result = false; - } - // Now process each oreseed vs this requested chunk - for( ; stones.size() != 0; stones.remove(0) ) { - int x = stones.get(0).mX*16; - int z = stones.get(0).mZ*16; - - stoneRNG.setSeed((long)aWorld.getSeed() ^ (( (long)x << 32) | ( (long)z & 0x00000000ffffffffL ))); - - for (int i = 0; i < this.mAmount; i++) { + // I think the real size of the balls is mSize/8, but the original code was difficult to understand. + // Overall there will be less GT stones since they aren't spheres any more. /16 since this code uses it as a radius. + double realSize = mSize/16; + int windowWidth = ((int)realSize)/16 + 1; // Width of chunks to check for a potential stoneseed + // Check stone seeds to see if they have been added + for( int x = aChunkX/16 - windowWidth; x < (aChunkX/16 + windowWidth + 1); x++ ) { + for( int z = aChunkZ/16 - windowWidth; z < (aChunkZ/16 + windowWidth + 1); z++ ) { + long hash = ((long)((aWorld.provider.dimensionId & 0xffL)<<56) |( ((long)x & 0x000000000fffffffL) << 28) | ( (long)z & 0x000000000fffffffL )); + if( !validStoneSeeds.containsKey(hash) ) { + // Determine if RNG says to add stone at this chunk + stoneRNG.setSeed((long)aWorld.getSeed() ^ hash + Math.abs(mBlockMeta) + Math.abs(mSize) + Math.abs(mProbability) + ((GregTech_API.sBlockGranites==mBlock)?(1000):(0))); //Don't judge me. Want different values for different block types + if ( (this.mProbability <= 1) || (stoneRNG.nextInt(this.mProbability*3/2) == 0) ) { // Decreased probability of stones by factor of 66%. + // Add stone at this chunk + validStoneSeeds.put( hash, new StoneSeeds(true) ); + // Add to generation list + stones.add( new ValidSeeds(x,z) ); + if (debugStones) GT_Log.out.println( + "New stoneseed="+mWorldGenName+ + " x="+x+ + " z="+z+ + " realSize="+realSize + ); + } else { + validStoneSeeds.put( hash, new StoneSeeds(false) ); + } + } else { + // This chunk has already been checked, check to see if a boulder exists here + if( validStoneSeeds.get(hash).mExists ) { + // Add to generation list + stones.add( new ValidSeeds(x,z) ); + } + } + } + } + + boolean result = true; + if (stones.size() == 0) { + result = false; + } + // Now process each oreseed vs this requested chunk + for( ; stones.size() != 0; stones.remove(0) ) { + int x = stones.get(0).mX*16; + int z = stones.get(0).mZ*16; + + stoneRNG.setSeed((long)aWorld.getSeed() ^ ((long)((aWorld.provider.dimensionId & 0xffL)<<60) |( ((long)x & 0x000000000fffffffL)<< 28) | ( (long)z & 0x000000000fffffffL )) + Math.abs(mBlockMeta) + Math.abs(mSize) + Math.abs(mProbability) + ((GregTech_API.sBlockGranites==mBlock)?(1000):(0))); //Don't judge me + for (int i = 0; i < this.mAmount; i++) { // Not sure why you would want more than one in a chunk! Left alone though. + // Locate the stoneseed XYZ. Original code would request an isAir at the seed location, causing a chunk generation request. + // To reduce potential worldgen cascade, we just always try to place a ball and use the check inside the for loop to prevent + // placement instead. + int tX = x + stoneRNG.nextInt(16); + int tY = mMinY + stoneRNG.nextInt(mMaxY - mMinY); + int tZ = z + stoneRNG.nextInt(16); + //Determine the XYZ sizes of the stoneseed + double xSize = sizeConversion[stoneRNG.nextInt(sizeConversion.length)]; + double ySize = sizeConversion[stoneRNG.nextInt(sizeConversion.length)/2]; // Skew the ySize towards the larger sizes, more long skinny pipes + double zSize = sizeConversion[stoneRNG.nextInt(sizeConversion.length)]; + + //Equation for an ellipsoid centered around 0,0,0 + // Sx, Sy, and Sz are size controls (size = 1/S_) + // 1 = full size, 1.333 = 75%, 2 = 50%, 4 = 25% + // (x * Sx)^2 + (y * Sy)^2 + (z * sZ)^2 <= (mSize)^2 + + //So, we setup the intial boundaries to be the size of the boulder plus a block in each direction + int tMinX = tX-(int)(realSize/xSize-1.0); + int tMaxX = tX+(int)(realSize/xSize+2.0); + int tMinY = tY-(int)(realSize/ySize-1.0); + int tMaxY = tY+(int)(realSize/ySize+2.0); + int tMinZ = tZ-(int)(realSize/zSize-1.0); + int tMaxZ = tZ+(int)(realSize/zSize+2.0); + + //Chop the boundaries by the parts that intersect with the current chunk + int wX = Math.max( tMinX, aChunkX + 8); + int eX = Math.min( tMaxX, aChunkX + 8 + 16 ); + + int sZ = Math.max( tMinZ, aChunkZ + 8); + int nZ = Math.min( tMaxZ, aChunkZ + 8 + 16 ); + + if (debugStones) GT_Log.out.println( + mWorldGenName + + " tX=" + tX + + " tY=" + tY + + " tZ=" + tZ + + " realSize=" + realSize + + " xSize=" + realSize/xSize + + " ySize=" + realSize/ySize + + " zSize=" + realSize/zSize + + " wX=" + wX + + " eX=" + eX + + " tMinY=" + tMinY + + " tMaxY=" + tMaxY + + " sZ=" + sZ + + " nZ=" + nZ + ); + + double rightHandSide = realSize*realSize + 1; //Precalc the right hand side + for( int iY = tMinY; iY < tMaxY; iY++) { // Do placement from the bottom up layer up. Maybe better on cache usage? + double yCalc = ( (double)(iY-tY)*ySize ); + yCalc = yCalc * yCalc; // (y*Sy)^2 + double leftHandSize = yCalc; + if( leftHandSize > rightHandSide ) { + continue; // If Y alone is larger than the RHS, skip the rest of the loops + } + for( int iX = wX; iX < eX; iX++) { + double xCalc = ( (double)(iX-tX)*xSize ); + xCalc = xCalc * xCalc; + leftHandSize = yCalc + xCalc; + if( leftHandSize > rightHandSide ) { // Again, if X and Y is larger than the RHS, skip to the next value + continue; + } + for( int iZ = sZ; iZ < nZ; iZ++ ) { + double zCalc = ( (double)(iZ-tZ)*zSize ); + zCalc = zCalc * zCalc; + leftHandSize = zCalc + xCalc + yCalc; + if( leftHandSize > rightHandSide ) { + continue; + } else { + // Yay! We can actually place a block now. (this part copied from original code) + Block tTargetedBlock = aWorld.getBlock(iX, iY, iZ); + if (tTargetedBlock instanceof GT_Block_Ores_Abstract) { + TileEntity tTileEntity = aWorld.getTileEntity(iX, iY, iZ); + if ((tTileEntity instanceof GT_TileEntity_Ores)) { + if (tTargetedBlock != GregTech_API.sBlockOres1) { + ((GT_TileEntity_Ores) tTileEntity).convertOreBlock(aWorld, iX, iY, iZ); + } + ((GT_TileEntity_Ores)tTileEntity).overrideOreBlockMaterial(this.mBlock, (byte) this.mBlockMeta); + } + } else if (((this.mAllowToGenerateinVoid) && (aWorld.getBlock(iX, iY, iZ).isAir(aWorld, iX, iY, iZ))) || ((tTargetedBlock != null) && ((tTargetedBlock.isReplaceableOreGen(aWorld, iX, iY, iZ, Blocks.stone)) || (tTargetedBlock.isReplaceableOreGen(aWorld, iX, iY, iZ, Blocks.end_stone)) || (tTargetedBlock.isReplaceableOreGen(aWorld, iX, iY, iZ, Blocks.netherrack)) || (tTargetedBlock.isReplaceableOreGen(aWorld, iX, iY, iZ, GregTech_API.sBlockGranites)) || (tTargetedBlock.isReplaceableOreGen(aWorld, iX, iY, iZ, GregTech_API.sBlockStones))))) { + aWorld.setBlock(iX, iY, iZ, this.mBlock, this.mBlockMeta, 0); + } + } + } + } + } + +/* Old stone code int tX = x + stoneRNG.nextInt(16); int tY = this.mMinY + stoneRNG.nextInt(this.mMaxY - this.mMinY); int tZ = z + stoneRNG.nextInt(16); @@ -105,19 +199,19 @@ public class GT_Worldgen_Stone float math_pi = 3.141593F;//FB: CNT - CNT_ROUGH_CONSTANT_VALUE float var6 = stoneRNG.nextFloat() * math_pi; float var1d = this.mSize / 8.0F; - int var2d = tX + 8; - int var3d = tZ + 8; - int var4d = tY - 2; + int var2d = tX + 8; + int var3d = tZ + 8; + int var4d = tY - 2; float mh_s_0 = MathHelper.sin(var6) * var1d; - float mh_c_0 = MathHelper.cos(var6) * var1d; + float mh_c_0 = MathHelper.cos(var6) * var1d; float var7 = var2d + mh_s_0; float var11 = var3d + mh_c_0; int var15r = stoneRNG.nextInt(3); - int var17r = stoneRNG.nextInt(3); + int var17r = stoneRNG.nextInt(3); int var15 = var4d + var15r; int mh_n_4=var17r - var15r; float mh_n_0 = -2*mh_s_0; - float mh_n_1 = -2*mh_c_0; + float mh_n_1 = -2*mh_c_0; for (int var19 = 0; var19 <= this.mSize; var19++) { float var5d = var19 / this.mSize; float var20 = var7 + mh_n_0 * var5d; @@ -133,12 +227,12 @@ public class GT_Worldgen_Stone int tMaxY = MathHelper.floor_float(var22 + var28); int tMaxZ = MathHelper.floor_float(var24 + var28); - int wX = Math.max( tMinX, aChunkX + 8); - int eX = Math.min( tMaxX, aChunkX + 8 + 16 ); + int wX = Math.max( tMinX, aChunkX + 8); + int eX = Math.min( tMaxX, aChunkX + 8 + 16 ); - int sZ = Math.max( tMinZ, aChunkZ + 8); - int nZ = Math.min( tMaxZ, aChunkZ + 8 + 16 ); - + int sZ = Math.max( tMinZ, aChunkZ + 8); + int nZ = Math.min( tMaxZ, aChunkZ + 8 + 16 ); + for (int iX = wX; iX < eX; iX++) { float var39 = (iX + 0.5F - var20) / (var28); float var10d = var39 * var39; @@ -170,6 +264,14 @@ public class GT_Worldgen_Stone } } } +*/ + + + + + + + } } return result; diff --git a/src/main/java/gregtech/common/GT_Worldgenerator.java b/src/main/java/gregtech/common/GT_Worldgenerator.java index 85fbcae141..d477065c55 100644 --- a/src/main/java/gregtech/common/GT_Worldgenerator.java +++ b/src/main/java/gregtech/common/GT_Worldgenerator.java @@ -74,21 +74,42 @@ implements IWorldGenerator { public void generate(Random aRandom, int aX, int aZ, World aWorld, IChunkProvider aChunkGenerator, IChunkProvider aChunkProvider) {
synchronized (listLock)
{
- if (!this.ProcChunks.contains( ((long)aX << 32) | ((long)(aZ) & 0x00000000ffffffffL)) ) {
- this.ProcChunks.add( ((long)aX << 32) | ((long)(aZ) & 0x00000000ffffffffL));
- this.mList.add(new WorldGenContainer(new XSTR(aRandom.nextInt()), aX, aZ, ((aChunkGenerator instanceof ChunkProviderEnd)) || (aWorld.getBiomeGenForCoords(aX * 16 + 8, aZ * 16 + 8) == BiomeGenBase.sky) ? 1 : ((aChunkGenerator instanceof ChunkProviderHell)) || (aWorld.getBiomeGenForCoords(aX * 16 + 8, aZ * 16 + 8) == BiomeGenBase.hell) ? -1 : 0, aWorld, aChunkGenerator, aChunkProvider, aWorld.getBiomeGenForCoords(aX * 16 + 8, aZ * 16 + 8).biomeName));
- if (debugWorldGen) {GT_Log.out.println("ADD WorldGen chunk x:" + aX + " z:" + aZ + " SIZE: " + this.mList.size());}
+/*
+ if (debugWorldGen) GT_Log.out.println(
+ "aWorld.getSeed()="+aWorld.getSeed()
+ );
+ if (!this.ProcChunks.contains( ((aWorld.provider.dimensionId & 0xffL)<<56) |( ((long)aX & 0x000000000fffffffL) << 28) | ( (long)aZ & 0x000000000fffffffL )) ) { // Have to add ProcChunks due to Deep Dark bug that calls oregen twice
+ this.ProcChunks.add( ((aWorld.provider.dimensionId & 0xffL)<<56) |( ((long)aX & 0x000000000fffffffL) << 28) | ( (long)aZ & 0x000000000fffffffL ));
+*/
+ this.mList.add(new WorldGenContainer(new XSTR(Math.abs(aRandom.nextInt()) +1), aX, aZ, ((aChunkGenerator instanceof ChunkProviderEnd)) || (aWorld.getBiomeGenForCoords(aX * 16 + 8, aZ * 16 + 8) == BiomeGenBase.sky) ? 1 : ((aChunkGenerator instanceof ChunkProviderHell)) || (aWorld.getBiomeGenForCoords(aX * 16 + 8, aZ * 16 + 8) == BiomeGenBase.hell) ? -1 : 0, aWorld, aChunkGenerator, aChunkProvider, aWorld.getBiomeGenForCoords(aX * 16 + 8, aZ * 16 + 8).biomeName));
+
+ if (debugWorldGen) GT_Log.out.println(
+ "ADD WorldSeed:"+aWorld.getSeed() +
+ " DimId" + aWorld.provider.dimensionId +
+ " chunk x:" + aX +
+ " z:" + aZ +
+ " SIZE: " + this.mList.size()
+ );
+/*
} else {
if (debugWorldGen) {GT_Log.out.println("DUP WorldGen chunk x:" + aX + " z:" + aZ + " SIZE: " + this.mList.size() + " ProcChunks.size(): " + ProcChunks.size() ); }
}
+*/
}
+
if (!this.mIsGenerating) {
this.mIsGenerating = true;
int mList_sS=this.mList.size();
for (int i = 0; i < mList_sS; i++) {
WorldGenContainer toRun = (WorldGenContainer) this.mList.get(0);
- if (debugWorldGen) {GT_Log.out.println("RUN WorldGen chunk x:" + toRun.mX + " z:" + toRun.mZ + " SIZE: " + this.mList.size() + " i: " + i );}
- this.ProcChunks.remove( ((long)(toRun.mX) << 32) | ((long)(toRun.mZ) & 0x00000000ffffffffL));
+ if (debugWorldGen) GT_Log.out.println(
+ "RUN WorldSeed:"+aWorld.getSeed()+
+ " DimId" + aWorld.provider.dimensionId +
+ " chunk x:" + toRun.mX +
+ " z:" + toRun.mZ +
+ " SIZE: " + this.mList.size() +
+ " i: " + i
+ );
synchronized (listLock)
{
this.mList.remove(0);
@@ -141,21 +162,26 @@ implements IWorldGenerator { }
public void worldGenFindVein( int oreseedX, int oreseedZ) {
- long oreveinSeed = (long)this.mWorld.getSeed() ^ (( (long)oreseedX << 32) | ( (long)oreseedZ & 0x00000000ffffffffL )); // Use an RNG that is identical every time it is called for this oreseed
+ // Explanation of oreveinseed implementation.
+ // (long)this.mWorld.getSeed()<<16) Deep Dark does two oregen passes, one with getSeed set to +1 the original world seed. This pushes that +1 off the low bits of oreseedZ, so that the hashes are far apart for the two passes.
+ // ((this.mWorld.provider.dimensionId & 0xffL)<<56) Puts the dimension in the top bits of the hash, to make sure to get unique hashes per dimension
+ // ((long)oreseedX & 0x000000000fffffffL) << 28) Puts the chunk X in the bits 29-55. Cuts off the top few bits of the chunk so we have bits for dimension.
+ // ( (long)oreseedZ & 0x000000000fffffffL )) Puts the chunk Z in the bits 0-27. Cuts off the top few bits of the chunk so we have bits for dimension.
+ long oreveinSeed = ((long)this.mWorld.getSeed()<<16) ^ ((long)((this.mWorld.provider.dimensionId & 0xffL)<<56) |( ((long)oreseedX & 0x000000000fffffffL) << 28) | ( (long)oreseedZ & 0x000000000fffffffL )); // Use an RNG that is identical every time it is called for this oreseed.
XSTR oreveinRNG = new XSTR( oreveinSeed );
int oreveinPercentageRoll = oreveinRNG.nextInt(100); // Roll the dice, see if we get an orevein here at all
int noOrePlacedCount=0;
String tDimensionName = "";
if (debugOrevein) { tDimensionName = this.mWorld.provider.getDimensionName(); }
- /*
+
if (debugOrevein) GT_Log.out.println(
" Finding oreveins for oreveinSeed="+ oreveinSeed +
" mX="+ this.mX +
" mZ="+ this.mZ +
" oreseedX="+ oreseedX +
- " oreseedZ="+ oreseedZ
+ " oreseedZ="+ oreseedZ +
+ " worldSeed="+this.mWorld.getSeed()
);
- */
// Search for a valid orevein for this dimension
if( !validOreveins.containsKey(oreveinSeed) ) {
@@ -163,7 +189,6 @@ implements IWorldGenerator { int placementAttempts = 0;
boolean oreveinFound = false;
int i;
-
for( i = 0; (i < oreveinAttempts) && (!oreveinFound) && (placementAttempts<oreveinMaxPlacementAttempts); i++ ) {
int tRandomWeight = oreveinRNG.nextInt(GT_Worldgen_GT_Ore_Layer.sWeight);
for (GT_Worldgen tWorldGen : GT_Worldgen_GT_Ore_Layer.sList) {
@@ -175,10 +200,6 @@ implements IWorldGenerator { case GT_Worldgen_GT_Ore_Layer.ORE_PLACED:
if (debugOrevein) GT_Log.out.println(
" Added oreveinSeed=" + oreveinSeed +
- " mX="+ this.mX +
- " mZ="+ this.mZ +
- " oreseedX="+ oreseedX +
- " oreseedZ="+ oreseedZ +
" tries at oremix=" + i +
" placementAttempts=" + placementAttempts +
" dimensionName=" + tDimensionName
@@ -243,8 +264,20 @@ implements IWorldGenerator { " validOreveins.size()=" + validOreveins.size() + " "
);
GT_Worldgen tWorldGen = validOreveins.get(oreveinSeed);
- oreveinRNG.setSeed(oreveinSeed); // reset seed for RNG to only be based on oreseed X/Z
- tWorldGen.executeWorldgenChunkified(this.mWorld, oreveinRNG, this.mBiome, this.mDimensionType, this.mX*16, this.mZ*16, oreseedX*16, oreseedZ*16, this.mChunkGenerator, this.mChunkProvider);
+ oreveinRNG.setSeed(oreveinSeed); // Reset RNG to only be based on oreseed X/Z
+ int placementResult = tWorldGen.executeWorldgenChunkified(this.mWorld, oreveinRNG, this.mBiome, this.mDimensionType, this.mX*16, this.mZ*16, oreseedX*16, oreseedZ*16, this.mChunkGenerator, this.mChunkProvider);
+ switch( placementResult )
+ {
+ case GT_Worldgen_GT_Ore_Layer.NO_ORE_IN_BOTTOM_LAYER:
+ if (debugOrevein) GT_Log.out.print(
+ " No ore in bottom layer"
+ );
+ break;
+ case GT_Worldgen_GT_Ore_Layer.NO_OVERLAP:
+ if (debugOrevein) GT_Log.out.print(
+ " No overlap"
+ );
+ }
}
}
@@ -252,16 +285,20 @@ implements IWorldGenerator { long startTime = System.nanoTime();
// Determine bounding box on how far out to check for oreveins affecting this chunk
- int wXbox = this.mX - (oreveinMaxSize/16
);
- int eXbox = this.mX + (oreveinMaxSize/16
+ 1); // Need to add 1 since it is compared using a <
- int nZbox = this.mZ - (oreveinMaxSize/16
);
- int sZbox = this.mZ + (oreveinMaxSize/16
+ 1);
+ int wXbox = this.mX - (oreveinMaxSize/16);
+ int eXbox = this.mX + (oreveinMaxSize/16 + 1); // Need to add 1 since it is compared using a <
+ int nZbox = this.mZ - (oreveinMaxSize/16);
+ int sZbox = this.mZ + (oreveinMaxSize/16 + 1);
// Search for orevein seeds and add to the list;
for( int x = wXbox; x < eXbox; x++ ) {
for( int z = nZbox; z < sZbox; z++ ) {
// Determine if this X/Z is an orevein seed
if ( ( (Math.abs(x)%3) == 1) && ( (Math.abs(z)%3) == 1 ) ) {
+ if (debugWorldGen) GT_Log.out.println(
+
"Adding seed x="+x+
+ " z="+z
+ );
seedList.add( new NearbySeeds(x,z) );
}
}
@@ -269,6 +306,10 @@ implements IWorldGenerator { // Now process each oreseed vs this requested chunk
for( ; seedList.size() != 0; seedList.remove(0) ) {
+ if (debugWorldGen) GT_Log.out.println(
+
"Processing seed x="+seedList.get(0).mX+
+ " z="+seedList.get(0).mZ
+ );
worldGenFindVein( seedList.get(0).mX, seedList.get(0).mZ );
}
|