diff options
Diffstat (limited to 'src/main/java/gtPlusPlus/australia/world')
6 files changed, 1022 insertions, 0 deletions
diff --git a/src/main/java/gtPlusPlus/australia/world/AustraliaPortalPosition.java b/src/main/java/gtPlusPlus/australia/world/AustraliaPortalPosition.java new file mode 100644 index 0000000000..865c0c3bb2 --- /dev/null +++ b/src/main/java/gtPlusPlus/australia/world/AustraliaPortalPosition.java @@ -0,0 +1,14 @@ +package gtPlusPlus.australia.world; + +import net.minecraft.util.ChunkCoordinates; + +public class AustraliaPortalPosition extends ChunkCoordinates { + public long field_85087_d; + final AustraliaTeleporterDimensionMod field_85088_e; + + public AustraliaPortalPosition(AustraliaTeleporterDimensionMod gladesTeleporter, int par2, int par3, int par4, long par5) { + super(par2, par3, par4); + this.field_85088_e = gladesTeleporter; + this.field_85087_d = par5; + } +}
\ No newline at end of file diff --git a/src/main/java/gtPlusPlus/australia/world/AustraliaTeleporterDimensionMod.java b/src/main/java/gtPlusPlus/australia/world/AustraliaTeleporterDimensionMod.java new file mode 100644 index 0000000000..4ad693263e --- /dev/null +++ b/src/main/java/gtPlusPlus/australia/world/AustraliaTeleporterDimensionMod.java @@ -0,0 +1,470 @@ +package gtPlusPlus.australia.world; + +import java.util.*; + +import net.minecraft.entity.Entity; +import net.minecraft.init.Blocks; +import net.minecraft.util.*; +import net.minecraft.world.ChunkCoordIntPair; +import net.minecraft.world.Teleporter; +import net.minecraft.world.WorldServer; +import gtPlusPlus.australia.dimension.Dimension_Australia; + +public class AustraliaTeleporterDimensionMod extends Teleporter { + + private final WorldServer worldServerInstance; + /** + * A private Random() function in Teleporter + */ + private final Random random; + /** + * Stores successful portal placement locations for rapid lookup. + */ + private final LongHashMap destinationCoordinateCache = new LongHashMap(); + /** + * A list of valid keys for the destinationCoordainteCache. These are + * based on the X & Z of the players initial location. + */ + @SuppressWarnings("rawtypes") + private final List destinationCoordinateKeys = new ArrayList(); + + public AustraliaTeleporterDimensionMod(WorldServer par1WorldServer) { + super(par1WorldServer); + this.worldServerInstance = par1WorldServer; + this.random = new Random(par1WorldServer.getSeed()); + } + + /** + * Place an entity in a nearby portal, creating one if necessary. + */ + @Override + public void placeInPortal(Entity par1Entity, double par2, double par4, double par6, float par8) { + if (this.worldServerInstance.provider.dimensionId != 1) { + if (!this.placeInExistingPortal(par1Entity, par2, par4, par6, par8)) { + this.makePortal(par1Entity); + this.placeInExistingPortal(par1Entity, par2, par4, par6, par8); + } + } + else { + int i = MathHelper.floor_double(par1Entity.posX); + int j = MathHelper.floor_double(par1Entity.posY) - 1; + int k = MathHelper.floor_double(par1Entity.posZ); + byte b0 = 1; + byte b1 = 0; + + for (int l = -2; l <= 2; ++l) { + for (int i1 = -2; i1 <= 2; ++i1) { + for (int j1 = -1; j1 < 3; ++j1) { + int k1 = i + i1 * b0 + l * b1; + int l1 = j + j1; + int i2 = k + i1 * b1 - l * b0; + boolean flag = j1 < 0; + this.worldServerInstance.setBlock(k1, l1, i2, flag ? Dimension_Australia.blockPortalFrame : Blocks.air); + } + } + } + + par1Entity.setLocationAndAngles(i, j, k, par1Entity.rotationYaw, 0.0F); + par1Entity.motionX = par1Entity.motionY = par1Entity.motionZ = 0.0D; + } + } + + /** + * Place an entity in a nearby portal which already exists. + */ + @Override + public boolean placeInExistingPortal(Entity par1Entity, double par2, double par4, double par6, float par8) { + short short1 = 128; + double d3 = -1.0D; + int i = 0; + int j = 0; + int k = 0; + int l = MathHelper.floor_double(par1Entity.posX); + int i1 = MathHelper.floor_double(par1Entity.posZ); + long j1 = ChunkCoordIntPair.chunkXZ2Int(l, i1); + boolean flag = true; + double d7; + int l3; + + if (this.destinationCoordinateCache.containsItem(j1)) { + Teleporter.PortalPosition portalposition = (Teleporter.PortalPosition) this.destinationCoordinateCache + .getValueByKey(j1); + d3 = 0.0D; + i = portalposition.posX; + j = portalposition.posY; + k = portalposition.posZ; + portalposition.lastUpdateTime = this.worldServerInstance.getTotalWorldTime(); + flag = false; + } + else { + for (l3 = l - short1; l3 <= l + short1; ++l3) { + double d4 = l3 + 0.5D - par1Entity.posX; + + for (int l1 = i1 - short1; l1 <= i1 + short1; ++l1) { + double d5 = l1 + 0.5D - par1Entity.posZ; + + for (int i2 = this.worldServerInstance.getActualHeight() - 1; i2 >= 0; --i2) { + if (this.worldServerInstance.getBlock(l3, i2, l1) == Dimension_Australia.portalBlock) { + while (this.worldServerInstance.getBlock(l3, i2 - 1, l1) == Dimension_Australia.portalBlock) { + --i2; + } + + d7 = i2 + 0.5D - par1Entity.posY; + double d8 = d4 * d4 + d7 * d7 + d5 * d5; + + if (d3 < 0.0D || d8 < d3) { + d3 = d8; + i = l3; + j = i2; + k = l1; + } + } + } + } + } + } + + if (d3 >= 0.0D) { + if (flag) { + this.destinationCoordinateCache.add(j1, + new Teleporter.PortalPosition(i, j, k, this.worldServerInstance.getTotalWorldTime())); + this.destinationCoordinateKeys.add(Long.valueOf(j1)); + } + + double d11 = i + 0.5D; + double d6 = j + 0.5D; + d7 = k + 0.5D; + int i4 = -1; + + if (this.worldServerInstance.getBlock(i - 1, j, k) == Dimension_Australia.portalBlock) { + i4 = 2; + } + + if (this.worldServerInstance.getBlock(i + 1, j, k) == Dimension_Australia.portalBlock) { + i4 = 0; + } + + if (this.worldServerInstance.getBlock(i, j, k - 1) == Dimension_Australia.portalBlock) { + i4 = 3; + } + + if (this.worldServerInstance.getBlock(i, j, k + 1) == Dimension_Australia.portalBlock) { + i4 = 1; + } + + int j2 = par1Entity.getTeleportDirection(); + + if (i4 > -1) { + int k2 = Direction.rotateLeft[i4]; + int l2 = Direction.offsetX[i4]; + int i3 = Direction.offsetZ[i4]; + int j3 = Direction.offsetX[k2]; + int k3 = Direction.offsetZ[k2]; + boolean flag1 = !this.worldServerInstance.isAirBlock(i + l2 + j3, j, k + i3 + k3) + || !this.worldServerInstance.isAirBlock(i + l2 + j3, j + 1, k + i3 + k3); + boolean flag2 = !this.worldServerInstance.isAirBlock(i + l2, j, k + i3) + || !this.worldServerInstance.isAirBlock(i + l2, j + 1, k + i3); + + if (flag1 && flag2) { + i4 = Direction.rotateOpposite[i4]; + k2 = Direction.rotateOpposite[k2]; + l2 = Direction.offsetX[i4]; + i3 = Direction.offsetZ[i4]; + j3 = Direction.offsetX[k2]; + k3 = Direction.offsetZ[k2]; + l3 = i - j3; + d11 -= j3; + int k1 = k - k3; + d7 -= k3; + flag1 = !this.worldServerInstance.isAirBlock(l3 + l2 + j3, j, k1 + i3 + k3) + || !this.worldServerInstance.isAirBlock(l3 + l2 + j3, j + 1, k1 + i3 + k3); + flag2 = !this.worldServerInstance.isAirBlock(l3 + l2, j, k1 + i3) + || !this.worldServerInstance.isAirBlock(l3 + l2, j + 1, k1 + i3); + } + + float f1 = 0.5F; + float f2 = 0.5F; + + if (!flag1 && flag2) { + f1 = 1.0F; + } + else if (flag1 && !flag2) { + f1 = 0.0F; + } + else if (flag1 && flag2) { + f2 = 0.0F; + } + + d11 += j3 * f1 + f2 * l2; + d7 += k3 * f1 + f2 * i3; + float f3 = 0.0F; + float f4 = 0.0F; + float f5 = 0.0F; + float f6 = 0.0F; + + if (i4 == j2) { + f3 = 1.0F; + f4 = 1.0F; + } + else if (i4 == Direction.rotateOpposite[j2]) { + f3 = -1.0F; + f4 = -1.0F; + } + else if (i4 == Direction.rotateRight[j2]) { + f5 = 1.0F; + f6 = -1.0F; + } + else { + f5 = -1.0F; + f6 = 1.0F; + } + + double d9 = par1Entity.motionX; + double d10 = par1Entity.motionZ; + par1Entity.motionX = d9 * f3 + d10 * f6; + par1Entity.motionZ = d9 * f5 + d10 * f4; + par1Entity.rotationYaw = par8 - j2 * 90 + i4 * 90; + } + else { + par1Entity.motionX = par1Entity.motionY = par1Entity.motionZ = 0.0D; + } + + par1Entity.setLocationAndAngles(d11, d6, d7, par1Entity.rotationYaw, par1Entity.rotationPitch); + return true; + } + else { + return false; + } + } + + @Override + public boolean makePortal(Entity par1Entity) { + byte b0 = 16; + double d0 = -1.0D; + int i = MathHelper.floor_double(par1Entity.posX); + int j = MathHelper.floor_double(par1Entity.posY); + int k = MathHelper.floor_double(par1Entity.posZ); + int l = i; + int i1 = j; + int j1 = k; + int k1 = 0; + int l1 = this.random.nextInt(4); + int i2; + double d1; + double d2; + int k2; + int i3; + int k3; + int j3; + int i4; + int l3; + int k4; + int j4; + int i5; + int l4; + double d3; + double d4; + + for (i2 = i - b0; i2 <= i + b0; ++i2) { + d1 = i2 + 0.5D - par1Entity.posX; + + for (k2 = k - b0; k2 <= k + b0; ++k2) { + d2 = k2 + 0.5D - par1Entity.posZ; + label274: + + for (i3 = this.worldServerInstance.getActualHeight() - 1; i3 >= 0; --i3) { + if (this.worldServerInstance.isAirBlock(i2, i3, k2)) { + while (i3 > 0 && this.worldServerInstance.isAirBlock(i2, i3 - 1, k2)) { + --i3; + } + + for (j3 = l1; j3 < l1 + 4; ++j3) { + k3 = j3 % 2; + l3 = 1 - k3; + + if (j3 % 4 >= 2) { + k3 = -k3; + l3 = -l3; + } + + for (i4 = 0; i4 < 3; ++i4) { + for (j4 = 0; j4 < 4; ++j4) { + for (k4 = -1; k4 < 4; ++k4) { + l4 = i2 + (j4 - 1) * k3 + i4 * l3; + i5 = i3 + k4; + int j5 = k2 + (j4 - 1) * l3 - i4 * k3; + + if (k4 < 0 + && !this.worldServerInstance.getBlock(l4, i5, j5).getMaterial() + .isSolid() + || k4 >= 0 && !this.worldServerInstance.isAirBlock(l4, i5, j5)) { + continue label274; + } + } + } + } + + d4 = i3 + 0.5D - par1Entity.posY; + d3 = d1 * d1 + d4 * d4 + d2 * d2; + + if (d0 < 0.0D || d3 < d0) { + d0 = d3; + l = i2; + i1 = i3; + j1 = k2; + k1 = j3 % 4; + } + } + } + } + } + } + + if (d0 < 0.0D) { + for (i2 = i - b0; i2 <= i + b0; ++i2) { + d1 = i2 + 0.5D - par1Entity.posX; + + for (k2 = k - b0; k2 <= k + b0; ++k2) { + d2 = k2 + 0.5D - par1Entity.posZ; + label222: + + for (i3 = this.worldServerInstance.getActualHeight() - 1; i3 >= 0; --i3) { + if (this.worldServerInstance.isAirBlock(i2, i3, k2)) { + while (i3 > 0 && this.worldServerInstance.isAirBlock(i2, i3 - 1, k2)) { + --i3; + } + + for (j3 = l1; j3 < l1 + 2; ++j3) { + k3 = j3 % 2; + l3 = 1 - k3; + + for (i4 = 0; i4 < 4; ++i4) { + for (j4 = -1; j4 < 4; ++j4) { + k4 = i2 + (i4 - 1) * k3; + l4 = i3 + j4; + i5 = k2 + (i4 - 1) * l3; + + if (j4 < 0 + && !this.worldServerInstance.getBlock(k4, l4, i5).getMaterial() + .isSolid() + || j4 >= 0 && !this.worldServerInstance.isAirBlock(k4, l4, i5)) { + continue label222; + } + } + } + + d4 = i3 + 0.5D - par1Entity.posY; + d3 = d1 * d1 + d4 * d4 + d2 * d2; + + if (d0 < 0.0D || d3 < d0) { + d0 = d3; + l = i2; + i1 = i3; + j1 = k2; + k1 = j3 % 2; + } + } + } + } + } + } + } + + int k5 = l; + int j2 = i1; + k2 = j1; + int l5 = k1 % 2; + int l2 = 1 - l5; + + if (k1 % 4 >= 2) { + l5 = -l5; + l2 = -l2; + } + + boolean flag; + + if (d0 < 0.0D) { + if (i1 < 70) { + i1 = 70; + } + + if (i1 > this.worldServerInstance.getActualHeight() - 10) { + i1 = this.worldServerInstance.getActualHeight() - 10; + } + + j2 = i1; + + for (i3 = -1; i3 <= 1; ++i3) { + for (j3 = 1; j3 < 3; ++j3) { + for (k3 = -1; k3 < 3; ++k3) { + l3 = k5 + (j3 - 1) * l5 + i3 * l2; + i4 = j2 + k3; + j4 = k2 + (j3 - 1) * l2 - i3 * l5; + flag = k3 < 0; + this.worldServerInstance.setBlock(l3, i4, j4, flag ? Dimension_Australia.blockPortalFrame : Blocks.air); + } + } + } + } + + for (i3 = 0; i3 < 4; ++i3) { + for (j3 = 0; j3 < 4; ++j3) { + for (k3 = -1; k3 < 4; ++k3) { + l3 = k5 + (j3 - 1) * l5; + i4 = j2 + k3; + j4 = k2 + (j3 - 1) * l2; + flag = j3 == 0 || j3 == 3 || k3 == -1 || k3 == 3; + this.worldServerInstance.setBlock(l3, i4, j4, flag ? Dimension_Australia.blockPortalFrame : Dimension_Australia.portalBlock, 0, 2); + } + } + + for (j3 = 0; j3 < 4; ++j3) { + for (k3 = -1; k3 < 4; ++k3) { + l3 = k5 + (j3 - 1) * l5; + i4 = j2 + k3; + j4 = k2 + (j3 - 1) * l2; + this.worldServerInstance.notifyBlocksOfNeighborChange(l3, i4, j4, + this.worldServerInstance.getBlock(l3, i4, j4)); + } + } + } + + return true; + } + + /** + * called periodically to remove out-of-date portal locations from the + * cache list. Argument par1 is a WorldServer.getTotalWorldTime() value. + */ + @Override + public void removeStalePortalLocations(long par1) { + if (par1 % 100L == 0L) { + @SuppressWarnings("rawtypes") + Iterator iterator = this.destinationCoordinateKeys.iterator(); + long j = par1 - 600L; + + while (iterator.hasNext()) { + Long olong = (Long) iterator.next(); + Teleporter.PortalPosition portalposition = (Teleporter.PortalPosition) this.destinationCoordinateCache + .getValueByKey(olong.longValue()); + + if (portalposition == null || portalposition.lastUpdateTime < j) { + iterator.remove(); + this.destinationCoordinateCache.remove(olong.longValue()); + } + } + } + } + + public class PortalPosition extends ChunkCoordinates { + /** + * The worldtime at which this PortalPosition was last verified + */ + public long lastUpdateTime; + + public PortalPosition(int par2, int par3, int par4, long par5) { + super(par2, par3, par4); + this.lastUpdateTime = par5; + } + } +}
\ No newline at end of file diff --git a/src/main/java/gtPlusPlus/australia/world/AustraliaWorldChunkManager.java b/src/main/java/gtPlusPlus/australia/world/AustraliaWorldChunkManager.java new file mode 100644 index 0000000000..f0bd35a8b9 --- /dev/null +++ b/src/main/java/gtPlusPlus/australia/world/AustraliaWorldChunkManager.java @@ -0,0 +1,257 @@ +package gtPlusPlus.australia.world; + +import java.util.ArrayList; +import java.util.List; +import java.util.Random; + +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; + +import net.minecraft.crash.CrashReport; +import net.minecraft.crash.CrashReportCategory; +import net.minecraft.util.ReportedException; +import net.minecraft.world.ChunkPosition; +import net.minecraft.world.World; +import net.minecraft.world.WorldType; +import net.minecraft.world.biome.BiomeCache; +import net.minecraft.world.biome.BiomeGenBase; +import net.minecraft.world.biome.WorldChunkManager; +import net.minecraft.world.gen.layer.GenLayer; +import net.minecraft.world.gen.layer.IntCache; +import gtPlusPlus.australia.biome.GenLayerAustralia; + +public class AustraliaWorldChunkManager extends WorldChunkManager { + + private GenLayer genBiomes; + /** A GenLayer containing the indices into BiomeGenBase.biomeList[] */ + private GenLayer biomeIndexLayer; + /** The BiomeCache object for this world. */ + private BiomeCache biomeCache; + /** A list of biomes that the player can spawn in. */ + private List<BiomeGenBase> biomesToSpawnIn; + + @SuppressWarnings({ "rawtypes" }) + public AustraliaWorldChunkManager() { + this.biomeCache = new BiomeCache(this); + this.biomesToSpawnIn = new ArrayList(); + this.biomesToSpawnIn.addAll(allowedBiomes); // TODO + } + + public AustraliaWorldChunkManager(long seed, WorldType worldType) { + this(); + // i changed this to my GenLayerDarkWorld + GenLayer[] agenlayer = GenLayerAustralia.makeTheWorld(seed, worldType); + + agenlayer = getModdedBiomeGenerators(worldType, seed, agenlayer); + this.genBiomes = agenlayer[0]; + this.biomeIndexLayer = agenlayer[1]; + + + + } + + public AustraliaWorldChunkManager(World world) { + this(world.getSeed(), world.getWorldInfo().getTerrainType()); + + } + + /** + * Gets the list of valid biomes for the player to spawn in. + */ + @Override + public List<BiomeGenBase> getBiomesToSpawnIn() { + return this.biomesToSpawnIn; + } + + /** + * Returns a list of rainfall values for the specified blocks. Args: + * listToReuse, x, z, width, length. + */ + @Override + public float[] getRainfall(float[] listToReuse, int x, int z, int width, int length) { + IntCache.resetIntCache(); + + if ((listToReuse == null) || (listToReuse.length < width * length)) { + listToReuse = new float[width * length]; + } + int[] aint = this.biomeIndexLayer.getInts(x, z, width, length); + for (int i1 = 0; i1 < width * length; i1++) { + try + { + float f = BiomeGenBase.getBiome(aint[i1]).getIntRainfall() / 65536.0F; + if (f > 1.0F) { + f = 1.0F; + } + listToReuse[i1] = f; + } + catch (Throwable throwable) + { + CrashReport crashreport = CrashReport.makeCrashReport(throwable, "Invalid Biome id"); + CrashReportCategory crashreportcategory = crashreport.makeCategory("DownfallBlock"); + crashreportcategory.addCrashSection("biome id", Integer.valueOf(i1)); + crashreportcategory.addCrashSection("downfalls[] size", Integer.valueOf(listToReuse.length)); + crashreportcategory.addCrashSection("x", Integer.valueOf(x)); + crashreportcategory.addCrashSection("z", Integer.valueOf(z)); + crashreportcategory.addCrashSection("w", Integer.valueOf(width)); + crashreportcategory.addCrashSection("h", Integer.valueOf(length)); + throw new ReportedException(crashreport); + } + } + return listToReuse; + } + + /** + * Return an adjusted version of a given temperature based on the y + * height + */ + @Override + @SideOnly(Side.CLIENT) + public float getTemperatureAtHeight(float par1, int par2) { + return par1; + } + + /** + * Returns an array of biomes for the location input. + */ + @Override + public BiomeGenBase[] getBiomesForGeneration(BiomeGenBase[] par1ArrayOfBiomeGenBase, int par2, int par3, int par4, int par5) { + IntCache.resetIntCache(); + + if ((par1ArrayOfBiomeGenBase == null) || (par1ArrayOfBiomeGenBase.length < par4 * par5)) { + par1ArrayOfBiomeGenBase = new BiomeGenBase[par4 * par5]; + } + int[] aint = this.genBiomes.getInts(par2, par3, par4, par5); + try + { + for (int i = 0; i < par4 * par5; i++) { + par1ArrayOfBiomeGenBase[i] = BiomeGenBase.getBiome(aint[i]); + } + return par1ArrayOfBiomeGenBase; + } + catch (Throwable throwable) + { + CrashReport crashreport = CrashReport.makeCrashReport(throwable, "Invalid Biome id"); + CrashReportCategory crashreportcategory = crashreport.makeCategory("RawBiomeBlock"); + crashreportcategory.addCrashSection("biomes[] size", Integer.valueOf(par1ArrayOfBiomeGenBase.length)); + crashreportcategory.addCrashSection("x", Integer.valueOf(par2)); + crashreportcategory.addCrashSection("z", Integer.valueOf(par3)); + crashreportcategory.addCrashSection("w", Integer.valueOf(par4)); + crashreportcategory.addCrashSection("h", Integer.valueOf(par5)); + throw new ReportedException(crashreport); + } + + } + + /** + * Returns biomes to use for the blocks and loads the other data like + * temperature and humidity onto the WorldChunkManager Args: + * oldBiomeList, x, z, width, depth + */ + @Override + public BiomeGenBase[] loadBlockGeneratorData(BiomeGenBase[] oldBiomeList, int x, int z, int width, int depth) { + return this.getBiomeGenAt(oldBiomeList, x, z, width, depth, true); + } + + /** + * Return a list of biomes for the specified blocks. Args: listToReuse, + * x, y, width, length, cacheFlag (if false, don't check biomeCache to + * avoid infinite loop in BiomeCacheBlock) + */ + @Override + public BiomeGenBase[] getBiomeGenAt(BiomeGenBase[] listToReuse, int x, int y, int width, int length, boolean cacheFlag) { + IntCache.resetIntCache(); + if ((listToReuse == null) || (listToReuse.length < width * length)) { + listToReuse = new BiomeGenBase[width * length]; + } + if ((cacheFlag) && (width == 16) && (length == 16) && ((x & 0xF) == 0) && ((y & 0xF) == 0)) + { + BiomeGenBase[] abiomegenbase1 = this.biomeCache.getCachedBiomes(x, y); + System.arraycopy(abiomegenbase1, 0, listToReuse, 0, width * length); + return listToReuse; + } + int[] aint = this.biomeIndexLayer.getInts(x, y, width, length); + for (int i = 0; i < width * length; i++) { + listToReuse[i] = BiomeGenBase.getBiome(aint[i]); + } + return listToReuse; + } + + /** + * checks given Chunk's Biomes against List of allowed ones + */ + @Override + @SuppressWarnings("rawtypes") + public boolean areBiomesViable(int x, int y, int z, List par4List) { + IntCache.resetIntCache(); + int l = x - z >> 2; + int i1 = y - z >> 2; + int j1 = x + z >> 2; + int k1 = y + z >> 2; + int l1 = j1 - l + 1; + int i2 = k1 - i1 + 1; + int[] aint = this.genBiomes.getInts(l, i1, l1, i2); + try + { + for (int j2 = 0; j2 < l1 * i2; j2++) + { + BiomeGenBase biomegenbase = BiomeGenBase.getBiome(aint[j2]); + if (!par4List.contains(biomegenbase)) { + return false; + } + } + return true; + } + catch (Throwable throwable) + { + CrashReport crashreport = CrashReport.makeCrashReport(throwable, "Invalid Biome id"); + CrashReportCategory crashreportcategory = crashreport.makeCategory("Layer"); + crashreportcategory.addCrashSection("Layer", this.genBiomes.toString()); + crashreportcategory.addCrashSection("x", Integer.valueOf(x)); + crashreportcategory.addCrashSection("z", Integer.valueOf(y)); + crashreportcategory.addCrashSection("radius", Integer.valueOf(z)); + crashreportcategory.addCrashSection("allowed", par4List); + throw new ReportedException(crashreport); + } + } + + /** + * Finds a valid position within a range, that is in one of the listed + * biomes. Searches {par1,par2} +-par3 blocks. Strongly favors positive + * y positions. + */ + @Override + @SuppressWarnings("rawtypes") + public ChunkPosition findBiomePosition(int p_150795_1_, int p_150795_2_, int p_150795_3_, List p_150795_4_, Random p_150795_5_) { + IntCache.resetIntCache(); + int l = p_150795_1_ - p_150795_3_ >> 2; + int i1 = p_150795_2_ - p_150795_3_ >> 2; + int j1 = p_150795_1_ + p_150795_3_ >> 2; + int k1 = p_150795_2_ + p_150795_3_ >> 2; + int l1 = j1 - l + 1; + int i2 = k1 - i1 + 1; + int[] aint = this.genBiomes.getInts(l, i1, l1, i2); + ChunkPosition chunkposition = null; + int j2 = 0; + for (int k2 = 0; k2 < l1 * i2; k2++) + { + int l2 = l + k2 % l1 << 2; + int i3 = i1 + k2 / l1 << 2; + BiomeGenBase biomegenbase = BiomeGenBase.getBiome(aint[k2]); + if ((p_150795_4_.contains(biomegenbase)) && ((chunkposition == null) || (p_150795_5_.nextInt(j2 + 1) == 0))) + { + chunkposition = new ChunkPosition(l2, 0, i3); + j2++; + } + } + return chunkposition; + } + + /** + * Calls the WorldChunkManager's biomeCache.cleanupCache() + */ + @Override + public void cleanupCache() { + this.biomeCache.cleanupCache(); + } + +}
\ No newline at end of file diff --git a/src/main/java/gtPlusPlus/australia/world/AustraliaWorldGenerator.java b/src/main/java/gtPlusPlus/australia/world/AustraliaWorldGenerator.java new file mode 100644 index 0000000000..93112bb30f --- /dev/null +++ b/src/main/java/gtPlusPlus/australia/world/AustraliaWorldGenerator.java @@ -0,0 +1,142 @@ +package gtPlusPlus.australia.world; + +import cpw.mods.fml.common.IWorldGenerator; +import gtPlusPlus.api.interfaces.IGeneratorWorld; +import gtPlusPlus.api.objects.Logger; +import gtPlusPlus.api.objects.data.AutoMap; +import gtPlusPlus.australia.GTplusplus_Australia; +import gtPlusPlus.australia.gen.map.MapGenExtendedVillage; +import gtPlusPlus.australia.gen.map.component.ComponentHut.WorldHandlerHut; +import gtPlusPlus.australia.gen.map.component.ComponentShack.WorldHandlerShack; +import gtPlusPlus.core.lib.CORE; + +import java.util.Arrays; +import java.util.Collections; +import java.util.LinkedList; +import java.util.List; +import java.util.Random; +import net.minecraft.world.ChunkCoordIntPair; +import net.minecraft.world.World; +import net.minecraft.world.biome.BiomeGenBase; +import net.minecraft.world.chunk.IChunkProvider; + +public class AustraliaWorldGenerator implements IWorldGenerator { + private LinkedList<ChunkCoordIntPair> structuresList = new LinkedList<ChunkCoordIntPair>(); + //private final WorldHandlerCoven covenGen; + //private final WorldHandlerWickerMan wickerManGen; + private final WorldHandlerShack shackGen; + private final WorldHandlerHut hutGen; + private final List<IGeneratorWorld> generators; + private int midX; + private int midZ; + int field_82665_g; + int field_82666_h = 8; + + public static final AutoMap<Integer> SHACK_ALLOWED_BIOMES = new AutoMap<Integer>(); + public static final AutoMap<Integer> HUT_ALLOWED_BIOMES = new AutoMap<Integer>(); + public static final AutoMap<Integer> ALLOWED_BIOMES = new AutoMap<Integer>(); + + public AustraliaWorldGenerator() { + + SHACK_ALLOWED_BIOMES.put(GTplusplus_Australia.Australian_Plains_Biome.biomeID); + SHACK_ALLOWED_BIOMES.put(GTplusplus_Australia.Australian_Forest_Biome.biomeID); + HUT_ALLOWED_BIOMES.put(GTplusplus_Australia.Australian_Desert_Biome_3.biomeID); + HUT_ALLOWED_BIOMES.put(GTplusplus_Australia.Australian_Outback_Biome.biomeID); + + ALLOWED_BIOMES.put(GTplusplus_Australia.Australian_Plains_Biome.biomeID); + ALLOWED_BIOMES.put(GTplusplus_Australia.Australian_Forest_Biome.biomeID); + ALLOWED_BIOMES.put(GTplusplus_Australia.Australian_Desert_Biome_3.biomeID); + ALLOWED_BIOMES.put(GTplusplus_Australia.Australian_Outback_Biome.biomeID); + + + this.shackGen = new WorldHandlerShack(3); + this.hutGen = new WorldHandlerHut(5); + + //IGeneratorWorld goblinHut = new WorldHandlerClonedStructure(ComponentGoblinHut.class, 1.0D, 400, 7, 7, 7); + this.generators = Arrays + .asList(new IGeneratorWorld[] { this.shackGen, this.hutGen }); + + this.field_82665_g = (8 + Math.max(gtPlusPlus.core.util.math.MathUtils.randInt(/*Config.instance().worldGenFrequency*/32, 64), 1)); + + this.midX = 0; + this.midZ = 0; + for (IGeneratorWorld gen : this.generators) { + this.midX = Math.max(this.midX, gen.getExtentX() / 2); + this.midZ = Math.max(this.midZ, gen.getExtentZ() / 2); + } + } + + public void generate(Random random, int chunkX, int chunkZ, World world, IChunkProvider chunkGenerator, + IChunkProvider chunkProvider) { + if (world.provider.dimensionId == CORE.AUSTRALIA_ID) { + generateOverworld(world, world.rand, chunkX * 16, chunkZ * 16); + } + } + + private void generateOverworld(World world, Random random, int x, int z) { + boolean gen = false; + try { + if (ALLOWED_BIOMES.containsValue(Integer.valueOf(world.getBiomeGenForCoords(x + this.midX, z + this.midZ).biomeID))) { + Collections.shuffle(this.generators, random); + for (IGeneratorWorld generator : this.generators) { + boolean canGenerate = false; + + if (generator instanceof WorldHandlerShack) { + if (SHACK_ALLOWED_BIOMES.containsValue(Integer.valueOf(world.getBiomeGenForCoords(x + this.midX, z + this.midZ).biomeID))) { + canGenerate = true; + } + } + else if (generator instanceof WorldHandlerHut) { + if (HUT_ALLOWED_BIOMES.containsValue(Integer.valueOf(world.getBiomeGenForCoords(x + this.midX, z + this.midZ).biomeID))) { + canGenerate = true; + } + } + + if (canGenerate) { + //Logger.WORLD("Running World Generator on Australia."); + boolean a1, a2; + a1 = generator.generate(world, random, x, z); + a2 = nonInRange(world, x, z, generator.getRange()); + //Logger.INFO("A1: "+a1+" | A2: "+a2); + if (a1 && a2) { + this.structuresList.add(new ChunkCoordIntPair(x, z)); + gen = true; + //Logger.INFO("Generated a structure"); + break; + } + } + } + } + } + catch (Throwable t) { + t.printStackTrace(); + } + } + + protected boolean nonInRange(World worldObj, int x, int z, int range) { + int par1 = x / 16; + int par2 = z / 16; + + int k = par1; + int l = par2; + if (par1 < 0) { + par1 -= this.field_82665_g - 1; + } + if (par2 < 0) { + par2 -= this.field_82665_g - 1; + } + int i1 = par1 / this.field_82665_g; + int j1 = par2 / this.field_82665_g; + Random random = worldObj.setRandomSeed(i1, j1, 10387312); + i1 *= this.field_82665_g; + j1 *= this.field_82665_g; + i1 += random.nextInt(this.field_82665_g - this.field_82666_h); + j1 += random.nextInt(this.field_82665_g - this.field_82666_h); + + return (k == i1) && (l == j1); + } + + public void initiate() { + this.structuresList.clear(); + } +} diff --git a/src/main/java/gtPlusPlus/australia/world/AustraliaWorldProvider.java b/src/main/java/gtPlusPlus/australia/world/AustraliaWorldProvider.java new file mode 100644 index 0000000000..af1ca90cc9 --- /dev/null +++ b/src/main/java/gtPlusPlus/australia/world/AustraliaWorldProvider.java @@ -0,0 +1,80 @@ +package gtPlusPlus.australia.world; + +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; + +import net.minecraft.util.Vec3; +import net.minecraft.world.WorldProvider; +import net.minecraft.world.WorldType; +import net.minecraft.world.chunk.IChunkProvider; +import gtPlusPlus.australia.chunk.ChunkProviderAustralia; +import gtPlusPlus.australia.dimension.Dimension_Australia; + +public class AustraliaWorldProvider extends WorldProvider { + + @Override + public void registerWorldChunkManager() { + this.worldChunkMgr = new AustraliaWorldChunkManager(this.worldObj.getSeed(), WorldType.LARGE_BIOMES); + this.isHellWorld = false; + this.hasNoSky = false; + this.dimensionId = Dimension_Australia.DIMID; + } + + @Override + public float getSunBrightness(float par1) { + return (par1*2F); + } + + @Override + public float getStarBrightness(float par1) { + return (par1*5F); + } + + @SideOnly(Side.CLIENT) + public Vec3 getFogColor(float par1, float par2) + { + return Vec3.createVectorHelper(0.8D, 0.8D, 0.8D); + } + + @Override + public IChunkProvider createChunkGenerator() { + return new ChunkProviderAustralia(this.worldObj, this.worldObj.getSeed() - 15726L); + } + + public boolean isSurfaceWorld() + { + return true; + } + + public boolean canCoordinateBeSpawn(int par1, int par2) + { + return false; + } + + public boolean canRespawnHere() + { + return true; + } + + @SideOnly(Side.CLIENT) + public boolean doesXZShowFog(int par1, int par2) + { + return false; + } + + public String getDimensionName() + { + return "Australia"; + } + + protected void generateLightBrightnessTable() + { + float f = 0.5F; + for (int i = 0; i <= 15; i++) + { + float f1 = 1.0F - i / 15.0F; + this.lightBrightnessTable[i] = ((1.0F - f1) / (f1 * 3.0F + 1.0F) * (1.0F - f) + f); + } + } + +}
\ No newline at end of file diff --git a/src/main/java/gtPlusPlus/australia/world/AustraliaWorldType.java b/src/main/java/gtPlusPlus/australia/world/AustraliaWorldType.java new file mode 100644 index 0000000000..e8c8af4f76 --- /dev/null +++ b/src/main/java/gtPlusPlus/australia/world/AustraliaWorldType.java @@ -0,0 +1,59 @@ +package gtPlusPlus.australia.world; + +import java.lang.reflect.Constructor; +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; + +import net.minecraft.world.WorldType; + +public class AustraliaWorldType extends WorldType{ + + public AustraliaWorldType(String name) { + super(name); + } + + public AustraliaWorldType(int p_i1959_1_, String p_i1959_2_){ + this("test"); + try { + //System.out.println(Arrays.toString(getClass().getSuperclass().getMethods())); + Method m = getClass().getSuperclass().getDeclaredMethod("WorldType", new Class<?>[]{}); + m.setAccessible(true); + m.invoke(this, p_i1959_1_, p_i1959_2_, 0); + } catch (Exception e) { + e.printStackTrace(); + } + } + + public AustraliaWorldType(int p_i1960_1_, String p_i1960_2_, int p_i1960_3_){ + this("test2"); + try { + //System.out.println(Arrays.toString(getClass().getSuperclass().getMethods())); + Method m = getClass().getSuperclass().getDeclaredMethod("WorldType", new Class<?>[]{}); + m.setAccessible(true); + m.invoke(this, p_i1960_1_, p_i1960_2_, p_i1960_3_); + } catch (Exception e) { + e.printStackTrace(); + } + + } + + private WorldType getMC(){ + try { + Constructor<WorldType> c = WorldType.class.getDeclaredConstructor(); + c.setAccessible(true); // solution + return c.newInstance(); + + // production code should handle these exceptions more gracefully + } catch (InvocationTargetException x) { + x.printStackTrace(); + } catch (NoSuchMethodException x) { + x.printStackTrace(); + } catch (InstantiationException x) { + x.printStackTrace(); + } catch (IllegalAccessException x) { + x.printStackTrace(); + } + return null; + } +} + |