10 files changed, 765 insertions, 0 deletions
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
--- /dev/null
+++ b/src/main/java/jp/plusplus/fbs/world/autumn/ChunkProviderAutumn.class
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
--- /dev/null
+++ b/src/main/java/jp/plusplus/fbs/world/autumn/TeleporterAutumn.class
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
--- /dev/null
+++ b/src/main/java/jp/plusplus/fbs/world/autumn/WorldChunkManagerAutumn.class
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
--- /dev/null
+++ b/src/main/java/jp/plusplus/fbs/world/autumn/WorldProviderAutumn.class
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
--- /dev/null
+++ b/src/main/java/jp/plusplus/fbs/world/autumn/WorldTypeAutumn.class
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