[1.5.1] [SOLVED] Dimension Teleportation Error!!!

[Mitchellbrine]

I have been working on my dimension for quite a while, but I've been getting this error where it will keep teleporting me back and forth from my dimension to the Overworld. If I get lucky with /kill, I can end up in my dimension, but I'm aiming for it to work like a regular portal should. Here's my code:

 

My Portal Block:

 

package mc.Mitchellbrine.HardcoreNether;

 

import java.util.Random;

 

import net.minecraft.block.Block;

import net.minecraft.block.BlockPortal;

import net.minecraft.client.renderer.texture.IconRegister;

import net.minecraft.creativetab.CreativeTabs;

import net.minecraft.entity.Entity;

import net.minecraft.entity.player.EntityPlayerMP;

import net.minecraft.world.World;

 

public class HardcorePortal extends BlockPortal

{

      public HardcorePortal(int id)

      {

            super(id);

            this.setCreativeTab(CreativeTabs.tabBlock);

      }

     

      public void updateTick(World par1World, int par2, int par3, int par4, Random par5Random)

      {

 

      }

     

      public void onEntityCollidedWithBlock(World par1World, int par2, int par3, int par4, Entity par5Entity)

      {

            if (par5Entity.ridingEntity == null && par5Entity.riddenByEntity == null)

            {

                    if (par5Entity instanceof EntityPlayerMP)

                    {

                          EntityPlayerMP thePlayer = (EntityPlayerMP) par5Entity;

                          if (par5Entity.dimension != MainMod.dimension)

                          {

                                  thePlayer.mcServer.getConfigurationManager().transferPlayerToDimension(thePlayer, MainMod.dimension, new TeleporterHardcore(thePlayer.mcServer.worldServerForDimension(MainMod.dimension)));

 

                          }

                          else

                          {

                                  thePlayer.mcServer.getConfigurationManager().transferPlayerToDimension(thePlayer, 0, new TeleporterHardcore(thePlayer.mcServer.worldServerForDimension(0)));

                          }

                    }

            }

      }

     

      public boolean tryToCreatePortal(World par1World, int par2, int par3, int par4)

    {

        byte b0 = 0;

        byte b1 = 0;

 

        if (par1World.getBlockId(par2 - 1, par3, par4) == MainMod.hardcoreBlock.blockID || par1World.getBlockId(par2 + 1, par3, par4) == MainMod.hardcoreBlock.blockID)

        {

            b0 = 1;

        }

 

        if (par1World.getBlockId(par2, par3, par4 - 1) == MainMod.hardcoreBlock.blockID || par1World.getBlockId(par2, par3, par4 + 1) == MainMod.hardcoreBlock.blockID)

        {

            b1 = 1;

        }

 

        if (b0 == b1)

        {

            return false;

        }

        else

        {

            if (par1World.getBlockId(par2 - b0, par3, par4 - b1) == 0)

            {

                par2 -= b0;

                par4 -= b1;

            }

 

            int l;

            int i1;

 

            for (l = -1; l <= 2; ++l)

            {

                for (i1 = -1; i1 <= 3; ++i1)

                {

                    boolean flag = l == -1 || l == 2 || i1 == -1 || i1 == 3;

 

                    if (l != -1 && l != 2 || i1 != -1 && i1 != 3)

                    {

                        int j1 = par1World.getBlockId(par2 + b0 * l, par3 + i1, par4 + b1 * l);

 

                        if (flag)

                        {

                            if (j1 != MainMod.hardcoreBlock.blockID)

                            {

                                return false;

                            }

                        }

                        else if (j1 != 0 && j1 != Block.fire.blockID)

                        {

                            return false;

                        }

                    }

                }

            }

 

            for (l = 0; l < 2; ++l)

            {

                for (i1 = 0; i1 < 3; ++i1)

                {

                    par1World.setBlock(par2 + b0 * l, par3 + i1, par4 + b1 * l, MainMod.hardcorePortal.blockID, 0, 2);

                }

            }

 

            return true;

        }

    }

     

      public void randomDisplayTick(World par1World, int par2, int par3, int par4, Random par5Random)

    {

     

    }

     

      public void onNeighborBlockChange(World par1World, int par2, int par3, int par4, int par5)

    {

        byte b0 = 0;

        byte b1 = 1;

 

        if (par1World.getBlockId(par2 - 1, par3, par4) == this.blockID || par1World.getBlockId(par2 + 1, par3, par4) == this.blockID)

        {

            b0 = 1;

            b1 = 0;

        }

 

        int i1;

 

        for (i1 = par3; par1World.getBlockId(par2, i1 - 1, par4) == this.blockID; --i1)

        {

            ;

        }

 

        if (par1World.getBlockId(par2, i1 - 1, par4) != MainMod.hardcoreBlock.blockID)

        {

            par1World.setBlockToAir(par2, par3, par4);

        }

        else

        {

            int j1;

 

            for (j1 = 1; j1 < 4 && par1World.getBlockId(par2, i1 + j1, par4) == this.blockID; ++j1)

            {

                ;

            }

 

            if (j1 == 3 && par1World.getBlockId(par2, i1 + j1, par4) == MainMod.hardcoreBlock.blockID)

            {

                boolean flag = par1World.getBlockId(par2 - 1, par3, par4) == this.blockID || par1World.getBlockId(par2 + 1, par3, par4) == this.blockID;

                boolean flag1 = par1World.getBlockId(par2, par3, par4 - 1) == this.blockID || par1World.getBlockId(par2, par3, par4 + 1) == this.blockID;

 

                if (flag && flag1)

                {

                    par1World.setBlockToAir(par2, par3, par4);

                }

                else

                {

                    if ((par1World.getBlockId(par2 + b0, par3, par4 + b1) != MainMod.hardcoreBlock.blockID || par1World.getBlockId(par2 - b0, par3, par4 - b1) != this.blockID) && (par1World.getBlockId(par2 - b0, par3, par4 - b1) != MainMod.hardcoreBlock.blockID || par1World.getBlockId(par2 + b0, par3, par4 + b1) != this.blockID))

                    {

                        par1World.setBlockToAir(par2, par3, par4);

                    }

                }

            }

            else

            {

                par1World.setBlockToAir(par2, par3, par4);

            }

        }

    }

}

 

 

My Teleporter:

 

package mc.Mitchellbrine.HardcoreNether;

 

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

import java.util.Random;

 

import net.minecraft.entity.Entity;

import net.minecraft.util.Direction;

import net.minecraft.util.LongHashMap;

import net.minecraft.util.MathHelper;

import net.minecraft.world.ChunkCoordIntPair;

import net.minecraft.world.PortalPosition;

import net.minecraft.world.Teleporter;

import net.minecraft.world.WorldServer;

 

public class TeleporterHardcore extends Teleporter

{

    private final WorldServer worldServerInstance;

 

    /** A private Random() function in Teleporter */

    private final Random random;

    private final LongHashMap field_85191_c = new LongHashMap();

    private final List field_85190_d = new ArrayList();

 

    public TeleporterHardcore(WorldServer par1WorldServer)

    {

    super(par1WorldServer);

        this.worldServerInstance = par1WorldServer;

        this.random = new Random(par1WorldServer.getSeed());

    }

 

    /**

    * Place an entity in a nearby portal, creating one if necessary.

    */

    public void placeInPortal(Entity par1Entity, double par2, double par4, double par6, float par8)

    {

        if (this.worldServerInstance.provider.dimensionId != 1)

        {

            if (!this.placeInExistingPortal(par1Entity, par2, par4, par6, par8))

            {

                this.makePortal(par1Entity);

                this.placeInExistingPortal(par1Entity, par2, par4, par6, par8);

            }

        }

        else

        {

            int i = MathHelper.floor_double(par1Entity.posX);

            int j = MathHelper.floor_double(par1Entity.posY) - 1;

            int k = MathHelper.floor_double(par1Entity.posZ);

            byte b0 = 1;

            byte b1 = 0;

 

            for (int l = -2; l <= 2; ++l)

            {

                for (int i1 = -2; i1 <= 2; ++i1)

                {

                    for (int j1 = -1; j1 < 3; ++j1)

                    {

                        int k1 = i + i1 * b0 + l * b1;

                        int l1 = j + j1;

                        int i2 = k + i1 * b1 - l * b0;

                        boolean flag = j1 < 0;

                        this.worldServerInstance.setBlock(k1, l1, i2, flag ? MainMod.hardcoreBlock.blockID : 0);

                    }

                }

            }

 

            par1Entity.setLocationAndAngles((double)i, (double)j, (double)k, par1Entity.rotationYaw, 0.0F);

            par1Entity.motionX = par1Entity.motionY = par1Entity.motionZ = 0.0D;

        }

    }

 

    /**

    * Place an entity in a nearby portal which already exists.

    */

    public boolean placeInExistingPortal(Entity par1Entity, double par2, double par4, double par6, float par8)

    {

        short short1 = 128;

        double d3 = -1.0D;

        int i = 0;

        int j = 0;

        int k = 0;

        int l = MathHelper.floor_double(par1Entity.posX);

        int i1 = MathHelper.floor_double(par1Entity.posZ);

        long j1 = ChunkCoordIntPair.chunkXZ2Int(l, i1);

        boolean flag = true;

        double d4;

        int k1;

 

        if (this.field_85191_c.containsItem(j1))

        {

            PortalPosition portalposition = (PortalPosition)this.field_85191_c.getValueByKey(j1);

            d3 = 0.0D;

            i = portalposition.posX;

            j = portalposition.posY;

            k = portalposition.posZ;

            portalposition.field_85087_d = this.worldServerInstance.getTotalWorldTime();

            flag = false;

        }

        else

        {

            for (k1 = l - short1; k1 <= l + short1; ++k1)

            {

                double d5 = (double)k1 + 0.5D - par1Entity.posX;

 

                for (int l1 = i1 - short1; l1 <= i1 + short1; ++l1)

                {

                    double d6 = (double)l1 + 0.5D - par1Entity.posZ;

 

                    for (int i2 = this.worldServerInstance.getActualHeight() - 1; i2 >= 0; --i2)

                    {

                        if (this.worldServerInstance.getBlockId(k1, i2, l1) == MainMod.hardcorePortal.blockID)

                        {

                            while (this.worldServerInstance.getBlockId(k1, i2 - 1, l1) == MainMod.hardcorePortal.blockID)

                            {

                                --i2;

                            }

 

                            d4 = (double)i2 + 0.5D - par1Entity.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.field_85191_c.add(j1, new PortalPosition(this, i, j, k, this.worldServerInstance.getTotalWorldTime()));

                this.field_85190_d.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.getBlockId(i - 1, j, k) == MainMod.hardcorePortal.blockID)

            {

                j2 = 2;

            }

 

            if (this.worldServerInstance.getBlockId(i + 1, j, k) == MainMod.hardcorePortal.blockID)

            {

                j2 = 0;

            }

 

            if (this.worldServerInstance.getBlockId(i, j, k - 1) == MainMod.hardcorePortal.blockID)

            {

                j2 = 3;

            }

 

            if (this.worldServerInstance.getBlockId(i, j, k + 1) == MainMod.hardcorePortal.blockID)

            {

                j2 = 1;

            }

 

            int k2 = par1Entity.func_82148_at();

 

            if (j2 > -1)

            {

                int l2 = Direction.field_71578_g[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.footInvisibleFaceRemap[j2];

                    l2 = Direction.footInvisibleFaceRemap[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.footInvisibleFaceRemap[k2])

                {

                    f3 = -1.0F;

                    f4 = -1.0F;

                }

                else if (j2 == Direction.enderEyeMetaToDirection[k2])

                {

                    f5 = 1.0F;

                    f6 = -1.0F;

                }

                else

                {

                    f5 = -1.0F;

                    f6 = 1.0F;

                }

 

                double d10 = par1Entity.motionX;

                double d11 = par1Entity.motionZ;

                par1Entity.motionX = d10 * (double)f3 + d11 * (double)f6;

                par1Entity.motionZ = d10 * (double)f5 + d11 * (double)f4;

                par1Entity.rotationYaw = par8 - (float)(k2 * 90) + (float)(j2 * 90);

            }

            else

            {

                par1Entity.motionX = par1Entity.motionY = par1Entity.motionZ = 0.0D;

            }

 

            par1Entity.setLocationAndAngles(d8, d9, d4, par1Entity.rotationYaw, par1Entity.rotationPitch);

            return true;

        }

        else

        {

            return false;

        }

    }

 

    public boolean makePortal(Entity par1Entity)

    {

        byte b0 = 16;

        double d0 = -1.0D;

        int i = MathHelper.floor_double(par1Entity.posX);

        int j = MathHelper.floor_double(par1Entity.posY);

        int k = MathHelper.floor_double(par1Entity.posZ);

        int l = i;

        int i1 = j;

        int j1 = k;

        int k1 = 0;

        int l1 = this.random.nextInt(4);

        int i2;

        double d1;

        double d2;

        int j2;

        int k2;

        int l2;

        int i3;

        int j3;

        int k3;

        int l3;

        int i4;

        int j4;

        int k4;

        double d3;

        double d4;

 

        for (i2 = i - b0; i2 <= i + b0; ++i2)

        {

            d1 = (double)i2 + 0.5D - par1Entity.posX;

 

            for (j2 = k - b0; j2 <= k + b0; ++j2)

            {

                d2 = (double)j2 + 0.5D - par1Entity.posZ;

                label274:

 

                for (k2 = this.worldServerInstance.getActualHeight() - 1; k2 >= 0; --k2)

                {

                    if (this.worldServerInstance.isAirBlock(i2, k2, j2))

                    {

                        while (k2 > 0 && this.worldServerInstance.isAirBlock(i2, k2 - 1, j2))

                        {

                            --k2;

                        }

 

                        for (i3 = l1; i3 < l1 + 4; ++i3)

                        {

                            l2 = i3 % 2;

                            k3 = 1 - l2;

 

                            if (i3 % 4 >= 2)

                            {

                                l2 = -l2;

                                k3 = -k3;

                            }

 

                            for (j3 = 0; j3 < 3; ++j3)

                            {

                                for (i4 = 0; i4 < 4; ++i4)

                                {

                                    for (l3 = -1; l3 < 4; ++l3)

                                    {

                                        k4 = i2 + (i4 - 1) * l2 + j3 * k3;

                                        j4 = k2 + l3;

                                        int l4 = j2 + (i4 - 1) * k3 - j3 * l2;

 

                                        if (l3 < 0 && !this.worldServerInstance.getBlockMaterial(k4, j4, l4).isSolid() || l3 >= 0 && !this.worldServerInstance.isAirBlock(k4, j4, l4))

                                        {

                                            continue label274;

                                        }

                                    }

                                }

                            }

 

                            d4 = (double)k2 + 0.5D - par1Entity.posY;

                            d3 = d1 * d1 + d4 * d4 + d2 * d2;

 

                            if (d0 < 0.0D || d3 < d0)

                            {

                                d0 = d3;

                                l = i2;

                                i1 = k2;

                                j1 = j2;

                                k1 = i3 % 4;

                            }

                        }

                    }

                }

            }

        }

 

        if (d0 < 0.0D)

        {

            for (i2 = i - b0; i2 <= i + b0; ++i2)

            {

                d1 = (double)i2 + 0.5D - par1Entity.posX;

 

                for (j2 = k - b0; j2 <= k + b0; ++j2)

                {

                    d2 = (double)j2 + 0.5D - par1Entity.posZ;

                    label222:

 

                    for (k2 = this.worldServerInstance.getActualHeight() - 1; k2 >= 0; --k2)

                    {

                        if (this.worldServerInstance.isAirBlock(i2, k2, j2))

                        {

                            while (k2 > 0 && this.worldServerInstance.isAirBlock(i2, k2 - 1, j2))

                            {

                                --k2;

                            }

 

                            for (i3 = l1; i3 < l1 + 2; ++i3)

                            {

                                l2 = i3 % 2;

                                k3 = 1 - l2;

 

                                for (j3 = 0; j3 < 4; ++j3)

                                {

                                    for (i4 = -1; i4 < 4; ++i4)

                                    {

                                        l3 = i2 + (j3 - 1) * l2;

                                        k4 = k2 + i4;

                                        j4 = j2 + (j3 - 1) * k3;

 

                                        if (i4 < 0 && !this.worldServerInstance.getBlockMaterial(l3, k4, j4).isSolid() || i4 >= 0 && !this.worldServerInstance.isAirBlock(l3, k4, j4))

                                        {

                                            continue label222;

                                        }

                                    }

                                }

 

                                d4 = (double)k2 + 0.5D - par1Entity.posY;

                                d3 = d1 * d1 + d4 * d4 + d2 * d2;

 

                                if (d0 < 0.0D || d3 < d0)

                                {

                                    d0 = d3;

                                    l = i2;

                                    i1 = k2;

                                    j1 = j2;

                                    k1 = i3 % 2;

                                }

                            }

                        }

                    }

                }

            }

        }

 

        int i5 = l;

        int j5 = i1;

        j2 = j1;

        int k5 = k1 % 2;

        int l5 = 1 - k5;

 

        if (k1 % 4 >= 2)

        {

            k5 = -k5;

            l5 = -l5;

        }

 

        boolean flag;

 

        if (d0 < 0.0D)

        {

            if (i1 < 70)

            {

                i1 = 70;

            }

 

            if (i1 > this.worldServerInstance.getActualHeight() - 10)

            {

                i1 = this.worldServerInstance.getActualHeight() - 10;

            }

 

            j5 = i1;

 

            for (k2 = -1; k2 <= 1; ++k2)

            {

                for (i3 = 1; i3 < 3; ++i3)

                {

                    for (l2 = -1; l2 < 3; ++l2)

                    {

                        k3 = i5 + (i3 - 1) * k5 + k2 * l5;

                        j3 = j5 + l2;

                        i4 = j2 + (i3 - 1) * l5 - k2 * k5;

                        flag = l2 < 0;

                        this.worldServerInstance.setBlock(k3, j3, i4, flag ? MainMod.hardcoreBlock.blockID : 0);

                    }

                }

            }

        }

 

        for (k2 = 0; k2 < 4; ++k2)

        {

            for (i3 = 0; i3 < 4; ++i3)

            {

                for (l2 = -1; l2 < 4; ++l2)

                {

                    k3 = i5 + (i3 - 1) * k5;

                    j3 = j5 + l2;

                    i4 = j2 + (i3 - 1) * l5;

                    flag = i3 == 0 || i3 == 3 || l2 == -1 || l2 == 3;

                    this.worldServerInstance.setBlock(k3, j3, i4, flag ? MainMod.hardcoreBlock.blockID : MainMod.hardcorePortal.blockID, 0, 2);

                }

            }

 

            for (i3 = 0; i3 < 4; ++i3)

            {

                for (l2 = -1; l2 < 4; ++l2)

                {

                    k3 = i5 + (i3 - 1) * k5;

                    j3 = j5 + l2;

                    i4 = j2 + (i3 - 1) * l5;

                    this.worldServerInstance.notifyBlocksOfNeighborChange(k3, j3, i4, this.worldServerInstance.getBlockId(k3, j3, i4));

                }

            }

        }

 

        return true;

    }

 

    public void func_85189_a(long par1)

    {

        if (par1 % 100L == 0L)

        {

            Iterator iterator = this.field_85190_d.iterator();

            long j = par1 - 600L;

 

            while (iterator.hasNext())

            {

                Long olong = (Long)iterator.next();

                PortalPosition portalposition = (PortalPosition)this.field_85191_c.getValueByKey(olong.longValue());

 

                if (portalposition == null || portalposition.field_85087_d < j)

                {

                    iterator.remove();

                    this.field_85191_c.remove(olong.longValue());

                }

            }

        }

    }

}

 

 

 

My WorldProvider:

 

package mc.Mitchellbrine.HardcoreNether;

 

import net.minecraft.world.WorldProvider;

import net.minecraft.world.biome.BiomeGenBase;

import net.minecraft.world.biome.WorldChunkManagerHell;

import net.minecraft.world.chunk.IChunkProvider;

 

public class WorldProviderHardcore extends WorldProvider

{

public String getDimensionName()

{

  return "Hardcore";

}

 

public boolean canRespawnHere()

{

  return true;

}

 

public void registerWorldChunkManager()

{

  this.worldChunkMgr = new WorldChunkManagerHell(MainMod.hardcoreBiome, 0.8F, 0.1F);

  this.dimensionId = MainMod.dimension;

}

 

@Override

public IChunkProvider createChunkGenerator()

{

  return new ChunkProviderHardcore(worldObj, worldObj.getSeed(), true);

}

}

 

 

 

My ChunkProvider:

 

package mc.Mitchellbrine.HardcoreNether;

 

import static net.minecraftforge.event.terraingen.InitMapGenEvent.EventType.CAVE;

import static net.minecraftforge.event.terraingen.InitMapGenEvent.EventType.MINESHAFT;

import static net.minecraftforge.event.terraingen.InitMapGenEvent.EventType.RAVINE;

import static net.minecraftforge.event.terraingen.InitMapGenEvent.EventType.SCATTERED_FEATURE;

import static net.minecraftforge.event.terraingen.InitMapGenEvent.EventType.STRONGHOLD;

import static net.minecraftforge.event.terraingen.InitMapGenEvent.EventType.VILLAGE;

import static net.minecraftforge.event.terraingen.PopulateChunkEvent.Populate.EventType.DUNGEON;

import static net.minecraftforge.event.terraingen.PopulateChunkEvent.Populate.EventType.ICE;

import static net.minecraftforge.event.terraingen.PopulateChunkEvent.Populate.EventType.LAKE;

import static net.minecraftforge.event.terraingen.PopulateChunkEvent.Populate.EventType.LAVA;

 

import java.util.List;

import java.util.Random;

 

import net.minecraft.block.Block;

import net.minecraft.block.BlockSand;

import net.minecraft.entity.EnumCreatureType;

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.MapGenBase;

import net.minecraft.world.gen.MapGenCaves;

import net.minecraft.world.gen.MapGenRavine;

import net.minecraft.world.gen.NoiseGeneratorOctaves;

import net.minecraft.world.gen.feature.MapGenScatteredFeature;

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.MapGenStronghold;

import net.minecraft.world.gen.structure.MapGenVillage;

import net.minecraftforge.common.MinecraftForge;

import net.minecraftforge.event.Event.Result;

import net.minecraftforge.event.terraingen.ChunkProviderEvent;

import net.minecraftforge.event.terraingen.PopulateChunkEvent;

import net.minecraftforge.event.terraingen.TerrainGen;

 

public class ChunkProviderHardcore implements IChunkProvider

{

    /** RNG. */

    private Random rand;

 

    /** A NoiseGeneratorOctaves used in generating terrain */

    private NoiseGeneratorOctaves noiseGen1;

 

    /** A NoiseGeneratorOctaves used in generating terrain */

    private NoiseGeneratorOctaves noiseGen2;

 

    /** A NoiseGeneratorOctaves used in generating terrain */

    private NoiseGeneratorOctaves noiseGen3;

 

    /** A NoiseGeneratorOctaves used in generating terrain */

    private NoiseGeneratorOctaves noiseGen4;

 

    /** A NoiseGeneratorOctaves used in generating terrain */

    public NoiseGeneratorOctaves noiseGen5;

 

    /** A NoiseGeneratorOctaves used in generating terrain */

    public NoiseGeneratorOctaves noiseGen6;

    public NoiseGeneratorOctaves mobSpawnerNoise;

 

    /** Reference to the World object. */

    private World worldObj;

 

    /** are map structures going to be generated (e.g. strongholds) */

    private final boolean mapFeaturesEnabled;

 

    /** Holds the overall noise array used in chunk generation */

    private double[] noiseArray;

    private double[] stoneNoise = new double[256];

    private MapGenBase caveGenerator = new MapGenCaves();

 

    /** Holds Stronghold Generator */

    private MapGenStronghold strongholdGenerator = new MapGenStronghold();

 

    /** Holds Village Generator */

    private MapGenVillage villageGenerator = new MapGenVillage();

 

    /** Holds Mineshaft Generator */

    private MapGenMineshaft mineshaftGenerator = new MapGenMineshaft();

    private MapGenScatteredFeature scatteredFeatureGenerator = new MapGenScatteredFeature();

 

    /** Holds ravine generator */

    private MapGenBase ravineGenerator = new MapGenRavine();

 

    /** The biomes that are used to generate the chunk */

    private BiomeGenBase[] biomesForGeneration;

 

    /** A double array that hold terrain noise from noiseGen3 */

    double[] noise3;

 

    /** A double array that hold terrain noise */

    double[] noise1;

 

    /** A double array that hold terrain noise from noiseGen2 */

    double[] noise2;

 

    /** A double array that hold terrain noise from noiseGen5 */

    double[] noise5;

 

    /** A double array that holds terrain noise from noiseGen6 */

    double[] noise6;

 

    /**

    * Used to store the 5x5 parabolic field that is used during terrain generation.

    */

    float[] parabolicField;

    int[][] field_73219_j = new int[32][32];

 

    {

        caveGenerator = TerrainGen.getModdedMapGen(caveGenerator, CAVE);

        strongholdGenerator = (MapGenStronghold) TerrainGen.getModdedMapGen(strongholdGenerator, STRONGHOLD);

        villageGenerator = (MapGenVillage) TerrainGen.getModdedMapGen(villageGenerator, VILLAGE);

        mineshaftGenerator = (MapGenMineshaft) TerrainGen.getModdedMapGen(mineshaftGenerator, MINESHAFT);

        scatteredFeatureGenerator = (MapGenScatteredFeature) TerrainGen.getModdedMapGen(scatteredFeatureGenerator, SCATTERED_FEATURE);

        ravineGenerator = TerrainGen.getModdedMapGen(ravineGenerator, RAVINE);

    }

 

    public ChunkProviderHardcore(World par1World, long par2, boolean par4)

    {

        this.worldObj = par1World;

        this.mapFeaturesEnabled = par4;

        this.rand = new Random(par2);

        this.noiseGen1 = new NoiseGeneratorOctaves(this.rand, 16);

        this.noiseGen2 = new NoiseGeneratorOctaves(this.rand, 16);

        this.noiseGen3 = new NoiseGeneratorOctaves(this.rand, ;

        this.noiseGen4 = new NoiseGeneratorOctaves(this.rand, 4);

        this.noiseGen5 = new NoiseGeneratorOctaves(this.rand, 10);

        this.noiseGen6 = new NoiseGeneratorOctaves(this.rand, 16);

        this.mobSpawnerNoise = new NoiseGeneratorOctaves(this.rand, ;

 

        NoiseGeneratorOctaves[] noiseGens = {noiseGen1, noiseGen2, noiseGen3, noiseGen4, noiseGen5, noiseGen6, mobSpawnerNoise};

        noiseGens = TerrainGen.getModdedNoiseGenerators(par1World, this.rand, noiseGens);

        this.noiseGen1 = noiseGens[0];

        this.noiseGen2 = noiseGens[1];

        this.noiseGen3 = noiseGens[2];

        this.noiseGen4 = noiseGens[3];

        this.noiseGen5 = noiseGens[4];

        this.noiseGen6 = noiseGens[5];

        this.mobSpawnerNoise = noiseGens[6];

    }

 

    /**

    * Generates the shape of the terrain for the chunk though its all stone though the water is frozen if the

    * temperature is low enough

    */

    public void generateTerrain(int par1, int par2, byte[] par3ArrayOfByte)

    {

        byte var4 = 4;

        byte var5 = 16;

        byte var6 = 63;

        int var7 = var4 + 1;

        byte var8 = 17;

        int var9 = var4 + 1;

        this.biomesForGeneration = this.worldObj.getWorldChunkManager().getBiomesForGeneration(this.biomesForGeneration, par1 * 4 - 2, par2 * 4 - 2, var7 + 5, var9 + 5);

        this.noiseArray = this.initializeNoiseField(this.noiseArray, par1 * var4, 0, par2 * var4, var7, var8, var9);

 

        for (int var10 = 0; var10 < var4; ++var10)

        {

            for (int var11 = 0; var11 < var4; ++var11)

            {

                for (int var12 = 0; var12 < var5; ++var12)

                {

                    double var13 = 0.125D;

                    double var15 = this.noiseArray[((var10 + 0) * var9 + var11 + 0) * var8 + var12 + 0];

                    double var17 = this.noiseArray[((var10 + 0) * var9 + var11 + 1) * var8 + var12 + 0];

                    double var19 = this.noiseArray[((var10 + 1) * var9 + var11 + 0) * var8 + var12 + 0];

                    double var21 = this.noiseArray[((var10 + 1) * var9 + var11 + 1) * var8 + var12 + 0];

                    double var23 = (this.noiseArray[((var10 + 0) * var9 + var11 + 0) * var8 + var12 + 1] - var15) * var13;

                    double var25 = (this.noiseArray[((var10 + 0) * var9 + var11 + 1) * var8 + var12 + 1] - var17) * var13;

                    double var27 = (this.noiseArray[((var10 + 1) * var9 + var11 + 0) * var8 + var12 + 1] - var19) * var13;

                    double var29 = (this.noiseArray[((var10 + 1) * var9 + var11 + 1) * var8 + var12 + 1] - var21) * var13;

 

                    for (int var31 = 0; var31 < 8; ++var31)

                    {

                        double var32 = 0.25D;

                        double var34 = var15;

                        double var36 = var17;

                        double var38 = (var19 - var15) * var32;

                        double var40 = (var21 - var17) * var32;

 

                        for (int var42 = 0; var42 < 4; ++var42)

                        {

                            int var43 = var42 + var10 * 4 << 11 | 0 + var11 * 4 << 7 | var12 * 8 + var31;

                            short var44 = 128;

                            var43 -= var44;

                            double var45 = 0.25D;

                            double var49 = (var36 - var34) * var45;

                            double var47 = var34 - var49;

 

                            for (int var51 = 0; var51 < 4; ++var51)

                            {

                                if ((var47 += var49) > 0.0D)

                                {

                                    par3ArrayOfByte[var43 += var44] = (byte)Block.stone.blockID;

                                }

                                else if (var12 * 8 + var31 < var6)

                                {

                                    par3ArrayOfByte[var43 += var44] = (byte)Block.waterStill.blockID;

                                }

                                else

                                {

                                    par3ArrayOfByte[var43 += var44] = 0;

                                }

                            }

 

                            var34 += var38;

                            var36 += var40;

                        }

 

                        var15 += var23;

                        var17 += var25;

                        var19 += var27;

                        var21 += var29;

                    }

                }

            }

        }

    }

 

    /**

    * Replaces the stone that was placed in with blocks that match the biome

    */

    public void replaceBlocksForBiome(int par1, int par2, byte[] par3ArrayOfByte, BiomeGenBase[] par4ArrayOfBiomeGenBase)

    {

        ChunkProviderEvent.ReplaceBiomeBlocks event = new ChunkProviderEvent.ReplaceBiomeBlocks(this, par1, par2, par3ArrayOfByte, par4ArrayOfBiomeGenBase);

        MinecraftForge.EVENT_BUS.post(event);

        if (event.getResult() == Result.DENY) return;

 

        byte var5 = 63;

        double var6 = 0.03125D;

        this.stoneNoise = this.noiseGen4.generateNoiseOctaves(this.stoneNoise, par1 * 16, par2 * 16, 0, 16, 16, 1, var6 * 2.0D, var6 * 2.0D, var6 * 2.0D);

 

        for (int var8 = 0; var8 < 16; ++var8)

        {

            for (int var9 = 0; var9 < 16; ++var9)

            {

                BiomeGenBase var10 = par4ArrayOfBiomeGenBase[var9 + var8 * 16];

                float var11 = var10.getFloatTemperature();

                int var12 = (int)(this.stoneNoise[var8 + var9 * 16] / 3.0D + 3.0D + this.rand.nextDouble() * 0.25D);

                int var13 = -1;

                byte var14 = var10.topBlock;

                byte var15 = var10.fillerBlock;

 

                for (int var16 = 127; var16 >= 0; --var16)

                {

                    int var17 = (var9 * 16 + var8) * 128 + var16;

 

                    if (var16 <= 0 + this.rand.nextInt(5))

                    {

                        par3ArrayOfByte[var17] = (byte)Block.bedrock.blockID;

                    }

                    else

                    {

                        byte var18 = par3ArrayOfByte[var17];

 

                        if (var18 == 0)

                        {

                            var13 = -1;

                        }

                        else if (var18 == Block.stone.blockID)

                        {

                            if (var13 == -1)

                            {

                                if (var12 <= 0)

                                {

                                    var14 = 0;

                                    var15 = (byte)Block.stone.blockID;

                                }

                                else if (var16 >= var5 - 4 && var16 <= var5 + 1)

                                {

                                    var14 = var10.topBlock;

                                    var15 = var10.fillerBlock;

                                }

 

                                if (var16 < var5 && var14 == 0)

                                {

                                    if (var11 < 0.15F)

                                    {

                                        var14 = (byte)Block.ice.blockID;

                                    }

                                    else

                                    {

                                        var14 = (byte)Block.waterStill.blockID;

                                    }

                                }

 

                                var13 = var12;

 

                                if (var16 >= var5 - 1)

                                {

                                    par3ArrayOfByte[var17] = var14;

                                }

                                else

                                {

                                    par3ArrayOfByte[var17] = var15;

                                }

                            }

                            else if (var13 > 0)

                            {

                                --var13;

                                par3ArrayOfByte[var17] = var15;

 

                                if (var13 == 0 && var15 == Block.sand.blockID)

                                {

                                    var13 = this.rand.nextInt(4);

                                    var15 = (byte)Block.sandStone.blockID;

                                }

                            }

                        }

                    }

                }

            }

        }

    }

 

    /**

    * loads or generates the chunk at the chunk location specified

    */

    public Chunk loadChunk(int par1, int par2)

    {

        return this.provideChunk(par1, par2);

    }

 

    /**

    * Will return back a chunk, if it doesn't exist and its not a MP client it will generates all the blocks for the

    * specified chunk from the map seed and chunk seed

    */

    public Chunk provideChunk(int par1, int par2)

    {

        this.rand.setSeed((long)par1 * 341873128712L + (long)par2 * 132897987541L);

        byte[] var3 = new byte[32768];

        this.generateTerrain(par1, par2, var3);

        this.biomesForGeneration = this.worldObj.getWorldChunkManager().loadBlockGeneratorData(this.biomesForGeneration, par1 * 16, par2 * 16, 16, 16);

        this.replaceBlocksForBiome(par1, par2, var3, this.biomesForGeneration);

        this.caveGenerator.generate(this, this.worldObj, par1, par2, var3);

        this.ravineGenerator.generate(this, this.worldObj, par1, par2, var3);

 

        if (this.mapFeaturesEnabled)

        {

            this.mineshaftGenerator.generate(this, this.worldObj, par1, par2, var3);

            this.villageGenerator.generate(this, this.worldObj, par1, par2, var3);

            this.strongholdGenerator.generate(this, this.worldObj, par1, par2, var3);

            this.scatteredFeatureGenerator.generate(this, this.worldObj, par1, par2, var3);

        }

 

        Chunk var4 = new Chunk(this.worldObj, var3, par1, par2);

        byte[] var5 = var4.getBiomeArray();

 

        for (int var6 = 0; var6 < var5.length; ++var6)

        {

            var5[var6] = (byte)this.biomesForGeneration[var6].biomeID;

        }

 

        var4.generateSkylightMap();

        return var4;

    }

 

    /**

    * generates a subset of the level's terrain data. Takes 7 arguments: the [empty] noise array, the position, and the

    * size.

    */

    private double[] initializeNoiseField(double[] par1ArrayOfDouble, int par2, int par3, int par4, int par5, int par6, int par7)

    {

        ChunkProviderEvent.InitNoiseField event = new ChunkProviderEvent.InitNoiseField(this, par1ArrayOfDouble, par2, par3, par4, par5, par6, par7);

        MinecraftForge.EVENT_BUS.post(event);

        if (event.getResult() == Result.DENY) return event.noisefield;

 

        if (par1ArrayOfDouble == null)

        {

            par1ArrayOfDouble = new double[par5 * par6 * par7];

        }

 

        if (this.parabolicField == null)

        {

            this.parabolicField = new float[25];

 

            for (int var8 = -2; var8 <= 2; ++var8)

            {

                for (int var9 = -2; var9 <= 2; ++var9)

                {

                    float var10 = 10.0F / MathHelper.sqrt_float((float)(var8 * var8 + var9 * var9) + 0.2F);

                    this.parabolicField[var8 + 2 + (var9 + 2) * 5] = var10;

                }

            }

        }

 

        double var44 = 684.412D;

        double var45 = 684.412D;

        this.noise5 = this.noiseGen5.generateNoiseOctaves(this.noise5, par2, par4, par5, par7, 1.121D, 1.121D, 0.5D);

        this.noise6 = this.noiseGen6.generateNoiseOctaves(this.noise6, par2, par4, par5, par7, 200.0D, 200.0D, 0.5D);

        this.noise3 = this.noiseGen3.generateNoiseOctaves(this.noise3, par2, par3, par4, par5, par6, par7, var44 / 80.0D, var45 / 160.0D, var44 / 80.0D);

        this.noise1 = this.noiseGen1.generateNoiseOctaves(this.noise1, par2, par3, par4, par5, par6, par7, var44, var45, var44);

        this.noise2 = this.noiseGen2.generateNoiseOctaves(this.noise2, par2, par3, par4, par5, par6, par7, var44, var45, var44);

        boolean var43 = false;

        boolean var42 = false;

        int var12 = 0;

        int var13 = 0;

 

        for (int var14 = 0; var14 < par5; ++var14)

        {

            for (int var15 = 0; var15 < par7; ++var15)

            {

                float var16 = 0.0F;

                float var17 = 0.0F;

                float var18 = 0.0F;

                byte var19 = 2;

                BiomeGenBase var20 = this.biomesForGeneration[var14 + 2 + (var15 + 2) * (par5 + 5)];

 

                for (int var21 = -var19; var21 <= var19; ++var21)

                {

                    for (int var22 = -var19; var22 <= var19; ++var22)

                    {

                        BiomeGenBase var23 = this.biomesForGeneration[var14 + var21 + 2 + (var15 + var22 + 2) * (par5 + 5)];

                        float var24 = this.parabolicField[var21 + 2 + (var22 + 2) * 5] / (var23.minHeight + 2.0F);

 

                        if (var23.minHeight > var20.minHeight)

                        {

                            var24 /= 2.0F;

                        }

 

                        var16 += var23.maxHeight * var24;

                        var17 += var23.minHeight * var24;

                        var18 += var24;

                    }

                }

 

                var16 /= var18;

                var17 /= var18;

                var16 = var16 * 0.9F + 0.1F;

                var17 = (var17 * 4.0F - 1.0F) / 8.0F;

                double var47 = this.noise6[var13] / 8000.0D;

 

                if (var47 < 0.0D)

                {

                    var47 = -var47 * 0.3D;

                }

 

                var47 = var47 * 3.0D - 2.0D;

 

                if (var47 < 0.0D)

                {

                    var47 /= 2.0D;

 

                    if (var47 < -1.0D)

                    {

                        var47 = -1.0D;

                    }

 

                    var47 /= 1.4D;

                    var47 /= 2.0D;

                }

                else

                {

                    if (var47 > 1.0D)

                    {

                        var47 = 1.0D;

                    }

 

                    var47 /= 8.0D;

                }

 

                ++var13;

 

                for (int var46 = 0; var46 < par6; ++var46)

                {

                    double var48 = (double)var17;

                    double var26 = (double)var16;

                    var48 += var47 * 0.2D;

                    var48 = var48 * (double)par6 / 16.0D;

                    double var28 = (double)par6 / 2.0D + var48 * 4.0D;

                    double var30 = 0.0D;

                    double var32 = ((double)var46 - var28) * 12.0D * 128.0D / 128.0D / var26;

 

                    if (var32 < 0.0D)

                    {

                        var32 *= 4.0D;

                    }

 

                    double var34 = this.noise1[var12] / 512.0D;

                    double var36 = this.noise2[var12] / 512.0D;

                    double var38 = (this.noise3[var12] / 10.0D + 1.0D) / 2.0D;

 

                    if (var38 < 0.0D)

                    {

                        var30 = var34;

                    }

                    else if (var38 > 1.0D)

                    {

                        var30 = var36;

                    }

                    else

                    {

                        var30 = var34 + (var36 - var34) * var38;

                    }

 

                    var30 -= var32;

 

                    if (var46 > par6 - 4)

                    {

                        double var40 = (double)((float)(var46 - (par6 - 4)) / 3.0F);

                        var30 = var30 * (1.0D - var40) + -10.0D * var40;

                    }

 

                    par1ArrayOfDouble[var12] = var30;

                    ++var12;

                }

            }

        }

 

        return par1ArrayOfDouble;

    }

 

    /**

    * Checks to see if a chunk exists at x, y

    */

    public boolean chunkExists(int par1, int par2)

    {

        return true;

    }

 

    /**

    * Populates chunk with ores etc etc

    */

    public void populate(IChunkProvider par1IChunkProvider, int par2, int par3)

    {

        BlockSand.fallInstantly = false;

        int var4 = par2 * 16;

        int var5 = par3 * 16;

        BiomeGenBase var6 = this.worldObj.getBiomeGenForCoords(var4 + 16, var5 + 16);

        this.rand.setSeed(this.worldObj.getSeed());

        long var7 = this.rand.nextLong() / 2L * 2L + 1L;

        long var9 = this.rand.nextLong() / 2L * 2L + 1L;

        this.rand.setSeed((long)par2 * var7 + (long)par3 * var9 ^ this.worldObj.getSeed());

        boolean var11 = false;

 

        MinecraftForge.EVENT_BUS.post(new PopulateChunkEvent.Pre(par1IChunkProvider, worldObj, rand, par2, par3, var11));

 

        if (this.mapFeaturesEnabled)

        {

            this.mineshaftGenerator.generateStructuresInChunk(this.worldObj, this.rand, par2, par3);

            var11 = this.villageGenerator.generateStructuresInChunk(this.worldObj, this.rand, par2, par3);

            this.strongholdGenerator.generateStructuresInChunk(this.worldObj, this.rand, par2, par3);

            this.scatteredFeatureGenerator.generateStructuresInChunk(this.worldObj, this.rand, par2, par3);

        }

 

        int var12;

        int var13;

        int var14;

 

        if (TerrainGen.populate(par1IChunkProvider, worldObj, rand, par2, par3, var11, LAKE) &&

                !var11 && this.rand.nextInt(4) == 0)

        {

            var12 = var4 + this.rand.nextInt(16) + 8;

            var13 = this.rand.nextInt(128);

            var14 = var5 + this.rand.nextInt(16) + 8;

            (new WorldGenLakes(Block.waterStill.blockID)).generate(this.worldObj, this.rand, var12, var13, var14);

        }

 

        if (TerrainGen.populate(par1IChunkProvider, worldObj, rand, par2, par3, var11, LAVA) &&

                !var11 && this.rand.nextInt( == 0)

        {

            var12 = var4 + this.rand.nextInt(16) + 8;

            var13 = this.rand.nextInt(this.rand.nextInt(120) + ;

            var14 = var5 + this.rand.nextInt(16) + 8;

 

            if (var13 < 63 || this.rand.nextInt(10) == 0)

            {

                (new WorldGenLakes(Block.lavaStill.blockID)).generate(this.worldObj, this.rand, var12, var13, var14);

            }

        }

 

        boolean doGen = TerrainGen.populate(par1IChunkProvider, worldObj, rand, par2, par3, var11, DUNGEON);

        for (var12 = 0; doGen && var12 < 8; ++var12)

        {

            var13 = var4 + this.rand.nextInt(16) + 8;

            var14 = this.rand.nextInt(128);

            int var15 = var5 + this.rand.nextInt(16) + 8;

 

            if ((new WorldGenDungeons()).generate(this.worldObj, this.rand, var13, var14, var15))

            {

                ;

            }

        }

 

        var6.decorate(this.worldObj, this.rand, var4, var5);

        SpawnerAnimals.performWorldGenSpawning(this.worldObj, var6, var4 + 8, var5 + 8, 16, 16, this.rand);

        var4 += 8;

        var5 += 8;

 

        doGen = TerrainGen.populate(par1IChunkProvider, worldObj, rand, par2, par3, var11, ICE);

        for (var12 = 0; doGen && var12 < 16; ++var12)

        {

            for (var13 = 0; var13 < 16; ++var13)

            {

                var14 = this.worldObj.getPrecipitationHeight(var4 + var12, var5 + var13);

 

                if (this.worldObj.isBlockFreezable(var12 + var4, var14 - 1, var13 + var5))

                {

                    this.worldObj.setBlock(var12 + var4, var14 - 1, var13 + var5, Block.ice.blockID);

                }

 

                if (this.worldObj.canSnowAt(var12 + var4, var14, var13 + var5))

                {

                    this.worldObj.setBlock(var12 + var4, var14, var13 + var5, Block.snow.blockID);

                }

            }

        }

 

        MinecraftForge.EVENT_BUS.post(new PopulateChunkEvent.Post(par1IChunkProvider, worldObj, rand, par2, par3, var11));

 

        BlockSand.fallInstantly = false;

    }

 

    /**

    * Two modes of operation: if passed true, save all Chunks in one go.  If passed false, save up to two chunks.

    * Return true if all chunks have been saved.

    */

    public boolean saveChunks(boolean par1, IProgressUpdate par2IProgressUpdate)

    {

        return true;

    }

 

    /**

    * Unloads the 100 oldest chunks from memory, due to a bug with chunkSet.add() never being called it thinks the list

    * is always empty and will not remove any chunks.

    */

    public boolean unload100OldestChunks()

    {

        return false;

    }

 

    /**

    * Returns if the IChunkProvider supports saving.

    */

    public boolean canSave()

    {

        return true;

    }

 

    /**

    * Converts the instance data to a readable string.

    */

    public String makeString()

    {

        return "RandomLevelSource";

    }

 

    /**

    * Returns a list of creatures of the specified type that can spawn at the given location.

    */

    public List getPossibleCreatures(EnumCreatureType par1EnumCreatureType, int par2, int par3, int par4)

    {

        BiomeGenBase var5 = this.worldObj.getBiomeGenForCoords(par2, par4);

        return var5 == null ? null : (var5 == BiomeGenBase.swampland && par1EnumCreatureType == EnumCreatureType.monster && this.scatteredFeatureGenerator.hasStructureAt(par2, par3, par4) ? this.scatteredFeatureGenerator.getScatteredFeatureSpawnList() : var5.getSpawnableList(par1EnumCreatureType));

    }

 

    /**

    * Returns the location of the closest structure of the specified type. If not found returns null.

    */

    public ChunkPosition findClosestStructure(World par1World, String par2Str, int par3, int par4, int par5)

    {

        return "Stronghold".equals(par2Str) && this.strongholdGenerator != null ? this.strongholdGenerator.getNearestInstance(par1World, par3, par4, par5) : null;

    }

 

    public int getLoadedChunkCount()

    {

        return 10;

    }

 

    public void recreateStructures(int par1, int par2)

    {

        if (this.mapFeaturesEnabled)

        {

            this.mineshaftGenerator.generate(this, this.worldObj, par1, par2, (byte[])null);

            this.villageGenerator.generate(this, this.worldObj, par1, par2, (byte[])null);

            this.strongholdGenerator.generate(this, this.worldObj, par1, par2, (byte[])null);

            this.scatteredFeatureGenerator.generate(this, this.worldObj, par1, par2, (byte[])null);

        }

    }

 

@Override

public boolean unloadQueuedChunks() {

return false;

}

}

 

 

 

So, that's my code. It's not a crashing error, so I don't have a crash report.

[Sypher]

I'm having the same problem, if you haven't already figured it's caused by the teleporter file dropping the player directly on the portal. I'm still looking for a way to fix it, I'll let you know if I have anything.

[Mitchellbrine]

Thank you!

[Gaara51]

Here use this :

 

 

public void onEntityCollidedWithBlock(World var1, int var2, int var3, int var4, Entity var5)

{

if ((var5.ridingEntity == null) && (var5.riddenByEntity == null) && ((var5 instanceof EntityPlayerMP)))

{

EntityPlayerMP thePlayer = (EntityPlayerMP)var5;

ModLoader.getMinecraftServerInstance(); MinecraftServer mServer = MinecraftServer.getServer();

 

if (thePlayer.timeUntilPortal > 0)

{

thePlayer.timeUntilPortal = 10;

} else if (thePlayer.dimension != mod_MainClass.DimensionTest)

{

thePlayer.timeUntilPortal = 10;

 

thePlayer.mcServer.getConfigurationManager().transferPlayerToDimension(thePlayer, mod_MainClass.DimensionTest, new TeleporterTestDimension(mServer.worldServerForDimension(mod_MainClass.DimensionTest)));

}

else {

thePlayer.timeUntilPortal = 10;

thePlayer.mcServer.getConfigurationManager().transferPlayerToDimension(thePlayer, 0, new TeleporterTestDimension(mServer.worldServerForDimension(0)));

}

}

}

 

Make sure your teleporter is extending to Teleporter. That way you can use transferPlayerToDimension properly. (This will stop the teleport from happening back and forth and make it an instant teleport when you walk into it.)

 

Other notes: mod_MainClass.DimensionTest = my dimension ID & TeleporterTestDimension will be your teleporter, and then the dimension id at the very end.

[Mitchellbrine]

THANK YOU SO MUCH!!!!!!!!!!!!! BTW, is there any way to do this without ModLoader methods? If so, I'd like to be informed so I can make my mod SMP compatible.

[Gaara51]

No problem, now can you help me with an issue I have with my dimension stuff? When you build your portal, how do you open it with fire? I want to make a custom block for it so i dont edit base classes. So if you are doing it like that, please share how your doing it. Because I cant for the life of me get it to open.

[Mitchellbrine]

If you want it to build the portal in like a placer class, instead of putting in a bunch of your mod portal blocks, put in your fire block. But I see what you mean. You want your custom fire to ignite it, right? So in your fire class, replace what's there with the following:

 

public void onBlockAdded(World par1World, int par2, int par3, int par4)
{
if (par1World.provider.dimensionId > 0 || par1World.getBlockId(par2, par3 - 1, par4) != BLOCKUSED4PORTALFRAME.blockID || !CUSTOMPORTALBLOCK.tryToCreatePortal(par1World, par2, par3, par4))
if (!par1World.doesBlockHaveSolidTopSurface(par2, par3 - 1, par4) && !this.canNeighborBurn(par1World, par2, par3, par4))
{
par1World.setBlockToAir(par2, par3, par4);
}
else
{
par1World.scheduleBlockUpdate(par2, par3, par4, this.blockID, this.tickRate(par1World) + par1World.rand.nextInt(10));
}
}

 

If you want it to spawn in a frame, replace whatever this is in your portal class with:

public boolean tryToCreatePortal(World par1World, int par2, int par3, int par4)
{
byte b0 = 0;
byte b1 = 0;
if (par1World.getBlockId(par2 - 1, par3, par4) == BLOCK4PORTAL.blockID || par1World.getBlockId(par2 + 1, par3, par4) == BLOCK4PORTAL.blockID)
{
b0 = 1;
}
if (par1World.getBlockId(par2, par3, par4 - 1) == BLOCK4PORTAL.blockID || par1World.getBlockId(par2, par3, par4 + 1) == BLOCK4PORTAL.blockID)
{
b1 = 1;
}
if (b0 == b1)
{
return false;
}
else
{
if (par1World.getBlockId(par2 - b0, par3, par4 - b1) == 0)
{
par2 -= b0;
par4 -= b1;
}
int l;
int i1;
for (l = -1; l <= 2; ++l)
{
for (i1 = -1; i1 <= 3; ++i1)
{
boolean flag = l == -1 || l == 2 || i1 == -1 || i1 == 3;
if (l != -1 && l != 2 || i1 != -1 && i1 != 3)
{
int j1 = par1World.getBlockId(par2 + b0 * l, par3 + i1, par4 + b1 * l);
if (flag)
{
if (j1 != BLOCK4PORTAL.blockID)
{
return false;
}
}
else if (j1 != 0 && j1 != YOURMODNAME.YOURMODFIRE.blockID)
{
return false;
}
}
}
}
for (l = 0; l < 2; ++l)
{
for (i1 = 0; i1 < 3; ++i1)
{
par1World.setBlock(par2 + b0 * l, par3 + i1, par4 + b1 * l, mod_OtherWorld.NewPortal.blockID, 0, 2);
}
}
return true;
}
}

 

If that doesn't help, PM me!

[Gaara51]

Ah sh.. Thanks bro! I've been trying to fix this for days! Applaud to you good sir. (I didn't need the onBlockAdded)