From 70c1354a4a96698758a88c032866288f79de6f5a Mon Sep 17 00:00:00 2001 From: Benjamin Culkin Date: Sat, 24 Aug 2024 08:16:37 -0400 Subject: Initial commit --- .../fbs/world/autumn/ChunkProviderAutumn.class | Bin 0 -> 5020 bytes .../fbs/world/autumn/ChunkProviderAutumn.java | 123 +++++++ .../fbs/world/autumn/TeleporterAutumn.class | Bin 0 -> 7674 bytes .../fbs/world/autumn/TeleporterAutumn.java | 354 +++++++++++++++++++++ .../fbs/world/autumn/WorldChunkManagerAutumn.class | Bin 0 -> 5764 bytes .../fbs/world/autumn/WorldChunkManagerAutumn.java | 202 ++++++++++++ .../fbs/world/autumn/WorldProviderAutumn.class | Bin 0 -> 2307 bytes .../fbs/world/autumn/WorldProviderAutumn.java | 57 ++++ .../fbs/world/autumn/WorldTypeAutumn.class | Bin 0 -> 1245 bytes .../plusplus/fbs/world/autumn/WorldTypeAutumn.java | 29 ++ 10 files changed, 765 insertions(+) create mode 100644 src/main/java/jp/plusplus/fbs/world/autumn/ChunkProviderAutumn.class create mode 100644 src/main/java/jp/plusplus/fbs/world/autumn/ChunkProviderAutumn.java create mode 100644 src/main/java/jp/plusplus/fbs/world/autumn/TeleporterAutumn.class create mode 100644 src/main/java/jp/plusplus/fbs/world/autumn/TeleporterAutumn.java create mode 100644 src/main/java/jp/plusplus/fbs/world/autumn/WorldChunkManagerAutumn.class create mode 100644 src/main/java/jp/plusplus/fbs/world/autumn/WorldChunkManagerAutumn.java create mode 100644 src/main/java/jp/plusplus/fbs/world/autumn/WorldProviderAutumn.class create mode 100644 src/main/java/jp/plusplus/fbs/world/autumn/WorldProviderAutumn.java create mode 100644 src/main/java/jp/plusplus/fbs/world/autumn/WorldTypeAutumn.class create mode 100644 src/main/java/jp/plusplus/fbs/world/autumn/WorldTypeAutumn.java (limited to 'src/main/java/jp/plusplus/fbs/world/autumn') diff --git a/src/main/java/jp/plusplus/fbs/world/autumn/ChunkProviderAutumn.class b/src/main/java/jp/plusplus/fbs/world/autumn/ChunkProviderAutumn.class new file mode 100644 index 0000000..2f44634 Binary files /dev/null and b/src/main/java/jp/plusplus/fbs/world/autumn/ChunkProviderAutumn.class differ diff --git a/src/main/java/jp/plusplus/fbs/world/autumn/ChunkProviderAutumn.java b/src/main/java/jp/plusplus/fbs/world/autumn/ChunkProviderAutumn.java new file mode 100644 index 0000000..925dbb4 --- /dev/null +++ b/src/main/java/jp/plusplus/fbs/world/autumn/ChunkProviderAutumn.java @@ -0,0 +1,123 @@ +package jp.plusplus.fbs.world.autumn; + +import cpw.mods.fml.common.eventhandler.Event; +import net.minecraft.block.Block; +import net.minecraft.block.BlockFalling; +import net.minecraft.block.material.Material; +import net.minecraft.entity.EnumCreatureType; +import net.minecraft.init.Blocks; +import net.minecraft.util.IProgressUpdate; +import net.minecraft.util.MathHelper; +import net.minecraft.world.ChunkPosition; +import net.minecraft.world.SpawnerAnimals; +import net.minecraft.world.World; +import net.minecraft.world.biome.BiomeGenBase; +import net.minecraft.world.chunk.Chunk; +import net.minecraft.world.chunk.IChunkProvider; +import net.minecraft.world.gen.ChunkProviderGenerate; +import net.minecraft.world.gen.NoiseGenerator; +import net.minecraft.world.gen.NoiseGeneratorOctaves; +import net.minecraft.world.gen.feature.WorldGenDungeons; +import net.minecraft.world.gen.feature.WorldGenLakes; +import net.minecraft.world.gen.structure.MapGenMineshaft; +import net.minecraftforge.common.MinecraftForge; +import net.minecraftforge.event.terraingen.ChunkProviderEvent; +import net.minecraftforge.event.terraingen.PopulateChunkEvent; +import net.minecraftforge.event.terraingen.TerrainGen; + +import java.util.List; +import java.util.Random; + +import static net.minecraftforge.event.terraingen.PopulateChunkEvent.Populate.EventType.*; +import static net.minecraftforge.event.terraingen.PopulateChunkEvent.Populate.EventType.ICE; + +/** + * Created by plusplus_F on 2015/10/29. + */ +public class ChunkProviderAutumn extends ChunkProviderGenerate implements IChunkProvider { + private World worldObj; + private Random rand = new Random(); + private boolean mapFeaturesEnabled; + private MapGenMineshaft mineshaftGenerator = new MapGenMineshaft(); + + public ChunkProviderAutumn(World par1World, long par2, boolean par4) { + super(par1World, par2, par4); + worldObj = par1World; + mapFeaturesEnabled = par4; + + } + + @Override + public void populate(IChunkProvider p_73153_1_, int p_73153_2_, int p_73153_3_) { + BlockFalling.fallInstantly = true; + int k = p_73153_2_ * 16; + int l = p_73153_3_ * 16; + BiomeGenBase biomegenbase = this.worldObj.getBiomeGenForCoords(k + 16, l + 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) p_73153_2_ * i1 + (long) p_73153_3_ * j1 ^ this.worldObj.getSeed()); + boolean flag = false; + + MinecraftForge.EVENT_BUS.post(new PopulateChunkEvent.Pre(p_73153_1_, worldObj, rand, p_73153_2_, p_73153_3_, flag)); + + if (this.mapFeaturesEnabled) { + this.mineshaftGenerator.generateStructuresInChunk(this.worldObj, this.rand, p_73153_2_, p_73153_3_); + } + + int k1; + int l1; + int i2; + + if (this.rand.nextInt(4) == 0 && TerrainGen.populate(p_73153_1_, worldObj, rand, p_73153_2_, p_73153_3_, flag, LAKE)) { + k1 = k + this.rand.nextInt(16) + 8; + l1 = this.rand.nextInt(256); + i2 = l + this.rand.nextInt(16) + 8; + (new WorldGenLakes(Blocks.water)).generate(this.worldObj, this.rand, k1, l1, i2); + } + + if (TerrainGen.populate(p_73153_1_, worldObj, rand, p_73153_2_, p_73153_3_, flag, LAVA) && !flag && this.rand.nextInt(8) == 0) { + k1 = k + this.rand.nextInt(16) + 8; + l1 = this.rand.nextInt(this.rand.nextInt(248) + 8); + i2 = l + this.rand.nextInt(16) + 8; + + if (l1 < 63 || this.rand.nextInt(10) == 0) { + (new WorldGenLakes(Blocks.lava)).generate(this.worldObj, this.rand, k1, l1, i2); + } + } + + boolean doGen = TerrainGen.populate(p_73153_1_, worldObj, rand, p_73153_2_, p_73153_3_, flag, DUNGEON); + for (k1 = 0; doGen && k1 < 8; ++k1) { + l1 = k + this.rand.nextInt(16) + 8; + i2 = this.rand.nextInt(256); + int j2 = l + this.rand.nextInt(16) + 8; + (new WorldGenDungeons()).generate(this.worldObj, this.rand, l1, i2, j2); + } + + biomegenbase.decorate(this.worldObj, this.rand, k, l); + if (TerrainGen.populate(p_73153_1_, worldObj, rand, p_73153_2_, p_73153_3_, flag, ANIMALS)) { + SpawnerAnimals.performWorldGenSpawning(this.worldObj, biomegenbase, k + 8, l + 8, 16, 16, this.rand); + } + k += 8; + l += 8; + + doGen = TerrainGen.populate(p_73153_1_, worldObj, rand, p_73153_2_, p_73153_3_, flag, ICE); + for (k1 = 0; doGen && k1 < 16; ++k1) { + for (l1 = 0; l1 < 16; ++l1) { + i2 = this.worldObj.getPrecipitationHeight(k + k1, l + l1); + + if (this.worldObj.isBlockFreezable(k1 + k, i2 - 1, l1 + l)) { + this.worldObj.setBlock(k1 + k, i2 - 1, l1 + l, Blocks.ice, 0, 2); + } + + if (this.worldObj.func_147478_e(k1 + k, i2, l1 + l, true)) { + this.worldObj.setBlock(k1 + k, i2, l1 + l, Blocks.snow_layer, 0, 2); + } + } + } + + MinecraftForge.EVENT_BUS.post(new PopulateChunkEvent.Post(p_73153_1_, worldObj, rand, p_73153_2_, p_73153_3_, flag)); + + BlockFalling.fallInstantly = false; + } +} \ No newline at end of file diff --git a/src/main/java/jp/plusplus/fbs/world/autumn/TeleporterAutumn.class b/src/main/java/jp/plusplus/fbs/world/autumn/TeleporterAutumn.class new file mode 100644 index 0000000..229e639 Binary files /dev/null and b/src/main/java/jp/plusplus/fbs/world/autumn/TeleporterAutumn.class differ diff --git a/src/main/java/jp/plusplus/fbs/world/autumn/TeleporterAutumn.java b/src/main/java/jp/plusplus/fbs/world/autumn/TeleporterAutumn.java new file mode 100644 index 0000000..8ff296a --- /dev/null +++ b/src/main/java/jp/plusplus/fbs/world/autumn/TeleporterAutumn.java @@ -0,0 +1,354 @@ +package jp.plusplus.fbs.world.autumn; + +import jp.plusplus.fbs.FBS; +import jp.plusplus.fbs.block.BlockCore; +import net.minecraft.block.Block; +import net.minecraft.block.BlockPortal; +import net.minecraft.entity.Entity; +import net.minecraft.init.Blocks; +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; + +import java.util.ArrayList; +import java.util.Iterator; +import java.util.List; +import java.util.Random; + +/** + * Created by plusplus_F on 2015/11/07. + */ +public class TeleporterAutumn extends Teleporter { + private final LongHashMap destinationCoordinateCache = new LongHashMap(); + private final List destinationCoordinateKeys = new ArrayList(); + private final WorldServer worldServerInstance; + private final Random random; + + public TeleporterAutumn(WorldServer p_i1963_1_) { + super(p_i1963_1_); + worldServerInstance=p_i1963_1_; + random=new Random(); + } + + // 近くにポータルがあったらそこに出現させる処理 + // このサンプルではネザーポータルの処理をそのまま利用する + @Override + public boolean placeInExistingPortal(Entity entity, double p_77184_2_, double p_77184_4_, double p_77184_6_, float p_77184_8_) { + 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 z; + 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 = (double) l3 + 0.5D - entity.posX; + + for (int l1 = i1 - short1; l1 <= i1 + short1; ++l1) { + double d5 = (double) l1 + 0.5D - entity.posZ; + + for (int i2 = this.worldServerInstance.getActualHeight() - 1; i2 >= 0; --i2) { + if (this.worldServerInstance.getBlock(l3, i2, l1) == BlockCore.portal2) { + while (this.worldServerInstance.getBlock(l3, i2 - 1, l1) == BlockCore.portal2) { + --i2; + } + + z = (double) i2 + 0.5D - entity.posY; + double d8 = d4 * d4 + z * z + 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 x = (double) i + 0.5D; + double y = (double) j + 0.5D; + z = (double) k + 0.5D; + + entity.motionX = entity.motionY = entity.motionZ = 0.0D; + + entity.setLocationAndAngles(x, y+1, z, entity.rotationYaw, entity.rotationPitch); + return true; + } else { + return false; + } + } + + // ポータルを作成する処理 + // このサンプルではネザーポータルの処理をそのまま利用する + @Override + public boolean makePortal(Entity p_85188_1_) { + byte b0 = 16; + double d0 = -1.0D; + int i = MathHelper.floor_double(p_85188_1_.posX); + int j = MathHelper.floor_double(p_85188_1_.posY); + int k = MathHelper.floor_double(p_85188_1_.posZ); + int l = i; + int i1 = j; + int j1 = k; + int k1 = 0; + int l1 = this.random.nextInt(4); + int x; + double d1; + int z; + double d2; + int y; + int j3; + int k3; + int l3; + int i4; + int j4; + int k4; + int x2; + int y2; + double d3; + double d4; + + for (x = i - b0; x <= i + b0; ++x) { + d1 = (double) x + 0.5D - p_85188_1_.posX; + + for (z = k - b0; z <= k + b0; ++z) { + d2 = (double) z + 0.5D - p_85188_1_.posZ; + label274: + + for (y = this.worldServerInstance.getActualHeight() - 1; y >= 0; --y) { + if (this.worldServerInstance.isAirBlock(x, y, z)) { + while (y > 0 && this.worldServerInstance.isAirBlock(x, y - 1, z)) { + --y; + } + + 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) { + x2 = x + (j4 - 1) * k3 + i4 * l3; + y2 = y + k4; + int z2 = z + (j4 - 1) * l3 - i4 * k3; + + if (k4 < 0 && !this.worldServerInstance.getBlock(x2, y2, z2).getMaterial().isSolid() || k4 >= 0 && !this.worldServerInstance.isAirBlock(x2, y2, z2)) { + continue label274; + } + } + } + } + + d3 = (double) y + 0.5D - p_85188_1_.posY; + d4 = d1 * d1 + d3 * d3 + d2 * d2; + + if (d0 < 0.0D || d4 < d0) { + d0 = d4; + l = x; + i1 = y; + j1 = z; + k1 = j3 % 4; + } + } + } + } + } + } + + if (d0 < 0.0D) { + for (x = i - b0; x <= i + b0; ++x) { + d1 = (double) x + 0.5D - p_85188_1_.posX; + + for (z = k - b0; z <= k + b0; ++z) { + d2 = (double) z + 0.5D - p_85188_1_.posZ; + label222: + + for (y = this.worldServerInstance.getActualHeight() - 1; y >= 0; --y) { + if (this.worldServerInstance.isAirBlock(x, y, z)) { + while (y > 0 && this.worldServerInstance.isAirBlock(x, y - 1, z)) { + --y; + } + + 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 = x + (i4 - 1) * k3; + x2 = y + j4; + y2 = z + (i4 - 1) * l3; + + if (j4 < 0 && !this.worldServerInstance.getBlock(k4, x2, y2).getMaterial().isSolid() || j4 >= 0 && !this.worldServerInstance.isAirBlock(k4, x2, y2)) { + continue label222; + } + } + } + + d3 = (double) y + 0.5D - p_85188_1_.posY; + d4 = d1 * d1 + d3 * d3 + d2 * d2; + + if (d0 < 0.0D || d4 < d0) { + d0 = d4; + l = x; + i1 = y; + j1 = z; + k1 = j3 % 2; + } + } + } + } + } + } + } + + int k5 = l; + int j2 = i1; + z = 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 (y = -1; y <= 1; ++y) { + for (j3 = 1; j3 < 3; ++j3) { + for (k3 = -1; k3 < 3; ++k3) { + l3 = k5 + (j3 - 1) * l5 + y * l2; + i4 = j2 + k3; + j4 = z + (j3 - 1) * l2 - y * l5; + flag = k3 < 0; + this.worldServerInstance.setBlock(l3, i4, j4, flag ? BlockCore.plank : Blocks.air); + } + } + } + } + + worldServerInstance.setBlock(k5, j2-1, z, BlockCore.portal2, 0, 2); + /* + for (y = 0; y < 4; ++y) { + for (j3 = 0; j3 < 4; ++j3) { + for (k3 = -1; k3 < 4; ++k3) { + l3 = k5 + (j3 - 1) * l5; + i4 = j2 + k3; + j4 = z + (j3 - 1) * l2; + flag = j3 == 0 || j3 == 3 || k3 == -1 || k3 == 3; + this.worldServerInstance.setBlock(l3, i4, j4, (Block) (flag ? BlockCore.plank : BlockCore.portal2), 0, 2); + } + } + + for (j3 = 0; j3 < 4; ++j3) { + for (k3 = -1; k3 < 4; ++k3) { + l3 = k5 + (j3 - 1) * l5; + i4 = j2 + k3; + j4 = z + (j3 - 1) * l2; + this.worldServerInstance.notifyBlocksOfNeighborChange(l3, i4, j4, this.worldServerInstance.getBlock(l3, i4, j4)); + } + } + } + */ + + return true; + } + + public void removeStalePortalLocations(long p_85189_1_) { + if (p_85189_1_ % 100L == 0L) { + Iterator iterator = this.destinationCoordinateKeys.iterator(); + long j = p_85189_1_ - 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()); + } + } + } + } + + @Override + public void placeInPortal(Entity p_77185_1_, double p_77185_2_, double p_77185_4_, double p_77185_6_, float p_77185_8_) { + if (!this.placeInExistingPortal(p_77185_1_, p_77185_2_, p_77185_4_, p_77185_6_, p_77185_8_)) { + this.makePortal(p_77185_1_); + this.placeInExistingPortal(p_77185_1_, p_77185_2_, p_77185_4_, p_77185_6_, p_77185_8_); + } + + /* + if (this.worldServerInstance.provider.dimensionId != FBS.dimensionAutumnId) { + if (!this.placeInExistingPortal(p_77185_1_, p_77185_2_, p_77185_4_, p_77185_6_, p_77185_8_)) { + this.makePortal(p_77185_1_); + this.placeInExistingPortal(p_77185_1_, p_77185_2_, p_77185_4_, p_77185_6_, p_77185_8_); + } + } else { + int i = MathHelper.floor_double(p_77185_1_.posX); + int j = MathHelper.floor_double(p_77185_1_.posY) - 1; + int k = MathHelper.floor_double(p_77185_1_.posZ); + byte b0 = 1; + byte b1 = 0; + + for (int l = -4; l <= 4; ++l) { + for (int i1 = -4; i1 <= 4; ++i1) { + for (int j1 = -1; j1 < 3; ++j1) { + int blockX = i + i1 * b0 + l * b1; + int blockY = j + j1; + int blockZ = k + i1 * b1 - l * b0; + boolean flag = j1 < 0; + this.worldServerInstance.setBlock(blockX, blockY, blockZ, flag ? BlockCore.plank : Blocks.air); + } + } + } + + p_77185_1_.setLocationAndAngles((double) i+2, (double) j, (double) k+2, p_77185_1_.rotationYaw, 0.0F); + p_77185_1_.motionX = p_77185_1_.motionY = p_77185_1_.motionZ = 0.0D; + } + */ + } +} diff --git a/src/main/java/jp/plusplus/fbs/world/autumn/WorldChunkManagerAutumn.class b/src/main/java/jp/plusplus/fbs/world/autumn/WorldChunkManagerAutumn.class new file mode 100644 index 0000000..21d5e51 Binary files /dev/null and b/src/main/java/jp/plusplus/fbs/world/autumn/WorldChunkManagerAutumn.class differ diff --git a/src/main/java/jp/plusplus/fbs/world/autumn/WorldChunkManagerAutumn.java b/src/main/java/jp/plusplus/fbs/world/autumn/WorldChunkManagerAutumn.java new file mode 100644 index 0000000..9c38067 --- /dev/null +++ b/src/main/java/jp/plusplus/fbs/world/autumn/WorldChunkManagerAutumn.java @@ -0,0 +1,202 @@ +package jp.plusplus.fbs.world.autumn; + +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import jp.plusplus.fbs.Registry; +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 java.util.ArrayList; +import java.util.List; +import java.util.Random; + +/** + * Created by plusplus_F on 2015/10/29. + */ +public class WorldChunkManagerAutumn extends WorldChunkManager { + // WorldChunkManagerのプライベート変数にはアクセスできないので専用の変数を作成 + private GenLayer genBiomes; + private GenLayer biomeIndexLayer; + private BiomeCache biomeCache; + private List biomesToSpawnIn; + + public static final BiomeGenBase[] biomeList = new BiomeGenBase[256]; + + static { + for (int i = 0; i < biomeList.length; ++i) { + biomeList[i]=Registry.biomeAutumn; + /* + if (i % 2 == 0) { + biomeList[i] = mushroomIsland; + } else if (i % 2 == 1) { + biomeList[i] = mesa; + } + */ + } + } + + protected WorldChunkManagerAutumn() { + this.biomeCache = new BiomeCache(this); + this.biomesToSpawnIn = new ArrayList(); + this.biomesToSpawnIn.add(Registry.biomeAutumn); + //this.biomesToSpawnIn.addAll(allowedBiomes); + } + + public WorldChunkManagerAutumn(long par1, WorldType par3WorldType) { + this(); + GenLayer[] var4 = GenLayer.initializeAllBiomeGenerators(par1, par3WorldType); + this.genBiomes = var4[0]; + this.biomeIndexLayer = var4[1]; + } + + public WorldChunkManagerAutumn(World par1World) { + this(par1World.getSeed(), par1World.getWorldInfo().getTerrainType()); + } + + /////////////////////////////////////////////////////////////////////// + // WorldChunkManagerのプライベート変数を使用するメソッドはすべて再実装 + + @Override + public List getBiomesToSpawnIn() { + return this.biomesToSpawnIn; + } + + @Override + public BiomeGenBase getBiomeGenAt(int par1, int par2) { + return this.biomeCache.getBiomeGenAt(par1, par2); + } + + @Override + public float[] getRainfall(float[] par1ArrayOfFloat, int par2, int par3, int par4, int par5) { + IntCache.resetIntCache(); + + if (par1ArrayOfFloat == null || par1ArrayOfFloat.length < par4 * par5) { + par1ArrayOfFloat = new float[par4 * par5]; + } + + int[] var6 = this.biomeIndexLayer.getInts(par2, par3, par4, par5); + + for (int var7 = 0; var7 < par4 * par5; ++var7) { + float var8 = (float) biomeList[var6[var7]].getIntRainfall() / 65536.0F; + + if (var8 > 1.0F) { + var8 = 1.0F; + } + + par1ArrayOfFloat[var7] = var8; + } + + return par1ArrayOfFloat; + } + + @SideOnly(Side.CLIENT) + @Override + public float getTemperatureAtHeight(float par1, int par2) { + return par1; + } + + @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[] var6 = this.genBiomes.getInts(par2, par3, par4, par5); + + for (int var7 = 0; var7 < par4 * par5; ++var7) { + par1ArrayOfBiomeGenBase[var7] = biomeList[var6[var7]]; + } + + return par1ArrayOfBiomeGenBase; + } + + @Override + public BiomeGenBase[] loadBlockGeneratorData(BiomeGenBase[] par1ArrayOfBiomeGenBase, int par2, int par3, int par4, int par5) { + return this.getBiomeGenAt(par1ArrayOfBiomeGenBase, par2, par3, par4, par5, true); + } + + @Override + public BiomeGenBase[] getBiomeGenAt(BiomeGenBase[] par1ArrayOfBiomeGenBase, int par2, int par3, int par4, int par5, boolean par6) { + IntCache.resetIntCache(); + + if (par1ArrayOfBiomeGenBase == null || par1ArrayOfBiomeGenBase.length < par4 * par5) { + par1ArrayOfBiomeGenBase = new BiomeGenBase[par4 * par5]; + } + + if (par6 && par4 == 16 && par5 == 16 && (par2 & 15) == 0 && (par3 & 15) == 0) { + BiomeGenBase[] var9 = this.biomeCache.getCachedBiomes(par2, par3); + System.arraycopy(var9, 0, par1ArrayOfBiomeGenBase, 0, par4 * par5); + return par1ArrayOfBiomeGenBase; + } else { + int[] var7 = this.biomeIndexLayer.getInts(par2, par3, par4, par5); + + for (int var8 = 0; var8 < par4 * par5; ++var8) { + par1ArrayOfBiomeGenBase[var8] = biomeList[var7[var8]]; + } + + return par1ArrayOfBiomeGenBase; + } + } + + @Override + public boolean areBiomesViable(int par1, int par2, int par3, List par4List) { + IntCache.resetIntCache(); + int var5 = par1 - par3 >> 2; + int var6 = par2 - par3 >> 2; + int var7 = par1 + par3 >> 2; + int var8 = par2 + par3 >> 2; + int var9 = var7 - var5 + 1; + int var10 = var8 - var6 + 1; + int[] var11 = this.genBiomes.getInts(var5, var6, var9, var10); + + for (int var12 = 0; var12 < var9 * var10; ++var12) { + BiomeGenBase var13 = biomeList[var11[var12]]; + + if (!par4List.contains(var13)) { + return false; + } + } + + return true; + } + + @Override + public ChunkPosition findBiomePosition(int par1, int par2, int par3, List par4List, Random par5Random) { + IntCache.resetIntCache(); + int var6 = par1 - par3 >> 2; + int var7 = par2 - par3 >> 2; + int var8 = par1 + par3 >> 2; + int var9 = par2 + par3 >> 2; + int var10 = var8 - var6 + 1; + int var11 = var9 - var7 + 1; + int[] var12 = this.genBiomes.getInts(var6, var7, var10, var11); + ChunkPosition var13 = null; + int var14 = 0; + + for (int var15 = 0; var15 < var10 * var11; ++var15) { + int var16 = var6 + var15 % var10 << 2; + int var17 = var7 + var15 / var10 << 2; + BiomeGenBase var18 = biomeList[var12[var15]]; + + if (par4List.contains(var18) && (var13 == null || par5Random.nextInt(var14 + 1) == 0)) { + var13 = new ChunkPosition(var16, 0, var17); + ++var14; + } + } + + return var13; + } + + @Override + public void cleanupCache() { + this.biomeCache.cleanupCache(); + } +} \ No newline at end of file diff --git a/src/main/java/jp/plusplus/fbs/world/autumn/WorldProviderAutumn.class b/src/main/java/jp/plusplus/fbs/world/autumn/WorldProviderAutumn.class new file mode 100644 index 0000000..a320bb1 Binary files /dev/null and b/src/main/java/jp/plusplus/fbs/world/autumn/WorldProviderAutumn.class differ diff --git a/src/main/java/jp/plusplus/fbs/world/autumn/WorldProviderAutumn.java b/src/main/java/jp/plusplus/fbs/world/autumn/WorldProviderAutumn.java new file mode 100644 index 0000000..8622a1b --- /dev/null +++ b/src/main/java/jp/plusplus/fbs/world/autumn/WorldProviderAutumn.java @@ -0,0 +1,57 @@ +package jp.plusplus.fbs.world.autumn; + +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import jp.plusplus.fbs.FBS; +import net.minecraft.util.ChunkCoordinates; +import net.minecraft.world.WorldProvider; +import net.minecraft.world.chunk.IChunkProvider; + +/** + * Created by plusplus_F on 2015/11/07. + */ +public class WorldProviderAutumn extends WorldProvider { + + @Override + public String getDimensionName() { + return "Eternal Autumn"; + } + + // 独自のワールドタイプやワールドチャンクマネージャーを設定 + @Override + protected void registerWorldChunkManager() { + worldObj.getWorldInfo().setTerrainType(WorldTypeAutumn.worldType); + worldChunkMgr = new WorldChunkManagerAutumn(worldObj); + setDimension(FBS.dimensionAutumnId); + } + + @Override + public IChunkProvider createChunkGenerator() { + return new ChunkProviderAutumn(worldObj, worldObj.getSeed(), worldObj.getWorldInfo().isMapFeaturesEnabled()); + } + + @Override + public boolean canRespawnHere() { + return false; + } + + @Override + public boolean isSurfaceWorld() { + return true; + } + + @Override + public boolean canCoordinateBeSpawn(int p_76566_1_, int p_76566_2_) { + return this.worldObj.getTopBlock(p_76566_1_, p_76566_2_).getMaterial().blocksMovement(); + } + + @Override + public String getWelcomeMessage() { + return "Entering the Eternal Autumn"; + } + + @Override + public String getDepartMessage() { + return "Leaving the Eternal Autumn"; + } +} diff --git a/src/main/java/jp/plusplus/fbs/world/autumn/WorldTypeAutumn.class b/src/main/java/jp/plusplus/fbs/world/autumn/WorldTypeAutumn.class new file mode 100644 index 0000000..74691f6 Binary files /dev/null and b/src/main/java/jp/plusplus/fbs/world/autumn/WorldTypeAutumn.class differ diff --git a/src/main/java/jp/plusplus/fbs/world/autumn/WorldTypeAutumn.java b/src/main/java/jp/plusplus/fbs/world/autumn/WorldTypeAutumn.java new file mode 100644 index 0000000..9bdbcda --- /dev/null +++ b/src/main/java/jp/plusplus/fbs/world/autumn/WorldTypeAutumn.java @@ -0,0 +1,29 @@ +package jp.plusplus.fbs.world.autumn; + +import jp.plusplus.fbs.world.crack.ChunkProviderCrack; +import jp.plusplus.fbs.world.crack.WorldChunkManagerCrack; +import net.minecraft.world.World; +import net.minecraft.world.WorldType; +import net.minecraft.world.biome.WorldChunkManager; +import net.minecraft.world.chunk.IChunkProvider; + +/** + * Created by plusplus_F on 2015/10/29. + */ +public class WorldTypeAutumn extends WorldType { + public static WorldType worldType = new WorldTypeAutumn("Eternal Autumn"); + + private WorldTypeAutumn(String name) { + super(name); + } + + @Override + public WorldChunkManager getChunkManager(World world) { + return new WorldChunkManagerAutumn(world); + } + + @Override + public IChunkProvider getChunkGenerator(World world, String generatorOptions) { + return new ChunkProviderAutumn(world, world.getSeed(), true); + } +} \ No newline at end of file -- cgit v1.2.3