Alors pour ceci
| |
| if (biomegenbase != BiomeGenBase.desert && biomegenbase != BiomeGenBase.desertHills && !flag && this.rand.nextInt(4) == 0 |
| && TerrainGen.populate(chunkProvider, worldObj, rand, x, z, flag, LAKE)) |
| { |
| x2 = x1 + this.rand.nextInt(16) + 8; |
| z2 = this.rand.nextInt(256); |
| i2 = z1 + this.rand.nextInt(16) + 8; |
| |
| (new WorldGenLakes(Blocks.water)).generate(this.worldObj, this.rand, x2, z2, i2); |
| } |
| |
| |
| if (TerrainGen.populate(chunkProvider, worldObj, rand, x, z, flag, LAVA) && !flag && this.rand.nextInt(8) == 0) |
| { |
| x2 = x1 + this.rand.nextInt(16) + 8; |
| |
| z2 = this.rand.nextInt(this.rand.nextInt(248) + 8); |
| i2 = z1 + this.rand.nextInt(16) + 8; |
| |
| if (z2 < 63 || this.rand.nextInt(10) == 0) |
| { |
| (new WorldGenLakes(Blocks.lava)).generate(this.worldObj, this.rand, x2, z2, i2); |
| } |
| } |
| |
| |
| boolean doGen = TerrainGen.populate(chunkProvider, worldObj, rand, x, z, flag, DUNGEON); |
| for (x2 = 0; doGen && x2 < 8; ++x2) |
| { |
| z2 = x1 + this.rand.nextInt(16) + 8; |
| i2 = this.rand.nextInt(256); |
| int j2 = z1 + this.rand.nextInt(16) + 8; |
| |
| (new WorldGenDungeons()).generate(this.worldObj, this.rand, z2, i2, j2); |
| } |
| |
| biomegenbase.decorate(this.worldObj, this.rand, x1, z1); |
| |
| if (TerrainGen.populate(chunkProvider, worldObj, rand, x, z, flag, ANIMALS)) |
| { |
| SpawnerAnimals.performWorldGenSpawning(this.worldObj, biomegenbase, x1 + 8, z1 + 8, 16, 16, this.rand); |
| } |
| x1 += 8; |
| z1 += 8; |
| |
| |
| doGen = TerrainGen.populate(chunkProvider, worldObj, rand, x, z, flag, ICE); |
| for (x2 = 0; doGen && x2 < 16; ++x2) |
| { |
| for (z2 = 0; z2 < 16; ++z2) |
| { |
| i2 = this.worldObj.getPrecipitationHeight(x1 + x2, z1 + z2); |
| |
| if (this.worldObj.isBlockFreezable(x2 + x1, i2 - 1, z2 + z1)) |
| { |
| this.worldObj.setBlock(x2 + x1, i2 - 1, z2 + z1, Blocks.ice, 0, 2); |
| } |
| |
| if (this.worldObj.func_147478_e(x2 + x1, i2, z2 + z1, true)) |
| { |
| this.worldObj.setBlock(x2 + x1, i2, z2 + z1, Blocks.snow_layer, 0, 2); |
| } |
| } |
| } |
Les attributs type LAVA , DUNGEONS, ANIMALS, ICE apparaissent en erreurs et je n’arrive pas a les importé 
Pour ceci j’ai l’erreurs sur le
compareTo(Object o)
| class AncientPortalPosition extends ChunkCoordinates |
| { |
| public long time; |
| final AncientTeleporter teleporter; |
| |
| public AncientPortalPosition(AncientTeleporter teleporter, int x, int y, int z, long creationTime) |
| { |
| super(x, y, z); |
| this.teleporter = teleporter; |
| this.time = creationTime; |
| } |
| |
| @Override |
| public int compareTo(Object o) |
| { |
| |
| } |
| |
| } |
Si j’enlève les DimensionManager qui enregistre la dimension , plus de crash je peut créer des nouveaux mondes , sauf la dimension
:::
DimensionRegister
| package mod.common.world.structure; |
| |
| import cpw.mods.fml.common.registry.GameRegistry; |
| import mod.common.world.type.AncientWorldProvider; |
| import net.minecraft.block.Block; |
| import net.minecraft.block.material.Material; |
| import net.minecraft.item.Item; |
| import net.minecraft.world.biome.BiomeCache; |
| import net.minecraft.world.biome.BiomeGenBase; |
| import net.minecraftforge.common.BiomeManager; |
| import net.minecraftforge.common.DimensionManager; |
| |
| public class DimensionRegister { |
| |
| public static Block AncientPortail; |
| public static Item AncientActivateur; |
| public static int tutoDimAncient4 = 2; |
| |
| public static void register() |
| { |
| AncientPortail = new AncientPortail(Material.portal).setBlockName("portail"); |
| AncientActivateur = new AncientActivateur().setUnlocalizedName("activateur"); |
| |
| GameRegistry.registerBlock(AncientPortail, "tuto_portail"); |
| GameRegistry.registerItem(AncientActivateur, "tuto_activateur"); |
| |
| DimensionManager.registerProviderType(DimensionRegister.tutoDimAncient4, AncientWorldProvider.class, false); |
| DimensionManager.registerDimension(DimensionRegister.tutoDimAncient4, DimensionRegister.tutoDimAncient4); |
| |
| } |
| } |
ChunkProvider
| package mod.common.world.type; |
| |
| import java.util.List; |
| import java.util.Random; |
| |
| import mod.common.world.biome.AncientBiome; |
| import net.minecraft.block.Block; |
| import net.minecraft.block.BlockFalling; |
| import net.minecraft.entity.EnumCreatureType; |
| import net.minecraft.init.Blocks; |
| import net.minecraft.util.MathHelper; |
| import net.minecraft.world.ChunkPosition; |
| import net.minecraft.world.SpawnerAnimals; |
| import net.minecraft.world.World; |
| import net.minecraft.world.WorldType; |
| import net.minecraft.world.biome.BiomeGenBase; |
| import net.minecraft.world.biome.BiomeGenPlains; |
| import net.minecraft.world.chunk.Chunk; |
| import net.minecraft.world.chunk.IChunkProvider; |
| import net.minecraft.world.gen.MapGenBase; |
| import net.minecraft.world.gen.MapGenCaves; |
| import net.minecraft.world.gen.MapGenRavine; |
| import net.minecraft.world.gen.NoiseGenerator; |
| import net.minecraft.world.gen.NoiseGeneratorOctaves; |
| import net.minecraft.world.gen.NoiseGeneratorPerlin; |
| import net.minecraft.world.gen.feature.WorldGenDungeons; |
| import net.minecraft.world.gen.feature.WorldGenLakes; |
| import net.minecraft.world.gen.structure.MapGenMineshaft; |
| import net.minecraft.world.gen.structure.MapGenScatteredFeature; |
| import net.minecraftforge.common.MinecraftForge; |
| import net.minecraftforge.event.terraingen.ChunkProviderEvent; |
| import net.minecraftforge.event.terraingen.PopulateChunkEvent; |
| import net.minecraftforge.event.terraingen.TerrainGen; |
| import cpw.mods.fml.common.eventhandler.Event.Result; |
| import static net.minecraftforge.event.terraingen.InitMapGenEvent.EventType.*; |
| |
| public abstract class AncientChunkProvider implements IChunkProvider { |
| |
| private Random rand; |
| private NoiseGeneratorOctaves noiseGen1; |
| private NoiseGeneratorOctaves noiseGen2; |
| private NoiseGeneratorOctaves noiseGen3; |
| private NoiseGeneratorPerlin noiseGen4; |
| public NoiseGeneratorOctaves noiseGen5; |
| public NoiseGeneratorOctaves noiseGen6; |
| public NoiseGeneratorOctaves mobSpawnerNoise; |
| private World worldObj; |
| private WorldType worldType; |
| private final double[] noiseArray; |
| private final float[] parabolicField; |
| private final boolean mapFeaturesEnabled; |
| |
| private MapGenBase caveGenerator = new MapGenCaves(); |
| private MapGenMineshaft mineshaftGenerator = new MapGenMineshaft(); |
| private MapGenScatteredFeature scatteredFeatureGenerator = new MapGenScatteredFeature(); |
| private MapGenBase ravineGenerator = new MapGenRavine(); |
| |
| private double[] stoneNoise = new double[256]; |
| private BiomeGenBase[] biomesForGeneration; |
| double[] noiseData1; |
| double[] noiseData2; |
| double[] noiseData3; |
| double[] noiseData4; |
| |
| { |
| caveGenerator = TerrainGen.getModdedMapGen(caveGenerator, CAVE); |
| mineshaftGenerator = (MapGenMineshaft) TerrainGen.getModdedMapGen(mineshaftGenerator, MINESHAFT); |
| scatteredFeatureGenerator = (MapGenScatteredFeature) TerrainGen.getModdedMapGen(scatteredFeatureGenerator, SCATTERED_FEATURE); |
| ravineGenerator = TerrainGen.getModdedMapGen(ravineGenerator, RAVINE); |
| } |
| |
| public AncientChunkProvider(World world, long seed, boolean features) |
| { |
| this.worldObj = world; |
| this.mapFeaturesEnabled = features; |
| this.worldType = world.getWorldInfo().getTerrainType(); |
| this.rand = new Random(seed); |
| this.noiseGen1 = new NoiseGeneratorOctaves(this.rand, 16); |
| this.noiseGen2 = new NoiseGeneratorOctaves(this.rand, 16); |
| this.noiseGen3 = new NoiseGeneratorOctaves(this.rand, 8); |
| this.noiseGen4 = new NoiseGeneratorPerlin(this.rand, 4); |
| this.noiseGen5 = new NoiseGeneratorOctaves(this.rand, 10); |
| this.noiseGen6 = new NoiseGeneratorOctaves(this.rand, 16); |
| this.mobSpawnerNoise = new NoiseGeneratorOctaves(this.rand, 8); |
| this.noiseArray = new double[825]; |
| this.parabolicField = new float[25]; |
| |
| for (int j = -2; j <= 2; ++j) |
| { |
| for (int k = -2; k <= 2; ++k) |
| { |
| float f = 10.0F / MathHelper.sqrt_float((float)(j * j + k * k) + 0.2F); |
| this.parabolicField[j + 2 + (k + 2) * 5] = f; |
| } |
| } |
| |
| NoiseGenerator[] noiseGens = {noiseGen1, noiseGen2, noiseGen3, noiseGen4, noiseGen5, noiseGen6, mobSpawnerNoise}; |
| noiseGens = TerrainGen.getModdedNoiseGenerators(world, this.rand, noiseGens); |
| this.noiseGen1 = (NoiseGeneratorOctaves)noiseGens[0]; |
| this.noiseGen2 = (NoiseGeneratorOctaves)noiseGens[1]; |
| this.noiseGen3 = (NoiseGeneratorOctaves)noiseGens[2]; |
| this.noiseGen4 = (NoiseGeneratorPerlin)noiseGens[3]; |
| this.noiseGen5 = (NoiseGeneratorOctaves)noiseGens[4]; |
| this.noiseGen6 = (NoiseGeneratorOctaves)noiseGens[5]; |
| this.mobSpawnerNoise = (NoiseGeneratorOctaves)noiseGens[6]; |
| } |
| |
| public void func_147424_a(int Xchunks, int Zchunks, Block[] topBlock) |
| { |
| byte b0 = 63; |
| this.biomesForGeneration = this.worldObj.getWorldChunkManager().getBiomesForGeneration(this.biomesForGeneration, Xchunks * 4 - 2, Zchunks * 4 - 2, 10, 10); |
| this.func_147423_a(Xchunks * 4, 0, Zchunks * 4); |
| |
| final Random rand = new Random(); |
| |
| for (int k = 0; k < 4; ++k) |
| { |
| int l = k * 5; |
| int i1 = (k + 1) * 5; |
| |
| for (int j1 = 0; j1 < 4; ++j1) |
| { |
| int k1 = (l + j1) * 33; |
| int l1 = (l + j1 + 1) * 33; |
| int i2 = (i1 + j1) * 33; |
| int j2 = (i1 + j1 + 1) * 33; |
| |
| for (int k2 = 0; k2 < 32; ++k2) |
| { |
| double d0 = 0.105D; |
| double d1 = this.noiseArray[k1 + k2]; |
| double d2 = this.noiseArray[l1 + k2]; |
| double d3 = this.noiseArray[i2 + k2]; |
| double d4 = this.noiseArray[j2 + k2]; |
| double d5 = (this.noiseArray[k1 + k2 + 1] - d1) * d0; |
| double d6 = (this.noiseArray[l1 + k2 + 1] - d2) * d0; |
| double d7 = (this.noiseArray[i2 + k2 + 1] - d3) * d0; |
| double d8 = (this.noiseArray[j2 + k2 + 1] - d4) * d0; |
| |
| for (int l2 = 0; l2 < 8; ++l2) |
| { |
| double d9 = 0.25D; |
| double d10 = d1; |
| double d11 = d2; |
| double d12 = (d3 - d1) * d9; |
| double d13 = (d4 - d2) * d9; |
| |
| for (int i3 = 0; i3 < 4; ++i3) |
| { |
| int j3 = i3 + k * 4 << 12 | 0 + j1 * 4 << 8 | k2 * 8 + l2; |
| short short1 = 256; |
| j3 -= short1; |
| double d14 = 0.25D; |
| double d16 = (d11 - d10) * d14; |
| double d15 = d10 - d16; |
| |
| for (int k3 = 0; k3 < 4; ++k3) |
| { |
| if ((d15 += d16) > 0.0D) |
| { |
| topBlock[j3 += short1] = Blocks.stone; |
| } |
| else if (k2 * 8 + l2 < b0) |
| { |
| topBlock[j3 += short1] = Blocks.water; |
| } |
| else |
| { |
| topBlock[j3 += short1] = null; |
| } |
| } |
| |
| d10 += d12; |
| d11 += d13; |
| } |
| |
| d1 += d5; |
| d2 += d6; |
| d3 += d7; |
| d4 += d8; |
| } |
| } |
| } |
| } |
| } |
| |
| public void replaceBlocksForBiome(int coordX, int coordZ, Block[] block, byte[] arrayOfByte, BiomeGenBase[] biomeList) |
| { |
| ChunkProviderEvent.ReplaceBiomeBlocks event = new ChunkProviderEvent.ReplaceBiomeBlocks(this, coordX, coordZ, block, biomeList); |
| MinecraftForge.EVENT_BUS.post(event); |
| if (event.getResult() == Result.DENY) return; |
| |
| double d0 = 0.03125D; |
| this.stoneNoise = this.noiseGen4.func_151599_a(this.stoneNoise, (double)(coordX * 16), (double)(coordZ * 16), 16, 16, d0 * 2.0D, d0 * 2.0D, 1.0D); |
| |
| for (int k = 0; k < 16; ++k) |
| { |
| for (int l = 0; l < 16; ++l) |
| { |
| AncientBiome biomegenbase = (AncientBiome )biomeList[l + k * 16]; |
| biomegenbase.genTerrainBlocks(this.worldObj, this.rand, block, arrayOfByte, coordX * 16 + k, coordZ * 16 + l, this.stoneNoise[l + k * 16]); |
| } |
| } |
| } |
| |
| public Chunk loadChunk(int par1, int par2) |
| { |
| return this.provideChunk(par1, par2); |
| } |
| |
| public Chunk provideChunk(int par1, int par2) |
| { |
| this.rand.setSeed((long)par1 * 341873128712L + (long)par2 * 132897987541L); |
| Block[] ablock = new Block[65536]; |
| byte[] abyte = new byte[65536]; |
| this.func_147424_a(par1, par2, ablock); |
| this.biomesForGeneration = this.worldObj.getWorldChunkManager().loadBlockGeneratorData(this.biomesForGeneration, par1 * 16, par2 * 16, 16, 16); |
| this.replaceBlocksForBiome(par1, par2, ablock, abyte, this.biomesForGeneration); |
| this.caveGenerator.func_151539_a(this, this.worldObj, par1, par2, ablock); |
| this.ravineGenerator.func_151539_a(this, this.worldObj, par1, par2, ablock); |
| |
| if (this.mapFeaturesEnabled) |
| { |
| this.mineshaftGenerator.func_151539_a(this, this.worldObj, par1, par2, ablock); |
| this.scatteredFeatureGenerator.func_151539_a(this, this.worldObj, par1, par2, ablock); |
| } |
| |
| Chunk chunk = new Chunk(this.worldObj, ablock, abyte, par1, par2); |
| byte[] abyte1 = chunk.getBiomeArray(); |
| |
| for (int k = 0; k < abyte1.length; ++k) |
| { |
| abyte1[k] = (byte)this.biomesForGeneration[k].biomeID; |
| } |
| |
| chunk.generateSkylightMap(); |
| return chunk; |
| } |
| |
| private void func_147423_a(int x, int y, int z) |
| { |
| double d0 = 684.412D; |
| double d1 = 684.412D; |
| double d2 = 512.0D; |
| double d3 = 512.0D; |
| this.noiseData4 = this.noiseGen6.generateNoiseOctaves(this.noiseData4, x, z, 5, 5, 200.0D, 200.0D, 0.5D); |
| this.noiseData1 = this.noiseGen3.generateNoiseOctaves(this.noiseData1, x, y, z, 5, 33, 5, 8.555150000000001D, 4.277575000000001D, 8.555150000000001D); |
| this.noiseData2 = this.noiseGen1.generateNoiseOctaves(this.noiseData2, x, y, z, 5, 33, 5, 684.412D, 684.412D, 684.412D); |
| this.noiseData3 = this.noiseGen2.generateNoiseOctaves(this.noiseData3, x, y, z, 5, 33, 5, 684.412D, 684.412D, 684.412D); |
| boolean flag1 = false; |
| boolean flag = false; |
| int l = 0; |
| int i1 = 0; |
| double d4 = 8.5D; |
| |
| for (int j1 = 0; j1 < 5; ++j1) |
| { |
| for (int k1 = 0; k1 < 5; ++k1) |
| { |
| float f = 0.0F; |
| float f1 = 0.0F; |
| float f2 = 0.0F; |
| byte b0 = 2; |
| BiomeGenBase biomegenbase = this.biomesForGeneration[j1 + 2 + (k1 + 2) * 10]; |
| |
| for (int l1 = -b0; l1 <= b0; ++l1) |
| { |
| for (int i2 = -b0; i2 <= b0; ++i2) |
| { |
| BiomeGenBase biomegenbase1 = this.biomesForGeneration[j1 + l1 + 2 + (k1 + i2 + 2) * 10]; |
| float f3 = biomegenbase1.rootHeight; |
| float f4 = biomegenbase1.heightVariation; |
| |
| float f5 = this.parabolicField[l1 + 2 + (i2 + 2) * 5] / (f3 + 2.0F); |
| |
| if (biomegenbase1.rootHeight > biomegenbase.rootHeight) |
| { |
| f5 /= 2.0F; |
| } |
| |
| f += f4 * f5; |
| f1 += f3 * f5; |
| f2 += f5; |
| } |
| } |
| |
| f /= f2; |
| f1 /= f2; |
| f = f * 0.9F + 0.1F; |
| f1 = (f1 * 4.0F - 1.0F) / 8.0F; |
| double d13 = this.noiseData4[i1] / 8000.0D; |
| |
| if (d13 < 0.0D) |
| { |
| d13 = -d13 * 0.3D; |
| } |
| |
| d13 = d13 * 3.0D - 2.0D; |
| |
| if (d13 < 0.0D) |
| { |
| d13 /= 2.0D; |
| |
| if (d13 < -1.0D) |
| { |
| d13 = -1.0D; |
| } |
| |
| d13 /= 1.4D; |
| d13 /= 2.0D; |
| } |
| else |
| { |
| if (d13 > 1.0D) |
| { |
| d13 = 1.0D; |
| } |
| |
| d13 /= 8.0D; |
| } |
| |
| ++i1; |
| double d12 = (double)f1; |
| double d14 = (double)f; |
| d12 += d13 * 0.2D; |
| d12 = d12 * 8.5D / 8.0D; |
| double d5 = 8.5D + d13 * 4.0D; |
| |
| for (int j2 = 0; j2 < 33; ++j2) |
| { |
| double d6 = ((double)j2 - d5) * 12.0D * 128.0D / 256.0D / d14; |
| |
| if (d6 < 0.0D) |
| { |
| d6 *= 4.0D; |
| } |
| |
| double d7 = this.noiseData2[l] / 512.0D; |
| double d8 = this.noiseData3[l] / 512.0D; |
| double d9 = (this.noiseData1[l] / 10.0D + 1.0D) / 2.0D; |
| double d10 = MathHelper.denormalizeClamp(d7, d8, d9) - d6; |
| |
| if (j2 > 29) |
| { |
| double d11 = (double)((float)(j2 - 29) / 3.0F); |
| d10 = d10 * (1.0D - d11) + -10.0D * d11; |
| } |
| |
| this.noiseArray[l] = d10; |
| ++l; |
| } |
| } |
| } |
| } |
| |
| public boolean chunkExists(int par1, int par2) |
| { |
| return true; |
| } |
| |
| public void populate(IChunkProvider chunkProvider, int x, int z) |
| { |
| BlockFalling.fallInstantly = true; |
| int x1 = x * 16; |
| int z1 = z * 16; |
| BiomeGenBase biomegenbase = this.worldObj.getBiomeGenForCoords(x1 + 16, z1 + 16); |
| this.rand.setSeed(this.worldObj.getSeed()); |
| long i1 = this.rand.nextLong() / 2L * 2L + 1L; |
| long j1 = this.rand.nextLong() / 2L * 2L + 1L; |
| this.rand.setSeed((long)x * i1 + (long)z * j1 ^ this.worldObj.getSeed()); |
| boolean flag = false; |
| |
| MinecraftForge.EVENT_BUS.post(new PopulateChunkEvent.Pre(chunkProvider, worldObj, rand, x, z, flag)); |
| |
| |
| |
| if (this.mapFeaturesEnabled) |
| { |
| this.mineshaftGenerator.generateStructuresInChunk(this.worldObj, this.rand, x, z); |
| this.scatteredFeatureGenerator.generateStructuresInChunk(this.worldObj, this.rand, x, z); |
| } |
| |
| int x2; |
| int z2; |
| int i2; |
| |
| |
| if (biomegenbase != BiomeGenBase.desert && biomegenbase != BiomeGenBase.desertHills && !flag && this.rand.nextInt(4) == 0 |
| && TerrainGen.populate(chunkProvider, worldObj, rand, x, z, flag, LAKE)) |
| { |
| x2 = x1 + this.rand.nextInt(16) + 8; |
| z2 = this.rand.nextInt(256); |
| i2 = z1 + this.rand.nextInt(16) + 8; |
| |
| (new WorldGenLakes(Blocks.water)).generate(this.worldObj, this.rand, x2, z2, i2); |
| } |
| |
| |
| if (TerrainGen.populate(chunkProvider, worldObj, rand, x, z, flag, LAVA) && !flag && this.rand.nextInt(8) == 0) |
| { |
| x2 = x1 + this.rand.nextInt(16) + 8; |
| |
| z2 = this.rand.nextInt(this.rand.nextInt(248) + 8); |
| i2 = z1 + this.rand.nextInt(16) + 8; |
| |
| if (z2 < 63 || this.rand.nextInt(10) == 0) |
| { |
| (new WorldGenLakes(Blocks.lava)).generate(this.worldObj, this.rand, x2, z2, i2); |
| } |
| } |
| |
| |
| boolean doGen = TerrainGen.populate(chunkProvider, worldObj, rand, x, z, flag, DUNGEON); |
| for (x2 = 0; doGen && x2 < 8; ++x2) |
| { |
| z2 = x1 + this.rand.nextInt(16) + 8; |
| i2 = this.rand.nextInt(256); |
| int j2 = z1 + this.rand.nextInt(16) + 8; |
| |
| (new WorldGenDungeons()).generate(this.worldObj, this.rand, z2, i2, j2); |
| } |
| |
| biomegenbase.decorate(this.worldObj, this.rand, x1, z1); |
| |
| if (TerrainGen.populate(chunkProvider, worldObj, rand, x, z, flag, ANIMALS)) |
| { |
| SpawnerAnimals.performWorldGenSpawning(this.worldObj, biomegenbase, x1 + 8, z1 + 8, 16, 16, this.rand); |
| } |
| x1 += 8; |
| z1 += 8; |
| |
| |
| doGen = TerrainGen.populate(chunkProvider, worldObj, rand, x, z, flag, ICE); |
| for (x2 = 0; doGen && x2 < 16; ++x2) |
| { |
| for (z2 = 0; z2 < 16; ++z2) |
| { |
| i2 = this.worldObj.getPrecipitationHeight(x1 + x2, z1 + z2); |
| |
| if (this.worldObj.isBlockFreezable(x2 + x1, i2 - 1, z2 + z1)) |
| { |
| this.worldObj.setBlock(x2 + x1, i2 - 1, z2 + z1, Blocks.ice, 0, 2); |
| } |
| |
| if (this.worldObj.func_147478_e(x2 + x1, i2, z2 + z1, true)) |
| { |
| this.worldObj.setBlock(x2 + x1, i2, z2 + z1, Blocks.snow_layer, 0, 2); |
| } |
| } |
| } |
| |
| MinecraftForge.EVENT_BUS.post(new PopulateChunkEvent.Post(chunkProvider, worldObj, rand, x, z, flag)); |
| |
| BlockFalling.fallInstantly = false; |
| } |
| |
| public String makeString() |
| { |
| return "RandomLevelSource"; |
| } |
| |
| public List getPossibleCreatures(EnumCreatureType par1EnumCreatureType, int par2, int par3, int par4) |
| { |
| AncientBiome biomegenbase = (AncientBiome)this.worldObj.getBiomeGenForCoords(par2, par4); |
| return par1EnumCreatureType == EnumCreatureType.monster && this.scatteredFeatureGenerator.func_143030_a(par2, par3, par4) ? this.scatteredFeatureGenerator.getScatteredFeatureSpawnList() : biomegenbase.getSpawnableList(par1EnumCreatureType); |
| } |
| |
| public ChunkPosition func_147416_a(World world, String strg, int x, int y, int z) |
| { |
| return null; |
| } |
| |
| public int getLoadedChunkCount() |
| { |
| return 0; |
| } |
| |
| public void recreateStructures(int par1, int par2) |
| { |
| if (this.mapFeaturesEnabled) |
| { |
| this.mineshaftGenerator.func_151539_a(this, this.worldObj, par1, par2, (Block[])null); |
| this.scatteredFeatureGenerator.func_151539_a(this, this.worldObj, par1, par2, (Block[])null); |
| } |
| } |
| |
| } |
Mon biome ( au cas ou )
| package mod.common.world.biome; |
| |
| import java.util.List; |
| import java.util.Random; |
| |
| import net.minecraft.block.Block; |
| import net.minecraft.block.material.Material; |
| import net.minecraft.entity.passive.EntityHorse; |
| import net.minecraft.init.Blocks; |
| import net.minecraft.world.World; |
| import net.minecraft.world.biome.BiomeGenBase; |
| import net.minecraft.world.biome.BiomeGenBase.SpawnListEntry; |
| import net.minecraft.world.biome.BiomeGenPlains; |
| import net.minecraft.world.gen.NoiseGeneratorPerlin; |
| import net.minecraft.world.gen.feature.WorldGenAbstractTree; |
| import net.minecraft.world.gen.feature.WorldGenDoublePlant; |
| import net.minecraft.world.gen.feature.WorldGenTrees; |
| |
| public class AncientBiome extends BiomeGenBase |
| { |
| public AncientBiome(int par1) |
| { |
| super(par1); |
| setTemperatureRainfall(0.8F, 0.4F); |
| setHeight(height_LowPlains); |
| this.spawnableCreatureList.add(new BiomeGenBase.SpawnListEntry(EntityHorse.class, 5, 2, 6)); |
| this.theBiomeDecorator.treesPerChunk = -999; |
| this.theBiomeDecorator.flowersPerChunk = 4; |
| this.theBiomeDecorator.grassPerChunk = 10; |
| this.flowers.clear(); |
| addFlower(Blocks.red_flower, 4, 3); |
| addFlower(Blocks.red_flower, 5, 3); |
| addFlower(Blocks.red_flower, 6, 3); |
| addFlower(Blocks.red_flower, 7, 3); |
| addFlower(Blocks.red_flower, 0, 20); |
| addFlower(Blocks.red_flower, 3, 20); |
| addFlower(Blocks.red_flower, 8, 20); |
| addFlower(Blocks.yellow_flower, 0, 30); |
| } |
| |
| public String func_150572_a(Random p_150572_1_, int p_150572_2_, int p_150572_3_, int p_150572_4_) |
| { |
| double d0 = plantNoise.func_151601_a(p_150572_2_ / 200.0D, p_150572_4_ / 200.0D); |
| |
| if (d0 < -0.8D) |
| { |
| int l = p_150572_1_.nextInt(4); |
| return net.minecraft.block.BlockFlower.field_149859_a[(4 + l)]; |
| } |
| if (p_150572_1_.nextInt(3) > 0) |
| { |
| int l = p_150572_1_.nextInt(3); |
| return l == 1 ? net.minecraft.block.BlockFlower.field_149859_a[3] : l == 0 ? net.minecraft.block.BlockFlower.field_149859_a[0] : net.minecraft.block.BlockFlower.field_149859_a[8]; |
| } |
| |
| return net.minecraft.block.BlockFlower.field_149858_b[0]; |
| } |
| |
| public void decorate(World par1World, Random par2Random, int par3, int par4) |
| { |
| double d0 = plantNoise.func_151601_a((par3 + 8) / 200.0D, (par4 + 8) / 200.0D); |
| |
| if (d0 < -0.8D) |
| { |
| this.theBiomeDecorator.flowersPerChunk = 15; |
| this.theBiomeDecorator.grassPerChunk = 5; |
| } |
| else |
| { |
| this.theBiomeDecorator.flowersPerChunk = 4; |
| this.theBiomeDecorator.grassPerChunk = 10; |
| genTallFlowers.func_150548_a(2); |
| |
| for (int k = 0; k < 7; k++) |
| { |
| int l = par3 + par2Random.nextInt(16) + 8; |
| int i1 = par4 + par2Random.nextInt(16) + 8; |
| int j1 = par2Random.nextInt(par1World.getHeightValue(l, i1) + 32); |
| genTallFlowers.generate(par1World, par2Random, l, j1, i1); |
| } |
| |
| } |
| |
| super.decorate(par1World, par2Random, par3, par4); |
| } |
| |
| public BiomeGenBase createMutation() |
| { |
| BiomeGenPlains biomegenplains = new BiomeGenPlains(this.biomeID + 128); |
| biomegenplains.setBiomeName("Sunflower Plains"); |
| biomegenplains.setColor(9286496); |
| biomegenplains.field_150609_ah = 14273354; |
| return biomegenplains; |
| } |
| |
| public int getBiomeGrassColor() |
| { |
| |
| return 0xFFFFFF; |
| } |
| } |
AncientTeleporter
| package mod.common.world.structure; |
| |
| import java.util.ArrayList; |
| import java.util.List; |
| import java.util.Random; |
| |
| import net.minecraft.entity.Entity; |
| import net.minecraft.init.Blocks; |
| import net.minecraft.util.ChunkCoordinates; |
| import net.minecraft.util.Direction; |
| import net.minecraft.util.LongHashMap; |
| import net.minecraft.util.MathHelper; |
| import net.minecraft.world.ChunkCoordIntPair; |
| import net.minecraft.world.Teleporter; |
| import net.minecraft.world.WorldServer; |
| |
| public class AncientTeleporter extends Teleporter |
| { |
| private final WorldServer worldServerInstance; |
| private final Random random; |
| private final LongHashMap destinationCoordinateCache = new LongHashMap(); |
| |
| private final List destinationCoordinateKeys = new ArrayList(); |
| |
| public AncientTeleporter(WorldServer worldServer) |
| { |
| super(worldServer); |
| this.worldServerInstance = worldServer; |
| this.random = new Random(worldServer.getSeed()); |
| |
| } |
| |
| public void placeInPortal(Entity entity, double x, double y, double z, float rotationYaw) |
| { |
| if(this.worldServerInstance.provider.dimensionId != 1) |
| { |
| if(!this.placeInExistingPortal(entity, x, y, z, rotationYaw)) |
| { |
| this.makePortal(entity); |
| this.placeInExistingPortal(entity, x, y, z, rotationYaw); |
| } |
| } |
| else |
| { |
| int i = MathHelper.floor_double(entity.posX); |
| int j = MathHelper.floor_double(entity.posY) - 1; |
| int k = MathHelper.floor_double(entity.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 ? Blocks.stone : Blocks.air); |
| } |
| } |
| } |
| entity.setLocationAndAngles((double)i, (double)j, (double)k, entity.rotationYaw, 0.0F); |
| entity.motionX = entity.motionY = entity.motionZ = 0.0D; |
| } |
| } |
| |
| public boolean placeInExistingPortal(Entity entity, double x, double y, double z, float rotationYaw) |
| { |
| short short1 = 128; |
| double d3 = -1.0D; |
| int i = 0; |
| int j = 0; |
| int k = 0; |
| int l = MathHelper.floor_double(entity.posX); |
| int i1 = MathHelper.floor_double(entity.posZ); |
| long j1 = ChunkCoordIntPair.chunkXZ2Int(l, i1); |
| |
| boolean flag = true; |
| double d4; |
| int k1; |
| |
| if(this.destinationCoordinateCache.containsItem(j1)) |
| { |
| PortalPosition portalposition = (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(k1 = l - short1; k1 <= l + short1; ++k1) |
| { |
| double d5 = (double)k1 + 0.5D - entity.posX; |
| for(int l1 = i1 - short1; l1 <= i1 + short1; ++l1) |
| { |
| double d6 = (double)l1 + 0.5D - entity.posZ; |
| |
| for(int i2 = this.worldServerInstance.getActualHeight() - 1; i2 >= 0; –i2) |
| { |
| if(this.worldServerInstance.getBlock(k1, i2, l1) == DimensionRegister.AncientPortail) |
| { |
| while(this.worldServerInstance.getBlock(k1, i2 - 1, l1) == DimensionRegister.AncientPortail) |
| { |
| --i2; |
| } |
| d4 = (double)i2 + 0.5D - entity.posY; |
| double d7 = d5 * d5 + d4 * d4 + d6 * d6; |
| if(d3 < 0.0D || d7 < d3) |
| { |
| d3 = d7; |
| i = k1; |
| j = i2; |
| k = l1; |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| if(d3 >= 0.0D) |
| { |
| if(flag) |
| { |
| this.destinationCoordinateCache.add(j1, new AncientPortalPosition(this, i, j, k, this.worldServerInstance.getTotalWorldTime())); |
| this.destinationCoordinateKeys.add(Long.valueOf(j1)); |
| } |
| double d8 = (double)i + 0.5D; |
| double d9 = (double)j + 0.5D; |
| d4 = (double)k + 0.5D; |
| int j2 = -1; |
| if(this.worldServerInstance.getBlock(i - 1, j, k) == DimensionRegister.AncientPortail) |
| { |
| j2 = 2; |
| } |
| if(this.worldServerInstance.getBlock(i + 1, j, k) == DimensionRegister.AncientPortail) |
| { |
| j2 = 0; |
| } |
| if(this.worldServerInstance.getBlock(i, j, k - 1) == DimensionRegister.AncientPortail) |
| { |
| j2 = 3; |
| } |
| if(this.worldServerInstance.getBlock(i, j, k + 1) == DimensionRegister.AncientPortail) |
| { |
| j2 = 1; |
| } |
| int k2 = entity.getTeleportDirection(); |
| if(j2 > -1) |
| { |
| |
| int l2 = Direction.rotateLeft[j2]; |
| int i3 = Direction.offsetX[j2]; |
| int j3 = Direction.offsetZ[j2]; |
| int k3 = Direction.offsetX[l2]; |
| int l3 = Direction.offsetZ[l2]; |
| boolean flag1 = !this.worldServerInstance.isAirBlock(i + i3 + k3, j, k + j3 + l3) || !this.worldServerInstance.isAirBlock(i + i3 + k3, j + 1, k + j3 + l3); |
| boolean flag2 = !this.worldServerInstance.isAirBlock(i + i3, j, k + j3) || !this.worldServerInstance.isAirBlock(i + i3, j + 1, k + j3); |
| if(flag1 && flag2) |
| { |
| j2 = Direction.rotateOpposite[j2]; |
| l2 = Direction.rotateOpposite[l2]; |
| i3 = Direction.offsetX[j2]; |
| j3 = Direction.offsetZ[j2]; |
| k3 = Direction.offsetX[l2]; |
| l3 = Direction.offsetZ[l2]; |
| k1 = i - k3; |
| d8 -= (double)k3; |
| int i4 = k - l3; |
| d4 -= (double)l3; |
| flag1 = !this.worldServerInstance.isAirBlock(k1 + i3 + k3, j, i4 + j3 + l3) || !this.worldServerInstance.isAirBlock(k1 + i3 + k3, j + 1, i4 + j3 + l3); |
| flag2 = !this.worldServerInstance.isAirBlock(k1 + i3, j, i4 + j3) || !this.worldServerInstance.isAirBlock(k1 + i3, j + 1, i4 + j3); |
| } |
| 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; |
| } |
| d8 += (double)((float)k3 * f1 + f2 * (float)i3); |
| d4 += (double)((float)l3 * f1 + f2 * (float)j3); |
| float f3 = 0.0F; |
| float f4 = 0.0F; |
| float f5 = 0.0F; |
| float f6 = 0.0F; |
| if(j2 == k2) |
| { |
| f3 = 1.0F; |
| f4 = 1.0F; |
| } |
| else if(j2 == Direction.rotateOpposite[k2]) |
| { |
| f3 = -1.0F; |
| f4 = -1.0F; |
| } |
| else if(j2 == Direction.rotateRight[k2]) |
| { |
| f5 = 1.0F; |
| f6 = -1.0F; |
| } |
| else |
| { |
| f5 = -1.0F; |
| f6 = 1.0F; |
| } |
| double d10 = entity.motionX; |
| double d11 = entity.motionZ; |
| entity.motionX = d10 * (double)f3 + d11 * (double)f6; |
| entity.motionZ = d10 * (double)f5 + d11 * (double)f4; |
| entity.rotationYaw = rotationYaw - (float)(k2 * 90) + (float)(j2 * 90); |
| } |
| else |
| { |
| entity.motionX = entity.motionY = entity.motionZ = 0.0D; |
| } |
| entity.setLocationAndAngles(d8, d9, d4, entity.rotationYaw, entity.rotationPitch); |
| return true; |
| } |
| else |
| { |
| return false; |
| } |
| } |
| |
| public boolean makePortal(Entity entity) |
| { |
| byte b0 = 16; |
| double d0 = -1.0D; |
| int x = MathHelper.floor_double(entity.posX); |
| int y = MathHelper.floor_double(entity.posY); |
| int z = MathHelper.floor_double(entity.posZ); |
| int l = x; |
| int i1 = y; |
| int j1 = z; |
| int k1 = 0; |
| int l1 = this.random.nextInt(4); |
| int i2; |
| double d1; |
| int k2; |
| double d2; |
| int i3; |
| int j3; |
| int k3; |
| int l3; |
| int i4; |
| int j4; |
| int k4; |
| int l4; |
| int i5; |
| double d3; |
| double d4; |
| |
| for(i2 = x - b0; i2 <= x + b0; ++i2) |
| { |
| d1 = (double)i2 + 0.5D - entity.posX; |
| |
| for(k2 = z - b0; k2 <= z + b0; ++k2) |
| { |
| d2 = (double)k2 + 0.5D - entity.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; |
| } |
| } |
| } |
| } |
| |
| d3 = (double)i3 + 0.5D - entity.posY; |
| d4 = d1 * d1 + d3 * d3 + d2 * d2; |
| |
| if(d0 < 0.0D || d4 < d0) |
| { |
| d0 = d4; |
| l = i2; |
| i1 = i3; |
| j1 = k2; |
| k1 = j3 % 4; |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| if(d0 < 0.0D) |
| { |
| for(i2 = x - b0; i2 <= x + b0; ++i2) |
| { |
| d1 = (double)i2 + 0.5D - entity.posX; |
| |
| for(k2 = z - b0; k2 <= z + b0; ++k2) |
| { |
| d2 = (double)k2 + 0.5D - entity.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; |
| } |
| } |
| } |
| |
| d3 = (double)i3 + 0.5D - entity.posY; |
| d4 = d1 * d1 + d3 * d3 + d2 * d2; |
| |
| if(d0 < 0.0D || d4 < d0) |
| { |
| d0 = d4; |
| 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 ? Blocks.stone : 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 ? Blocks.stone : DimensionRegister.AncientPortail), 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; |
| } |
| |
| class AncientPortalPosition extends ChunkCoordinates |
| { |
| public long time; |
| final AncientTeleporter teleporter; |
| |
| public AncientPortalPosition(AncientTeleporter teleporter, int x, int y, int z, long creationTime) |
| { |
| super(x, y, z); |
| this.teleporter = teleporter; |
| this.time = creationTime; |
| } |
| |
| @Override |
| public int compareTo(Object o) |
| { |
| |
| } |
| |
| } |
| |
| } |
| |
AncientActivateur
| package mod.common.world.structure; |
| |
| import mod.common.block.BlockRegister; |
| import mod.common.world.type.AncientChunkProvider; |
| import mod.common.world.type.AncientWorldChunkManager; |
| import mod.common.world.type.AncientWorldProvider; |
| import net.minecraft.entity.player.EntityPlayer; |
| import net.minecraft.init.Blocks; |
| import net.minecraft.item.Item; |
| import net.minecraft.item.ItemStack; |
| import net.minecraft.world.World; |
| |
| public class AncientActivateur extends Item |
| { |
| public boolean onItemUse(ItemStack stack, EntityPlayer player, World world, int x, int y, int z, int side, float par8, float par9, float par10) |
| { |
| if(world.getBlock(x, y, z).equals(BlockRegister.BlockAmbre)) |
| { |
| if(world.getBlock(x + 1, y, z).equals(BlockRegister.BlockAmbre)) |
| { |
| |
| } |
| |
| if(world.getBlock(x - 1, y, z).equals(BlockRegister.BlockAmbre)) |
| { |
| |
| } |
| |
| if(world.getBlock(x, y, z + 1).equals(BlockRegister.BlockAmbre)) |
| { |
| |
| } |
| |
| if(world.getBlock(x, y, z - 1).equals(BlockRegister.BlockAmbre)) |
| { |
| |
| } |
| |
| if(world.getBlock(x, y + 4, z).equals(BlockRegister.BlockAmbre)) |
| { |
| if(world.getBlock(x + 1, y + 4, z).equals(BlockRegister.BlockAmbre)) |
| { |
| if(world.getBlock(x - 1, y + 1, z).equals(BlockRegister.BlockAmbre)) |
| { |
| if(world.getBlock(x - 1, y + 2, z).equals(BlockRegister.BlockAmbre)) |
| { |
| if(world.getBlock(x - 1, y + 3, z).equals(BlockRegister.BlockAmbre)) |
| { |
| if(world.getBlock(x + 2, y + 1, z).equals(BlockRegister.BlockAmbre)) |
| { |
| if(world.getBlock(x + 2, y + 2, z).equals(BlockRegister.BlockAmbre)) |
| { |
| if(world.getBlock(x + 2, y + 3, z).equals(BlockRegister.BlockAmbre)) |
| { |
| |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| for(int l = 0; l < 2; l++) |
| { |
| for(int h = 0; h < 3; h++) |
| { |
| world.setBlock(x + l, y + 1 + h, z, DimensionRegister.AncientPortail); |
| } |
| } |
| } |
| |
| return false; |
| } |
| |
| } |
AncientTeleporter
| package mod.common.world.structure; |
| |
| import java.util.ArrayList; |
| import java.util.List; |
| import java.util.Random; |
| |
| import net.minecraft.entity.Entity; |
| import net.minecraft.init.Blocks; |
| import net.minecraft.util.ChunkCoordinates; |
| import net.minecraft.util.Direction; |
| import net.minecraft.util.LongHashMap; |
| import net.minecraft.util.MathHelper; |
| import net.minecraft.world.ChunkCoordIntPair; |
| import net.minecraft.world.Teleporter; |
| import net.minecraft.world.WorldServer; |
| |
| public class AncientTeleporter extends Teleporter |
| { |
| private final WorldServer worldServerInstance; |
| private final Random random; |
| private final LongHashMap destinationCoordinateCache = new LongHashMap(); |
| |
| private final List destinationCoordinateKeys = new ArrayList(); |
| |
| public AncientTeleporter(WorldServer worldServer) |
| { |
| super(worldServer); |
| this.worldServerInstance = worldServer; |
| this.random = new Random(worldServer.getSeed()); |
| |
| } |
| |
| public void placeInPortal(Entity entity, double x, double y, double z, float rotationYaw) |
| { |
| if(this.worldServerInstance.provider.dimensionId != 1) |
| { |
| if(!this.placeInExistingPortal(entity, x, y, z, rotationYaw)) |
| { |
| this.makePortal(entity); |
| this.placeInExistingPortal(entity, x, y, z, rotationYaw); |
| } |
| } |
| else |
| { |
| int i = MathHelper.floor_double(entity.posX); |
| int j = MathHelper.floor_double(entity.posY) - 1; |
| int k = MathHelper.floor_double(entity.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 ? Blocks.stone : Blocks.air); |
| } |
| } |
| } |
| entity.setLocationAndAngles((double)i, (double)j, (double)k, entity.rotationYaw, 0.0F); |
| entity.motionX = entity.motionY = entity.motionZ = 0.0D; |
| } |
| } |
| |
| public boolean placeInExistingPortal(Entity entity, double x, double y, double z, float rotationYaw) |
| { |
| short short1 = 128; |
| double d3 = -1.0D; |
| int i = 0; |
| int j = 0; |
| int k = 0; |
| int l = MathHelper.floor_double(entity.posX); |
| int i1 = MathHelper.floor_double(entity.posZ); |
| long j1 = ChunkCoordIntPair.chunkXZ2Int(l, i1); |
| |
| boolean flag = true; |
| double d4; |
| int k1; |
| |
| if(this.destinationCoordinateCache.containsItem(j1)) |
| { |
| PortalPosition portalposition = (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(k1 = l - short1; k1 <= l + short1; ++k1) |
| { |
| double d5 = (double)k1 + 0.5D - entity.posX; |
| for(int l1 = i1 - short1; l1 <= i1 + short1; ++l1) |
| { |
| double d6 = (double)l1 + 0.5D - entity.posZ; |
| |
| for(int i2 = this.worldServerInstance.getActualHeight() - 1; i2 >= 0; --i2) |
| { |
| if(this.worldServerInstance.getBlock(k1, i2, l1) == DimensionRegister.AncientPortail) |
| { |
| while(this.worldServerInstance.getBlock(k1, i2 - 1, l1) == DimensionRegister.AncientPortail) |
| { |
| --i2; |
| } |
| d4 = (double)i2 + 0.5D - entity.posY; |
| double d7 = d5 * d5 + d4 * d4 + d6 * d6; |
| if(d3 < 0.0D || d7 < d3) |
| { |
| d3 = d7; |
| i = k1; |
| j = i2; |
| k = l1; |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| if(d3 >= 0.0D) |
| { |
| if(flag) |
| { |
| this.destinationCoordinateCache.add(j1, new AncientPortalPosition(this, i, j, k, this.worldServerInstance.getTotalWorldTime())); |
| this.destinationCoordinateKeys.add(Long.valueOf(j1)); |
| } |
| double d8 = (double)i + 0.5D; |
| double d9 = (double)j + 0.5D; |
| d4 = (double)k + 0.5D; |
| int j2 = -1; |
| if(this.worldServerInstance.getBlock(i - 1, j, k) == DimensionRegister.AncientPortail) |
| { |
| j2 = 2; |
| } |
| if(this.worldServerInstance.getBlock(i + 1, j, k) == DimensionRegister.AncientPortail) |
| { |
| j2 = 0; |
| } |
| if(this.worldServerInstance.getBlock(i, j, k - 1) == DimensionRegister.AncientPortail) |
| { |
| j2 = 3; |
| } |
| if(this.worldServerInstance.getBlock(i, j, k + 1) == DimensionRegister.AncientPortail) |
| { |
| j2 = 1; |
| } |
| int k2 = entity.getTeleportDirection(); |
| if(j2 > -1) |
| { |
| |
| int l2 = Direction.rotateLeft[j2]; |
| int i3 = Direction.offsetX[j2]; |
| int j3 = Direction.offsetZ[j2]; |
| int k3 = Direction.offsetX[l2]; |
| int l3 = Direction.offsetZ[l2]; |
| boolean flag1 = !this.worldServerInstance.isAirBlock(i + i3 + k3, j, k + j3 + l3) || !this.worldServerInstance.isAirBlock(i + i3 + k3, j + 1, k + j3 + l3); |
| boolean flag2 = !this.worldServerInstance.isAirBlock(i + i3, j, k + j3) || !this.worldServerInstance.isAirBlock(i + i3, j + 1, k + j3); |
| if(flag1 && flag2) |
| { |
| j2 = Direction.rotateOpposite[j2]; |
| l2 = Direction.rotateOpposite[l2]; |
| i3 = Direction.offsetX[j2]; |
| j3 = Direction.offsetZ[j2]; |
| k3 = Direction.offsetX[l2]; |
| l3 = Direction.offsetZ[l2]; |
| k1 = i - k3; |
| d8 -= (double)k3; |
| int i4 = k - l3; |
| d4 -= (double)l3; |
| flag1 = !this.worldServerInstance.isAirBlock(k1 + i3 + k3, j, i4 + j3 + l3) || !this.worldServerInstance.isAirBlock(k1 + i3 + k3, j + 1, i4 + j3 + l3); |
| flag2 = !this.worldServerInstance.isAirBlock(k1 + i3, j, i4 + j3) || !this.worldServerInstance.isAirBlock(k1 + i3, j + 1, i4 + j3); |
| } |
| 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; |
| } |
| d8 += (double)((float)k3 * f1 + f2 * (float)i3); |
| d4 += (double)((float)l3 * f1 + f2 * (float)j3); |
| float f3 = 0.0F; |
| float f4 = 0.0F; |
| float f5 = 0.0F; |
| float f6 = 0.0F; |
| if(j2 == k2) |
| { |
| f3 = 1.0F; |
| f4 = 1.0F; |
| } |
| else if(j2 == Direction.rotateOpposite[k2]) |
| { |
| f3 = -1.0F; |
| f4 = -1.0F; |
| } |
| else if(j2 == Direction.rotateRight[k2]) |
| { |
| f5 = 1.0F; |
| f6 = -1.0F; |
| } |
| else |
| { |
| f5 = -1.0F; |
| f6 = 1.0F; |
| } |
| double d10 = entity.motionX; |
| double d11 = entity.motionZ; |
| entity.motionX = d10 * (double)f3 + d11 * (double)f6; |
| entity.motionZ = d10 * (double)f5 + d11 * (double)f4; |
| entity.rotationYaw = rotationYaw - (float)(k2 * 90) + (float)(j2 * 90); |
| } |
| else |
| { |
| entity.motionX = entity.motionY = entity.motionZ = 0.0D; |
| } |
| entity.setLocationAndAngles(d8, d9, d4, entity.rotationYaw, entity.rotationPitch); |
| return true; |
| } |
| else |
| { |
| return false; |
| } |
| } |
| |
| public boolean makePortal(Entity entity) |
| { |
| byte b0 = 16; |
| double d0 = -1.0D; |
| int x = MathHelper.floor_double(entity.posX); |
| int y = MathHelper.floor_double(entity.posY); |
| int z = MathHelper.floor_double(entity.posZ); |
| int l = x; |
| int i1 = y; |
| int j1 = z; |
| int k1 = 0; |
| int l1 = this.random.nextInt(4); |
| int i2; |
| double d1; |
| int k2; |
| double d2; |
| int i3; |
| int j3; |
| int k3; |
| int l3; |
| int i4; |
| int j4; |
| int k4; |
| int l4; |
| int i5; |
| double d3; |
| double d4; |
| |
| for(i2 = x - b0; i2 <= x + b0; ++i2) |
| { |
| d1 = (double)i2 + 0.5D - entity.posX; |
| |
| for(k2 = z - b0; k2 <= z + b0; ++k2) |
| { |
| d2 = (double)k2 + 0.5D - entity.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; |
| } |
| } |
| } |
| } |
| |
| d3 = (double)i3 + 0.5D - entity.posY; |
| d4 = d1 * d1 + d3 * d3 + d2 * d2; |
| |
| if(d0 < 0.0D || d4 < d0) |
| { |
| d0 = d4; |
| l = i2; |
| i1 = i3; |
| j1 = k2; |
| k1 = j3 % 4; |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| if(d0 < 0.0D) |
| { |
| for(i2 = x - b0; i2 <= x + b0; ++i2) |
| { |
| d1 = (double)i2 + 0.5D - entity.posX; |
| |
| for(k2 = z - b0; k2 <= z + b0; ++k2) |
| { |
| d2 = (double)k2 + 0.5D - entity.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; |
| } |
| } |
| } |
| |
| d3 = (double)i3 + 0.5D - entity.posY; |
| d4 = d1 * d1 + d3 * d3 + d2 * d2; |
| |
| if(d0 < 0.0D || d4 < d0) |
| { |
| d0 = d4; |
| 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 ? Blocks.stone : 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 ? Blocks.stone : DimensionRegister.AncientPortail), 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; |
| } |
| |
| class AncientPortalPosition extends ChunkCoordinates |
| { |
| public long time; |
| final AncientTeleporter teleporter; |
| |
| public AncientPortalPosition(AncientTeleporter teleporter, int x, int y, int z, long creationTime) |
| { |
| super(x, y, z); |
| this.teleporter = teleporter; |
| this.time = creationTime; |
| } |
| |
| @Override |
| public int compareTo(Object o) |
| { |
| |
| } |
| |
| } |
| |
| } |
| |
:::