public void rMapVolcanoes(Chunk primer, World world, IBiomeProviderRTG cmr, int baseX, int baseY, int chunkX, int chunkY, OpenSimplexNoise simplex, CellNoise cell, float[] noise) { // Have volcanoes been disabled in the global config? if (!rtgConfig.ENABLE_VOLCANOES) { return; } // Let's go ahead and generate the volcano. Exciting!!! :D if (baseX % 4 == 0 && baseY % 4 == 0) { int biomeId = cmr.getBiomeGenAt(baseX * 16, baseY * 16).getBiomeID(); RealisticBiomeBase realisticBiome = RealisticBiomeBase.getBiome(biomeId); // Do we need to patch the biome? if (realisticBiome == null) { RealisticBiomePatcher biomePatcher = new RealisticBiomePatcher(); realisticBiome = biomePatcher.getPatchedRealisticBiome( "NULL biome found when mapping volcanoes."); } if (!realisticBiome.getConfig().ALLOW_VOLCANOES) { return; } // Have volcanoes been disabled via frequency? // Use the global frequency unless the biome frequency has been explicitly set. int chance = realisticBiome.getConfig().VOLCANO_CHANCE == -1 ? rtgConfig.VOLCANO_CHANCE : realisticBiome.getConfig().VOLCANO_CHANCE; if (chance < 1) { return; } if (mapRand.Next(chance) > 0) { return; } float river = cmr.getRiverStrength(baseX * 16, baseY * 16) + 1f; if (river > 0.98f && cmr.isBorderlessAt(baseX * 16, baseY * 16)) { // we have to pull it out of noVolcano. We do it this way to avoid having to make a ChunkPos twice ChunkPos probe = new ChunkPos(baseX, baseY); noVolcano.Remove(probe); long i1 = mapRand.Next() / 2L * 2L + 1L; long j1 = mapRand.Next() / 2L * 2L + 1L; mapRand = new Random((int)((long)chunkX * i1 + (long)chunkY * j1 ^ world.getSeed())); WorldGenVolcano.build(primer, world, mapRand, baseX, baseY, chunkX, chunkY, simplex, cell, noise); } } }
public float[] getRainfall(float[] par1ArrayOfFloat, int par2, int par3, int par4, int par5) { if (par1ArrayOfFloat == null || par1ArrayOfFloat.Length < par4 * par5) { par1ArrayOfFloat = new float[par4 * par5]; } int[] aint = this.biomeIndexLayer.getInts(par2, par3, par4, par5); for (int i1 = 0; i1 < par4 * par5; ++i1) { float f = 0; int biome = aint[i1]; try { if (biome > 255) { throw new Exception(biomeIndexLayer.ToString()); } f = RealisticBiomeBase.getBiome(biome).baseBiome.getRainfall() / 65536.0F; } catch (Exception e) { if (biome > 255) { throw new Exception(biomeIndexLayer.ToString()); } if (RealisticBiomeBase.getBiome(biome) == null) { f = biomePatcher.getPatchedRealisticBiome("Problem with biome " + biome + " from " + e.Message).baseBiome.getRainfall() / 65536.0F; } } if (f > 1.0F) { f = 1.0F; } par1ArrayOfFloat[i1] = f; } return(par1ArrayOfFloat); }
/** * @see IBiomeProviderRTG */ //Can't override for some reason, shouldn't matter too much at the moment. public RealisticBiomeBase getBiomeDataAt(int par1, int par2) { /*long coords = ChunkCoordIntPair.chunkXZ2Int(par1, par2); * if (biomeDataMap.containsKey(coords)) { * return biomeDataMap.get(coords); * }*/ RealisticBiomeBase output; output = RealisticBiomeBase.getBiome(this.getBiomeGenAt(par1, par2).getBiomeID()); if (output == null) { output = biomePatcher.getPatchedRealisticBiome("No biome " + par1 + " " + par2); } /*if (biomeDataMap.size() > 4096) { * biomeDataMap.clear(); * } * biomeDataMap.put(coords, output);*/ return(output); }
private void setupBeachesForBiomes() { preferredBeach = new int[256]; for (int i = 0; i < preferredBeach.Length; i++) { // We need to work with the realistic biome, so let's try to get it from the base biome, aborting if necessary. Biome biome = Biome.getBiome(i); if (biome == null) { continue; } RealisticBiomeBase realisticBiome = RealisticBiomeBase.getBiome(i); if (realisticBiome == null) { continue; } preferredBeach[i] = realisticBiome._beachBiome.getBiomeID(); // If stone beaches aren't allowed in this biome, then determine the best beach to use based on the biome's temperature. if (realisticBiome.disallowStoneBeaches) { if (realisticBiome._beachBiome.getBiomeID() == Biomes.STONE_BEACH.getBiomeID()) { preferredBeach[i] = (biome.getTemperature() <= 0.05f) ? Biomes.COLD_BEACH.getBiomeID() : Biomes.BEACHES.getBiomeID(); } } // If beaches aren't allowed in this biome, then use this biome as the beach. if (realisticBiome.disallowAllBeaches) { preferredBeach[i] = i; } } }
private void getNewerNoise(IBiomeProviderRTG cmr, int cx, int cz, ChunkLandscape landscape) { // get area biome map for (int i = -sampleSize; i < sampleSize + 5; i++) { for (int j = -sampleSize; j < sampleSize + 5; j++) { biomeData[(i + sampleSize) * sampleArraySize + (j + sampleSize)] = cmr.getBiomeDataAt(cx + ((i * 8)), cz + ((j * 8))).baseBiome.getBiomeID(); } } float river; // fill the old smallRender for (int i = 0; i < 16; i++) { for (int j = 0; j < 16; j++) { float totalWeight = 0; for (int mapX = 0; mapX < sampleArraySize; mapX++) { for (int mapZ = 0; mapZ < sampleArraySize; mapZ++) { float weight = weightings[mapX * sampleArraySize + mapZ, i * 16 + j]; if (weight > 0) { totalWeight += weight; weightedBiomes[biomeData[mapX * sampleArraySize + mapZ]] += weight; } } } // normalize biome weights for (int biomeIndex = 0; biomeIndex < weightedBiomes.Length; biomeIndex++) { weightedBiomes[biomeIndex] /= totalWeight; } landscape.noise[i * 16 + j] = 0f; river = cmr.getRiverStrength(cx + i, cz + j); landscape.river[i * 16 + j] = -river; float totalBorder = 0f; for (int k = 0; k < 256; k++) { if (weightedBiomes[k] > 0f) { totalBorder += weightedBiomes[k]; RealisticBiomeBase realisticBiome = RealisticBiomeBase.getBiome(k); // Do we need to patch the biome? if (realisticBiome == null) { realisticBiome = biomePatcher.getPatchedRealisticBiome( "NULL biome (" + k + ") found when getting newer noise."); } landscape.noise[i * 16 + j] += realisticBiome.rNoise(this.rtgWorld, cx + i, cz + j, weightedBiomes[k], river + 1f) * weightedBiomes[k]; // 0 for the next column weightedBiomes[k] = 0f; } } if (totalBorder < .999 || totalBorder > 1.001) { throw new Exception("" + totalBorder); } } } //fill biomes array with biomeData for (int i = 0; i < 16; i++) { for (int j = 0; j < 16; j++) { landscape.biome[i * 16 + j] = cmr.getBiomeDataAt(cx + (((i - 7) * 8 + 4)), cz + (((j - 7) * 8 + 4))); } } }
/* HUNTING * */ public void newRepair(int[] genLayerBiomes, RealisticBiomeBase[] jitteredBiomes, int[] biomeNeighborhood, int neighborhoodSize, float[] noise, float[] riverStrength) { int sampleSize = 8; RealisticBiomeBase realisticBiome; int realisticBiomeId; if (neighborhoodSize != sampleSize) { throw new Exception("mismatch between chunk and analyzer neighborhood sizes"); } // currently just stuffs the genLayer into the jitter; for (int i = 0; i < 256; i++) { realisticBiome = RealisticBiomeBase.getBiome(genLayerBiomes[i]); // Do we need to patch the biome? if (realisticBiome == null) { realisticBiome = biomePatcher.getPatchedRealisticBiome( "NULL biome (" + i + ") found when performing new repair."); } realisticBiomeId = realisticBiome.baseBiome.getBiomeID(); bool canBeRiver = riverStrength[i] > 0.7; // save what's there since the jitter keeps changing savedJittered[i] = jitteredBiomes[i]; //if (savedJittered[i]== null) throw new RuntimeException(); if (noise[i] > 61.5) { // replace jitteredBiomes[i] = realisticBiome; } else { // check for river if (canBeRiver && !oceanBiome[realisticBiomeId] && !swampBiome[realisticBiomeId]) { // make river int riverBiomeID = realisticBiome.riverBiome.getBiomeID(); jitteredBiomes[i] = RealisticBiomeBase.getBiome(riverBiomeID); } else { // replace jitteredBiomes[i] = realisticBiome; } } } // put beaches on shores beachSearch.notHunted = true; beachSearch.absent = false; float beachTop = 64.5f; for (int i = 0; i < 256; i++) { if (beachSearch.absent) { break; //no point } float beachBottom = 61.5f; if (noise[i] < beachBottom || noise[i] > riverAdjusted(beachTop, riverStrength[i])) { continue; // this block isn't beach level } int biomeID = jitteredBiomes[i].baseBiome.getBiomeID(); if (swampBiome[biomeID]) { continue; // swamps are acceptable at beach level } if (beachSearch.notHunted) { beachSearch.hunt(biomeNeighborhood); landSearch.hunt(biomeNeighborhood); } int foundBiome = beachSearch.biomes[i]; if (foundBiome != NO_BIOME) { int nearestLandBiome = landSearch.biomes[i]; if (nearestLandBiome > -1) { foundBiome = preferredBeach[nearestLandBiome]; } realisticBiome = RealisticBiomeBase.getBiome(foundBiome); // Do we need to patch the biome? if (realisticBiome == null) { realisticBiome = biomePatcher.getPatchedRealisticBiome( "NULL biome (" + i + ") found when performing new repair."); } jitteredBiomes[i] = realisticBiome; } } // put land higher up; landSearch.absent = false; landSearch.notHunted = true; for (int i = 0; i < 256; i++) { if (landSearch.absent && beachSearch.absent) { break; //no point } // skip if this block isn't above beach level, adjusted for river effect to prevent abrupt beach stops if (noise[i] < riverAdjusted(beachTop, riverStrength[i])) { continue; } int biomeID = jitteredBiomes[i].baseBiome.getBiomeID(); // already land if (landBiome[biomeID]) { continue; } // swamps are acceptable above water if (swampBiome[biomeID]) { continue; } if (landSearch.notHunted) { landSearch.hunt(biomeNeighborhood); } int foundBiome = landSearch.biomes[i]; if (foundBiome == NO_BIOME) { // no land found; try for a beach if (beachSearch.notHunted) { beachSearch.hunt(biomeNeighborhood); } foundBiome = beachSearch.biomes[i]; } if (foundBiome != NO_BIOME) { realisticBiome = RealisticBiomeBase.getBiome(foundBiome); // Do we need to patch the biome? if (realisticBiome == null) { realisticBiome = biomePatcher.getPatchedRealisticBiome( "NULL biome (" + i + ") found when performing new repair."); } jitteredBiomes[i] = realisticBiome; } } // put ocean below sea level oceanSearch.absent = false; oceanSearch.notHunted = true; for (int i = 0; i < 256; i++) { if (oceanSearch.absent) { break; //no point } float oceanTop = 61.5f; if (noise[i] > oceanTop) { continue; // too hight } int biomeID = jitteredBiomes[i].baseBiome.getBiomeID(); if (oceanBiome[biomeID]) { continue; // obviously ocean is OK } if (swampBiome[biomeID]) { continue; // swamps are acceptable } if (riverBiome[biomeID]) { continue; // rivers stay rivers } if (oceanSearch.notHunted) { oceanSearch.hunt(biomeNeighborhood); } int foundBiome = oceanSearch.biomes[i]; if (foundBiome != NO_BIOME) { realisticBiome = RealisticBiomeBase.getBiome(foundBiome); // Do we need to patch the biome? if (realisticBiome == null) { realisticBiome = biomePatcher.getPatchedRealisticBiome( "NULL biome (" + i + ") found when performing new repair."); } jitteredBiomes[i] = realisticBiome; } } // convert remainder below sea level to lake biome for (int i = 0; i < 256; i++) { int biomeID = jitteredBiomes[i].baseBiome.getBiomeID(); if (noise[i] <= 61.5 && !riverBiome[biomeID]) { // check for river if (!oceanBiome[biomeID] && !swampBiome[biomeID] && !beachBiome[biomeID]) { int riverReplacement = jitteredBiomes[i].riverBiome.getBiomeID(); // make river if (riverReplacement == Biomes.FROZEN_RIVER.getBiomeID()) { jitteredBiomes[i] = scenicFrozenLakeBiome; } else { jitteredBiomes[i] = scenicLakeBiome; } } } } }