I need help with my portal.  I have created the teleporter which successfully teleports me to a new dimension.  I have also defined my portal itself which is made of diamonds.  The only thing I need help with is being able to light the portal like a nether portal.  How would I do this.

 

Here is the code for the teleporter and the portal

 

package mods.beanstalk;

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

import net.minecraft.block.Block;
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 BeanstalkTeleporter extends Teleporter{

private final WorldServer worldServerInstance;
/** A private Random() function in Teleporter */
private final Random random;
/** Stores successful portal placement locations for rapid lookup. */
private final LongHashMap destinationCoordinateCache = new LongHashMap();
/**
         * A list of valid keys for the destinationCoordainteCache. These are based on the X & Z of the players initial
         * location.
         */
private final List destinationCoordinateKeys = new ArrayList();
public BeanstalkTeleporter(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;
                                        
                                         /** change this block **/
                                         this.worldServerInstance.setBlock(k1, l1, i2, flag ? Block.blockDiamond.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.destinationCoordinateCache.containsItem(j1))
         {
                 PortalPosition portalposition = (PortalPosition)this.destinationCoordinateCache.getValueByKey(j1);
                 d3 = 0.0D;
                 i = portalposition.posX;
                 j = portalposition.posY;
                 k = portalposition.posZ;
                 portalposition.lastUpdateTime = this.worldServerInstance.getTotalWorldTime();
                 flag = false;
         }
         else
         {
                 for (k1 = l - short1; k1 <= l + short1; ++k1)
                 {
                         double d5 = (double)k1 + 0.5D - 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)
                                 {
                                         /** change this block **/
                                         if (this.worldServerInstance.getBlockId(k1, i2, l1) == beanstalk_main.BeanstalkPortal.blockID)
                                         {
                                                 /** change this block **/
                                                 while (this.worldServerInstance.getBlockId(k1, i2 - 1, l1) == beanstalk_main.BeanstalkPortal.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.destinationCoordinateCache.add(j1, new BeanstalkPortalPosition(this, i, j, k, this.worldServerInstance.getTotalWorldTime()));
                         this.destinationCoordinateKeys.add(Long.valueOf(j1));
                 }
                 double d8 = (double)i + 0.5D;
                 double d9 = (double)j + 0.5D;
                 d4 = (double)k + 0.5D;
                 int j2 = -1;
                 /** change this block **/
                 if (this.worldServerInstance.getBlockId(i - 1, j, k) == beanstalk_main.BeanstalkPortal.blockID)
                 {
                         j2 = 2;
                 }
                 /** change this block **/
                 if (this.worldServerInstance.getBlockId(i + 1, j, k) == beanstalk_main.BeanstalkPortal.blockID)
                 {
                         j2 = 0;
                 }
                 /** change this block **/
                 if (this.worldServerInstance.getBlockId(i, j, k - 1) == beanstalk_main.BeanstalkPortal.blockID)
                 {
                         j2 = 3;
                 }
                 /** change this block **/
                 if (this.worldServerInstance.getBlockId(i, j, k + 1) == beanstalk_main.BeanstalkPortal.blockID)
                 {
                         j2 = 1;
                 }
                 int k2 = par1Entity.getTeleportDirection();
                 if (j2 > -1)
                 {
                         int l2 = Direction.rotateLeft[j2];
                         int i3 = Direction.offsetX[j2];
                         int j3 = Direction.offsetZ[j2];
                         int k3 = Direction.offsetX[l2];
                         int l3 = Direction.offsetZ[l2];
                         boolean flag1 = !this.worldServerInstance.isAirBlock(i + i3 + k3, j, k + j3 + l3) || !this.worldServerInstance.isAirBlock(i + i3 + k3, j + 1, k + j3 + l3);
                         boolean flag2 = !this.worldServerInstance.isAirBlock(i + i3, j, k + j3) || !this.worldServerInstance.isAirBlock(i + i3, j + 1, k + j3);
                         if (flag1 && flag2)
                         {
                                 j2 = Direction.rotateOpposite[j2];
                                 l2 = Direction.rotateOpposite[l2];
                                 i3 = Direction.offsetX[j2];
                                 j3 = Direction.offsetZ[j2];
                                 k3 = Direction.offsetX[l2];
                                 l3 = Direction.offsetZ[l2];
                                 k1 = i - k3;
                                 d8 -= (double)k3;
                                 int i4 = k - l3;
                                 d4 -= (double)l3;
                                 flag1 = !this.worldServerInstance.isAirBlock(k1 + i3 + k3, j, i4 + j3 + l3) || !this.worldServerInstance.isAirBlock(k1 + i3 + k3, j + 1, i4 + j3 + l3);
                                 flag2 = !this.worldServerInstance.isAirBlock(k1 + i3, j, i4 + j3) || !this.worldServerInstance.isAirBlock(k1 + i3, j + 1, i4 + j3);
                         }
                         float f1 = 0.5F;
                         float f2 = 0.5F;
                         if (!flag1 && flag2)
                         {
                                 f1 = 1.0F;
                         }
                         else if (flag1 && !flag2)
                         {
                                 f1 = 0.0F;
                         }
                         else if (flag1 && flag2)
                         {
                                 f2 = 0.0F;
                         }
                         d8 += (double)((float)k3 * f1 + f2 * (float)i3);
                         d4 += (double)((float)l3 * f1 + f2 * (float)j3);
                         float f3 = 0.0F;
                         float f4 = 0.0F;
                         float f5 = 0.0F;
                         float f6 = 0.0F;
                         if (j2 == k2)
                         {
                                 f3 = 1.0F;
                                 f4 = 1.0F;
                         }
                         else if (j2 == Direction.rotateOpposite[k2])
                         {
                                 f3 = -1.0F;
                                 f4 = -1.0F;
                         }
                         else if (j2 == Direction.rotateRight[k2])
                         {
                                 f5 = 1.0F;
                                 f6 = -1.0F;
                         }
                         else
                         {
                                 f5 = -1.0F;
                                 f6 = 1.0F;
                         }
                         double d10 = 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;
                                        
                                         /** change this block **/
                                         this.worldServerInstance.setBlock(k3, j3, i4, flag ? Block.blockDiamond.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;
                                
                                 /** change these blocks **/
                                 this.worldServerInstance.setBlock(k3, j3, i4, flag ? Block.blockDiamond.blockID : beanstalk_main.BeanstalkPortal.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;
}
/**
         * called periodically to remove out-of-date portal locations from the cache list. Argument par1 is a
         * WorldServer.getTotalWorldTime() value.
         */
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();
                         PortalPosition portalposition = (PortalPosition)this.destinationCoordinateCache.getValueByKey(olong.longValue());
                         if (portalposition == null || portalposition.lastUpdateTime < j)
                         {
                                 iterator.remove();
                                 this.destinationCoordinateCache.remove(olong.longValue());
                         }
                 }
         }
}
}

 

 

package mods.beanstalk;

import java.util.Random;

import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;

import net.minecraft.block.Block;
import net.minecraft.block.BlockBreakable;
import net.minecraft.block.material.Material;
import net.minecraft.creativetab.CreativeTabs;
import net.minecraft.entity.Entity;
import net.minecraft.entity.player.EntityPlayerMP;
import net.minecraft.item.ItemMonsterPlacer;
import net.minecraft.util.AxisAlignedBB;
import net.minecraft.world.IBlockAccess;
import net.minecraft.world.World;

public class BlockBeanstalkPortal extends BlockBreakable{

public BlockBeanstalkPortal(int par1)
{
super(par1,"BeanstalkPortal", Material.portal, false);
this.setTickRandomly(true);
this.setHardness(-1.0F);
this.setStepSound(soundGlassFootstep);
this.setLightValue(0.75F);
         this.setCreativeTab(CreativeTabs.tabBlock);
}
/**
* Ticks the block if it's been scheduled
*/
public void updateTick(World par1World, int par2, int par3, int par4, Random par5Random)
{
super.updateTick(par1World, par2, par3, par4, par5Random);
if (par1World.provider.isSurfaceWorld() && par5Random.nextInt(2000) < par1World.difficultySetting)
{
int l;
for (l = par3; !par1World.doesBlockHaveSolidTopSurface(par2, l, par4) && l > 0; --l)
{
;
}
if (l > 0 && !par1World.isBlockNormalCube(par2, l + 1, par4))
{
Entity entity = ItemMonsterPlacer.spawnCreature(par1World, 57, (double)par2 + 0.5D, (double)l + 1.1D, (double)par4 + 0.5D);
if (entity != null)
{
         entity.timeUntilPortal = entity.getPortalCooldown();
}
}
}
}
/**
* 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 par1World, int par2, int par3, int par4)
{
return null;
}
/**
* Updates the blocks bounds based on its current state. Args: world, x, y, z
*/
public void setBlockBoundsBasedOnState(IBlockAccess par1IBlockAccess, int par2, int par3, int par4)
{
float f;
float f1;
if (par1IBlockAccess.getBlockId(par2 - 1, par3, par4) != this.blockID && par1IBlockAccess.getBlockId(par2 + 1, par3, par4) != this.blockID)
{
f = 0.125F;
f1 = 0.5F;
this.setBlockBounds(0.5F - f, 0.0F, 0.5F - f1, 0.5F + f, 1.0F, 0.5F + f1);
}
else
{
f = 0.5F;
f1 = 0.125F;
this.setBlockBounds(0.5F - f, 0.0F, 0.5F - f1, 0.5F + f, 1.0F, 0.5F + f1);
}
}
/**
* Is this block (a) opaque and (B) a full 1m cube? This determines whether or not to render the shared face of two
* adjacent blocks and also whether the player can attach torches, redstone wire, etc to this block.
*/
public boolean isOpaqueCube()
{
return false;
}
/**
* If this block doesn't render as an ordinary block it will return False (examples: signs, buttons, stairs, etc)
*/
@Override
public boolean renderAsNormalBlock()
{
return false;
}
/**
* Checks to see if this location is valid to create a portal and will return True if it does. Args: world, x, y, z
*/
public boolean tryToCreatePortal(World par1World, int par2, int par3, int par4)
{
byte b0 = 0;
byte b1 = 0;
if (par1World.getBlockId(par2 - 1, par3, par4) == Block.blockDiamond.blockID || par1World.getBlockId(par2 + 1, par3, par4) == Block.blockDiamond.blockID)
{
b0 = 1;
}
if (par1World.getBlockId(par2, par3, par4 - 1) == Block.blockDiamond.blockID || par1World.getBlockId(par2, par3, par4 + 1) == Block.blockDiamond.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 != Block.blockDiamond.blockID)
         {
         return false;
         }
         }
         else if (j1 != 0 && j1 != Block.obsidian.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, beanstalk_main.BeanstalkPortal.blockID, 0, 2);
}
}
return true;
}
}
/**
* 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 blockID
*/
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) != Block.blockDiamond.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) == Block.blockDiamond.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) != Block.blockDiamond.blockID || par1World.getBlockId(par2 - b0, par3, par4 - b1) != this.blockID) && (par1World.getBlockId(par2 - b0, par3, par4 - b1) != Block.blockDiamond.blockID || par1World.getBlockId(par2 + b0, par3, par4 + b1) != this.blockID))
         {
         par1World.setBlockToAir(par2, par3, par4);
         }
}
}
else
{
par1World.setBlockToAir(par2, par3, par4);
}
}
}
@SideOnly(Side.CLIENT)
/**
* 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
*/
public boolean shouldSideBeRendered(IBlockAccess par1IBlockAccess, int par2, int par3, int par4, int par5)
{
if (par1IBlockAccess.getBlockId(par2, par3, par4) == this.blockID)
{
return false;
}
else
{
boolean flag = par1IBlockAccess.getBlockId(par2 - 1, par3, par4) == this.blockID && par1IBlockAccess.getBlockId(par2 - 2, par3, par4) != this.blockID;
boolean flag1 = par1IBlockAccess.getBlockId(par2 + 1, par3, par4) == this.blockID && par1IBlockAccess.getBlockId(par2 + 2, par3, par4) != this.blockID;
boolean flag2 = par1IBlockAccess.getBlockId(par2, par3, par4 - 1) == this.blockID && par1IBlockAccess.getBlockId(par2, par3, par4 - 2) != this.blockID;
boolean flag3 = par1IBlockAccess.getBlockId(par2, par3, par4 + 1) == this.blockID && par1IBlockAccess.getBlockId(par2, par3, par4 + 2) != this.blockID;
boolean flag4 = flag || flag1;
boolean flag5 = flag2 || flag3;
return flag4 && par5 == 4 ? true : (flag4 && par5 == 5 ? true : (flag5 && par5 == 2 ? true : flag5 && par5 == 3));
}
}
/**
* Returns the quantity of items to drop on block destruction.
*/
public int quantityDropped(Random par1Random)
{
return 0;
}
/**
* Triggered whenever an entity collides with this block (enters into the block). Args: world, x, y, z, entity
*/
public void onEntityCollidedWithBlock(World par1World, int par2, int par3, int par4, Entity par5Entity)
{
if ((par5Entity.ridingEntity == null) && (par5Entity.riddenByEntity == null) && ((par5Entity instanceof EntityPlayerMP)))
         {
         EntityPlayerMP thePlayer = (EntityPlayerMP)par5Entity;
         if (thePlayer.timeUntilPortal > 0)
         {
                 thePlayer.timeUntilPortal = 10;
         }
         else if (thePlayer.dimension != beanstalk_main.DimID)
         {
                 thePlayer.timeUntilPortal = 10;
                 thePlayer.mcServer.getConfigurationManager().transferPlayerToDimension(thePlayer, beanstalk_main.DimID, new BeanstalkTeleporter(thePlayer.mcServer.worldServerForDimension(beanstalk_main.DimID)));
         }
         else {
                 thePlayer.timeUntilPortal = 10;
                 thePlayer.mcServer.getConfigurationManager().transferPlayerToDimension(thePlayer, 0, new BeanstalkTeleporter(thePlayer.mcServer.worldServerForDimension(0)));
         }
         }
}
@SideOnly(Side.CLIENT)
/**
* Returns which pass should this block be rendered on. 0 for solids and 1 for alpha
*/
public int getRenderBlockPass()
{
return 1;
}
@SideOnly(Side.CLIENT)
/**
* A randomly called display update to be able to add particles or other items for display
*/
public void randomDisplayTick(World par1World, int par2, int par3, int par4, Random par5Random)
{
if (par5Random.nextInt(100) == 0)
{
par1World.playSound((double)par2 + 0.5D, (double)par3 + 0.5D, (double)par4 + 0.5D, "portal.portal", 0.5F, par5Random.nextFloat() * 0.4F + 0.8F, false);
}
for (int l = 0; l < 4; ++l)
{
double d0 = (double)((float)par2 + par5Random.nextFloat());
double d1 = (double)((float)par3 + par5Random.nextFloat());
double d2 = (double)((float)par4 + par5Random.nextFloat());
double d3 = 0.0D;
double d4 = 0.0D;
double d5 = 0.0D;
int i1 = par5Random.nextInt(2) * 2 - 1;
d3 = ((double)par5Random.nextFloat() - 0.5D) * 0.5D;
d4 = ((double)par5Random.nextFloat() - 0.5D) * 0.5D;
d5 = ((double)par5Random.nextFloat() - 0.5D) * 0.5D;
if (par1World.getBlockId(par2 - 1, par3, par4) != this.blockID && par1World.getBlockId(par2 + 1, par3, par4) != this.blockID)
{
d0 = (double)par2 + 0.5D + 0.25D * (double)i1;
d3 = (double)(par5Random.nextFloat() * 2.0F * (float)i1);
}
else
{
d2 = (double)par4 + 0.5D + 0.25D * (double)i1;
d5 = (double)(par5Random.nextFloat() * 2.0F * (float)i1);
}
par1World.spawnParticle("portal", d0, d1, d2, d3, d4, d5);
}
}
@SideOnly(Side.CLIENT)
/**
* only called by clickMiddleMouseButton , and passed to inventory.setCurrentItem (along with isCreative)
*/
public int idPicked(World par1World, int par2, int par3, int par4)
{
return 0;
}
}

Here's a forum topic on setting the block light levels

Never mind I figured i out, but now I can't get the texture to show up