[1.7.2][Dimensions] Return portal is a flat platform

[RadioactiveStud]

What should be a return portal is just a flat platform like so:

 

 

Teleporter:

 

package net.divinerpg.twilight.gen.eden;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Random;

import net.divinerpg.helper.blocks.TwilightBlocks;
import net.divinerpg.helper.blocks.VanillaBlocks;
import net.divinerpg.helper.config.ConfigurationHelper;
import net.minecraft.entity.Entity;
import net.minecraft.init.Blocks;
import net.minecraft.util.ChunkCoordinates;
import net.minecraft.util.Direction;
import net.minecraft.util.LongHashMap;
import net.minecraft.util.MathHelper;
import net.minecraft.world.ChunkCoordIntPair;
import net.minecraft.world.Teleporter;
import net.minecraft.world.WorldServer;

public class TeleporterEden extends Teleporter{

    private final WorldServer worldServerInstance;
    private final Random random;
    private final LongHashMap destinationCoordinateCache = new LongHashMap();
    private final List destinationCoordinateKeys = new ArrayList();

    public TeleporterEden(WorldServer par1WorldServer) {
    	super(par1WorldServer);
        this.worldServerInstance = par1WorldServer;
        this.random = new Random(par1WorldServer.getSeed());
    }

    public void placeInPortal(Entity par1Entity, double par2, double par4, double par6, float par8)
    {
        if (this.worldServerInstance.provider.dimensionId != ConfigurationHelper.Eden)
        {
            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 ? VanillaBlocks.divineRock : Blocks.air);
                    }
                }
            }

            par1Entity.setLocationAndAngles((double)i, (double)j, (double)k, par1Entity.rotationYaw, 0.0F);
            par1Entity.motionX = par1Entity.motionY = par1Entity.motionZ = 0.0D;
        }
    }

    public boolean placeInExistingPortal(Entity par1Entity, double par2, double par4, double par6, float par8)
    {
        short short1 = 128;
        double d3 = -1.0D;
        int i = 0;
        int j = 0;
        int k = 0;
        int l = MathHelper.floor_double(par1Entity.posX);
        int i1 = MathHelper.floor_double(par1Entity.posZ);
        long j1 = ChunkCoordIntPair.chunkXZ2Int(l, i1);
        boolean flag = true;
        double d7;
        int l3;

        if (this.destinationCoordinateCache.containsItem(j1))
        {
            TeleporterEden.PortalPosition portalposition = (TeleporterEden.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 - par1Entity.posX;

                for (int l1 = i1 - short1; l1 <= i1 + short1; ++l1)
                {
                    double d5 = (double)l1 + 0.5D - par1Entity.posZ;

                    for (int i2 = this.worldServerInstance.getActualHeight() - 1; i2 >= 0; --i2)
                    {
                        if (this.worldServerInstance.getBlock(l3, i2, l1) == TwilightBlocks.edenPortal)
                        {
                            while (this.worldServerInstance.getBlock(l3, i2 - 1, l1) == TwilightBlocks.edenPortal)
                            {
                                --i2;
                            }

                            d7 = (double)i2 + 0.5D - par1Entity.posY;
                            double d8 = d4 * d4 + d7 * d7 + d5 * d5;

                            if (d3 < 0.0D || d8 < d3)
                            {
                                d3 = d8;
                                i = l3;
                                j = i2;
                                k = l1;
                            }
                        }
                    }
                }
            }
        }

        if (d3 >= 0.0D)
        {
            if (flag)
            {
                this.destinationCoordinateCache.add(j1, new TeleporterEden.PortalPosition(i, j, k, this.worldServerInstance.getTotalWorldTime()));
                this.destinationCoordinateKeys.add(Long.valueOf(j1));
            }

            double d11 = (double)i + 0.5D;
            double d6 = (double)j + 0.5D;
            d7 = (double)k + 0.5D;
            int i4 = -1;

            if (this.worldServerInstance.getBlock(i - 1, j, k) == TwilightBlocks.edenPortal)
            {
                i4 = 2;
            }

            if (this.worldServerInstance.getBlock(i + 1, j, k) == TwilightBlocks.edenPortal)
            {
                i4 = 0;
            }

            if (this.worldServerInstance.getBlock(i, j, k - 1) == TwilightBlocks.edenPortal)
            {
                i4 = 3;
            }

            if (this.worldServerInstance.getBlock(i, j, k + 1) == TwilightBlocks.edenPortal)
            {
                i4 = 1;
            }

            int j2 = par1Entity.getTeleportDirection();

            if (i4 > -1)
            {
                int k2 = Direction.rotateLeft[i4];
                int l2 = Direction.offsetX[i4];
                int i3 = Direction.offsetZ[i4];
                int j3 = Direction.offsetX[k2];
                int k3 = Direction.offsetZ[k2];
                boolean flag1 = !this.worldServerInstance.isAirBlock(i + l2 + j3, j, k + i3 + k3) || !this.worldServerInstance.isAirBlock(i + l2 + j3, j + 1, k + i3 + k3);
                boolean flag2 = !this.worldServerInstance.isAirBlock(i + l2, j, k + i3) || !this.worldServerInstance.isAirBlock(i + l2, j + 1, k + i3);

                if (flag1 && flag2)
                {
                    i4 = Direction.rotateOpposite[i4];
                    k2 = Direction.rotateOpposite[k2];
                    l2 = Direction.offsetX[i4];
                    i3 = Direction.offsetZ[i4];
                    j3 = Direction.offsetX[k2];
                    k3 = Direction.offsetZ[k2];
                    l3 = i - j3;
                    d11 -= (double)j3;
                    int k1 = k - k3;
                    d7 -= (double)k3;
                    flag1 = !this.worldServerInstance.isAirBlock(l3 + l2 + j3, j, k1 + i3 + k3) || !this.worldServerInstance.isAirBlock(l3 + l2 + j3, j + 1, k1 + i3 + k3);
                    flag2 = !this.worldServerInstance.isAirBlock(l3 + l2, j, k1 + i3) || !this.worldServerInstance.isAirBlock(l3 + l2, j + 1, k1 + i3);
                }

                float f1 = 0.5F;
                float f2 = 0.5F;

                if (!flag1 && flag2)
                {
                    f1 = 1.0F;
                }
                else if (flag1 && !flag2)
                {
                    f1 = 0.0F;
                }
                else if (flag1 && flag2)
                {
                    f2 = 0.0F;
                }

                d11 += (double)((float)j3 * f1 + f2 * (float)l2);
                d7 += (double)((float)k3 * f1 + f2 * (float)i3);
                float f3 = 0.0F;
                float f4 = 0.0F;
                float f5 = 0.0F;
                float f6 = 0.0F;

                if (i4 == j2)
                {
                    f3 = 1.0F;
                    f4 = 1.0F;
                }
                else if (i4 == Direction.rotateOpposite[j2])
                {
                    f3 = -1.0F;
                    f4 = -1.0F;
                }
                else if (i4 == Direction.rotateRight[j2])
                {
                    f5 = 1.0F;
                    f6 = -1.0F;
                }
                else
                {
                    f5 = -1.0F;
                    f6 = 1.0F;
                }

                double d9 = par1Entity.motionX;
                double d10 = par1Entity.motionZ;
                par1Entity.motionX = d9 * (double)f3 + d10 * (double)f6;
                par1Entity.motionZ = d9 * (double)f5 + d10 * (double)f4;
                par1Entity.rotationYaw = par8 - (float)(j2 * 90) + (float)(i4 * 90);
            }
            else
            {
                par1Entity.motionX = par1Entity.motionY = par1Entity.motionZ = 0.0D;
            }

            par1Entity.setLocationAndAngles(d11, d6, d7, par1Entity.rotationYaw, par1Entity.rotationPitch);
            return true;
        }
        else
        {
            return false;
        }
    }

    public boolean makePortal(Entity par1Entity)
    {
        byte b0 = 16;
        double d0 = -1.0D;
        int i = MathHelper.floor_double(par1Entity.posX);
        int j = MathHelper.floor_double(par1Entity.posY);
        int k = MathHelper.floor_double(par1Entity.posZ);
        int l = i;
        int i1 = j;
        int j1 = k;
        int k1 = 0;
        int l1 = this.random.nextInt(4);
        int i2;
        double d1;
        double d2;
        int k2;
        int i3;
        int k3;
        int j3;
        int i4;
        int l3;
        int k4;
        int j4;
        int i5;
        int l4;
        double d3;
        double d4;

        for (i2 = i - b0; i2 <= i + b0; ++i2)
        {
            d1 = (double)i2 + 0.5D - par1Entity.posX;

            for (k2 = k - b0; k2 <= k + b0; ++k2)
            {
                d2 = (double)k2 + 0.5D - par1Entity.posZ;
                label274:

                for (i3 = this.worldServerInstance.getActualHeight() - 1; i3 >= 0; --i3)
                {
                    if (this.worldServerInstance.isAirBlock(i2, i3, k2))
                    {
                        while (i3 > 0 && this.worldServerInstance.isAirBlock(i2, i3 - 1, k2))
                        {
                            --i3;
                        }

                        for (j3 = l1; j3 < l1 + 4; ++j3)
                        {
                            k3 = j3 % 2;
                            l3 = 1 - k3;

                            if (j3 % 4 >= 2)
                            {
                                k3 = -k3;
                                l3 = -l3;
                            }

                            for (i4 = 0; i4 < 3; ++i4)
                            {
                                for (j4 = 0; j4 < 4; ++j4)
                                {
                                    for (k4 = -1; k4 < 4; ++k4)
                                    {
                                        l4 = i2 + (j4 - 1) * k3 + i4 * l3;
                                        i5 = i3 + k4;
                                        int j5 = k2 + (j4 - 1) * l3 - i4 * k3;

                                        if (k4 < 0 && !this.worldServerInstance.getBlock(l4, i5, j5).getMaterial().isSolid() || k4 >= 0 && !this.worldServerInstance.isAirBlock(l4, i5, j5))
                                        {
                                            continue label274;
                                        }
                                    }
                                }
                            }

                            d4 = (double)i3 + 0.5D - par1Entity.posY;
                            d3 = d1 * d1 + d4 * d4 + d2 * d2;

                            if (d0 < 0.0D || d3 < d0)
                            {
                                d0 = d3;
                                l = i2;
                                i1 = i3;
                                j1 = k2;
                                k1 = j3 % 4;
                            }
                        }
                    }
                }
            }
        }

        if (d0 < 0.0D)
        {
            for (i2 = i - b0; i2 <= i + b0; ++i2)
            {
                d1 = (double)i2 + 0.5D - par1Entity.posX;

                for (k2 = k - b0; k2 <= k + b0; ++k2)
                {
                    d2 = (double)k2 + 0.5D - par1Entity.posZ;
                    label222:

                    for (i3 = this.worldServerInstance.getActualHeight() - 1; i3 >= 0; --i3)
                    {
                        if (this.worldServerInstance.isAirBlock(i2, i3, k2))
                        {
                            while (i3 > 0 && this.worldServerInstance.isAirBlock(i2, i3 - 1, k2))
                            {
                                --i3;
                            }

                            for (j3 = l1; j3 < l1 + 2; ++j3)
                            {
                                k3 = j3 % 2;
                                l3 = 1 - k3;

                                for (i4 = 0; i4 < 4; ++i4)
                                {
                                    for (j4 = -1; j4 < 4; ++j4)
                                    {
                                        k4 = i2 + (i4 - 1) * k3;
                                        l4 = i3 + j4;
                                        i5 = k2 + (i4 - 1) * l3;

                                        if (j4 < 0 && !this.worldServerInstance.getBlock(k4, l4, i5).getMaterial().isSolid() || j4 >= 0 && !this.worldServerInstance.isAirBlock(k4, l4, i5))
                                        {
                                            continue label222;
                                        }
                                    }
                                }

                                d4 = (double)i3 + 0.5D - par1Entity.posY;
                                d3 = d1 * d1 + d4 * d4 + d2 * d2;

                                if (d0 < 0.0D || d3 < d0)
                                {
                                    d0 = d3;
                                    l = i2;
                                    i1 = i3;
                                    j1 = k2;
                                    k1 = j3 % 2;
                                }
                            }
                        }
                    }
                }
            }
        }

        int k5 = l;
        int j2 = i1;
        k2 = j1;
        int l5 = k1 % 2;
        int l2 = 1 - l5;

        if (k1 % 4 >= 2)
        {
            l5 = -l5;
            l2 = -l2;
        }

        boolean flag;

        if (d0 < 0.0D)
        {
            if (i1 < 70)
            {
                i1 = 70;
            }

            if (i1 > this.worldServerInstance.getActualHeight() - 10)
            {
                i1 = this.worldServerInstance.getActualHeight() - 10;
            }

            j2 = i1;

            for (i3 = -1; i3 <= 1; ++i3)
            {
                for (j3 = 1; j3 < 3; ++j3)
                {
                    for (k3 = -1; k3 < 3; ++k3)
                    {
                        l3 = k5 + (j3 - 1) * l5 + i3 * l2;
                        i4 = j2 + k3;
                        j4 = k2 + (j3 - 1) * l2 - i3 * l5;
                        flag = k3 < 0;
                        this.worldServerInstance.setBlock(l3, i4, j4, flag ? VanillaBlocks.divineRock : Blocks.air);
                    }
                }
            }
        }

        for (i3 = 0; i3 < 4; ++i3)
        {
            for (j3 = 0; j3 < 4; ++j3)
            {
                for (k3 = -1; k3 < 4; ++k3)
                {
                    l3 = k5 + (j3 - 1) * l5;
                    i4 = j2 + k3;
                    j4 = k2 + (j3 - 1) * l2;
                    flag = j3 == 0 || j3 == 3 || k3 == -1 || k3 == 3;
                    this.worldServerInstance.setBlock(l3, i4, j4, (flag ? VanillaBlocks.divineRock : TwilightBlocks.edenPortal), 0, 2);
                }
            }

            for (j3 = 0; j3 < 4; ++j3)
            {
                for (k3 = -1; k3 < 4; ++k3)
                {
                    l3 = k5 + (j3 - 1) * l5;
                    i4 = j2 + k3;
                    j4 = k2 + (j3 - 1) * l2;
                    this.worldServerInstance.notifyBlocksOfNeighborChange(l3, i4, j4, this.worldServerInstance.getBlock(l3, i4, j4));
                }
            }
        }

        return true;
    }

    public void removeStalePortalLocations(long par1)
    {
        if (par1 % 100L == 0L)
        {
            Iterator iterator = this.destinationCoordinateKeys.iterator();
            long j = par1 - 600L;

            while (iterator.hasNext())
            {
                Long olong = (Long)iterator.next();
                TeleporterEden.PortalPosition portalposition = (TeleporterEden.PortalPosition)this.destinationCoordinateCache.getValueByKey(olong.longValue());

                if (portalposition == null || portalposition.lastUpdateTime < j)
                {
                    iterator.remove();
                    this.destinationCoordinateCache.remove(olong.longValue());
                }
            }
        }
    }

    public class PortalPosition extends ChunkCoordinates {
        public long lastUpdateTime;

        public PortalPosition(int par2, int par3, int par4, long par5)
        {
            super(par2, par3, par4);
            this.lastUpdateTime = par5;
        }
    }
}

 

Portal:

 

package net.divinerpg.twilight.blocks;

import java.util.Random;

import net.divinerpg.Reference;
import net.divinerpg.helper.blocks.TwilightBlocks;
import net.divinerpg.helper.blocks.VanillaBlocks;
import net.divinerpg.helper.config.ConfigurationHelper;
import net.divinerpg.helper.tabs.DivineRPGTabs;
import net.divinerpg.helper.utils.LangRegistry;
import net.divinerpg.twilight.entity.fx.EntityEdenPortalFX;
import net.divinerpg.twilight.gen.eden.TeleporterEden;
import net.divinerpg.twilight.gen.wildwoods.TeleporterWildWoods;
import net.minecraft.block.Block;
import net.minecraft.block.BlockBreakable;
import net.minecraft.block.material.Material;
import net.minecraft.entity.Entity;
import net.minecraft.entity.player.EntityPlayerMP;
import net.minecraft.init.Blocks;
import net.minecraft.item.Item;
import net.minecraft.item.ItemMonsterPlacer;
import net.minecraft.util.AxisAlignedBB;
import net.minecraft.util.ChunkCoordinates;
import net.minecraft.util.Direction;
import net.minecraft.world.IBlockAccess;
import net.minecraft.world.World;
import cpw.mods.fml.client.FMLClientHandler;
import cpw.mods.fml.common.registry.GameRegistry;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;

public class BlockEdenPortal extends BlockBreakable
{
public static final int[][] field_150001_a = new int[][] {new int[0], {3, 1}, {2, 0}};

public String name;
public BlockEdenPortal() {
	super(Reference.PREFIX + "edenPortal", Material.portal, false);
	this.setTickRandomly(true);
	LangRegistry.addBlock(this);
	setCreativeTab(DivineRPGTabs.blocks);
}

    @Override
    public Item getItem(World par1World, int par2, int par3, int par4) {
        return Item.getItemFromBlock(this);
    }

/**
 * Ticks the block if it's been scheduled
 */
public void updateTick(World p_149674_1_, int p_149674_2_, int p_149674_3_, int p_149674_4_, Random p_149674_5_)
{
	super.updateTick(p_149674_1_, p_149674_2_, p_149674_3_, p_149674_4_, p_149674_5_);

	if (p_149674_1_.provider.isSurfaceWorld() && p_149674_1_.getGameRules().getGameRuleBooleanValue("doMobSpawning") && p_149674_5_.nextInt(2000) < p_149674_1_.difficultySetting.getDifficultyId())
	{
		int l;

		for (l = p_149674_3_; !World.doesBlockHaveSolidTopSurface(p_149674_1_, p_149674_2_, l, p_149674_4_) && l > 0; --l)
		{
			;
		}

		if (l > 0 && !p_149674_1_.getBlock(p_149674_2_, l + 1, p_149674_4_).isNormalCube())
		{
			Entity entity = ItemMonsterPlacer.spawnCreature(p_149674_1_, 57, (double)p_149674_2_ + 0.5D, (double)l + 1.1D, (double)p_149674_4_ + 0.5D);

			if (entity != null)
			{
				entity.timeUntilPortal = entity.getPortalCooldown();
			}
		}
	}
}

@Override
    public void onEntityCollidedWithBlock(World par1World, int par2, int par3, int par4, Entity par5Entity) {
        if ((par5Entity.ridingEntity == null) && (par5Entity.riddenByEntity == null) && ((par5Entity instanceof EntityPlayerMP))) {
        	int dim = ConfigurationHelper.Eden;
        	
            EntityPlayerMP thePlayer = (EntityPlayerMP)par5Entity;
            if (thePlayer.timeUntilPortal > 0) {
                thePlayer.timeUntilPortal = 10;
            }
            else if (thePlayer.dimension != dim) {
                thePlayer.timeUntilPortal = 10;
                thePlayer.mcServer.getConfigurationManager().transferPlayerToDimension(thePlayer, dim, new TeleporterEden(thePlayer.mcServer.worldServerForDimension(dim)));
            } else {
                thePlayer.timeUntilPortal = 10;
                thePlayer.mcServer.getConfigurationManager().transferPlayerToDimension(thePlayer, 0, new TeleporterEden(thePlayer.mcServer.worldServerForDimension(0)));
            }
        }
    }

/**
 * Returns a bounding box from the pool of bounding boxes (this means this box can change after the pool has been
 * cleared to be reused)
 */
public AxisAlignedBB getCollisionBoundingBoxFromPool(World p_149668_1_, int p_149668_2_, int p_149668_3_, int p_149668_4_)
{
	return null;
}

/**
 * Updates the blocks bounds based on its current state. Args: world, x, y, z
 */
public void setBlockBoundsBasedOnState(IBlockAccess p_149719_1_, int p_149719_2_, int p_149719_3_, int p_149719_4_)
{
	int l = func_149999_b(p_149719_1_.getBlockMetadata(p_149719_2_, p_149719_3_, p_149719_4_));

	if (l == 0)
	{
		if (p_149719_1_.getBlock(p_149719_2_ - 1, p_149719_3_, p_149719_4_) != this && p_149719_1_.getBlock(p_149719_2_ + 1, p_149719_3_, p_149719_4_) != this)
		{
			l = 2;
		}
		else
		{
			l = 1;
		}

		if (p_149719_1_ instanceof World && !((World)p_149719_1_).isRemote)
		{
			((World)p_149719_1_).setBlockMetadataWithNotify(p_149719_2_, p_149719_3_, p_149719_4_, l, 2);
		}
	}

	float f = 0.125F;
	float f1 = 0.125F;

	if (l == 1)
	{
		f = 0.5F;
	}

	if (l == 2)
	{
		f1 = 0.5F;
	}

	this.setBlockBounds(0.5F - f, 0.0F, 0.5F - f1, 0.5F + f, 1.0F, 0.5F + f1);
}

/**
 * If this block doesn't render as an ordinary block it will return False (examples: signs, buttons, stairs, etc)
 */
public boolean renderAsNormalBlock()
{
	return false;
}

public boolean func_150000_e(World p_150000_1_, int p_150000_2_, int p_150000_3_, int p_150000_4_)
{
	BlockEdenPortal.Size size = new BlockEdenPortal.Size(p_150000_1_, p_150000_2_, p_150000_3_, p_150000_4_, 1);
	BlockEdenPortal.Size size1 = new BlockEdenPortal.Size(p_150000_1_, p_150000_2_, p_150000_3_, p_150000_4_, 2);

	if (size.func_150860_b() && size.field_150864_e == 0)
	{
		size.func_150859_c();
		return true;
	}
	else if (size1.func_150860_b() && size1.field_150864_e == 0)
	{
		size1.func_150859_c();
		return true;
	}
	else
	{
		return false;
	}
}

/**
 * Lets the block know when one of its neighbor changes. Doesn't know which neighbor changed (coordinates passed are
 * their own) Args: x, y, z, neighbor Block
 */
public void onNeighborBlockChange(World p_149695_1_, int p_149695_2_, int p_149695_3_, int p_149695_4_, Block p_149695_5_)
{
	int l = func_149999_b(p_149695_1_.getBlockMetadata(p_149695_2_, p_149695_3_, p_149695_4_));
	BlockEdenPortal.Size size = new BlockEdenPortal.Size(p_149695_1_, p_149695_2_, p_149695_3_, p_149695_4_, 1);
	BlockEdenPortal.Size size1 = new BlockEdenPortal.Size(p_149695_1_, p_149695_2_, p_149695_3_, p_149695_4_, 2);

	if (l == 1 && (!size.func_150860_b() || size.field_150864_e < size.field_150868_h * size.field_150862_g))
	{
		p_149695_1_.setBlock(p_149695_2_, p_149695_3_, p_149695_4_, Blocks.air);
	}
	else if (l == 2 && (!size1.func_150860_b() || size1.field_150864_e < size1.field_150868_h * size1.field_150862_g))
	{
		p_149695_1_.setBlock(p_149695_2_, p_149695_3_, p_149695_4_, Blocks.air);
	}
	else if (l == 0 && !size.func_150860_b() && !size1.func_150860_b())
	{
		p_149695_1_.setBlock(p_149695_2_, p_149695_3_, p_149695_4_, Blocks.air);
	}
}

/**
 * Returns true if the given side of this block type should be rendered, if the adjacent block is at the given
 * coordinates.  Args: blockAccess, x, y, z, side
 */
@SideOnly(Side.CLIENT)
public boolean shouldSideBeRendered(IBlockAccess p_149646_1_, int p_149646_2_, int p_149646_3_, int p_149646_4_, int p_149646_5_)
{
	int i1 = 0;

	if (p_149646_1_.getBlock(p_149646_2_, p_149646_3_, p_149646_4_) == this)
	{
		i1 = func_149999_b(p_149646_1_.getBlockMetadata(p_149646_2_, p_149646_3_, p_149646_4_));

		if (i1 == 0)
		{
			return false;
		}

		if (i1 == 2 && p_149646_5_ != 5 && p_149646_5_ != 4)
		{
			return false;
		}

		if (i1 == 1 && p_149646_5_ != 3 && p_149646_5_ != 2)
		{
			return false;
		}
	}

	boolean flag = p_149646_1_.getBlock(p_149646_2_ - 1, p_149646_3_, p_149646_4_) == this && p_149646_1_.getBlock(p_149646_2_ - 2, p_149646_3_, p_149646_4_) != this;
	boolean flag1 = p_149646_1_.getBlock(p_149646_2_ + 1, p_149646_3_, p_149646_4_) == this && p_149646_1_.getBlock(p_149646_2_ + 2, p_149646_3_, p_149646_4_) != this;
	boolean flag2 = p_149646_1_.getBlock(p_149646_2_, p_149646_3_, p_149646_4_ - 1) == this && p_149646_1_.getBlock(p_149646_2_, p_149646_3_, p_149646_4_ - 2) != this;
	boolean flag3 = p_149646_1_.getBlock(p_149646_2_, p_149646_3_, p_149646_4_ + 1) == this && p_149646_1_.getBlock(p_149646_2_, p_149646_3_, p_149646_4_ + 2) != this;
	boolean flag4 = flag || flag1 || i1 == 1;
	boolean flag5 = flag2 || flag3 || i1 == 2;
	return flag4 && p_149646_5_ == 4 ? true : (flag4 && p_149646_5_ == 5 ? true : (flag5 && p_149646_5_ == 2 ? true : flag5 && p_149646_5_ == 3));
}

/**
 * Returns the quantity of items to drop on block destruction.
 */
public int quantityDropped(Random p_149745_1_)
{
	return 0;
}

/**
 * Returns which pass should this block be rendered on. 0 for solids and 1 for alpha
 */
@SideOnly(Side.CLIENT)
public int getRenderBlockPass()
{
	return 1;
}

/**
 * A randomly called display update to be able to add particles or other items for display
 */
@SideOnly(Side.CLIENT)
public void randomDisplayTick(World p_149734_1_, int p_149734_2_, int p_149734_3_, int p_149734_4_, Random p_149734_5_)
{
	for (int l = 0; l < 4; ++l)
	{
		double d0 = (double)((float)p_149734_2_ + p_149734_5_.nextFloat());
		double d1 = (double)((float)p_149734_3_ + p_149734_5_.nextFloat());
		double d2 = (double)((float)p_149734_4_ + p_149734_5_.nextFloat());
		double d3 = 0.0D;
		double d4 = 0.0D;
		double d5 = 0.0D;
		int i1 = p_149734_5_.nextInt(2) * 2 - 1;
		d3 = ((double)p_149734_5_.nextFloat() - 0.5D) * 0.5D;
		d4 = ((double)p_149734_5_.nextFloat() - 0.5D) * 0.5D;
		d5 = ((double)p_149734_5_.nextFloat() - 0.5D) * 0.5D;

		if (p_149734_1_.getBlock(p_149734_2_ - 1, p_149734_3_, p_149734_4_) != this && p_149734_1_.getBlock(p_149734_2_ + 1, p_149734_3_, p_149734_4_) != this)
		{
			d0 = (double)p_149734_2_ + 0.5D + 0.25D * (double)i1;
			d3 = (double)(p_149734_5_.nextFloat() * 2.0F * (float)i1);
		}
		else
		{
			d2 = (double)p_149734_4_ + 0.5D + 0.25D * (double)i1;
			d5 = (double)(p_149734_5_.nextFloat() * 2.0F * (float)i1);
		}

		EntityEdenPortalFX var20 = new EntityEdenPortalFX(p_149734_1_, d0, d1, d2, d3, d4, d5);
            FMLClientHandler.instance().getClient().effectRenderer.addEffect(var20);
	}
}

public static int func_149999_b(int p_149999_0_)
{
	return p_149999_0_ & 3;
}

public static class Size
{
	private final World field_150867_a;
	private final int field_150865_b;
	private final int field_150866_c;
	private final int field_150863_d;
	private int field_150864_e = 0;
	private ChunkCoordinates field_150861_f;
	private int field_150862_g;
	private int field_150868_h;
	private static final String __OBFID = "CL_00000285";

	public Size(World p_i45415_1_, int p_i45415_2_, int p_i45415_3_, int p_i45415_4_, int p_i45415_5_)
	{
		this.field_150867_a = p_i45415_1_;
		this.field_150865_b = p_i45415_5_;
		this.field_150863_d = BlockEdenPortal.field_150001_a[p_i45415_5_][0];
		this.field_150866_c = BlockEdenPortal.field_150001_a[p_i45415_5_][1];

		for (int i1 = p_i45415_3_; p_i45415_3_ > i1 - 21 && p_i45415_3_ > 0 && this.func_150857_a(p_i45415_1_.getBlock(p_i45415_2_, p_i45415_3_ - 1, p_i45415_4_)); --p_i45415_3_)
		{
			;
		}

		int j1 = this.func_150853_a(p_i45415_2_, p_i45415_3_, p_i45415_4_, this.field_150863_d) - 1;

		if (j1 >= 0)
		{
			this.field_150861_f = new ChunkCoordinates(p_i45415_2_ + j1 * Direction.offsetX[this.field_150863_d], p_i45415_3_, p_i45415_4_ + j1 * Direction.offsetZ[this.field_150863_d]);
			this.field_150868_h = this.func_150853_a(this.field_150861_f.posX, this.field_150861_f.posY, this.field_150861_f.posZ, this.field_150866_c);

			if (this.field_150868_h < 2 || this.field_150868_h > 21)
			{
				this.field_150861_f = null;
				this.field_150868_h = 0;
			}
		}

		if (this.field_150861_f != null)
		{
			this.field_150862_g = this.func_150858_a();
		}
	}

	protected int func_150853_a(int p_150853_1_, int p_150853_2_, int p_150853_3_, int p_150853_4_)
	{
		int j1 = Direction.offsetX[p_150853_4_];
		int k1 = Direction.offsetZ[p_150853_4_];
		int i1;
		Block block;

		for (i1 = 0; i1 < 22; ++i1)
		{
			block = this.field_150867_a.getBlock(p_150853_1_ + j1 * i1, p_150853_2_, p_150853_3_ + k1 * i1);

			if (!this.func_150857_a(block))
			{
				break;
			}

			Block block1 = this.field_150867_a.getBlock(p_150853_1_ + j1 * i1, p_150853_2_ - 1, p_150853_3_ + k1 * i1);

			if (block1 != VanillaBlocks.divineRock)
			{
				break;
			}
		}

		block = this.field_150867_a.getBlock(p_150853_1_ + j1 * i1, p_150853_2_, p_150853_3_ + k1 * i1);
		return block == VanillaBlocks.divineRock ? i1 : 0;
	}

	protected int func_150858_a()
	{
		int i;
		int j;
		int k;
		int l;
		label56:

			for (this.field_150862_g = 0; this.field_150862_g < 21; ++this.field_150862_g)
			{
				i = this.field_150861_f.posY + this.field_150862_g;

				for (j = 0; j < this.field_150868_h; ++j)
				{
					k = this.field_150861_f.posX + j * Direction.offsetX[blockEdenPortal.field_150001_a[this.field_150865_b][1]];
					l = this.field_150861_f.posZ + j * Direction.offsetZ[blockEdenPortal.field_150001_a[this.field_150865_b][1]];
					Block block = this.field_150867_a.getBlock(k, i, l);

					if (!this.func_150857_a(block))
					{
						break label56;
					}

					if (block == TwilightBlocks.edenPortal)
					{
						++this.field_150864_e;
					}

					if (j == 0)
					{
						block = this.field_150867_a.getBlock(k + Direction.offsetX[blockEdenPortal.field_150001_a[this.field_150865_b][0]], i, l + Direction.offsetZ[blockEdenPortal.field_150001_a[this.field_150865_b][0]]);

						if (block != VanillaBlocks.divineRock)
						{
							break label56;
						}
					}
					else if (j == this.field_150868_h - 1)
					{
						block = this.field_150867_a.getBlock(k + Direction.offsetX[blockEdenPortal.field_150001_a[this.field_150865_b][1]], i, l + Direction.offsetZ[blockEdenPortal.field_150001_a[this.field_150865_b][1]]);

						if (block != VanillaBlocks.divineRock)
						{
							break label56;
						}
					}
				}
			}

		for (i = 0; i < this.field_150868_h; ++i)
		{
			j = this.field_150861_f.posX + i * Direction.offsetX[blockEdenPortal.field_150001_a[this.field_150865_b][1]];
			k = this.field_150861_f.posY + this.field_150862_g;
			l = this.field_150861_f.posZ + i * Direction.offsetZ[blockEdenPortal.field_150001_a[this.field_150865_b][1]];

			if (this.field_150867_a.getBlock(j, k, l) != VanillaBlocks.divineRock)
			{
				this.field_150862_g = 0;
				break;
			}
		}

		if (this.field_150862_g <= 21 && this.field_150862_g >= 3)
		{
			return this.field_150862_g;
		}
		else
		{
			this.field_150861_f = null;
			this.field_150868_h = 0;
			this.field_150862_g = 0;
			return 0;
		}
	}

	protected boolean func_150857_a(Block block)
	{
		return block.getMaterial() == Material.air || block == TwilightBlocks.blueFire || block == TwilightBlocks.edenPortal;
	}

	public boolean func_150860_b()
	{
		return this.field_150861_f != null && this.field_150868_h >= 2 && this.field_150868_h <= 21 && this.field_150862_g >= 3 && this.field_150862_g <= 21;
	}

	public void func_150859_c()
	{
		for (int i = 0; i < this.field_150868_h; ++i)
		{
			int j = this.field_150861_f.posX + Direction.offsetX[this.field_150866_c] * i;
			int k = this.field_150861_f.posZ + Direction.offsetZ[this.field_150866_c] * i;

			for (int l = 0; l < this.field_150862_g; ++l)
			{
				int i1 = this.field_150861_f.posY + l;
				this.field_150867_a.setBlock(j, i1, k, TwilightBlocks.edenPortal, this.field_150865_b, 2);
			}
		}
	}
}

    public Block setTextureName(String name) {
        return setBlockTextureName(Reference.PREFIX + name);
    }

    public Block setName(String name) {
        this.name = name;
        setTextureName(name);
        setBlockName(name);
        register();
        return this;
    }

    public String getName() {
        return name;
    }

    public String getTextureName() {
        return Reference.PREFIX + name;
    }

    public void register() {
        int numChars = 0;
        char firstLetter = name.charAt(0);
        if (Character.isLowerCase(firstLetter))
            firstLetter = Character.toUpperCase(firstLetter);
        String inGame = name.substring(1);
        for (int k = 0; k < name.length(); k++) {
            char c = name.charAt(k);
            int code = (int) c;

            if (k != 0) {
                for (int p = 65; p < 90; p++) {
                    if (code == p) {
                        numChars++;
                        if (numChars == 1) inGame = new StringBuffer(inGame).insert(k - 1, " ").toString();
                        else inGame = new StringBuffer(inGame).insert(k, " ").toString();
                    }
                }
            }
        }
        GameRegistry.registerBlock(this, name);
    }
}

 

Let me know if you need any more code. (Or you could look at the source: GitHub)

[coolboy4531]

You probably used some code from the Sky [End] portal generator.

[RadioactiveStud]

Telling what code would be helpful.

[coolboy4531]

Never created a dimension in 1.7, but I'd have to bet that you should change:

 

if (this.worldServerInstance.provider.dimensionId != ConfigurationHelper.Eden)

 

to this:

if (this.worldServerInstance.provider.dimensionId == ConfigurationHelper.Eden)

 

For your sake, this is located in your Teleporter [TeleporterEden]

[RadioactiveStud]

I will try that later.